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.

41 files changed, 6972 insertions, 4646 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5e0170a3..9a06bb9b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -30,6 +30,8 @@ add_subdirectory(supplemental/tls)
 add_subdirectory(supplemental/util)
 add_subdirectory(supplemental/websocket)
 
+add_subdirectory(testing)
+
 # When building shared libraries we prefer to suppress default symbol
 # visibility, so that only the symbols that should be exposed in the
 # resulting library are.  This is the default with Windows.
diff --git a/src/compat/nanomsg/compat_tcp_test.c b/src/compat/nanomsg/compat_tcp_test.c
index 24b42a01..ae4193b7 100644
--- a/src/compat/nanomsg/compat_tcp_test.c
+++ b/src/compat/nanomsg/compat_tcp_test.c
@@ -32,28 +32,28 @@
 
 #include "compat_testutil.h"
 
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 void
 test_bind_and_close(void)
 {
-	int      sb;
-	char     addr[64];
-	testutil_scratch_addr("tcp", sizeof (addr), addr);
+	int   sb;
+	char *addr;
 
-	TEST_CHECK((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK(nn_bind(sb, addr) >= 0);
-	TEST_CHECK(nn_close(sb) == 0);
+	NUTS_ADDR(addr, "tcp");
+
+	NUTS_TRUE((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE(nn_bind(sb, addr) >= 0);
+	NUTS_TRUE(nn_close(sb) == 0);
 }
 
 void
 test_connect_and_close(void)
 {
-	int      sc;
-	char     addr[64];
-	testutil_scratch_addr("tcp", sizeof (addr), addr);
+	int   sc;
+	char *addr;
 
+	NUTS_ADDR(addr, "tcp");
 	TEST_NN_PASS((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
 	TEST_NN_PASS(nn_connect(sc, addr));
 	TEST_NN_PASS(nn_close(sc));
@@ -62,26 +62,25 @@ test_connect_and_close(void)
 void
 test_bind_and_connect(void)
 {
-	int      sb, sc, p1, p2;
-	char     addr[64];
-
-	testutil_scratch_addr("tcp", sizeof (addr), addr);
+	int   sb, sc, p1, p2;
+	char *addr;
 
-	TEST_CHECK((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK(sb != sc);
+	NUTS_ADDR(addr, "tcp");
+	NUTS_TRUE((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE(sb != sc);
 
 	TEST_NN_MARRY_EX(sb, sc, addr, p1, p2);
 
-	TEST_CHECK(nn_close(sb) == 0);
-	TEST_CHECK(nn_close(sc) == 0);
+	TEST_NN_PASS(nn_close(sb));
+	TEST_NN_PASS(nn_close(sc));
 }
 
 void
 test_bad_addresses(void)
 {
 	int s;
-	TEST_CHECK((s = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((s = nn_socket(AF_SP, NN_PAIR)) >= 0);
 
 	TEST_NN_FAIL(nn_connect(s, "tcp://*:"), EINVAL);
 	TEST_NN_FAIL(nn_connect(s, "tcp://*:1000000"), EINVAL);
@@ -100,12 +99,12 @@ test_no_delay(void)
 	int    s;
 	int    opt;
 	size_t sz;
-	TEST_CHECK((s = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((s = nn_socket(AF_SP, NN_PAIR)) >= 0);
 
 	sz = sizeof(opt);
 	TEST_NN_PASS(nn_getsockopt(s, NN_TCP, NN_TCP_NODELAY, &opt, &sz));
-	TEST_CHECK(sz == sizeof(opt));
-	TEST_CHECK(opt == 0);
+	NUTS_TRUE(sz == sizeof(opt));
+	NUTS_TRUE(opt == 0);
 	opt = 2;
 	TEST_NN_FAIL(
 	    nn_setsockopt(s, NN_TCP, NN_TCP_NODELAY, &opt, sz), EINVAL);
@@ -115,25 +114,24 @@ test_no_delay(void)
 
 	opt = 3;
 	TEST_NN_PASS(nn_getsockopt(s, NN_TCP, NN_TCP_NODELAY, &opt, &sz));
-	TEST_CHECK(sz == sizeof(opt));
-	TEST_CHECK(opt == 1);
+	NUTS_TRUE(sz == sizeof(opt));
+	NUTS_TRUE(opt == 1);
 	TEST_NN_PASS(nn_close(s));
 }
 
 void
 test_ping_pong(void)
 {
-	int  sb, sc, p1, p2;
-	char addr[64];
-
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
+	int   sb, sc, p1, p2;
+	char *addr;
 
+	NUTS_ADDR(addr, "tcp");
 	TEST_NN_PASS((sb = nn_socket(AF_SP, NN_PAIR)));
 	TEST_NN_PASS((sc = nn_socket(AF_SP, NN_PAIR)));
-	TEST_CHECK(sb != sc);
+	NUTS_TRUE(sb != sc);
 	TEST_NN_MARRY_EX(sc, sb, addr, p1, p2);
-	TEST_CHECK(p1 >= 0);
-	TEST_CHECK(p2 >= 0);
+	NUTS_TRUE(p1 >= 0);
+	NUTS_TRUE(p2 >= 0);
 
 	/*  Ping-pong test. */
 	for (int i = 0; i != 100; ++i) {
@@ -142,75 +140,74 @@ test_ping_pong(void)
 		int  n;
 		TEST_NN_PASS(nn_send(sc, "ABC", 3, 0));
 		TEST_NN_PASS(n = nn_recv(sb, buf, 4, 0));
-		TEST_CHECK(n == 3);
-		TEST_CHECK(memcmp(buf, "ABC", 3) == 0);
+		NUTS_TRUE(n == 3);
+		NUTS_TRUE(memcmp(buf, "ABC", 3) == 0);
 
 		TEST_NN_PASS(nn_send(sb, "DEF", 3, 0));
 		TEST_NN_PASS(n = nn_recv(sc, buf, 4, 0));
-		TEST_CHECK(n == 3);
-		TEST_CHECK(memcmp(buf, "DEF", 3) == 0);
+		NUTS_TRUE(n == 3);
+		NUTS_TRUE(memcmp(buf, "DEF", 3) == 0);
 	}
 
-	TEST_CHECK(nn_close(sb) == 0);
-	TEST_CHECK(nn_close(sc) == 0);
+	TEST_NN_PASS(nn_close(sb));
+	TEST_NN_PASS(nn_close(sc));
 }
 
 void
 test_pair_reject(void)
 {
-	int      sb, sc, sd, p1, p2;
-	char     addr[32];
+	int   sb, sc, sd, p1, p2;
+	char *addr;
 
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
+	NUTS_ADDR(addr, "tcp");
 
-	TEST_CHECK((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK((sd = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK(sb != sc);
+	NUTS_TRUE((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((sd = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE(sb != sc);
 
 	TEST_NN_MARRY_EX(sc, sb, addr, p1, p2);
 
-	TEST_CHECK(nn_connect(sd, addr) >= 0);
-	testutil_sleep(200);
+	NUTS_TRUE(nn_connect(sd, addr) >= 0);
+	NUTS_SLEEP(200);
 
-	TEST_CHECK(nn_close(sb) == 0);
-	TEST_CHECK(nn_close(sc) == 0);
-	TEST_CHECK(nn_close(sd) == 0);
+	TEST_NN_PASS(nn_close(sb));
+	TEST_NN_PASS(nn_close(sc));
+	TEST_NN_PASS(nn_close(sd));
 }
 
 void
 test_addr_in_use(void)
 {
-	int      sb, sc;
-	char     addr[64];
-
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
+	int   sb, sc;
+	char *addr;
 
-	TEST_CHECK((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK(sb != sc);
+	NUTS_ADDR(addr, "tcp");
+	NUTS_TRUE((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE(sb != sc);
 	TEST_NN_PASS(nn_bind(sb, addr));
 	TEST_NN_FAIL(nn_bind(sc, addr), EADDRINUSE);
 
-	TEST_CHECK(nn_close(sb) == 0);
-	TEST_CHECK(nn_close(sc) == 0);
+	TEST_NN_PASS(nn_close(sb));
+	TEST_NN_PASS(nn_close(sc));
 }
 
 void
 test_max_recv_size(void)
 {
-	int      sb, sc, p1, p2;
-	int      opt;
-	int      n;
-	size_t   sz;
-	char     addr[64];
-	char     buf[64];
-
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
-
-	TEST_CHECK((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
-	TEST_CHECK(sb != sc);
+	int    sb, sc, p1, p2;
+	int    opt;
+	int    n;
+	size_t sz;
+	char   buf[64];
+	char *addr;
+
+	NUTS_ADDR(addr, "tcp");
+
+	NUTS_TRUE((sb = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE((sc = nn_socket(AF_SP, NN_PAIR)) >= 0);
+	NUTS_TRUE(sb != sc);
 	opt = 100;
 	sz  = sizeof(opt);
 	TEST_NN_PASS(nn_setsockopt(sb, NN_SOL_SOCKET, NN_RCVTIMEO, &opt, sz));
@@ -231,8 +228,8 @@ test_max_recv_size(void)
 	opt = -5;
 	TEST_NN_PASS(
 	    nn_getsockopt(sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, &sz));
-	TEST_CHECK(opt == 4);
-	TEST_CHECK(sz == sizeof(opt));
+	NUTS_TRUE(opt == 4);
+	NUTS_TRUE(sz == sizeof(opt));
 
 	TEST_NN_MARRY_EX(sc, sb, addr, p1, p2);
 
@@ -240,8 +237,8 @@ test_max_recv_size(void)
 	TEST_NN_PASS(nn_send(sc, "012345", 6, 0));
 
 	TEST_NN_PASS(n = nn_recv(sb, buf, sizeof(buf), 0));
-	TEST_CHECK(n == 4);
-	TEST_CHECK(strcmp(buf, "ABC") == 0);
+	NUTS_TRUE(n == 4);
+	NUTS_TRUE(strcmp(buf, "ABC") == 0);
 
 	TEST_NN_FAIL(nn_recv(sb, buf, sizeof(buf), 0), ETIMEDOUT);
 
diff --git a/src/compat/nanomsg/compat_testutil.h b/src/compat/nanomsg/compat_testutil.h
index 113d6672..e0612adb 100644
--- a/src/compat/nanomsg/compat_testutil.h
+++ b/src/compat/nanomsg/compat_testutil.h
@@ -45,30 +45,26 @@ extern "C" {
 // We do that to facilitate testing.  Don't rely on this equivalence in your
 // own application code.
 
-#define TEST_NN_MARRY(s1, s2)                                          \
-	do {                                                           \
-		int        rv_;                                        \
-		nng_socket s1_, s2_;                                   \
-		s1_.id = s1;                                           \
-		s2_.id = s2;                                           \
-                                                                       \
-		TEST_CHECK_(testutil_marry(s1_, s2_) == 0, "marry %s", \
-		    nng_strerror(rv_));                                \
+#define TEST_NN_MARRY(s1, s2)         \
+	do {                          \
+		nng_socket s1_, s2_;  \
+		s1_.id = s1;          \
+		s2_.id = s2;          \
+                                      \
+		NUTS_MARRY(s1_, s2_); \
 	} while (0)
 
-#define TEST_NN_MARRY_EX(s1, s2, url, p1, p2)                          \
-	do {                                                           \
-		int        rv_;                                        \
-		nng_socket s1_, s2_;                                   \
-		nng_pipe   p1_, p2_;                                   \
-		s1_.id = s1;                                           \
-		s2_.id = s2;                                           \
-		rv_    = testutil_marry_ex(s1_, s2_, url, &p1_, &p2_); \
-		TEST_CHECK_(rv_ == 0, "marry %s", nng_strerror(rv_));  \
-		p1 = p1_.id;                                           \
-		p2 = p2_.id;                                           \
-		TEST_CHECK(p1 >= 0);                                   \
-		TEST_CHECK(p2 >= 0);                                   \
+#define TEST_NN_MARRY_EX(s1, s2, url, p1, p2)             \
+	do {                                              \
+		nng_socket s1_, s2_;                      \
+		nng_pipe   p1_, p2_;                      \
+		s1_.id = s1;                              \
+		s2_.id = s2;                              \
+		NUTS_MARRY_EX(s1_, s2_, url, &p1_, &p2_); \
+		p1 = p1_.id;                              \
+		p2 = p2_.id;                              \
+		NUTS_TRUE(p1 >= 0);                       \
+		NUTS_TRUE(p2 >= 0);                       \
 	} while (0)
 
 #ifdef __cplusplus
diff --git a/src/core/aio_test.c b/src/core/aio_test.c
index 787b6149..3dab4b04 100644
--- a/src/core/aio_test.c
+++ b/src/core/aio_test.c
@@ -10,12 +10,7 @@
 
 #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>
 
 static void
 cb_done(void *p)
@@ -43,16 +38,16 @@ test_sleep(void)
 	nng_time end   = 0;
 	nng_aio *aio;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, sleep_done, &end));
+	NUTS_PASS(nng_aio_alloc(&aio, sleep_done, &end));
 	start = nng_clock();
 	nng_sleep_aio(200, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(end != 0);
-	TEST_CHECK((end - start) >= 200);
-	TEST_CHECK((end - start) <= 1000);
-	TEST_CHECK((nng_clock() - start) >= 200);
-	TEST_CHECK((nng_clock() - start) <= 1000);
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(end != 0);
+	NUTS_TRUE((end - start) >= 200);
+	NUTS_TRUE((end - start) <= 1000);
+	NUTS_TRUE((nng_clock() - start) >= 200);
+	NUTS_TRUE((nng_clock() - start) <= 1000);
 	nng_aio_free(aio);
 }
 
@@ -63,17 +58,17 @@ test_sleep_timeout(void)
 	nng_time end   = 0;
 	nng_aio *aio;
 
-	TEST_CHECK(nng_aio_alloc(&aio, sleep_done, &end) == 0);
+	NUTS_TRUE(nng_aio_alloc(&aio, sleep_done, &end) == 0);
 	nng_aio_set_timeout(aio, 100);
 	start = nng_clock();
 	nng_sleep_aio(2000, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_CHECK(end != 0);
-	TEST_CHECK((end - start) >= 100);
-	TEST_CHECK((end - start) <= 1000);
-	TEST_CHECK((nng_clock() - start) >= 100);
-	TEST_CHECK((nng_clock() - start) <= 1000);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_TRUE(end != 0);
+	NUTS_TRUE((end - start) >= 100);
+	NUTS_TRUE((end - start) <= 1000);
+	NUTS_TRUE((nng_clock() - start) >= 100);
+	NUTS_TRUE((nng_clock() - start) <= 1000);
 	nng_aio_free(aio);
 }
 
@@ -83,8 +78,8 @@ test_insane_nio(void)
 	nng_aio *aio;
 	nng_iov  iov;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_FAIL(nng_aio_set_iov(aio, 1024, &iov), NNG_EINVAL);
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_FAIL(nng_aio_set_iov(aio, 1024, &iov), NNG_EINVAL);
 	nng_aio_free(aio);
 }
 
@@ -94,12 +89,12 @@ test_provider_cancel(void)
 	nng_aio *aio;
 	int      rv = 0;
 	// We fake an empty provider that does not do anything.
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_CHECK(nng_aio_begin(aio) == true);
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_TRUE(nng_aio_begin(aio) == true);
 	nng_aio_defer(aio, cancel, &rv);
 	nng_aio_cancel(aio);
 	nng_aio_wait(aio);
-	TEST_CHECK(rv == NNG_ECANCELED);
+	NUTS_TRUE(rv == NNG_ECANCELED);
 	nng_aio_free(aio);
 }
 
@@ -110,18 +105,18 @@ test_consumer_cancel(void)
 	nng_socket s1;
 	int        done = 0;
 
-	TEST_CHECK(nng_pair1_open(&s1) == 0);
-	TEST_CHECK(nng_aio_alloc(&a, cb_done, &done) == 0);
+	NUTS_TRUE(nng_pair1_open(&s1) == 0);
+	NUTS_TRUE(nng_aio_alloc(&a, cb_done, &done) == 0);
 
 	nng_aio_set_timeout(a, NNG_DURATION_INFINITE);
 	nng_recv_aio(s1, a);
 	nng_aio_cancel(a);
 	nng_aio_wait(a);
-	TEST_CHECK(done == 1);
-	TEST_CHECK(nng_aio_result(a) == NNG_ECANCELED);
+	NUTS_TRUE(done == 1);
+	NUTS_TRUE(nng_aio_result(a) == NNG_ECANCELED);
 
 	nng_aio_free(a);
-	TEST_CHECK(nng_close(s1) == 0);
+	NUTS_TRUE(nng_close(s1) == 0);
 }
 
 void
@@ -136,20 +131,20 @@ test_traffic(void)
 	nng_msg *  m;
 	char *     addr = "inproc://traffic";
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&s2));
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_pair1_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 
-	TEST_NNG_PASS(nng_aio_alloc(&rx_aio, cb_done, &rx_done));
-	TEST_NNG_PASS(nng_aio_alloc(&tx_aio, cb_done, &tx_done));
+	NUTS_PASS(nng_aio_alloc(&rx_aio, cb_done, &rx_done));
+	NUTS_PASS(nng_aio_alloc(&tx_aio, cb_done, &tx_done));
 
 	nng_aio_set_timeout(rx_aio, 1000);
 	nng_aio_set_timeout(tx_aio, 1000);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append(m, "hello", strlen("hello")));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append(m, "hello", strlen("hello")));
 
 	nng_recv_aio(s2, rx_aio);
 
@@ -159,22 +154,22 @@ test_traffic(void)
 	nng_aio_wait(tx_aio);
 	nng_aio_wait(rx_aio);
 
-	TEST_NNG_PASS(nng_aio_result(rx_aio));
-	TEST_NNG_PASS(nng_aio_result(tx_aio));
+	NUTS_PASS(nng_aio_result(rx_aio));
+	NUTS_PASS(nng_aio_result(tx_aio));
 
-	TEST_CHECK((m = nng_aio_get_msg(rx_aio)) != NULL);
-	TEST_CHECK(nng_msg_len(m) == strlen("hello"));
-	TEST_CHECK(memcmp(nng_msg_body(m), "hello", strlen("hello")) == 0);
+	NUTS_TRUE((m = nng_aio_get_msg(rx_aio)) != NULL);
+	NUTS_TRUE(nng_msg_len(m) == strlen("hello"));
+	NUTS_TRUE(memcmp(nng_msg_body(m), "hello", strlen("hello")) == 0);
 
 	nng_msg_free(m);
 
-	TEST_CHECK(rx_done == 1);
-	TEST_CHECK(tx_done == 1);
+	NUTS_TRUE(rx_done == 1);
+	NUTS_TRUE(tx_done == 1);
 
 	nng_aio_free(rx_aio);
 	nng_aio_free(tx_aio);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s2));
 }
 
 void
@@ -184,15 +179,15 @@ test_explicit_timeout(void)
 	nng_aio *  a;
 	int        done = 0;
 
-	TEST_NNG_PASS(nng_pair1_open(&s));
-	TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done));
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_aio_alloc(&a, cb_done, &done));
 	nng_aio_set_timeout(a, 40);
 	nng_recv_aio(s, a);
 	nng_aio_wait(a);
-	TEST_CHECK(done == 1);
-	TEST_NNG_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
+	NUTS_TRUE(done == 1);
+	NUTS_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
 	nng_aio_free(a);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_close(s));
 }
 
 void
@@ -202,15 +197,15 @@ test_inherited_timeout(void)
 	nng_aio *  a;
 	int        done = 0;
 
-	TEST_NNG_PASS(nng_pair1_open(&s));
-	TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done));
-	TEST_NNG_PASS(nng_socket_set_ms(s, NNG_OPT_RECVTIMEO, 40));
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_aio_alloc(&a, cb_done, &done));
+	NUTS_PASS(nng_socket_set_ms(s, NNG_OPT_RECVTIMEO, 40));
 	nng_recv_aio(s, a);
 	nng_aio_wait(a);
-	TEST_CHECK(done == 1);
-	TEST_NNG_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
+	NUTS_TRUE(done == 1);
+	NUTS_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
 	nng_aio_free(a);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_close(s));
 }
 
 void
@@ -220,18 +215,18 @@ test_zero_timeout(void)
 	nng_aio *  a;
 	int        done = 0;
 
-	TEST_NNG_PASS(nng_pair1_open(&s));
-	TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done));
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_aio_alloc(&a, cb_done, &done));
 	nng_aio_set_timeout(a, NNG_DURATION_ZERO);
 	nng_recv_aio(s, a);
 	nng_aio_wait(a);
-	TEST_CHECK(done == 1);
-	TEST_NNG_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
+	NUTS_TRUE(done == 1);
+	NUTS_FAIL(nng_aio_result(a), NNG_ETIMEDOUT);
 	nng_aio_free(a);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_close(s));
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "sleep", test_sleep },
 	{ "sleep timeout", test_sleep_timeout },
 	{ "insane nio", test_insane_nio },
diff --git a/src/core/buf_size_test.c b/src/core/buf_size_test.c
index 172cb1f0..b8757991 100644
--- a/src/core/buf_size_test.c
+++ b/src/core/buf_size_test.c
@@ -8,16 +8,11 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/util/platform.h>
+#include <nuts.h>
 
 #include <nng/compat/nanomsg/nn.h>
 
-#include "acutest.h"
-#include "testutil.h"
-
-void
+	void
 test_buffer_options(void)
 {
 	nng_socket s1;
@@ -31,38 +26,37 @@ test_buffer_options(void)
 		NULL,
 	};
 
-	TEST_CHECK(nng_pair1_open(&s1) == 0);
+	NUTS_PASS(nng_pair1_open(&s1));
 	for (int i = 0; (opt = cases[i]) != NULL; i++) {
 
-		TEST_CASE(opt);
+		NUTS_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 size
-		TEST_NNG_PASS(nng_socket_set_int(s1, opt, 1234));
-		TEST_NNG_PASS(nng_socket_get_int(s1, opt, &val));
-		TEST_CHECK(val == 1234);
+		NUTS_PASS(nng_socket_set_int(s1, opt, 1234));
+		NUTS_PASS(nng_socket_get_int(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 set a negative size
-		TEST_NNG_FAIL(nng_socket_set_int(s1, opt, -5), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_set_int(s1, opt, -5), NNG_EINVAL);
 
 		// 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);
 		// Buffer sizes are limited to sane levels
-		TEST_NNG_FAIL(
-		    nng_socket_set_int(s1, opt, 0x100000), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_set_int(s1, opt, 0x100000), NNG_EINVAL);
 	}
-	TEST_CHECK(nng_close(s1) == 0);
+	NUTS_PASS(nng_close(s1));
 }
 
 void
@@ -81,38 +75,38 @@ test_buffer_legacy(void)
 		NN_SNDBUF,
 	};
 
-	TEST_CHECK(nng_pair1_open(&s1) == 0);
+	NUTS_PASS(nng_pair1_open(&s1));
 	for (int i = 0; (opt = cases[i]) != NULL; i++) {
 		int    cnt;
 		int    os = (int) s1.id;
 		size_t sz;
 		int    nno = legacy[i];
 
-		TEST_CASE(opt);
+		NUTS_CASE(opt);
 
 		sz = sizeof(cnt);
-		TEST_NNG_PASS(nng_socket_set_int(s1, opt, 10));
-		TEST_CHECK(
+		NUTS_PASS(nng_socket_set_int(s1, opt, 10));
+		NUTS_TRUE(
 		    nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0);
-		TEST_CHECK(cnt == 10240); // 1k multiple
+		NUTS_TRUE(cnt == 10240); // 1k multiple
 
 		cnt = 1;
-		TEST_CHECK(
+		NUTS_TRUE(
 		    nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, sz) == 0);
-		TEST_CHECK(
+		NUTS_TRUE(
 		    nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0);
-		TEST_CHECK(cnt == 1024); // round up!
-		TEST_NNG_PASS(nng_socket_get_int(s1, opt, &cnt));
-		TEST_CHECK(cnt == 1);
+		NUTS_TRUE(cnt == 1024); // round up!
+		NUTS_PASS(nng_socket_get_int(s1, opt, &cnt));
+		NUTS_TRUE(cnt == 1);
 
-		TEST_CHECK(
+		NUTS_TRUE(
 		    nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, 100) == -1);
-		TEST_CHECK(nn_errno() == EINVAL);
+		NUTS_TRUE(nn_errno() == EINVAL);
 	}
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s1));
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "buffer options", test_buffer_options },
 	{ "buffer legacy", test_buffer_legacy },
 	{ NULL, NULL },
diff --git a/src/core/errors_test.c b/src/core/errors_test.c
index 4e50467c..52d820fe 100644
--- a/src/core/errors_test.c
+++ b/src/core/errors_test.c
@@ -10,35 +10,31 @@
 #include <errno.h>
 #include <string.h>
 
-#include <nng/nng.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_known_errors(void)
 {
-
-	TEST_STREQUAL(nng_strerror(NNG_ECLOSED), "Object closed");
-	TEST_STREQUAL(nng_strerror(NNG_ETIMEDOUT), "Timed out");
+	NUTS_MATCH(nng_strerror(NNG_ECLOSED), "Object closed");
+	NUTS_MATCH(nng_strerror(NNG_ETIMEDOUT), "Timed out");
 }
 
 static void
 test_unknown_errors(void)
 {
 	for (unsigned i = 1; i < 0x1000000; i = i * 2 + 100) {
-		TEST_CHECK(nng_strerror(i) != NULL);
+		NUTS_TRUE(nng_strerror(i) != NULL);
 	}
 }
 
 static void
 test_system_errors(void)
 {
-	TEST_STREQUAL(nng_strerror(NNG_ESYSERR + ENOENT), strerror(ENOENT));
-	TEST_STREQUAL(nng_strerror(NNG_ESYSERR + EINVAL), strerror(EINVAL));
+	NUTS_MATCH(nng_strerror(NNG_ESYSERR + ENOENT), strerror(ENOENT));
+	NUTS_MATCH(nng_strerror(NNG_ESYSERR + EINVAL), strerror(EINVAL));
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "known errors", test_known_errors },
 	{ "unknown errors", test_unknown_errors },
 	{ "system errors", test_system_errors },
diff --git a/src/core/id_test.c b/src/core/id_test.c
index 8312b5cc..51872e69 100644
--- a/src/core/id_test.c
+++ b/src/core/id_test.c
@@ -7,8 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include "acutest.h"
-#include "testutil.h"
+#include <nuts.h>
 
 #include "idhash.h"
 
@@ -22,16 +21,16 @@ test_basic(void)
 	nni_id_map_init(&m, 0, 0, false);
 
 	// insert it
-	TEST_NNG_PASS(nni_id_set(&m, 5, five));
+	NUTS_PASS(nni_id_set(&m, 5, five));
 	// retrieve it
-	TEST_CHECK(nni_id_get(&m, 5) == five);
+	NUTS_TRUE(nni_id_get(&m, 5) == five);
 
 	// change it
-	TEST_NNG_PASS(nni_id_set(&m, 5, four));
-	TEST_CHECK(nni_id_get(&m, 5) == four);
+	NUTS_PASS(nni_id_set(&m, 5, four));
+	NUTS_TRUE(nni_id_get(&m, 5) == four);
 
 	// delete
-	TEST_NNG_PASS(nni_id_remove(&m, 5));
+	NUTS_PASS(nni_id_remove(&m, 5));
 
 	nni_id_map_fini(&m);
 }
@@ -44,17 +43,17 @@ test_random(void)
 	for (i = 0; i < 2; i++) {
 		nni_id_map m;
 		nni_id_map_init(&m, 0, 0, true);
-		TEST_NNG_PASS(nni_id_alloc(&m, &id, &id));
+		NUTS_PASS(nni_id_alloc(&m, &id, &id));
 		nni_id_map_fini(&m);
-		TEST_CHECK(id != 0);
+		NUTS_TRUE(id != 0);
 		if (id != 1) {
 			break;
 		}
 		// one chance in 4 billion, but try again
 	}
 
-	TEST_CHECK(id != 1);
-	TEST_CHECK(i < 2);
+	NUTS_TRUE(id != 1);
+	NUTS_TRUE(i < 2);
 }
 
 void
@@ -67,14 +66,14 @@ test_collision(void)
 	nni_id_map_init(&m, 0, 0, false);
 
 	// Carefully crafted -- 13 % 8 == 5.
-	TEST_NNG_PASS(nni_id_set(&m, 5, five));
-	TEST_NNG_PASS(nni_id_set(&m, 13, four));
-	TEST_CHECK(nni_id_get(&m, 5) == five);
-	TEST_CHECK(nni_id_get(&m, 13) == four);
+	NUTS_PASS(nni_id_set(&m, 5, five));
+	NUTS_PASS(nni_id_set(&m, 13, four));
+	NUTS_TRUE(nni_id_get(&m, 5) == five);
+	NUTS_TRUE(nni_id_get(&m, 13) == four);
 
 	// Delete the intermediate
-	TEST_NNG_PASS(nni_id_remove(&m, 5));
-	TEST_CHECK(nni_id_get(&m, 13) == four);
+	NUTS_PASS(nni_id_remove(&m, 5));
+	NUTS_TRUE(nni_id_get(&m, 13) == four);
 
 	nni_id_map_fini(&m);
 }
@@ -85,9 +84,9 @@ test_empty(void)
 	nni_id_map m;
 	nni_id_map_init(&m, 0, 0, false);
 
-	TEST_CHECK(nni_id_get(&m, 42) == NULL);
-	TEST_NNG_FAIL(nni_id_remove(&m, 42), NNG_ENOENT);
-	TEST_NNG_FAIL(nni_id_remove(&m, 1), NNG_ENOENT);
+	NUTS_TRUE(nni_id_get(&m, 42) == NULL);
+	NUTS_FAIL(nni_id_remove(&m, 42), NNG_ENOENT);
+	NUTS_FAIL(nni_id_remove(&m, 1), NNG_ENOENT);
 	nni_id_map_fini(&m);
 }
 
@@ -98,10 +97,10 @@ test_not_found(void)
 	uint32_t   id;
 	nni_id_map_init(&m, 0, 0, false);
 
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &id));
-	TEST_NNG_FAIL(nni_id_remove(&m, 42), NNG_ENOENT);
-	TEST_NNG_FAIL(nni_id_remove(&m, 2), NNG_ENOENT);
-	TEST_NNG_PASS(nni_id_remove(&m, id));
+	NUTS_PASS(nni_id_alloc(&m, &id, &id));
+	NUTS_FAIL(nni_id_remove(&m, 42), NNG_ENOENT);
+	NUTS_FAIL(nni_id_remove(&m, 2), NNG_ENOENT);
+	NUTS_PASS(nni_id_remove(&m, id));
 	nni_id_map_fini(&m);
 }
 
@@ -121,13 +120,13 @@ test_resize(void)
 
 	for (i = 0; i < 1024; i++) {
 		if ((rv = nni_id_set(&m, i, &expect[i])) != 0) {
-			TEST_NNG_PASS(rv);
+			NUTS_PASS(rv);
 		}
 	}
 
 	for (i = 0; i < 1024; i++) {
 		if ((rv = nni_id_remove(&m, i)) != 0) {
-			TEST_NNG_PASS(rv);
+			NUTS_PASS(rv);
 		}
 	}
 	nni_id_map_fini(&m);
@@ -143,24 +142,24 @@ test_dynamic(void)
 	nni_id_map_init(&m, 10, 13, false);
 
         // We can fill the table.
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &expect[0]));
-	TEST_CHECK(id == 10);
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &expect[1]));
-	TEST_CHECK(id == 11);
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &expect[2]));
-	TEST_CHECK(id == 12);
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &expect[3]));
-	TEST_CHECK(id == 13);
+	NUTS_PASS(nni_id_alloc(&m, &id, &expect[0]));
+	NUTS_TRUE(id == 10);
+	NUTS_PASS(nni_id_alloc(&m, &id, &expect[1]));
+	NUTS_TRUE(id == 11);
+	NUTS_PASS(nni_id_alloc(&m, &id, &expect[2]));
+	NUTS_TRUE(id == 12);
+	NUTS_PASS(nni_id_alloc(&m, &id, &expect[3]));
+	NUTS_TRUE(id == 13);
 
 	// Adding another fails.
-	TEST_NNG_FAIL(nni_id_alloc(&m, &id, &expect[4]), NNG_ENOMEM);
+	NUTS_FAIL(nni_id_alloc(&m, &id, &expect[4]), NNG_ENOMEM);
 
 	// Delete one.
-	TEST_NNG_PASS(nni_id_remove(&m, 11));
+	NUTS_PASS(nni_id_remove(&m, 11));
 
 	// And now we can allocate one.
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &expect[4]));
-	TEST_CHECK(id == 11);
+	NUTS_PASS(nni_id_alloc(&m, &id, &expect[4]));
+	NUTS_TRUE(id == 11);
 	nni_id_map_fini(&m);
 }
 
@@ -174,10 +173,10 @@ test_set_out_of_range(void)
 	nni_id_map_init(&m, 10, 13, false);
 
 	// We can insert outside the range forcibly.
-	TEST_NNG_PASS(nni_id_set(&m, 1, &x));
-	TEST_NNG_PASS(nni_id_set(&m, 100, &x));
-	TEST_NNG_PASS(nni_id_alloc(&m, &id, &x));
-	TEST_CHECK(id == 10);
+	NUTS_PASS(nni_id_set(&m, 1, &x));
+	NUTS_PASS(nni_id_set(&m, 100, &x));
+	NUTS_PASS(nni_id_alloc(&m, &id, &x));
+	NUTS_TRUE(id == 10);
 	nni_id_map_fini(&m);
 }
 
@@ -207,7 +206,7 @@ test_stress(void)
 			x         = &values[rand() % NUM_VALUES];
 			values[v] = x;
 			if ((rv = nni_id_set(&m, v, x)) != 0) {
-				TEST_NNG_PASS(rv);
+				NUTS_PASS(rv);
 				goto out;
 			}
 			break;
@@ -216,13 +215,13 @@ test_stress(void)
 			rv = nni_id_remove(&m, v);
 			if (values[v] == NULL) {
 				if (rv != NNG_ENOENT) {
-					TEST_NNG_FAIL(rv, NNG_ENOENT);
+					NUTS_FAIL(rv, NNG_ENOENT);
 					goto out;
 				}
 			} else {
 				values[v] = NULL;
 				if (rv != 0) {
-					TEST_NNG_PASS(rv);
+					NUTS_PASS(rv);
 					goto out;
 				}
 			}
@@ -230,20 +229,20 @@ test_stress(void)
 		case 2:
 			x = nni_id_get(&m, v);
 			if (x != values[v]) {
-				TEST_CHECK(x == values[v]);
+				NUTS_TRUE(x == values[v]);
 				goto out;
 			}
 			break;
 		}
 	}
 out:
-	TEST_CHECK(i == STRESS_LOAD);
+	NUTS_TRUE(i == STRESS_LOAD);
 
 	// Post stress check.
 	for (i = 0; i < NUM_VALUES; i++) {
 		x = nni_id_get(&m, i);
 		if (x != values[i]) {
-			TEST_CHECK(x == values[i]);
+			NUTS_TRUE(x == values[i]);
 			break;
 		}
 
@@ -251,17 +250,17 @@ out:
 		// to fail.  Otherwise there will be too many errors reported.
 		rv = nni_id_remove(&m, i);
 		if ((x == NULL) && (rv != NNG_ENOENT)) {
-			TEST_NNG_FAIL(rv, NNG_ENOENT);
+			NUTS_FAIL(rv, NNG_ENOENT);
 		} else if ((x != NULL) && (rv != 0)) {
-			TEST_NNG_PASS(rv);
+			NUTS_PASS(rv);
 		}
 	}
-	TEST_CHECK(i == NUM_VALUES);
+	NUTS_TRUE(i == NUM_VALUES);
 
 	nni_id_map_fini(&m);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "basic", test_basic },
 	{ "random", test_random },
 	{ "collision", test_collision },
diff --git a/src/core/reconnect_test.c b/src/core/reconnect_test.c
index 669261c9..308a3f78 100644
--- a/src/core/reconnect_test.c
+++ b/src/core/reconnect_test.c
@@ -10,101 +10,95 @@
 
 #include <string.h>
 
-#include <nng/nng.h>
-#include <nng/protocol/pipeline0/pull.h>
-#include <nng/protocol/pipeline0/push.h>
-#include <nng/supplemental/util/platform.h>
-
-#include "acutest.h"
-#include "testutil.h"
+#include <nuts.h>
 
 void
 test_dial_before_listen(void)
 {
-	nng_socket push;
-	nng_socket pull;
-	char       addr[64];
+	nng_socket s1;
+	nng_socket s2;
+	char       *addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_push0_open(&push));
-	TEST_NNG_PASS(nng_pull0_open(&pull));
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10));
-	TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMAXT, 10));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECONNMINT, 10));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECONNMAXT, 10));
 
-	TEST_NNG_PASS(nng_dial(pull, addr, NULL, NNG_FLAG_NONBLOCK));
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_listen(push, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 
-	TEST_NNG_SEND_STR(push, "hello");
-	TEST_NNG_RECV_STR(pull, "hello");
+	NUTS_SEND(s1, "hello");
+	NUTS_RECV(s2, "hello");
 
-	TEST_NNG_PASS(nng_close(push));
-	TEST_NNG_PASS(nng_close(pull));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
 test_reconnect(void)
 {
-	nng_socket   push;
-	nng_socket   pull;
+	nng_socket   s1;
+	nng_socket   s2;
 	nng_listener l;
-	char         addr[64];
+	char         *addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_push0_open(&push));
-	TEST_NNG_PASS(nng_pull0_open(&pull));
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10));
-	TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMAXT, 10));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECONNMINT, 10));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECONNMAXT, 10));
 
-	TEST_NNG_PASS(nng_dial(pull, addr, NULL, NNG_FLAG_NONBLOCK));
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_listen(push, addr, &l, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_listen(s1, addr, &l, 0));
 
-	TEST_NNG_SEND_STR(push, "hello");
-	TEST_NNG_RECV_STR(pull, "hello");
+	NUTS_SEND(s1, "hello");
+	NUTS_RECV(s2, "hello");
 
 	// Close the listener
-	TEST_NNG_PASS(nng_listener_close(l));
+	NUTS_PASS(nng_listener_close(l));
 
-	TEST_NNG_PASS(nng_listen(push, addr, &l, 0));
-	TEST_NNG_SEND_STR(push, "again");
-	TEST_NNG_RECV_STR(pull, "again");
+	NUTS_PASS(nng_listen(s1, addr, &l, 0));
+	NUTS_SEND(s1, "again");
+	NUTS_RECV(s2, "again");
 
-	TEST_NNG_PASS(nng_close(push));
-	TEST_NNG_PASS(nng_close(pull));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
 test_reconnect_pipe(void)
 {
-	nng_socket   push;
-	nng_socket   pull;
+	nng_socket   s1;
+	nng_socket   s2;
 	nng_listener l;
 	nng_msg *    msg;
-	char         addr[64];
+	char *       addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_push0_open(&push));
-	TEST_NNG_PASS(nng_pull0_open(&pull));
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10));
-	TEST_NNG_PASS(nng_socket_set_ms(pull, 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(pull, addr, NULL, NNG_FLAG_NONBLOCK));
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_listen(push, addr, &l, 0));
+	NUTS_PASS(nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_listen(s2, addr, &l, 0));
 
-	TEST_NNG_SEND_STR(push, "hello");
+	NUTS_SEND(s2, "hello");
 
-	TEST_NNG_PASS(nng_recvmsg(pull, &msg, 0));
-	TEST_CHECK(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 6);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "hello") == 0);
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_TRUE(msg != NULL);
+	NUTS_TRUE(nng_msg_len(msg) == 6);
+	NUTS_MATCH(nng_msg_body(msg), "hello");
 	nng_pipe_close(nng_msg_get_pipe(msg));
 	nng_msg_free(msg);
 
@@ -112,53 +106,54 @@ test_reconnect_pipe(void)
 	// receiver, the receiver might not have got the update.  If we
 	// send too soon, then the message gets routed to the sender pipe
 	// that is about to close.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
-	// Reconnect should happen more ore less immediately.
-	TEST_NNG_SEND_STR(push, "again");
-	TEST_NNG_RECV_STR(pull, "again");
+	// Reconnect should happen more or less immediately.
+	NUTS_SEND(s2, "again");
+	NUTS_RECV(s1, "again");
 
-	TEST_NNG_PASS(nng_close(push));
-	TEST_NNG_PASS(nng_close(pull));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
 test_reconnect_back_off_zero(void)
 {
-	nng_socket push;
-	nng_socket pull;
-	nng_time   start;
-	char       addr[64];
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	nng_socket s1;
+	nng_socket s2;
+	uint64_t   start;
+	char *     addr;
+
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_push0_open(&push));
-	TEST_NNG_PASS(nng_pull0_open(&pull));
+	NUTS_ADDR(addr, "inproc");
 
 	// redial every 10 ms.
-	TEST_NNG_PASS(nng_socket_set_ms(push, NNG_OPT_RECONNMAXT, 0));
-	TEST_NNG_PASS(nng_socket_set_ms(push, NNG_OPT_RECONNMINT, 10));
-	TEST_NNG_PASS(nng_dial(push, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMAXT, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMINT, 10));
+	NUTS_PASS(nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK));
 
 	// Start up the dialer first.  It should keep retrying every 10 ms.
 
 	// Wait 500 milliseconds. This gives a chance for an exponential
 	// back-off to increase to a longer time.  It should by this point
 	// be well over 100 and probably closer to 200 ms.
-	nng_msleep(500);
+	NUTS_SLEEP(500);
 
-	start = nng_clock();
-	TEST_NNG_PASS(nng_listen(pull, addr, NULL, 0));
+	NUTS_CLOCK(start);
+	NUTS_PASS(nng_listen(s2, addr, NULL, 0));
 
-	TEST_NNG_SEND_STR(push, "hello");
-	TEST_NNG_RECV_STR(pull, "hello");
+	NUTS_SEND(s1, "hello");
+	NUTS_RECV(s2, "hello");
 
-	TEST_CHECK(nng_clock() - start < 100);
+	NUTS_BEFORE(start + 100);
 
-	TEST_NNG_PASS(nng_close(push));
-	TEST_NNG_PASS(nng_close(pull));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "dial before listen", test_dial_before_listen },
 	{ "reconnect", test_reconnect },
 	{ "reconnect back-off zero", test_reconnect_back_off_zero },
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 },
diff --git a/src/core/stats.c b/src/core/stats.c
index 85e7d030..e4765078 100644
--- a/src/core/stats.c
+++ b/src/core/stats.c
@@ -79,8 +79,8 @@ stat_unregister(nni_stat_item *item)
 	}
 	if ((item->si_info->si_alloc) &&
 	    (item->si_info->si_type == NNG_STAT_STRING)) {
-		nni_strfree(item->si_value.sv_string);
-		item->si_value.sv_string = NULL;
+		nni_strfree(item->si_u.sv_string);
+		item->si_u.sv_string = NULL;
 	}
 	nni_list_node_remove(&item->si_node);
 }
@@ -116,9 +116,9 @@ nni_stat_inc(nni_stat_item *item, uint64_t inc)
 {
 #ifdef NNG_ENABLE_STATS
 	if (item->si_info->si_atomic) {
-		nni_atomic_add64(&item->si_value.sv_atomic, inc);
+		nni_atomic_add64(&item->si_u.sv_atomic, inc);
 	} else {
-		item->si_value.sv_number += inc;
+		item->si_u.sv_number += inc;
 	}
 #else
 	NNI_ARG_UNUSED(item);
@@ -132,9 +132,9 @@ nni_stat_dec(nni_stat_item *item, uint64_t inc)
 #ifdef NNG_ENABLE_STATS
 
 	if (item->si_info->si_atomic) {
-		nni_atomic_sub64(&item->si_value.sv_atomic, inc);
+		nni_atomic_sub64(&item->si_u.sv_atomic, inc);
 	} else {
-		item->si_value.sv_number -= inc;
+		item->si_u.sv_number -= inc;
 	}
 #else
 	NNI_ARG_UNUSED(item);
@@ -147,7 +147,7 @@ nni_stat_set_id(nni_stat_item *item, int id)
 {
 #ifdef NNG_ENABLE_STATS
 	// IDs don't change, so just set it.
-	item->si_value.sv_id = id;
+	item->si_u.sv_id = id;
 #else
 	NNI_ARG_UNUSED(item);
 	NNI_ARG_UNUSED(id);
@@ -159,7 +159,7 @@ nni_stat_set_bool(nni_stat_item *item, bool b)
 {
 #ifdef NNG_ENABLE_STATS
 	// bool is atomic by definitions.
-	item->si_value.sv_bool = b;
+	item->si_u.sv_bool = b;
 #else
 	NNI_ARG_UNUSED(item);
 	NNI_ARG_UNUSED(b);
@@ -171,7 +171,7 @@ nni_stat_set_string(nni_stat_item *item, const char *s)
 {
 #ifdef NNG_ENABLE_STATS
 	const nni_stat_info *info = item->si_info;
-	char *               old  = item->si_value.sv_string;
+	char *               old  = item->si_u.sv_string;
 
 	nni_mtx_lock(&stats_val_lock);
 	if ((s != NULL) && (old != NULL) && (strcmp(s, old) == 0)) {
@@ -182,12 +182,12 @@ nni_stat_set_string(nni_stat_item *item, const char *s)
 
 	if (!info->si_alloc) {
 		// no allocation, just set it.
-		item->si_value.sv_string = (char *) s;
+		item->si_u.sv_string = (char *) s;
 		nni_mtx_unlock(&stats_val_lock);
 		return;
 	}
 
-	item->si_value.sv_string = nni_strdup(s);
+	item->si_u.sv_string = nni_strdup(s);
 	nni_mtx_unlock(&stats_val_lock);
 
 	nni_strfree(old);
@@ -202,9 +202,9 @@ nni_stat_set_value(nni_stat_item *item, uint64_t v)
 {
 #ifdef NNG_ENABLE_STATS
 	if (item->si_info->si_atomic) {
-		nni_atomic_set64(&item->si_value.sv_atomic, v);
+		nni_atomic_set64(&item->si_u.sv_atomic, v);
 	} else {
-		item->si_value.sv_number = v;
+		item->si_u.sv_number = v;
 	}
 #else
 	NNI_ARG_UNUSED(item);
@@ -272,24 +272,24 @@ stat_update(nni_stat *stat)
 	switch (info->si_type) {
 	case NNG_STAT_SCOPE:
 	case NNG_STAT_ID:
-		stat->s_val.sv_id = item->si_value.sv_id;
+		stat->s_val.sv_id = item->si_u.sv_id;
 		break;
 	case NNG_STAT_BOOLEAN:
-		stat->s_val.sv_bool = item->si_value.sv_bool;
+		stat->s_val.sv_bool = item->si_u.sv_bool;
 		break;
 	case NNG_STAT_COUNTER:
 	case NNG_STAT_LEVEL:
 		if (info->si_atomic) {
 			stat->s_val.sv_value = nni_atomic_get64(
-			    (nni_atomic_u64 *) &item->si_value.sv_atomic);
+			    (nni_atomic_u64 *) &item->si_u.sv_atomic);
 		} else {
-			stat->s_val.sv_value = item->si_value.sv_number;
+			stat->s_val.sv_value = item->si_u.sv_number;
 		}
 		break;
 	case NNG_STAT_STRING:
 		nni_mtx_lock(&stats_val_lock);
 		old = stat->s_val.sv_string;
-		str = item->si_value.sv_string;
+		str = item->si_u.sv_string;
 
 		// If we have to allocate a new string, do so.  But
 		// only do it if new string is different.
diff --git a/src/core/stats.h b/src/core/stats.h
index 950df78f..de1879ca 100644
--- a/src/core/stats.h
+++ b/src/core/stats.h
@@ -14,7 +14,7 @@
 #include "core/defs.h"
 
 // Statistics support.  This is inspired in part by the Solaris
-// kstats framework, but we've simplified and tuned it for our use.
+// kernel stats framework, but we've simplified and tuned it for our use.
 //
 // Collection of the stats will be done in two steps.  First we
 // will walk the list of stats, with the chain held, allocating
@@ -45,7 +45,7 @@ struct nni_stat_item {
 		char *         sv_string;
 		bool           sv_bool;
 		int            sv_id;
-	} si_value;
+	} si_u;
 };
 
 struct nni_stat_info {
diff --git a/src/core/url_test.c b/src/core/url_test.c
index 847b7df3..6504ff6c 100644
--- a/src/core/url_test.c
+++ b/src/core/url_test.c
@@ -1,5 +1,5 @@
 //
-// Copyright 2018 Staysail Systems, Inc. <info@staysail.tech>
+// 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
@@ -8,33 +8,26 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-
-#include "acutest.h"
-
+#include "nng_impl.h"
+#include <nuts.h>
 #include <string.h>
 
-#include <nng/nng.h>
-
-#include "core/url.h"
-
-#include "testutil.h"
-
 void
 test_url_host(void)
 {
 	nng_url *url;
 
-	TEST_NNG_PASS(nng_url_parse(&url, "http://www.google.com"));
-	TEST_ASSERT(url != NULL);
-	TEST_CHECK(strcmp(url->u_scheme, "http") == 0);
-	TEST_CHECK(strcmp(url->u_host, "www.google.com") == 0);
-	TEST_CHECK(strcmp(url->u_hostname, "www.google.com") == 0);
-	TEST_CHECK(strcmp(url->u_port, "80") == 0);
-	TEST_CHECK(strcmp(url->u_path, "") == 0);
-	TEST_CHECK(strcmp(url->u_requri, "") == 0);
-	TEST_CHECK(url->u_query == NULL);
-	TEST_CHECK(url->u_fragment == NULL);
-	TEST_CHECK(url->u_userinfo == NULL);
+	NUTS_PASS(nng_url_parse(&url, "http://www.google.com"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_TRUE(strcmp(url->u_scheme, "http") == 0);
+	NUTS_TRUE(strcmp(url->u_host, "www.google.com") == 0);
+	NUTS_TRUE(strcmp(url->u_hostname, "www.google.com") == 0);
+	NUTS_TRUE(strcmp(url->u_port, "80") == 0);
+	NUTS_TRUE(strcmp(url->u_path, "") == 0);
+	NUTS_TRUE(strcmp(url->u_requri, "") == 0);
+	NUTS_TRUE(url->u_query == NULL);
+	NUTS_TRUE(url->u_fragment == NULL);
+	NUTS_TRUE(url->u_userinfo == NULL);
 	nng_url_free(url);
 }
 
@@ -42,17 +35,17 @@ void
 test_url_host_port(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://www.google.com:1234"));
-	TEST_ASSERT(url != NULL);
-	TEST_CHECK(strcmp(url->u_scheme, "http") == 0);
-	TEST_CHECK(strcmp(url->u_host, "www.google.com:1234") == 0);
-	TEST_CHECK(strcmp(url->u_hostname, "www.google.com") == 0);
-	TEST_CHECK(strcmp(url->u_port, "1234") == 0);
-	TEST_CHECK(strcmp(url->u_path, "") == 0);
-	TEST_CHECK(strcmp(url->u_requri, "") == 0);
-	TEST_CHECK(url->u_query == NULL);
-	TEST_CHECK(url->u_fragment == NULL);
-	TEST_CHECK(url->u_userinfo == NULL);
+	NUTS_PASS(nng_url_parse(&url, "http://www.google.com:1234"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_TRUE(strcmp(url->u_scheme, "http") == 0);
+	NUTS_TRUE(strcmp(url->u_host, "www.google.com:1234") == 0);
+	NUTS_TRUE(strcmp(url->u_hostname, "www.google.com") == 0);
+	NUTS_TRUE(strcmp(url->u_port, "1234") == 0);
+	NUTS_TRUE(strcmp(url->u_path, "") == 0);
+	NUTS_TRUE(strcmp(url->u_requri, "") == 0);
+	NUTS_TRUE(url->u_query == NULL);
+	NUTS_TRUE(url->u_fragment == NULL);
+	NUTS_TRUE(url->u_userinfo == NULL);
 	nng_url_free(url);
 }
 
@@ -61,18 +54,18 @@ test_url_host_port_path(void)
 {
 	nng_url *url;
 
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_url_parse(&url, "http://www.google.com:1234/somewhere"));
-	TEST_ASSERT(url != NULL);
-	TEST_CHECK(strcmp(url->u_scheme, "http") == 0);
-	TEST_CHECK(strcmp(url->u_host, "www.google.com:1234") == 0);
-	TEST_CHECK(strcmp(url->u_hostname, "www.google.com") == 0);
-	TEST_CHECK(strcmp(url->u_port, "1234") == 0);
-	TEST_CHECK(strcmp(url->u_path, "/somewhere") == 0);
-	TEST_CHECK(strcmp(url->u_requri, "/somewhere") == 0);
-	TEST_CHECK(url->u_userinfo == NULL);
-	TEST_CHECK(url->u_query == NULL);
-	TEST_CHECK(url->u_fragment == NULL);
+	NUTS_ASSERT(url != NULL);
+	NUTS_TRUE(strcmp(url->u_scheme, "http") == 0);
+	NUTS_TRUE(strcmp(url->u_host, "www.google.com:1234") == 0);
+	NUTS_TRUE(strcmp(url->u_hostname, "www.google.com") == 0);
+	NUTS_TRUE(strcmp(url->u_port, "1234") == 0);
+	NUTS_TRUE(strcmp(url->u_path, "/somewhere") == 0);
+	NUTS_TRUE(strcmp(url->u_requri, "/somewhere") == 0);
+	NUTS_TRUE(url->u_userinfo == NULL);
+	NUTS_TRUE(url->u_query == NULL);
+	NUTS_TRUE(url->u_fragment == NULL);
 	nng_url_free(url);
 }
 
@@ -80,18 +73,18 @@ void
 test_url_user_info(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(
+	NUTS_PASS(nng_url_parse(
 	    &url, "http://garrett@www.google.com:1234/somewhere"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_userinfo, "garrett");
-	TEST_STREQUAL(url->u_host, "www.google.com:1234");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_port, "1234");
-	TEST_STREQUAL(url->u_path, "/somewhere");
-	TEST_STREQUAL(url->u_requri, "/somewhere");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_userinfo, "garrett");
+	NUTS_MATCH(url->u_host, "www.google.com:1234");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_port, "1234");
+	NUTS_MATCH(url->u_path, "/somewhere");
+	NUTS_MATCH(url->u_requri, "/somewhere");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
 	nng_url_free(url);
 }
 
@@ -99,18 +92,18 @@ void
 test_url_path_query_param(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_url_parse(&url, "http://www.google.com/somewhere?result=yes"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "www.google.com");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/somewhere");
-	TEST_STREQUAL(url->u_query, "result=yes");
-	TEST_STREQUAL(url->u_requri, "/somewhere?result=yes");
-	TEST_NULL(url->u_userinfo);
-	TEST_NULL(url->u_fragment);
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "www.google.com");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/somewhere");
+	NUTS_MATCH(url->u_query, "result=yes");
+	NUTS_MATCH(url->u_requri, "/somewhere?result=yes");
+	NUTS_NULL(url->u_userinfo);
+	NUTS_NULL(url->u_fragment);
 	nng_url_free(url);
 }
 
@@ -118,19 +111,19 @@ void
 test_url_query_param_anchor(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url,
+	NUTS_PASS(nng_url_parse(&url,
 	    "http://www.google.com/"
 	    "somewhere?result=yes#chapter1"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "www.google.com");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/somewhere");
-	TEST_STREQUAL(url->u_query, "result=yes");
-	TEST_STREQUAL(url->u_fragment, "chapter1");
-	TEST_STREQUAL(url->u_requri, "/somewhere?result=yes#chapter1");
-	TEST_NULL(url->u_userinfo);
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "www.google.com");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/somewhere");
+	NUTS_MATCH(url->u_query, "result=yes");
+	NUTS_MATCH(url->u_fragment, "chapter1");
+	NUTS_MATCH(url->u_requri, "/somewhere?result=yes#chapter1");
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -138,18 +131,18 @@ void
 test_url_path_anchor(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_url_parse(&url, "http://www.google.com/somewhere#chapter2"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "www.google.com");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/somewhere");
-	TEST_STREQUAL(url->u_fragment, "chapter2");
-	TEST_STREQUAL(url->u_requri, "/somewhere#chapter2");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_userinfo);
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "www.google.com");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/somewhere");
+	NUTS_MATCH(url->u_fragment, "chapter2");
+	NUTS_MATCH(url->u_requri, "/somewhere#chapter2");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -157,17 +150,17 @@ void
 test_url_anchor(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://www.google.com#chapter3"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "www.google.com");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_fragment, "chapter3");
-	TEST_STREQUAL(url->u_requri, "#chapter3");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "http://www.google.com#chapter3"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "www.google.com");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_fragment, "chapter3");
+	NUTS_MATCH(url->u_requri, "#chapter3");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -175,17 +168,17 @@ void
 test_url_query_param(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://www.google.com?color=red"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "www.google.com");
-	TEST_STREQUAL(url->u_hostname, "www.google.com");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_query, "color=red");
-	TEST_STREQUAL(url->u_requri, "?color=red");
-	TEST_ASSERT(url != NULL);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "http://www.google.com?color=red"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "www.google.com");
+	NUTS_MATCH(url->u_hostname, "www.google.com");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_query, "color=red");
+	NUTS_MATCH(url->u_requri, "?color=red");
+	NUTS_ASSERT(url != NULL);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -193,16 +186,16 @@ void
 test_url_v6_host(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://[::1]"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "[::1]");
-	TEST_STREQUAL(url->u_hostname, "::1");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "http://[::1]"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "[::1]");
+	NUTS_MATCH(url->u_hostname, "::1");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -210,16 +203,16 @@ void
 test_url_v6_host_port(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://[::1]:29"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "[::1]:29");
-	TEST_STREQUAL(url->u_hostname, "::1");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "29");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "http://[::1]:29"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "[::1]:29");
+	NUTS_MATCH(url->u_hostname, "::1");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "29");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -227,16 +220,16 @@ void
 test_url_v6_host_port_path(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://[::1]:29/bottles"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_host, "[::1]:29");
-	TEST_STREQUAL(url->u_hostname, "::1");
-	TEST_STREQUAL(url->u_path, "/bottles");
-	TEST_STREQUAL(url->u_port, "29");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "http://[::1]:29/bottles"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_host, "[::1]:29");
+	NUTS_MATCH(url->u_hostname, "::1");
+	NUTS_MATCH(url->u_path, "/bottles");
+	NUTS_MATCH(url->u_port, "29");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -244,16 +237,16 @@ void
 test_url_tcp_port(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "tcp://:9876/"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "tcp");
-	TEST_STREQUAL(url->u_host, ":9876");
-	TEST_STREQUAL(url->u_hostname, "");
-	TEST_STREQUAL(url->u_path, "/");
-	TEST_STREQUAL(url->u_port, "9876");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "tcp://:9876/"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "tcp");
+	NUTS_MATCH(url->u_host, ":9876");
+	NUTS_MATCH(url->u_hostname, "");
+	NUTS_MATCH(url->u_path, "/");
+	NUTS_MATCH(url->u_port, "9876");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -262,16 +255,16 @@ test_url_bare_ws(void)
 {
 	nng_url *url;
 
-	TEST_NNG_PASS(nng_url_parse(&url, "ws://"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "ws");
-	TEST_STREQUAL(url->u_host, "");
-	TEST_STREQUAL(url->u_hostname, "");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "ws://"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "ws");
+	NUTS_MATCH(url->u_host, "");
+	NUTS_MATCH(url->u_hostname, "");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -279,16 +272,16 @@ void
 test_url_ws_wildcard(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "ws://*:12345/foobar"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "ws");
-	TEST_STREQUAL(url->u_host, ":12345");
-	TEST_STREQUAL(url->u_hostname, "");
-	TEST_STREQUAL(url->u_path, "/foobar");
-	TEST_STREQUAL(url->u_port, "12345");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_NULL(url->u_userinfo);
+	NUTS_PASS(nng_url_parse(&url, "ws://*:12345/foobar"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "ws");
+	NUTS_MATCH(url->u_host, ":12345");
+	NUTS_MATCH(url->u_hostname, "");
+	NUTS_MATCH(url->u_path, "/foobar");
+	NUTS_MATCH(url->u_port, "12345");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_NULL(url->u_userinfo);
 	nng_url_free(url);
 }
 
@@ -296,16 +289,16 @@ void
 test_url_ssh(void)
 {
 	nng_url *url;
-	TEST_NNG_PASS(nng_url_parse(&url, "ssh://user@host.example.com"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "ssh");
-	TEST_STREQUAL(url->u_host, "host.example.com");
-	TEST_STREQUAL(url->u_hostname, "host.example.com");
-	TEST_STREQUAL(url->u_path, "");
-	TEST_STREQUAL(url->u_port, "22");
-	TEST_NULL(url->u_query);
-	TEST_NULL(url->u_fragment);
-	TEST_STREQUAL(url->u_userinfo, "user");
+	NUTS_PASS(nng_url_parse(&url, "ssh://user@host.example.com"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "ssh");
+	NUTS_MATCH(url->u_host, "host.example.com");
+	NUTS_MATCH(url->u_hostname, "host.example.com");
+	NUTS_MATCH(url->u_path, "");
+	NUTS_MATCH(url->u_port, "22");
+	NUTS_NULL(url->u_query);
+	NUTS_NULL(url->u_fragment);
+	NUTS_MATCH(url->u_userinfo, "user");
 	nng_url_free(url);
 }
 
@@ -313,33 +306,33 @@ void
 test_url_bad_scheme(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_FAIL(nng_url_parse(&url, "www.google.com"), NNG_EINVAL);
-	TEST_NULL(url);
-	TEST_NNG_FAIL(nng_url_parse(&url, "http:www.google.com"), NNG_EINVAL);
-	TEST_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "www.google.com"), NNG_EINVAL);
+	NUTS_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "http:www.google.com"), NNG_EINVAL);
+	NUTS_NULL(url);
 }
 
 void
 test_url_bad_ipv6(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_FAIL(nng_url_parse(&url, "http://[::1"), NNG_EINVAL);
-	TEST_NULL(url);
-	TEST_NNG_FAIL(nng_url_parse(&url, "http://[::1]bogus"), NNG_EINVAL);
-	TEST_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "http://[::1"), NNG_EINVAL);
+	NUTS_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "http://[::1]bogus"), NNG_EINVAL);
+	NUTS_NULL(url);
 }
 
 void
 test_url_canonify(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_PASS(nng_url_parse(
+	NUTS_PASS(nng_url_parse(
 	    &url, "hTTp://www.EXAMPLE.com/bogus/.%2e/%7egarrett"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_hostname, "www.example.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/~garrett");
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_hostname, "www.example.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/~garrett");
 	nng_url_free(url);
 }
 
@@ -347,12 +340,12 @@ void
 test_url_path_resolve(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_url_parse(&url, "http://www.x.com//abc/def/./x/..///./../y"));
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_hostname, "www.x.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/abc/y");
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_hostname, "www.x.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/abc/y");
 	nng_url_free(url);
 }
 
@@ -360,14 +353,14 @@ void
 test_url_query_info_pass(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_url_parse(&url, "http://www.x.com/?/abc/def/./x/.././../y"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_hostname, "www.x.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/");
-	TEST_STREQUAL(url->u_query, "/abc/def/./x/.././../y");
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_hostname, "www.x.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/");
+	NUTS_MATCH(url->u_query, "/abc/def/./x/.././../y");
 	nng_url_free(url);
 }
 
@@ -375,22 +368,22 @@ void
 test_url_bad_utf8(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_FAIL(nng_url_parse(&url, "http://x.com/x%80x"), NNG_EINVAL);
-	TEST_NULL(url);
-	TEST_NNG_FAIL(nng_url_parse(&url, "http://x.com/x%c0%81"), NNG_EINVAL);
-	TEST_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "http://x.com/x%80x"), NNG_EINVAL);
+	NUTS_NULL(url);
+	NUTS_FAIL(nng_url_parse(&url, "http://x.com/x%c0%81"), NNG_EINVAL);
+	NUTS_NULL(url);
 }
 
 void
 test_url_good_utf8(void)
 {
 	nng_url *url = NULL;
-	TEST_NNG_PASS(nng_url_parse(&url, "http://www.x.com/%c2%a2_cents"));
-	TEST_ASSERT(url != NULL);
-	TEST_STREQUAL(url->u_scheme, "http");
-	TEST_STREQUAL(url->u_hostname, "www.x.com");
-	TEST_STREQUAL(url->u_port, "80");
-	TEST_STREQUAL(url->u_path, "/\xc2\xa2_cents");
+	NUTS_PASS(nng_url_parse(&url, "http://www.x.com/%c2%a2_cents"));
+	NUTS_ASSERT(url != NULL);
+	NUTS_MATCH(url->u_scheme, "http");
+	NUTS_MATCH(url->u_hostname, "www.x.com");
+	NUTS_MATCH(url->u_port, "80");
+	NUTS_MATCH(url->u_path, "/\xc2\xa2_cents");
 	nng_url_free(url);
 }
 
@@ -402,55 +395,55 @@ test_url_decode(void)
 
 	out[3] = 'x';
 	len    = nni_url_decode(out, "abc", 3);
-	TEST_CHECK(len == 3);
-	TEST_CHECK(memcmp(out, "abc", 3) == 0);
-	TEST_CHECK(out[3] == 'x');
+	NUTS_TRUE(len == 3);
+	NUTS_TRUE(memcmp(out, "abc", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
 	len = nni_url_decode(out, "x%00y", 3); // embedded NULL
-	TEST_CHECK(len == 3);
-	TEST_CHECK(memcmp(out, "x\x00y", 3) == 0);
-	TEST_CHECK(out[3] == 'x');
+	NUTS_TRUE(len == 3);
+	NUTS_TRUE(memcmp(out, "x\x00y", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
 	len = nni_url_decode(out, "%3987", 3);
-	TEST_CHECK(len == 3);
-	TEST_CHECK(memcmp(out, "987", 3) == 0);
-	TEST_CHECK(out[3] == 'x');
+	NUTS_TRUE(len == 3);
+	NUTS_TRUE(memcmp(out, "987", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
 	len = nni_url_decode(out, "78%39", 3);
-	TEST_CHECK(len == 3);
-	TEST_CHECK(memcmp(out, "789", 3) == 0);
-	TEST_CHECK(out[3] == 'x');
+	NUTS_TRUE(len == 3);
+	NUTS_TRUE(memcmp(out, "789", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
-        len = nni_url_decode(out, "", 5);
-        TEST_CHECK(len == 0);
-        TEST_CHECK(memcmp(out, "789", 3) == 0);
-        TEST_CHECK(out[3] == 'x');
+	len = nni_url_decode(out, "", 5);
+	NUTS_TRUE(len == 0);
+	NUTS_TRUE(memcmp(out, "789", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
-        len = nni_url_decode(out, "be", 2);
-        TEST_CHECK(len == 2);
-        TEST_CHECK(memcmp(out, "be9", 3) == 0);
-        TEST_CHECK(out[3] == 'x');
+	len = nni_url_decode(out, "be", 2);
+	NUTS_TRUE(len == 2);
+	NUTS_TRUE(memcmp(out, "be9", 3) == 0);
+	NUTS_TRUE(out[3] == 'x');
 
-        len = nni_url_decode(out, "78%39", 2);
-	TEST_CHECK(len == (size_t) -1);
+	len = nni_url_decode(out, "78%39", 2);
+	NUTS_TRUE(len == (size_t) -1);
 
-        len = nni_url_decode(out, "", 2);
-        TEST_CHECK(len == 0);
+	len = nni_url_decode(out, "", 2);
+	NUTS_TRUE(len == 0);
 
-        len = nni_url_decode(out, "78%", 5);
-        TEST_CHECK(len == (size_t) -1);
+	len = nni_url_decode(out, "78%", 5);
+	NUTS_TRUE(len == (size_t) -1);
 
-        len = nni_url_decode(out, "78%xy", 5);
-        TEST_CHECK(len == (size_t) -1);
+	len = nni_url_decode(out, "78%xy", 5);
+	NUTS_TRUE(len == (size_t) -1);
 
-        len = nni_url_decode(out, "78%1$", 5);
-        TEST_CHECK(len == (size_t) -1);
+	len = nni_url_decode(out, "78%1$", 5);
+	NUTS_TRUE(len == (size_t) -1);
 
-        len = nni_url_decode(out, "%%20", 5);
-        TEST_CHECK(len == (size_t) -1);
+	len = nni_url_decode(out, "%%20", 5);
+	NUTS_TRUE(len == (size_t) -1);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "url host", test_url_host },
 	{ "url host port", test_url_host_port },
 	{ "url host port path", test_url_host_port_path },
diff --git a/src/platform/platform_test.c b/src/platform/platform_test.c
index e7dcabaa..900efe36 100644
--- a/src/platform/platform_test.c
+++ b/src/platform/platform_test.c
@@ -8,17 +8,13 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include "testutil.h"
-
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
-#include "acutest.h"
+#include <nuts.h>
 
 struct add_arg {
-	int      cnt;
-	nng_mtx *mx;
-	nng_cv * cv;
+	int          cnt;
+	nng_duration delay;
+	nng_mtx *    mx;
+	nng_cv *     cv;
 };
 
 void
@@ -26,58 +22,51 @@ add(void *arg)
 {
 	struct add_arg *aa = arg;
 
+	if (aa->delay > 0) {
+		nng_msleep(aa->delay);
+	}
 	nng_mtx_lock(aa->mx);
 	aa->cnt++;
 	nng_cv_wake(aa->cv);
 	nng_mtx_unlock(aa->mx);
 }
 
+#ifdef __has_feature
+#if __has_feature(thread_sanitizer) || __has_feature(memory_sanitizer)
+#define RELAXED_CLOCKS
+#endif
+#endif
+
 void
 test_sleep(void)
 {
-	uint64_t start, end;
-	start = testutil_clock();
+	uint64_t start;
+	NUTS_CLOCK(start);
 	nng_msleep(100);
-	end = testutil_clock();
-	TEST_CHECK((end - start) >= 100);
-#ifdef __has_feature
-#if !__has_feature(thread_sanitizer) && !__has_feature(memory_sanitizer)
-	TEST_CHECK((end - start) <= 500);
-#endif
+	NUTS_AFTER(start + 100);
+#ifndef RELAXED_CLOCKS
+	NUTS_BEFORE(start + 500);
 #endif
 }
 
 void
 test_clock(void)
 {
-	uint64_t mstart;
-	uint64_t msend;
-	nng_time usend;
-	nng_time usnow;
+	uint64_t s0, s1;
+	nng_time t0, t1;
 
-	mstart = testutil_clock();
-	usnow  = nng_clock();
+	NUTS_CLOCK(s0);
+	t0 = nng_clock();
 	nng_msleep(200);
-	usend = nng_clock();
-	msend = testutil_clock();
+	t1 = nng_clock();
+	NUTS_CLOCK(s1);
 
-	TEST_CHECK(usend > usnow);
-	TEST_CHECK(msend > mstart);
+	NUTS_TRUE(t1 > t0);
+	NUTS_TRUE((t1 - t0) >= 200);
+	NUTS_TRUE((t1 - t0) < 500);
 
-#ifdef __has_feature
-#if !__has_feature(thread_sanitizer) && !__has_feature(memory_sanitizer)
-	uint64_t usdelta;
-	uint64_t msdelta;
-	usdelta = usend - usnow;
-	msdelta = msend - mstart;
-	TEST_CHECK(usdelta >= 200);
-	TEST_CHECK(usdelta < 500); // increased tolerance for CIs
-	if (msdelta > usdelta) {
-		TEST_CHECK((msdelta - usdelta) < 50);
-	} else {
-		TEST_CHECK((usdelta - msdelta) < 50);
-	}
-#endif
+#ifndef RELAXED_CLOCKS
+	NUTS_TRUE(abs((int) (s1 - s0) - (int) (t1 - t0)) < 50);
 #endif
 }
 
@@ -86,7 +75,7 @@ test_mutex(void)
 {
 	nng_mtx *mx, *mx2;
 
-	TEST_CHECK(nng_mtx_alloc(&mx) == 0);
+	NUTS_PASS(nng_mtx_alloc(&mx));
 	nng_mtx_lock(mx);
 	nng_mtx_unlock(mx);
 
@@ -95,9 +84,9 @@ test_mutex(void)
 	nng_mtx_free(mx);
 
 	// Verify that the mutexes are not always the same!
-	TEST_CHECK(nng_mtx_alloc(&mx) == 0);
-	TEST_CHECK(nng_mtx_alloc(&mx2) == 0);
-	TEST_CHECK(mx != mx2);
+	NUTS_PASS(nng_mtx_alloc(&mx));
+	NUTS_PASS(nng_mtx_alloc(&mx2));
+	NUTS_TRUE(mx != mx2);
 	nng_mtx_free(mx);
 	nng_mtx_free(mx2);
 }
@@ -106,16 +95,16 @@ void
 test_thread(void)
 {
 	nng_thread *   thr;
-	int            rv;
 	struct add_arg aa;
 
-	TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0);
-	TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0);
-	aa.cnt = 0;
+	NUTS_PASS(nng_mtx_alloc(&aa.mx));
+	NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
+	aa.cnt   = 0;
+	aa.delay = 0;
 
-	TEST_CHECK((rv = nng_thread_create(&thr, add, &aa)) == 0);
+	NUTS_PASS(nng_thread_create(&thr, add, &aa));
 	nng_thread_destroy(thr);
-	TEST_CHECK(aa.cnt == 1);
+	NUTS_TRUE(aa.cnt == 1);
 
 	nng_cv_free(aa.cv);
 	nng_mtx_free(aa.mx);
@@ -124,15 +113,15 @@ test_thread(void)
 void
 test_cond_var(void)
 {
-	nng_thread *  thr;
-	int           rv;
+	nng_thread *   thr;
 	struct add_arg aa;
 
-	TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0);
-	TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0);
-	aa.cnt = 0;
+	NUTS_PASS(nng_mtx_alloc(&aa.mx));
+	NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
+	aa.cnt   = 0;
+	aa.delay = 0;
 
-	TEST_CHECK((rv = nng_thread_create(&thr, add, &aa)) == 0);
+	NUTS_PASS(nng_thread_create(&thr, add, &aa));
 
 	nng_mtx_lock(aa.mx);
 	while (aa.cnt == 0) {
@@ -140,7 +129,64 @@ test_cond_var(void)
 	}
 	nng_mtx_unlock(aa.mx);
 	nng_thread_destroy(thr);
-	TEST_CHECK(aa.cnt == 1);
+	NUTS_TRUE(aa.cnt == 1);
+
+	nng_cv_free(aa.cv);
+	nng_mtx_free(aa.mx);
+}
+
+void
+test_cond_wake(void)
+{
+	nng_thread *   thr;
+	struct add_arg aa;
+	nng_time       now;
+
+	NUTS_PASS(nng_mtx_alloc(&aa.mx));
+	NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
+	aa.cnt   = 0;
+	aa.delay = 200;
+
+	now = nng_clock();
+
+	NUTS_PASS(nng_thread_create(&thr, add, &aa));
+
+	nng_mtx_lock(aa.mx);
+	nng_cv_until(aa.cv, now + 500);
+	nng_mtx_unlock(aa.mx);
+
+	NUTS_TRUE(nng_clock() >= now + 200);
+	NUTS_TRUE(nng_clock() < now + 500);
+
+	nng_thread_destroy(thr);
+	nng_cv_free(aa.cv);
+	nng_mtx_free(aa.mx);
+}
+
+void
+test_cond_until(void)
+{
+	struct add_arg aa;
+	nng_time       now;
+
+	NUTS_PASS(nng_mtx_alloc(&aa.mx));
+	NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
+	aa.cnt   = 0;
+	aa.delay = 0;
+
+	now = nng_clock();
+	nng_mtx_lock(aa.mx);
+	nng_cv_until(aa.cv, now + 100);
+	nng_mtx_unlock(aa.mx);
+
+	NUTS_TRUE(nng_clock() >= now);
+#ifdef NO_SPRIOUS_WAKEUPS
+	// Some systems (e.g. Win32) will occasionally wake a threaed
+	// spuriously.  We therefore can't rely on condwait to be
+	// an absolute guarantee of minimum time passage.
+	NUTS_TRUE(nng_clock() >= now + 100);
+#endif
+	NUTS_TRUE(nng_clock() < now + 1000);
 
 	nng_cv_free(aa.cv);
 	nng_mtx_free(aa.mx);
@@ -166,16 +212,18 @@ test_random(void)
 	// 1% reproduction is *highly* unlikely.
 	// There are 4 billion possible options, we are only looking at
 	// 1000 of them.  In general, it would be an extreme outlier
-	// to see more than 2 repeats, unless you RNG is biased.
-	TEST_CHECK_(same < 5, "fewer than 5 in 1000 repeats: %d", same);
+	// to see more than 2 repeats, unless your RNG is biased.
+	NUTS_TRUE(same < 5);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "sleep", test_sleep },
 	{ "clock", test_clock },
 	{ "mutex", test_mutex },
 	{ "thread", test_thread },
 	{ "cond var", test_cond_var },
+	{ "cond wake", test_cond_wake },
+	{ "cond until", test_cond_until },
 	{ "random", test_random },
 	{ NULL, NULL },
 };
diff --git a/src/platform/resolver_test.c b/src/platform/resolver_test.c
index 43168cdb..d4dd4465 100644
--- a/src/platform/resolver_test.c
+++ b/src/platform/resolver_test.c
@@ -8,18 +8,9 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include "testutil.h"
-
-#include <string.h>
-
 #include "core/nng_impl.h"
-#include "stubs.h"
-
-#include "acutest.h"
 
-#ifndef _WIN32
-#include <arpa/inet.h> // for htons, htonl
-#endif
+#include <nuts.h>
 
 uint8_t v6loop[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 
@@ -29,14 +20,14 @@ test_google_dns(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("google-public-dns-a.google.com", "80", NNG_AF_INET,
 	    true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET);
-	TEST_CHECK(sa.s_in.sa_port == ntohs(80));
-	TEST_CHECK(sa.s_in.sa_addr == 0x08080808); // aka 8.8.8.8
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in.sa_family == NNG_AF_INET);
+	NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
+	NUTS_TRUE(sa.s_in.sa_addr == 0x08080808); // aka 8.8.8.8
 	nng_aio_free(aio);
 }
 
@@ -46,13 +37,13 @@ test_numeric_addr(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("8.8.4.4", "69", NNG_AF_INET, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET);
-	TEST_CHECK(sa.s_in.sa_port == ntohs(69));
-	TEST_CHECK(sa.s_in.sa_addr == ntohl(0x08080404)); // 8.8.4.4.
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in.sa_family == NNG_AF_INET);
+	NUTS_TRUE(sa.s_in.sa_port == nuts_be16(69));
+	NUTS_TRUE(sa.s_in.sa_addr == nuts_be32(0x08080404)); // 8.8.4.4.
 	nng_aio_free(aio);
 }
 
@@ -69,13 +60,13 @@ test_numeric_v6(void)
 		return; // skip this one.
 	}
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("::1", "80", NNG_AF_INET6, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in6.sa_family == NNG_AF_INET6);
-	TEST_CHECK(sa.s_in6.sa_port == ntohs(80));
-	TEST_CHECK(memcmp(sa.s_in6.sa_addr, v6loop, 16) == 0);
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in6.sa_family == NNG_AF_INET6);
+	NUTS_TRUE(sa.s_in6.sa_port == nuts_be16(80));
+	NUTS_TRUE(memcmp(sa.s_in6.sa_addr, v6loop, 16) == 0);
 	nng_aio_free(aio);
 }
 
@@ -85,12 +76,12 @@ test_service_names(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("8.8.4.4", "http", NNG_AF_INET, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in.sa_port == ntohs(80));
-	TEST_CHECK(sa.s_in.sa_addr = ntohl(0x08080404));
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
+	NUTS_TRUE(sa.s_in.sa_addr = nuts_be32(0x08080404));
 	nng_aio_free(aio);
 }
 
@@ -100,36 +91,36 @@ test_localhost_v4(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("localhost", "80", NNG_AF_INET, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET);
-	TEST_CHECK(sa.s_in.sa_port == ntohs(80));
-	TEST_CHECK(sa.s_in.sa_addr == ntohl(0x7f000001));
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in.sa_family == NNG_AF_INET);
+	NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
+	NUTS_TRUE(sa.s_in.sa_addr == nuts_be32(0x7f000001));
 	nng_aio_free(aio);
 }
 
 void
-test_localhost_unspec(void)
+test_localhost_unspecified(void)
 {
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("localhost", "80", NNG_AF_UNSPEC, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(
 	    (sa.s_family == NNG_AF_INET) || (sa.s_family == NNG_AF_INET6));
 	switch (sa.s_family) {
 	case NNG_AF_INET:
-		TEST_CHECK(sa.s_in.sa_port == ntohs(80));
-		TEST_CHECK(sa.s_in.sa_addr == ntohl(0x7f000001));
+		NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
+		NUTS_TRUE(sa.s_in.sa_addr == nuts_be32(0x7f000001));
 		break;
 	case NNG_AF_INET6:
-		TEST_CHECK(sa.s_in6.sa_port == ntohs(80));
-		TEST_CHECK(memcmp(sa.s_in6.sa_addr, v6loop, 16) == 0);
+		NUTS_TRUE(sa.s_in6.sa_port == nuts_be16(80));
+		NUTS_TRUE(memcmp(sa.s_in6.sa_addr, v6loop, 16) == 0);
 		break;
 	}
 	nng_aio_free(aio);
@@ -141,13 +132,13 @@ test_null_passive(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip(NULL, "80", NNG_AF_INET, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET);
-	TEST_CHECK(sa.s_in.sa_port == ntohs(80));
-	TEST_CHECK(sa.s_in.sa_addr == 0); // INADDR_ANY
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_TRUE(sa.s_in.sa_family == NNG_AF_INET);
+	NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
+	NUTS_TRUE(sa.s_in.sa_addr == 0); // any local address
 	nng_aio_free(aio);
 }
 
@@ -157,17 +148,17 @@ test_null_not_passive(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip(NULL, "80", NNG_AF_INET, false, &sa, aio);
 	nng_aio_wait(aio);
-	// We can either get NNG_EADDRINVAL, or a loopback address.
+	// We can either get invalid address, or a loopback address.
 	// Most systems do the former, but Linux does the latter.
 	if (nng_aio_result(aio) == 0) {
-		TEST_CHECK(sa.s_family == NNG_AF_INET);
-		TEST_CHECK(sa.s_in.sa_addr == htonl(0x7f000001));
-		TEST_CHECK(sa.s_in.sa_port == htons(80));
+		NUTS_TRUE(sa.s_family == NNG_AF_INET);
+		NUTS_TRUE(sa.s_in.sa_addr == nuts_be32(0x7f000001));
+		NUTS_TRUE(sa.s_in.sa_port == nuts_be16(80));
 	} else {
-		TEST_NNG_FAIL(nng_aio_result(aio), NNG_EADDRINVAL);
+		NUTS_FAIL(nng_aio_result(aio), NNG_EADDRINVAL);
 	}
 	nng_aio_free(aio);
 }
@@ -178,20 +169,20 @@ test_bad_port_number(void)
 	nng_aio *    aio;
 	nng_sockaddr sa;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nni_resolv_ip("1.1.1.1", "1000000", NNG_AF_INET, true, &sa, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_EADDRINVAL);
+	NUTS_FAIL(nng_aio_result(aio), NNG_EADDRINVAL);
 	nng_aio_free(aio);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "resolve google dns", test_google_dns },
 	{ "resolve numeric addr", test_numeric_addr },
 	{ "resolve numeric v6", test_numeric_v6 },
 	{ "resolve service names", test_service_names },
 	{ "resolve localhost v4", test_localhost_v4 },
-	{ "resolve localhost unspec", test_localhost_unspec },
+	{ "resolve localhost unspecified", test_localhost_unspecified },
 	{ "resolve null passive", test_null_passive },
 	{ "resolve null not passive", test_null_not_passive },
 	{ "resolve bad port number", test_bad_port_number },
diff --git a/src/protocol/bus0/bug1247_test.c b/src/protocol/bus0/bug1247_test.c
index 6f418f53..bbc6958b 100644
--- a/src/protocol/bus0/bug1247_test.c
+++ b/src/protocol/bus0/bug1247_test.c
@@ -7,30 +7,26 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
+#include <nuts.h>
 
-#include <nng/nng.h>
 #include <nng/protocol/bus0/bus.h>
 
-#include "acutest.h"
-#include "testutil.h"
-
 void
 test_bug1247(void)
 {
 	nng_socket bus1, bus2;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
+	NUTS_ADDR(addr, "tcp");
 
-	TEST_NNG_PASS(nng_bus0_open(&bus1));
-	TEST_NNG_PASS(nng_bus0_open(&bus2));
+	NUTS_PASS(nng_bus0_open(&bus1));
+	NUTS_PASS(nng_bus0_open(&bus2));
 
-	TEST_NNG_PASS(nng_listen(bus1, addr, NULL, 0));
-	TEST_NNG_FAIL(nng_listen(bus2, addr, NULL, 0), NNG_EADDRINUSE);
+	NUTS_PASS(nng_listen(bus1, addr, NULL, 0));
+	NUTS_FAIL(nng_listen(bus2, addr, NULL, 0), NNG_EADDRINUSE);
 
-	TEST_NNG_PASS(nng_close(bus2));
-	TEST_NNG_PASS(nng_close(bus1));
+	NUTS_PASS(nng_close(bus2));
+	NUTS_PASS(nng_close(bus1));
 }
 
 TEST_LIST = {
diff --git a/src/protocol/pair1/pair1_poly_test.c b/src/protocol/pair1/pair1_poly_test.c
index c4acbd86..f26f7809 100644
--- a/src/protocol/pair1/pair1_poly_test.c
+++ b/src/protocol/pair1/pair1_poly_test.c
@@ -8,22 +8,35 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pair0/pair.h>
-#include <nng/protocol/pair1/pair.h>
-
-#include <testutil.h>
-
-#include <acutest.h>
+#include <nuts.h>
 
 #define SECOND 1000
 
-#define APPEND_STR(m, s) TEST_NNG_PASS(nng_msg_append(m, s, strlen(s)))
-#define CHECK_STR(m, s)                          \
-	TEST_CHECK(nng_msg_len(m) == strlen(s)); \
-	TEST_CHECK(memcmp(nng_msg_body(m), s, strlen(s)) == 0)
+#define APPEND_STR(m, s) NUTS_PASS(nng_msg_append(m, s, strlen(s)))
+#define CHECK_STR(m, s)                         \
+	NUTS_TRUE(nng_msg_len(m) == strlen(s)); \
+	NUTS_TRUE(memcmp(nng_msg_body(m), s, strlen(s)) == 0)
+
+static void
+test_poly_identity(void)
+{
+	nng_socket s;
+	int        p;
+	char *     n;
+
+	NUTS_PASS(nng_pair1_open_poly(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NUTS_PROTO(1u, 1u)); // 32
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NUTS_PROTO(1u, 1u)); // 33
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, "pair1");
+	nng_strfree(n);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, "pair1");
+	nng_strfree(n);
+	NUTS_CLOSE(s);
+}
 
 void
 test_poly_best_effort(void)
@@ -32,23 +45,23 @@ test_poly_best_effort(void)
 	nng_socket c1;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nng_pair1_open_poly(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
 
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(c1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(c1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_MARRY(s1, c1);
 
 	for (int i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-		TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
+		NUTS_PASS(nng_msg_alloc(&msg, 0));
+		NUTS_PASS(nng_sendmsg(s1, msg, 0));
 	}
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -62,69 +75,69 @@ test_poly_cooked(void)
 	nng_pipe   p1;
 	nng_pipe   p2;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
-	TEST_NNG_PASS(nng_pair1_open(&c2));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 10));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 10));
-	TEST_NNG_PASS(nng_setopt_ms(c2, NNG_OPT_RECVTIMEO, SECOND / 10));
+	NUTS_PASS(nng_pair1_open_poly(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nng_pair1_open(&c2));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 10));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 10));
+	NUTS_PASS(nng_setopt_ms(c2, NNG_OPT_RECVTIMEO, SECOND / 10));
 
-	TEST_NNG_PASS(nng_getopt_bool(s1, NNG_OPT_PAIR1_POLY, &v));
-	TEST_CHECK(v == true);
+	NUTS_PASS(nng_getopt_bool(s1, NNG_OPT_PAIR1_POLY, &v));
+	NUTS_TRUE(v);
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
-	TEST_NNG_PASS(testutil_marry(s1, c2));
+	NUTS_MARRY(s1, c1);
+	NUTS_MARRY(s1, c2);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "ONE");
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
 	CHECK_STR(msg, "ONE");
 	p1 = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p1) > 0);
+	NUTS_TRUE(nng_pipe_id(p1) > 0);
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "TWO");
-	TEST_NNG_PASS(nng_sendmsg(c2, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_sendmsg(c2, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
 	CHECK_STR(msg, "TWO");
 	p2 = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p2) > 0);
+	NUTS_TRUE(nng_pipe_id(p2) > 0);
 	nng_msg_free(msg);
 
-	TEST_CHECK(nng_pipe_id(p1) != nng_pipe_id(p2));
+	NUTS_TRUE(nng_pipe_id(p1) != nng_pipe_id(p2));
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
 	nng_msg_set_pipe(msg, p1);
 	APPEND_STR(msg, "UNO");
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c1, &msg, 0));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c1, &msg, 0));
 	CHECK_STR(msg, "UNO");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	nng_msg_set_pipe(msg, p2);
 	APPEND_STR(msg, "DOS");
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c2, &msg, 0));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c2, &msg, 0));
 	CHECK_STR(msg, "DOS");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_PASS(nng_close(c1));
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	nng_msg_set_pipe(msg, p1);
 	APPEND_STR(msg, "EIN");
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(c2, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(c2, &msg, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c2);
 }
 
 void
@@ -135,38 +148,38 @@ test_poly_default(void)
 	nng_socket c2;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
-	TEST_NNG_PASS(nng_pair1_open(&c2));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_pair1_open_poly(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nng_pair1_open(&c2));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
-	TEST_NNG_PASS(testutil_marry(s1, c2));
+	NUTS_MARRY(s1, c1);
+	NUTS_MARRY(s1, c2);
 
 	// This assumes poly picks the first suitor.  Applications
 	// should not make the same assumption.
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "YES");
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c1, &msg, 0));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c1, &msg, 0));
 	CHECK_STR(msg, "YES");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(c1));
-	testutil_sleep(10);
+	NUTS_CLOSE(c1);
+	NUTS_SLEEP(10);
 
 	// Verify that the other pipe is chosen as the next suitor.
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "AGAIN");
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c2, &msg, 0));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c2, &msg, 0));
 	CHECK_STR(msg, "AGAIN");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c2);
 }
 
 void
@@ -175,25 +188,24 @@ test_poly_close_abort(void)
 	nng_socket s;
 	nng_socket c;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s));
-	TEST_NNG_PASS(nng_pair1_open(&c));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_int(s, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(c, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_pair1_open_poly(&s));
+	NUTS_PASS(nng_pair1_open(&c));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_setopt_int(s, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_int(c, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry(c, s));
+	NUTS_MARRY(c, s);
 
 	for (int i = 0; i < 20; i++) {
-		TEST_NNG_SEND_STR(c, "TEST");
+		NUTS_SEND(c, "TEST");
 	}
-	testutil_sleep(50);
+	NUTS_SLEEP(50);
 
-	TEST_NNG_PASS(nng_close(s));
-	TEST_NNG_PASS(nng_close(c));
+	NUTS_CLOSE(s);
+	NUTS_CLOSE(c);
 }
 
-
 void
 test_poly_recv_no_header(void)
 {
@@ -201,20 +213,20 @@ test_poly_recv_no_header(void)
 	nng_socket c;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s));
-	TEST_NNG_PASS(nng_pair1_open(&c));
-	TEST_NNG_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_pair1_open_poly(&s));
+	NUTS_PASS(nng_pair1_open(&c));
+	NUTS_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
 
-	TEST_NNG_PASS(testutil_marry(c, s));
+	NUTS_MARRY(c, s);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_sendmsg(c, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_sendmsg(c, m, 0));
+	NUTS_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(c));
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(c);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -224,22 +236,22 @@ test_poly_recv_garbage(void)
 	nng_socket c;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s));
-	TEST_NNG_PASS(nng_pair1_open(&c));
-	TEST_NNG_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_pair1_open_poly(&s));
+	NUTS_PASS(nng_pair1_open(&c));
+	NUTS_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
 
-	TEST_NNG_PASS(testutil_marry(c, s));
+	NUTS_MARRY(c, s);
 
 	// ridiculous hop count
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x1000));
-	TEST_NNG_PASS(nng_sendmsg(c, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 0x1000));
+	NUTS_PASS(nng_sendmsg(c, m, 0));
+	NUTS_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(c));
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(c);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -251,65 +263,65 @@ test_poly_ttl(void)
 	uint32_t   val;
 	int        ttl;
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s1));
-	TEST_NNG_PASS(nng_pair1_open_raw(&c1));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_PASS(nng_pair1_open_poly(&s1));
+	NUTS_PASS(nng_pair1_open_raw(&c1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
 
 	// cannot set insane TTLs
-	TEST_NNG_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 1000), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 1000), NNG_EINVAL);
 	ttl = 8;
-	TEST_NNG_FAIL(nng_setopt(s1, NNG_OPT_MAXTTL, &ttl, 1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(s1, NNG_OPT_MAXTTL, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_setopt(s1, NNG_OPT_MAXTTL, &ttl, 1), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_bool(s1, NNG_OPT_MAXTTL, true), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_MARRY(s1, c1);
 
 	// Let's check enforcement of TTL
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 4));
-	TEST_NNG_PASS(nng_getopt_int(s1, NNG_OPT_MAXTTL, &ttl));
-	TEST_CHECK(ttl == 4);
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 4));
+	NUTS_PASS(nng_getopt_int(s1, NNG_OPT_MAXTTL, &ttl));
+	NUTS_TRUE(ttl == 4);
 
 	// Bad TTL bounces
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 4));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 4));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
 	// Good TTL passes
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 3));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &val));
-	TEST_CHECK(val == 0xFEEDFACE);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &val));
-	TEST_CHECK(val == 4);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 3));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &val));
+	NUTS_TRUE(val == 0xFEEDFACE);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &val));
+	NUTS_TRUE(val == 4);
 	nng_msg_free(msg);
 
 	// Large TTL passes
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 1234));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 14));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &val));
-	TEST_CHECK(val == 1234);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &val));
-	TEST_CHECK(val == 15);
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 1234));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 14));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &val));
+	NUTS_TRUE(val == 1234);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &val));
+	NUTS_TRUE(val == 15);
 	nng_msg_free(msg);
 
 	// Max TTL fails
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 15));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
-
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 15));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -318,40 +330,41 @@ test_poly_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_pair1_open_poly(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_PASS(nng_pair1_open_poly(&s1));
+	NUTS_PASS(nng_pair0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
 TEST_LIST = {
-	{ "pair1 polyamorous best effort", test_poly_best_effort },
-	{ "pair1 polyamorous cooked", test_poly_cooked },
-	{ "pair1 polyamorous default", test_poly_default },
-	{ "pair1 polyamorous recv no header", test_poly_recv_no_header },
-	{ "pair1 polyamorous recv garbage", test_poly_recv_garbage },
-	{ "pair1 polyamorous ttl", test_poly_ttl },
-	{ "pair1 polyamorous close abort", test_poly_close_abort },
-	{ "pair1 polyamorous validate peer", test_poly_validate_peer },
+	{ "pair1 poly identity", test_poly_identity },
+	{ "pair1 poly best effort", test_poly_best_effort },
+	{ "pair1 poly cooked", test_poly_cooked },
+	{ "pair1 poly default", test_poly_default },
+	{ "pair1 poly recv no header", test_poly_recv_no_header },
+	{ "pair1 poly recv garbage", test_poly_recv_garbage },
+	{ "pair1 poly ttl", test_poly_ttl },
+	{ "pair1 poly close abort", test_poly_close_abort },
+	{ "pair1 poly validate peer", test_poly_validate_peer },
 
 	{ NULL, NULL },
 };
diff --git a/src/protocol/pair1/pair1_test.c b/src/protocol/pair1/pair1_test.c
index 0f0131b5..881c4ac8 100644
--- a/src/protocol/pair1/pair1_test.c
+++ b/src/protocol/pair1/pair1_test.c
@@ -8,22 +8,35 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pair0/pair.h>
-#include <nng/protocol/pair1/pair.h>
-
-#include <testutil.h>
-
-#include <acutest.h>
+#include <nuts.h>
 
 #define SECOND 1000
 
-#define APPEND_STR(m, s) TEST_CHECK(nng_msg_append(m, s, strlen(s)) == 0)
-#define CHECK_STR(m, s)                          \
-	TEST_CHECK(nng_msg_len(m) == strlen(s)); \
-	TEST_CHECK(memcmp(nng_msg_body(m), s, strlen(s)) == 0)
+#define APPEND_STR(m, s) NUTS_TRUE(nng_msg_append(m, s, strlen(s)) == 0)
+#define CHECK_STR(m, s)                         \
+	NUTS_TRUE(nng_msg_len(m) == strlen(s)); \
+	NUTS_TRUE(memcmp(nng_msg_body(m), s, strlen(s)) == 0)
+
+static void
+test_mono_identity(void)
+{
+	nng_socket s;
+	int        p;
+	char *     n;
+
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NUTS_PROTO(1u, 1u)); // 32
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NUTS_PROTO(1u, 1u)); // 33
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, "pair1");
+	nng_strfree(n);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, "pair1");
+	nng_strfree(n);
+	NUTS_CLOSE(s);
+}
 
 void
 test_mono_cooked(void)
@@ -32,28 +45,28 @@ test_mono_cooked(void)
 	nng_socket c1;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nuts_marry(s1, c1));
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append(msg, "ALPHA", strlen("ALPHA") + 1));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_CHECK(nng_msg_len(msg) == strlen("ALPHA") + 1);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "ALPHA") == 0);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "ALPHA", strlen("ALPHA") + 1));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_TRUE(nng_msg_len(msg) == strlen("ALPHA") + 1);
+	NUTS_MATCH(nng_msg_body(msg), "ALPHA");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append(msg, "BETA", strlen("BETA") + 1));
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c1, &msg, 0));
-	TEST_CHECK(nng_msg_len(msg) == strlen("BETA") + 1);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "BETA") == 0);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "BETA", strlen("BETA") + 1));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c1, &msg, 0));
+	NUTS_TRUE(nng_msg_len(msg) == strlen("BETA") + 1);
+	NUTS_MATCH(nng_msg_body(msg), "BETA");
 
 	nng_msg_free(msg);
-	TEST_NNG_PASS(nng_close(c1));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(c1);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -65,35 +78,35 @@ test_mono_faithful(void)
 	nng_msg *   msg;
 	const char *addr = "inproc://pair1_mono_faithful";
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
-	TEST_NNG_PASS(nng_pair1_open(&c2));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 4));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_int(c2, NNG_OPT_SENDBUF, 2));
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nng_pair1_open(&c2));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 4));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c2, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_int(c2, NNG_OPT_SENDBUF, 2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(testutil_marry(s1, c1));
-	TEST_NNG_PASS(nng_dial(c2, addr, NULL, 0));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_MARRY(s1, c1);
+	NUTS_PASS(nng_dial(c2, addr, NULL, 0));
 
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "ONE");
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
 	CHECK_STR(msg, "ONE");
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "TWO");
-	TEST_NNG_PASS(nng_sendmsg(c2, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(c2, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
-	TEST_NNG_PASS(nng_close(c2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
+	NUTS_CLOSE(c2);
 }
 
 void
@@ -106,28 +119,28 @@ test_mono_back_pressure(void)
 	nng_msg *    msg;
 	nng_duration to = 100;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&c1));
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(c1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, to));
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_pair1_open(&c1));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(c1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, to));
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_MARRY(s1, c1);
 
 	// We choose to allow some buffering.  In reality the
 	// buffer size is just 1, and we will fail after 2.
 	for (i = 0, rv = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+		NUTS_PASS(nng_msg_alloc(&msg, 0));
 		if ((rv = nng_sendmsg(s1, msg, 0)) != 0) {
 			nng_msg_free(msg);
 			break;
 		}
 	}
-	TEST_NNG_FAIL(rv, NNG_ETIMEDOUT);
-	TEST_CHECK(i < 10);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_FAIL(rv, NNG_ETIMEDOUT);
+	NUTS_TRUE(i < 10);
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -139,45 +152,45 @@ test_mono_raw_exchange(void)
 	nng_msg *msg;
 	uint32_t hops;
 
-	TEST_NNG_PASS(nng_pair1_open_raw(&s1));
-	TEST_NNG_PASS(nng_pair1_open_raw(&c1));
+	NUTS_PASS(nng_pair1_open_raw(&s1));
+	NUTS_PASS(nng_pair1_open_raw(&c1));
 
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_MARRY(s1, c1);
 
 	nng_pipe p = NNG_PIPE_INITIALIZER;
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "GAMMA");
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 1));
-	TEST_CHECK(nng_msg_header_len(msg) == sizeof(uint32_t));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 1));
+	NUTS_TRUE(nng_msg_header_len(msg) == sizeof(uint32_t));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
 	p = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p) > 0);
+	NUTS_TRUE(nng_pipe_id(p) > 0);
 
 	CHECK_STR(msg, "GAMMA");
-	TEST_CHECK(nng_msg_header_len(msg) == sizeof(uint32_t));
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &hops));
-	TEST_CHECK(hops == 2);
+	NUTS_TRUE(nng_msg_header_len(msg) == sizeof(uint32_t));
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &hops));
+	NUTS_TRUE(hops == 2);
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	APPEND_STR(msg, "EPSILON");
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 1));
-	TEST_NNG_PASS(nng_sendmsg(s1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(c1, &msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 1));
+	NUTS_PASS(nng_sendmsg(s1, msg, 0));
+	NUTS_PASS(nng_recvmsg(c1, &msg, 0));
 	CHECK_STR(msg, "EPSILON");
-	TEST_CHECK(nng_msg_header_len(msg) == sizeof(uint32_t));
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &hops));
+	NUTS_TRUE(nng_msg_header_len(msg) == sizeof(uint32_t));
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &hops));
 	p = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p) > 0);
+	NUTS_TRUE(nng_pipe_id(p) > 0);
 
-	TEST_CHECK(hops == 2);
+	NUTS_TRUE(hops == 2);
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -188,52 +201,52 @@ test_mono_raw_header(void)
 	nng_msg *  msg;
 	uint32_t   v;
 
-	TEST_NNG_PASS(nng_pair1_open_raw(&s1));
-	TEST_NNG_PASS(nng_pair1_open_raw(&c1));
+	NUTS_PASS(nng_pair1_open_raw(&s1));
+	NUTS_PASS(nng_pair1_open_raw(&c1));
 
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_MARRY(s1, c1);
 
 	// Missing bits in the header
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
 	// Valid header works
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 1));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &v));
-	TEST_CHECK(v == 0xFEEDFACE);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 1));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &v));
+	NUTS_TRUE(v == 0xFEEDFACE);
 	nng_msg_free(msg);
 
 	// Header with reserved bits set dropped
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 0xDEAD0000));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 0xDEAD0000));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
 	// Header with no chance to add another hop gets dropped
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 0xff));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 0xff));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
 	// With the same bits clear it works
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 1));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &v));
-	TEST_CHECK(v == 0xFEEDFACE);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 1));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &v));
+	NUTS_TRUE(v == 0xFEEDFACE);
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -242,17 +255,17 @@ test_pair1_raw(void)
 	nng_socket s1;
 	bool       raw;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_getopt_bool(s1, NNG_OPT_RAW, &raw));
-	TEST_CHECK(raw == false);
-	TEST_NNG_FAIL(nng_setopt_bool(s1, NNG_OPT_RAW, true), NNG_EREADONLY);
-	TEST_NNG_PASS(nng_close(s1));
-
-	TEST_NNG_PASS(nng_pair1_open_raw(&s1));
-	TEST_NNG_PASS(nng_getopt_bool(s1, NNG_OPT_RAW, &raw));
-	TEST_CHECK(raw == true);
-	TEST_NNG_FAIL(nng_setopt_bool(s1, NNG_OPT_RAW, false), NNG_EREADONLY);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_getopt_bool(s1, NNG_OPT_RAW, &raw));
+	NUTS_TRUE(raw == false);
+	NUTS_FAIL(nng_setopt_bool(s1, NNG_OPT_RAW, true), NNG_EREADONLY);
+	NUTS_PASS(nng_close(s1));
+
+	NUTS_PASS(nng_pair1_open_raw(&s1));
+	NUTS_PASS(nng_getopt_bool(s1, NNG_OPT_RAW, &raw));
+	NUTS_TRUE(raw == true);
+	NUTS_FAIL(nng_setopt_bool(s1, NNG_OPT_RAW, false), NNG_EREADONLY);
+	NUTS_PASS(nng_close(s1));
 }
 
 void
@@ -264,65 +277,65 @@ test_pair1_ttl(void)
 	uint32_t   val;
 	int        ttl;
 
-	TEST_NNG_PASS(nng_pair1_open_raw(&s1));
-	TEST_NNG_PASS(nng_pair1_open_raw(&c1));
-	TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
-	TEST_NNG_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_PASS(nng_pair1_open_raw(&s1));
+	NUTS_PASS(nng_pair1_open_raw(&c1));
+	NUTS_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, SECOND / 5));
+	NUTS_PASS(nng_setopt_ms(c1, NNG_OPT_RECVTIMEO, SECOND / 5));
 
 	// cannot set insane TTLs
-	TEST_NNG_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 1000), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(s1, NNG_OPT_MAXTTL, 1000), NNG_EINVAL);
 	ttl = 8;
-	TEST_NNG_FAIL(nng_setopt(s1, NNG_OPT_MAXTTL, &ttl, 1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(s1, NNG_OPT_MAXTTL, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_setopt(s1, NNG_OPT_MAXTTL, &ttl, 1), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_bool(s1, NNG_OPT_MAXTTL, true), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(testutil_marry(s1, c1));
+	NUTS_MARRY(s1, c1);
 
 	// Let's check enforcement of TTL
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 4));
-	TEST_NNG_PASS(nng_getopt_int(s1, NNG_OPT_MAXTTL, &ttl));
-	TEST_CHECK(ttl == 4);
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 4));
+	NUTS_PASS(nng_getopt_int(s1, NNG_OPT_MAXTTL, &ttl));
+	NUTS_TRUE(ttl == 4);
 
 	// Bad TTL bounces
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 4));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 4));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
 
 	// Good TTL passes
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 3));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &val));
-	TEST_CHECK(val == 0xFEEDFACE);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &val));
-	TEST_CHECK(val == 4);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0xFEEDFACE));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 3));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &val));
+	NUTS_TRUE(val == 0xFEEDFACE);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &val));
+	NUTS_TRUE(val == 4);
 	nng_msg_free(msg);
 
 	// Large TTL passes
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 1234));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 14));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(s1, &msg, 0));
-	TEST_NNG_PASS(nng_msg_trim_u32(msg, &val));
-	TEST_CHECK(val == 1234);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(msg, &val));
-	TEST_CHECK(val == 15);
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 1234));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 14));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_PASS(nng_recvmsg(s1, &msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &val));
+	NUTS_TRUE(val == 1234);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &val));
+	NUTS_TRUE(val == 15);
 	nng_msg_free(msg);
 
 	// Max TTL fails
-	TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(msg, 15));
-	TEST_NNG_PASS(nng_sendmsg(c1, msg, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
-
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(c1));
+	NUTS_PASS(nng_setopt_int(s1, NNG_OPT_MAXTTL, 15));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 15));
+	NUTS_PASS(nng_sendmsg(c1, msg, 0));
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(c1);
 }
 
 void
@@ -331,28 +344,27 @@ test_pair1_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
-
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	char *     addr;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_ADDR(addr, "inproc");
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_PASS(nng_pair0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -363,20 +375,20 @@ test_pair1_recv_no_header(void)
 	nng_socket c;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_pair1_open(&s));
-	TEST_NNG_PASS(nng_pair1_open(&c));
-	TEST_NNG_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_pair1_open(&c));
+	NUTS_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
 
-	TEST_NNG_PASS(testutil_marry(c, s));
+	NUTS_MARRY(c, s);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_sendmsg(c, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_sendmsg(c, m, 0));
+	NUTS_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(c));
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(c);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -386,30 +398,31 @@ test_pair1_recv_garbage(void)
 	nng_socket c;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_pair1_open(&s));
-	TEST_NNG_PASS(nng_pair1_open(&c));
-	TEST_NNG_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_pair1_open(&s));
+	NUTS_PASS(nng_pair1_open(&c));
+	NUTS_PASS(nng_setopt_bool(c, "pair1_test_inject_header", true));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_setopt_ms(s, NNG_OPT_SENDTIMEO, 200));
 
-	TEST_NNG_PASS(testutil_marry(c, s));
+	NUTS_MARRY(c, s);
 
 	// ridiculous hop count
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x1000));
-	TEST_NNG_PASS(nng_sendmsg(c, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 0x1000));
+	NUTS_PASS(nng_sendmsg(c, m, 0));
+	NUTS_FAIL(nng_recvmsg(s, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(c));
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(c);
+	NUTS_CLOSE(s);
 }
 
-TEST_LIST = {
-	{ "pair1 monogamous cooked", test_mono_cooked },
-	{ "pair1 monogamous faithful", test_mono_faithful },
-	{ "pair1 monogamous back pressure", test_mono_back_pressure },
-	{ "pair1 monogamous raw exchange", test_mono_raw_exchange },
-	{ "pair1 monogamous raw header", test_mono_raw_header },
+NUTS_TESTS = {
+	{ "pair1 mono identity", test_mono_identity },
+	{ "pair1 mono cooked", test_mono_cooked },
+	{ "pair1 mono faithful", test_mono_faithful },
+	{ "pair1 mono back pressure", test_mono_back_pressure },
+	{ "pair1 mono raw exchange", test_mono_raw_exchange },
+	{ "pair1 mono raw header", test_mono_raw_header },
 	{ "pair1 raw", test_pair1_raw },
 	{ "pair1 ttl", test_pair1_ttl },
 	{ "pair1 validate peer", test_pair1_validate_peer },
diff --git a/src/protocol/pubsub0/pub_test.c b/src/protocol/pubsub0/pub_test.c
index 94d5c333..a430b610 100644
--- a/src/protocol/pubsub0/pub_test.c
+++ b/src/protocol/pubsub0/pub_test.c
@@ -7,18 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pubsub0/pub.h>
-#include <nng/protocol/pubsub0/sub.h>
-
-#include <acutest.h>
-#include <testutil.h>
-
-#ifndef NNI_PROTO
-#define NNI_PROTO(x, y) (((x) << 4u) | (y))
-#endif
+#include <nuts.h>
 
 static void
 test_pub_identity(void)
@@ -27,18 +16,18 @@ test_pub_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_NNG_PASS(nng_pub0_open(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 0u)); // 32
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 1u)); // 33
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n));
-	TEST_CHECK(strcmp(n, "pub") == 0);
+	NUTS_PASS(nng_pub0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 0u)); // 32
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 1u)); // 33
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, "pub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n));
-	TEST_CHECK(strcmp(n, "sub") == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, "sub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -46,9 +35,9 @@ test_pub_cannot_recv(void)
 {
 	nng_socket pub;
 
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_FAIL(nng_recv(pub, "", 0, 0), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_FAIL(nng_recv(pub, "", 0, 0), NNG_ENOTSUP);
+	NUTS_CLOSE(pub);
 }
 
 static void
@@ -57,9 +46,9 @@ test_pub_no_context(void)
 	nng_socket pub;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, pub), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_FAIL(nng_ctx_open(&ctx, pub), NNG_ENOTSUP);
+	NUTS_CLOSE(pub);
 }
 
 static void
@@ -68,9 +57,9 @@ test_pub_not_readable(void)
 	int        fd;
 	nng_socket pub;
 
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_FAIL(nng_getopt_int(pub, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_FAIL(nng_socket_get_int(pub, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_CLOSE(pub);
 }
 
 static void
@@ -80,25 +69,24 @@ test_pub_poll_writeable(void)
 	nng_socket pub;
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_getopt_int(pub, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_get_int(pub, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Pub is *always* writeable
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_MARRY(pub, sub);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	// But once we send messages, it is.
-	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(pub, "abc");
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	// Even if we send messages.
+	NUTS_SEND(pub, "abc");
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -106,10 +94,10 @@ test_pub_send_no_pipes(void)
 {
 	nng_socket pub;
 
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_SEND_STR(pub, "DROP1");
-	TEST_NNG_SEND_STR(pub, "DROP2");
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_SEND(pub, "DROP1");
+	NUTS_SEND(pub, "DROP2");
+	NUTS_CLOSE(pub);
 }
 
 void
@@ -118,28 +106,28 @@ test_pub_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char       *addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_pub0_open(&s1));
-	TEST_NNG_PASS(nng_pub0_open(&s2));
+	NUTS_PASS(nng_pub0_open(&s1));
+	NUTS_PASS(nng_pub0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -152,26 +140,26 @@ test_pub_send_queued(void)
 	// MB: What we really need is a mock so that we can send harder
 	// than we receive -- we need a way to apply back-pressure for this
 	// test to be really meaningful.
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "", 0));
-	TEST_NNG_PASS(nng_setopt_int(pub, NNG_OPT_SENDBUF, 10));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 10));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_NNG_SEND_STR(pub, "first");
-	TEST_NNG_SEND_STR(pub, "second");
-	TEST_NNG_SEND_STR(pub, "three musketeers");
-	TEST_NNG_SEND_STR(pub, "four");
-	testutil_sleep(50);
-	TEST_NNG_RECV_STR(sub, "first");
-	TEST_NNG_RECV_STR(sub, "second");
-	TEST_NNG_RECV_STR(sub, "three musketeers");
-	TEST_NNG_RECV_STR(sub, "four");
-
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "", 0));
+	NUTS_PASS(nng_socket_set_int(pub, NNG_OPT_SENDBUF, 10));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 10));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_MARRY(pub, sub);
+	NUTS_SEND(pub, "first");
+	NUTS_SEND(pub, "second");
+	NUTS_SEND(pub, "three musketeers");
+	NUTS_SEND(pub, "four");
+	NUTS_SLEEP(50);
+	NUTS_RECV(sub, "first");
+	NUTS_RECV(sub, "second");
+	NUTS_RECV(sub, "three musketeers");
+	NUTS_RECV(sub, "four");
+
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 static void
 test_sub_recv_ctx_closed(void)
@@ -179,15 +167,15 @@ test_sub_recv_ctx_closed(void)
 	nng_socket sub;
 	nng_ctx    ctx;
 	nng_aio *  aio;
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_ctx_close(ctx);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -197,16 +185,16 @@ test_sub_ctx_recv_aio_stopped(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
 
 	nng_aio_stop(aio);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -217,16 +205,16 @@ test_sub_close_context_recv(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_aio_set_timeout(aio, 1000);
 	nng_ctx_recv(ctx, aio);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
+	NUTS_PASS(nng_ctx_close(ctx));
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -237,16 +225,16 @@ test_sub_ctx_recv_nonblock(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -257,17 +245,17 @@ test_sub_ctx_recv_cancel(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 1000);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_abort(aio, NNG_ECANCELED);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -280,28 +268,28 @@ test_pub_send_buf_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_SENDBUF;
 
-	TEST_NNG_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_pub0_open(&pub));
 
-	TEST_NNG_PASS(nng_setopt_int(pub, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(pub, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(pub, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(pub, opt, 1000000), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(pub, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(pub, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(pub, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(pub, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(pub, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(pub, opt, 1000000), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(pub, opt, 3));
+	NUTS_PASS(nng_socket_get_int(pub, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(pub, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(pub, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(pub, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(pub, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(pub, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(pub, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(pub, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(pub, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(pub, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(pub, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_CLOSE(pub);
 }
 
 static void
@@ -310,20 +298,20 @@ test_pub_cooked(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_pub0_open(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(!b);
-	TEST_NNG_FAIL(nng_setopt_bool(s, NNG_OPT_RAW, true), NNG_EREADONLY);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_pub0_open(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(!b);
+	NUTS_FAIL(nng_socket_set_bool(s, NNG_OPT_RAW, true), NNG_EREADONLY);
+	NUTS_PASS(nng_close(s));
 
 	// raw pub only differs in the option setting
-	TEST_NNG_PASS(nng_pub0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_pub0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "pub identity", test_pub_identity },
 	{ "pub cannot recv", test_pub_cannot_recv },
 	{ "put no context", test_pub_no_context },
diff --git a/src/protocol/pubsub0/sub_test.c b/src/protocol/pubsub0/sub_test.c
index 3edf1d16..b830ae80 100644
--- a/src/protocol/pubsub0/sub_test.c
+++ b/src/protocol/pubsub0/sub_test.c
@@ -7,18 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pubsub0/pub.h>
-#include <nng/protocol/pubsub0/sub.h>
-
-#include <acutest.h>
-#include <testutil.h>
-
-#ifndef NNI_PROTO
-#define NNI_PROTO(x, y) (((x) << 4u) | (y))
-#endif
+#include <nuts.h>
 
 static void
 test_sub_identity(void)
@@ -27,18 +16,18 @@ test_sub_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_NNG_PASS(nng_sub0_open(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 1u)); // 33
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 0u)); // 32
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n));
-	TEST_CHECK(strcmp(n, "sub") == 0);
+	NUTS_PASS(nng_sub0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 1u)); // 33
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 0u)); // 32
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, "sub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n));
-	TEST_CHECK(strcmp(n, "pub") == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, "pub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -46,9 +35,9 @@ test_sub_cannot_send(void)
 {
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_FAIL(nng_send(sub, "", 0, 0), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_FAIL(nng_send(sub, "", 0, 0), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -59,17 +48,17 @@ test_sub_context_cannot_send(void)
 	nng_msg *  m;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_aio_set_msg(aio, m);
 	nng_aio_set_timeout(aio, 1000);
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 	nng_msg_free(m);
 }
@@ -80,9 +69,9 @@ test_sub_not_writeable(void)
 	int        fd;
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_FAIL(nng_getopt_int(sub, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_FAIL(nng_socket_get_int(sub, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -92,38 +81,38 @@ test_sub_poll_readable(void)
 	nng_socket pub;
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "a", 1));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_getopt_int(sub, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "a", 1));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_get_int(sub, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(pub, sub);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// If we send a message we didn't subscribe to, that doesn't matter.
-	TEST_NNG_SEND_STR(pub, "def");
-	testutil_sleep(100);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_SEND(pub, "def");
+	NUTS_SLEEP(100);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(pub, "abc");
-	testutil_sleep(100);
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_SEND(pub, "abc");
+	NUTS_SLEEP(100);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
 	// and receiving makes it no longer ready
-	TEST_NNG_RECV_STR(sub, "abc");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_RECV(sub, "abc");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -135,41 +124,41 @@ test_sub_recv_late(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "", 0));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_getopt_int(sub, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "", 0));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_get_int(sub, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(pub, sub);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	nng_recv_aio(sub, aio);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(pub, "abc");
-	testutil_sleep(200);
+	NUTS_SEND(pub, "abc");
+	NUTS_SLEEP(200);
 
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	msg = nng_aio_get_msg(aio);
 	nng_aio_set_msg(aio, NULL);
-	TEST_CHECK(nng_msg_len(msg) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "abc") == 0);
+	NUTS_TRUE(nng_msg_len(msg) == 4);
+	NUTS_MATCH(nng_msg_body(msg), "abc");
 
 	nng_msg_free(msg);
 	nng_aio_free(aio);
 
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -179,14 +168,12 @@ test_sub_context_no_poll(void)
 	nng_socket sub;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -195,28 +182,28 @@ test_sub_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_sub0_open(&s1));
-	TEST_NNG_PASS(nng_sub0_open(&s2));
+	NUTS_PASS(nng_sub0_open(&s1));
+	NUTS_PASS(nng_sub0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -226,15 +213,15 @@ test_sub_recv_ctx_closed(void)
 	nng_socket sub;
 	nng_ctx    ctx;
 	nng_aio *  aio;
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_ctx_close(ctx);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -244,16 +231,16 @@ test_sub_ctx_recv_aio_stopped(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
 
 	nng_aio_stop(aio);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -264,16 +251,16 @@ test_sub_close_context_recv(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_aio_set_timeout(aio, 1000);
 	nng_ctx_recv(ctx, aio);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
+	NUTS_PASS(nng_ctx_close(ctx));
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -284,16 +271,16 @@ test_sub_ctx_recv_nonblock(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -304,17 +291,17 @@ test_sub_ctx_recv_cancel(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_ctx_open(&ctx, sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 1000);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_abort(aio, NNG_ECANCELED);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -327,28 +314,28 @@ test_sub_recv_buf_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_RECVBUF;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_sub0_open(&sub));
 
-	TEST_NNG_PASS(nng_setopt_int(sub, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, 1000000), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(sub, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(sub, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(sub, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(sub, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(sub, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(sub, opt, 1000000), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(sub, opt, 3));
+	NUTS_PASS(nng_socket_get_int(sub, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(sub, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(sub, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(sub, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(sub, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(sub, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(sub, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(sub, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(sub, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(sub, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(sub, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -359,16 +346,16 @@ test_sub_subscribe_option(void)
 	int         v;
 	const char *opt = NNG_OPT_SUB_SUBSCRIBE;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_sub0_open(&sub));
 
-	TEST_NNG_PASS(nng_setopt(sub, opt, "abc", 3));
-	TEST_NNG_PASS(nng_setopt(sub, opt, "abc", 3)); // duplicate
-	TEST_NNG_PASS(nng_setopt_bool(sub, opt, false));
-	TEST_NNG_PASS(nng_setopt_int(sub, opt, 32));
+	NUTS_PASS(nng_socket_set(sub, opt, "abc", 3));
+	NUTS_PASS(nng_socket_set(sub, opt, "abc", 3)); // duplicate
+	NUTS_PASS(nng_socket_set_bool(sub, opt, false));
+	NUTS_PASS(nng_socket_set_int(sub, opt, 32));
 	sz = sizeof(v);
-	TEST_NNG_FAIL(nng_getopt(sub, opt, &v, &sz), NNG_EWRITEONLY);
+	NUTS_FAIL(nng_socket_get(sub, opt, &v, &sz), NNG_EWRITEONLY);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -380,19 +367,19 @@ test_sub_unsubscribe_option(void)
 	const char *opt1 = NNG_OPT_SUB_SUBSCRIBE;
 	const char *opt2 = NNG_OPT_SUB_UNSUBSCRIBE;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_sub0_open(&sub));
 
-	TEST_NNG_PASS(nng_setopt(sub, opt1, "abc", 3));
-	TEST_NNG_FAIL(nng_setopt(sub, opt2, "abcdef", 6), NNG_ENOENT);
-	TEST_NNG_PASS(nng_setopt(sub, opt2, "abc", 3));
-	TEST_NNG_FAIL(nng_setopt(sub, opt2, "abc", 3), NNG_ENOENT);
-	TEST_NNG_PASS(nng_setopt_int(sub, opt1, 32));
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt2, 23), NNG_ENOENT);
-	TEST_NNG_PASS(nng_setopt_int(sub, opt2, 32));
+	NUTS_PASS(nng_socket_set(sub, opt1, "abc", 3));
+	NUTS_FAIL(nng_socket_set(sub, opt2, "abc123", 6), NNG_ENOENT);
+	NUTS_PASS(nng_socket_set(sub, opt2, "abc", 3));
+	NUTS_FAIL(nng_socket_set(sub, opt2, "abc", 3), NNG_ENOENT);
+	NUTS_PASS(nng_socket_set_int(sub, opt1, 32));
+	NUTS_FAIL(nng_socket_set_int(sub, opt2, 23), NNG_ENOENT);
+	NUTS_PASS(nng_socket_set_int(sub, opt2, 32));
 	sz = sizeof(v);
-	TEST_NNG_FAIL(nng_getopt(sub, opt2, &v, &sz), NNG_EWRITEONLY);
+	NUTS_FAIL(nng_socket_get(sub, opt2, &v, &sz), NNG_EWRITEONLY);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -403,22 +390,22 @@ test_sub_prefer_new_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_SUB_PREFNEW;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_sub0_open(&sub));
 
-	TEST_NNG_PASS(nng_setopt_bool(sub, opt, true));
-	TEST_NNG_PASS(nng_setopt_bool(sub, opt, false));
-	TEST_NNG_PASS(nng_getopt_bool(sub, opt, &b));
-	TEST_CHECK(b == false);
+	NUTS_PASS(nng_socket_set_bool(sub, opt, true));
+	NUTS_PASS(nng_socket_set_bool(sub, opt, false));
+	NUTS_PASS(nng_socket_get_bool(sub, opt, &b));
+	NUTS_TRUE(b == false);
 	sz = sizeof(b);
 	b  = true;
-	TEST_NNG_PASS(nng_getopt(sub, opt, &b, &sz));
-	TEST_CHECK(b == false);
-	TEST_CHECK(sz == sizeof(bool));
+	NUTS_PASS(nng_socket_get(sub, opt, &b, &sz));
+	NUTS_TRUE(b == false);
+	NUTS_TRUE(sz == sizeof(bool));
 
-	TEST_NNG_FAIL(nng_setopt(sub, opt, "abc", 3), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, 1), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_set(sub, opt, "abc", 3), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(sub, opt, 1), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -428,23 +415,23 @@ test_sub_drop_new(void)
 	nng_socket pub;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 2));
-	TEST_NNG_PASS(nng_setopt_bool(sub, NNG_OPT_SUB_PREFNEW, false));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, NULL, 0));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_NNG_SEND_STR(pub, "one");
-	TEST_NNG_SEND_STR(pub, "two");
-	TEST_NNG_SEND_STR(pub, "three");
-	testutil_sleep(100);
-	TEST_NNG_RECV_STR(sub, "one");
-	TEST_NNG_RECV_STR(sub, "two");
-	TEST_NNG_FAIL(nng_recvmsg(sub, &msg, 0), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 2));
+	NUTS_PASS(nng_socket_set_bool(sub, NNG_OPT_SUB_PREFNEW, false));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, NULL, 0));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_MARRY(pub, sub);
+	NUTS_SEND(pub, "one");
+	NUTS_SEND(pub, "two");
+	NUTS_SEND(pub, "three");
+	NUTS_SLEEP(100);
+	NUTS_RECV(sub, "one");
+	NUTS_RECV(sub, "two");
+	NUTS_FAIL(nng_recvmsg(sub, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -454,23 +441,23 @@ test_sub_drop_old(void)
 	nng_socket pub;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 2));
-	TEST_NNG_PASS(nng_setopt_bool(sub, NNG_OPT_SUB_PREFNEW, true));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, NULL, 0));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_NNG_SEND_STR(pub, "one");
-	TEST_NNG_SEND_STR(pub, "two");
-	TEST_NNG_SEND_STR(pub, "three");
-	testutil_sleep(100);
-	TEST_NNG_RECV_STR(sub, "two");
-	TEST_NNG_RECV_STR(sub, "three");
-	TEST_NNG_FAIL(nng_recvmsg(sub, &msg, 0), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 2));
+	NUTS_PASS(nng_socket_set_bool(sub, NNG_OPT_SUB_PREFNEW, true));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, NULL, 0));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_MARRY(pub, sub);
+	NUTS_SEND(pub, "one");
+	NUTS_SEND(pub, "two");
+	NUTS_SEND(pub, "three");
+	NUTS_SLEEP(100);
+	NUTS_RECV(sub, "two");
+	NUTS_RECV(sub, "three");
+	NUTS_FAIL(nng_recvmsg(sub, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -481,46 +468,46 @@ test_sub_filter(void)
 	char       buf[32];
 	size_t     sz;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 10));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 10));
 
 	// Set up some default filters
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "abc", 3));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "def", 3));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "ghi", 3));
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_SUBSCRIBE, "jkl", 3));
-
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-
-	TEST_NNG_PASS(nng_send(pub, "def", 3, 0));
-	TEST_NNG_PASS(nng_send(pub, "de", 2, 0)); // will not go through
-	TEST_NNG_PASS(nng_send(pub, "abc123", 6, 0));
-	TEST_NNG_PASS(nng_send(pub, "xzy", 3, 0));     // does not match
-	TEST_NNG_PASS(nng_send(pub, "ghidrop", 7, 0)); // dropped by unsub
-	TEST_NNG_PASS(nng_send(pub, "jklmno", 6, 0));
-
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_setopt(sub, NNG_OPT_SUB_UNSUBSCRIBE, "ghi", 3));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "abc", 3));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "def", 3));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "ghi", 3));
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_SUBSCRIBE, "jkl", 3));
+
+	NUTS_MARRY(pub, sub);
+
+	NUTS_PASS(nng_send(pub, "def", 3, 0));
+	NUTS_PASS(nng_send(pub, "de", 2, 0)); // will not go through
+	NUTS_PASS(nng_send(pub, "abc123", 6, 0));
+	NUTS_PASS(nng_send(pub, "xzy", 3, 0));     // does not match
+	NUTS_PASS(nng_send(pub, "ghi-drop", 7, 0)); // dropped by unsub
+	NUTS_PASS(nng_send(pub, "jkl-mno", 6, 0));
+
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_socket_set(sub, NNG_OPT_SUB_UNSUBSCRIBE, "ghi", 3));
 	sz = sizeof(buf);
-	TEST_NNG_PASS(nng_recv(sub, buf, &sz, 0));
-	TEST_CHECK(sz == 3);
-	TEST_CHECK(memcmp(buf, "def", 3) == 0);
+	NUTS_PASS(nng_recv(sub, buf, &sz, 0));
+	NUTS_TRUE(sz == 3);
+	NUTS_TRUE(memcmp(buf, "def", 3) == 0);
 
 	sz = sizeof(buf);
-	TEST_NNG_PASS(nng_recv(sub, buf, &sz, 0));
-	TEST_CHECK(sz == 6);
-	TEST_CHECK(memcmp(buf, "abc123", 6) == 0);
+	NUTS_PASS(nng_recv(sub, buf, &sz, 0));
+	NUTS_TRUE(sz == 6);
+	NUTS_TRUE(memcmp(buf, "abc123", 6) == 0);
 
 	sz = sizeof(buf);
-	TEST_NNG_PASS(nng_recv(sub, buf, &sz, 0));
-	TEST_CHECK(sz == 6);
-	TEST_CHECK(memcmp(buf, "jklmno", 6) == 0);
+	NUTS_PASS(nng_recv(sub, buf, &sz, 0));
+	NUTS_TRUE(sz == 6);
+	NUTS_TRUE(memcmp(buf, "jkl-mno", 6) == 0);
 
-	TEST_NNG_PASS(nng_close(sub));
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_CLOSE(sub);
+	NUTS_CLOSE(pub);
 }
 
 static void
@@ -534,55 +521,55 @@ test_sub_multi_context(void)
 	nng_aio *  aio2;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_sub0_open(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
-	TEST_NNG_PASS(nng_ctx_open(&c1, sub));
-	TEST_NNG_PASS(nng_ctx_open(&c2, sub));
+	NUTS_PASS(nng_sub0_open(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_ctx_open(&c1, sub));
+	NUTS_PASS(nng_ctx_open(&c2, sub));
 
-	TEST_NNG_PASS(nng_ctx_setopt(c1, NNG_OPT_SUB_SUBSCRIBE, "one", 3));
-	TEST_NNG_PASS(nng_ctx_setopt(c1, NNG_OPT_SUB_SUBSCRIBE, "all", 3));
+	NUTS_PASS(nng_ctx_set(c1, NNG_OPT_SUB_SUBSCRIBE, "one", 3));
+	NUTS_PASS(nng_ctx_set(c1, NNG_OPT_SUB_SUBSCRIBE, "all", 3));
 
-	TEST_NNG_PASS(nng_ctx_setopt(c2, NNG_OPT_SUB_SUBSCRIBE, "two", 3));
-	TEST_NNG_PASS(nng_ctx_setopt(c2, NNG_OPT_SUB_SUBSCRIBE, "all", 3));
+	NUTS_PASS(nng_ctx_set(c2, NNG_OPT_SUB_SUBSCRIBE, "two", 3));
+	NUTS_PASS(nng_ctx_set(c2, NNG_OPT_SUB_SUBSCRIBE, "all", 3));
 
 	nng_aio_set_timeout(aio1, 100);
 	nng_aio_set_timeout(aio2, 100);
 
-	TEST_NNG_PASS(testutil_marry(pub, sub));
+	NUTS_MARRY(pub, sub);
 
-	TEST_NNG_SEND_STR(pub, "one for the money");
-	TEST_NNG_SEND_STR(pub, "all dogs go to heaven");
-	TEST_NNG_SEND_STR(pub, "nobody likes a snitch");
-	TEST_NNG_SEND_STR(pub, "two for the show");
+	NUTS_SEND(pub, "one for the money");
+	NUTS_SEND(pub, "all dogs go to heaven");
+	NUTS_SEND(pub, "nobody likes a snitch");
+	NUTS_SEND(pub, "two for the show");
 
 	nng_ctx_recv(c1, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio1));
 	m = nng_aio_get_msg(aio1);
-	TEST_CHECK(strcmp(nng_msg_body(m), "one for the money") == 0);
+	NUTS_MATCH(nng_msg_body(m), "one for the money");
 	nng_msg_free(m);
 
 	nng_ctx_recv(c1, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio1));
 	m = nng_aio_get_msg(aio1);
-	TEST_CHECK(strcmp(nng_msg_body(m), "all dogs go to heaven") == 0);
+	NUTS_MATCH(nng_msg_body(m), "all dogs go to heaven");
 	nng_msg_free(m);
 
 	nng_ctx_recv(c2, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio1));
 	m = nng_aio_get_msg(aio1);
-	TEST_CHECK(strcmp(nng_msg_body(m), "all dogs go to heaven") == 0);
+	NUTS_MATCH(nng_msg_body(m), "all dogs go to heaven");
 	nng_msg_free(m);
 
 	nng_ctx_recv(c2, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio1));
 	m = nng_aio_get_msg(aio1);
-	TEST_CHECK(strcmp(nng_msg_body(m), "two for the show") == 0);
+	NUTS_MATCH(nng_msg_body(m), "two for the show");
 	nng_msg_free(m);
 
 	nng_ctx_recv(c1, aio1);
@@ -590,10 +577,10 @@ test_sub_multi_context(void)
 
 	nng_aio_wait(aio1);
 	nng_aio_wait(aio2);
-	TEST_NNG_FAIL(nng_aio_result(aio1), NNG_ETIMEDOUT);
-	TEST_NNG_FAIL(nng_aio_result(aio2), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(sub));
-	TEST_NNG_PASS(nng_close(pub));
+	NUTS_FAIL(nng_aio_result(aio1), NNG_ETIMEDOUT);
+	NUTS_FAIL(nng_aio_result(aio2), NNG_ETIMEDOUT);
+	NUTS_CLOSE(sub);
+	NUTS_CLOSE(pub);
 	nng_aio_free(aio1);
 	nng_aio_free(aio2);
 }
@@ -604,10 +591,10 @@ test_sub_cooked(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_sub0_open(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(!b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_sub0_open(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(!b);
+	NUTS_CLOSE(s);
 }
 
 TEST_LIST = {
diff --git a/src/protocol/pubsub0/xsub_test.c b/src/protocol/pubsub0/xsub_test.c
index a05b893c..19815661 100644
--- a/src/protocol/pubsub0/xsub_test.c
+++ b/src/protocol/pubsub0/xsub_test.c
@@ -7,18 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pubsub0/pub.h>
-#include <nng/protocol/pubsub0/sub.h>
-
-#include <acutest.h>
-#include <testutil.h>
-
-#ifndef NNI_PROTO
-#define NNI_PROTO(x, y) (((x) << 4u) | (y))
-#endif
+#include <nuts.h>
 
 static void
 test_xsub_identity(void)
@@ -27,18 +16,18 @@ test_xsub_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 1u)); // 33
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p));
-	TEST_CHECK(p == NNI_PROTO(2u, 0u)); // 32
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n));
-	TEST_CHECK(strcmp(n, "sub") == 0);
+	NUTS_PASS(nng_sub0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 1u)); // 33
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NUTS_PROTO(2u, 0u)); // 32
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, "sub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n));
-	TEST_CHECK(strcmp(n, "pub") == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, "pub");
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -46,9 +35,9 @@ test_xsub_cannot_send(void)
 {
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_FAIL(nng_send(sub, "", 0, 0), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_FAIL(nng_send(sub, "", 0, 0), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -57,9 +46,9 @@ test_xsub_not_writeable(void)
 	int        fd;
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_FAIL(nng_getopt_int(sub, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_FAIL(nng_socket_get_int(sub, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -69,33 +58,33 @@ test_xsub_poll_readable(void)
 	nng_socket pub;
 	nng_socket sub;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_getopt_int(sub, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_get_int(sub, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(pub, sub);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(pub, "abc");
-	testutil_sleep(200);
+	NUTS_SEND(pub, "abc");
+	NUTS_SLEEP(200);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
 	// and receiving makes it no longer ready
-	TEST_NNG_RECV_STR(sub, "abc");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_RECV(sub, "abc");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -107,40 +96,40 @@ test_xsub_recv_late(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_getopt_int(sub, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_get_int(sub, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(pub, sub));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(pub, sub);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	nng_recv_aio(sub, aio);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(pub, "abc");
-	testutil_sleep(200);
+	NUTS_SEND(pub, "abc");
+	NUTS_SLEEP(200);
 
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	msg = nng_aio_get_msg(aio);
 	nng_aio_set_msg(aio, NULL);
-	TEST_CHECK(nng_msg_len(msg) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "abc") == 0);
+	NUTS_TRUE(nng_msg_len(msg) == 4);
+	NUTS_TRUE(strcmp(nng_msg_body(msg), "abc") == 0);
 
 	nng_msg_free(msg);
 	nng_aio_free(aio);
 
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -149,9 +138,9 @@ test_xsub_no_context(void)
 	nng_socket sub;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, sub), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_FAIL(nng_ctx_open(&ctx, sub), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 void
@@ -160,28 +149,28 @@ test_xsub_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&s1));
-	TEST_NNG_PASS(nng_sub0_open_raw(&s2));
+	NUTS_PASS(nng_sub0_open_raw(&s1));
+	NUTS_PASS(nng_sub0_open_raw(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -190,12 +179,12 @@ test_xsub_recv_closed(void)
 {
 	nng_socket sub;
 	nng_aio *  aio;
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	nng_close(sub);
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_CLOSE(sub);
 	nng_recv_aio(sub, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
 }
 
@@ -205,13 +194,13 @@ test_xsub_close_recv(void)
 	nng_socket sub;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_aio_set_timeout(aio, 1000);
 	nng_recv_aio(sub, aio);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 
 	nng_aio_free(aio);
 }
@@ -222,15 +211,15 @@ test_xsub_recv_nonblock(void)
 	nng_socket sub;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_recv_aio(sub, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
@@ -243,27 +232,27 @@ test_xsub_recv_buf_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_RECVBUF;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
 
-	TEST_NNG_PASS(nng_setopt_int(sub, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(sub, opt, 1000000), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(sub, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(sub, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(sub, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(sub, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(sub, opt, 1000000), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(sub, opt, 3));
+	NUTS_PASS(nng_socket_get_int(sub, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(sub, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(sub, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(sub, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(sub, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(sub, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(sub, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(sub, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(sub, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(sub, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(sub, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -272,9 +261,9 @@ test_xsub_subscribe_option(void)
 	nng_socket  sub;
 	const char *opt = NNG_OPT_SUB_SUBSCRIBE;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_FAIL(nng_setopt(sub, opt, "abc", 3), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_FAIL(nng_socket_set(sub, opt, "abc", 3), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -283,9 +272,9 @@ test_xsub_unsubscribe_option(void)
 	nng_socket  sub;
 	const char *opt = NNG_OPT_SUB_UNSUBSCRIBE;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_FAIL(nng_setopt(sub, opt, "abc", 3), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_FAIL(nng_socket_set(sub, opt, "abc", 3), NNG_ENOTSUP);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -294,10 +283,10 @@ test_xsub_raw(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_sub0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -306,20 +295,20 @@ test_xsub_close_during_recv(void)
 	nng_socket sub;
 	nng_socket pub;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(pub, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(pub, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry(pub, sub));
+	NUTS_MARRY(pub, sub);
 
 	for (unsigned i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_send(pub, "abc", 3, 0));
+		NUTS_PASS(nng_send(pub, "abc", 3, 0));
 	}
-	TEST_NNG_PASS(nng_close(pub));
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(pub);
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -328,14 +317,14 @@ test_xsub_close_during_pipe_recv(void)
 	nng_socket sub;
 	nng_socket pub;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_pub0_open(&pub));
-	TEST_NNG_PASS(nng_setopt_ms(sub, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(pub, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(sub, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(pub, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_pub0_open(&pub));
+	NUTS_PASS(nng_socket_set_ms(sub, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(pub, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(sub, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(pub, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry(pub, sub));
+	NUTS_MARRY(pub, sub);
 
 	for (unsigned i = 0; i < 100; i++) {
 		int rv;
@@ -343,9 +332,9 @@ test_xsub_close_during_pipe_recv(void)
 		if (rv == NNG_ETIMEDOUT) {
 			break;
 		}
-		testutil_sleep(1);
+		NUTS_SLEEP(1);
 	}
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_CLOSE(sub);
 }
 
 static void
@@ -354,14 +343,14 @@ test_xsub_recv_aio_stopped(void)
 	nng_socket sub;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_sub0_open_raw(&sub));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_sub0_open_raw(&sub));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_stop(aio);
 	nng_recv_aio(sub, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(sub));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(sub);
 	nng_aio_free(aio);
 }
 
diff --git a/src/protocol/reqrep0/rep_test.c b/src/protocol/reqrep0/rep_test.c
index a79a342b..5a47e67a 100644
--- a/src/protocol/reqrep0/rep_test.c
+++ b/src/protocol/reqrep0/rep_test.c
@@ -7,15 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/reqrep0/rep.h>
-#include <nng/protocol/reqrep0/req.h>
-#include <nng/supplemental/util/platform.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_rep_identity(void)
@@ -25,16 +17,16 @@ test_rep_identity(void)
 	char *     n1;
 	char *     n2;
 
-	TEST_NNG_PASS(nng_rep0_open(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p1));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p2));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n1));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n2));
-	TEST_NNG_PASS(nng_close(s));
-	TEST_CHECK(p1 == NNG_REP0_SELF);
-	TEST_CHECK(p2 == NNG_REP0_PEER);
-	TEST_CHECK(strcmp(n1, NNG_REP0_SELF_NAME) == 0);
-	TEST_CHECK(strcmp(n2, NNG_REP0_PEER_NAME) == 0);
+	NUTS_PASS(nng_rep0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p1));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p2));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n1));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n2));
+	NUTS_CLOSE(s);
+	NUTS_TRUE(p1 == NNG_REP0_SELF);
+	NUTS_TRUE(p2 == NNG_REP0_PEER);
+	NUTS_MATCH(n1, NNG_REP0_SELF_NAME);
+	NUTS_MATCH(n2, NNG_REP0_PEER_NAME);
 	nng_strfree(n1);
 	nng_strfree(n2);
 }
@@ -45,11 +37,11 @@ test_rep_send_bad_state(void)
 	nng_socket rep;
 	nng_msg *  msg = NULL;
 
-	TEST_CHECK(nng_rep0_open(&rep) == 0);
-	TEST_CHECK(nng_msg_alloc(&msg, 0) == 0);
-	TEST_CHECK(nng_sendmsg(rep, msg, 0) == NNG_ESTATE);
+	NUTS_TRUE(nng_rep0_open(&rep) == 0);
+	NUTS_TRUE(nng_msg_alloc(&msg, 0) == 0);
+	NUTS_TRUE(nng_sendmsg(rep, msg, 0) == NNG_ESTATE);
 	nng_msg_free(msg);
-	TEST_CHECK(nng_close(rep) == 0);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -59,33 +51,33 @@ test_rep_poll_writeable(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(rep, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(rep, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not writable before connect.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// Still not writable.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// If we get a job, *then* we become writable
-	TEST_NNG_SEND_STR(req, "abc");
-	TEST_NNG_RECV_STR(rep, "abc");
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_SEND(req, "abc");
+	NUTS_RECV(rep, "abc");
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// And is no longer writable once we send a message
-	TEST_NNG_SEND_STR(rep, "def");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_SEND(rep, "def");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 	// Even after receiving it
-	TEST_NNG_RECV_STR(req, "def");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_RECV(req, "def");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -96,34 +88,34 @@ test_rep_poll_readable(void)
 	nng_socket rep;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(rep, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(rep, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(req, rep);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(req, "abc");
-	testutil_sleep(100);
+	NUTS_SEND(req, "abc");
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0));
+	NUTS_PASS(nng_recvmsg(rep, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// TODO verify unsolicited response
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -133,14 +125,12 @@ test_rep_context_no_poll(void)
 	nng_socket req;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_rep0_open(&req));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_PASS(nng_rep0_open(&req));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(req);
 }
 
 void
@@ -149,28 +139,27 @@ test_rep_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
-
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	char *     addr;
 
-	TEST_NNG_PASS(nng_rep0_open(&s1));
-	TEST_NNG_PASS(nng_rep0_open(&s2));
+	NUTS_ADDR(addr, "inproc");
+	NUTS_PASS(nng_rep0_open(&s1));
+	NUTS_PASS(nng_rep0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -181,17 +170,17 @@ test_rep_double_recv(void)
 	nng_aio *  aio1;
 	nng_aio *  aio2;
 
-	TEST_NNG_PASS(nng_rep0_open(&s1));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_rep0_open(&s1));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
 
 	nng_recv_aio(s1, aio1);
 	nng_recv_aio(s1, aio2);
 
 	nng_aio_wait(aio2);
-	TEST_NNG_FAIL(nng_aio_result(aio2), NNG_ESTATE);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_FAIL(nng_aio_result(aio1), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio2), NNG_ESTATE);
+	NUTS_CLOSE(s1);
+	NUTS_FAIL(nng_aio_result(aio1), NNG_ECLOSED);
 	nng_aio_free(aio1);
 	nng_aio_free(aio2);
 }
@@ -205,26 +194,26 @@ test_rep_close_pipe_before_send(void)
 	nng_aio *  aio1;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_NNG_SEND_STR(req, "test");
+	NUTS_MARRY(req, rep);
+	NUTS_SEND(req, "test");
 
 	nng_recv_aio(rep, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_CHECK((m = nng_aio_get_msg(aio1)) != NULL);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_TRUE((m = nng_aio_get_msg(aio1)) != NULL);
 	p = nng_msg_get_pipe(m);
-	TEST_NNG_PASS(nng_pipe_close(p));
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
+	NUTS_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio1);
 }
 
@@ -236,25 +225,24 @@ test_rep_close_pipe_during_send(void)
 	nng_pipe   p = NNG_PIPE_INITIALIZER;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 20));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_RECVBUF, 1));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	for (int i = 0; i < 100; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-		TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(req, m, 0));
+		NUTS_PASS(nng_recvmsg(rep, &m, 0));
 		p  = nng_msg_get_pipe(m);
 		rv = nng_sendmsg(rep, m, 0);
 		if (rv == NNG_ETIMEDOUT) {
@@ -262,12 +250,12 @@ test_rep_close_pipe_during_send(void)
 			nng_msg_free(m);
 			break;
 		}
-		TEST_NNG_PASS(rv);
+		NUTS_PASS(rv);
 	}
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -277,16 +265,16 @@ test_rep_ctx_recv_aio_stopped(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, rep));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_ctx_open(&ctx, rep));
 
 	nng_aio_stop(aio);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio);
 }
 
@@ -301,54 +289,53 @@ test_rep_close_pipe_context_send(void)
 	nng_aio *  aio[100];
 	int        i;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
 	for (i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], rep));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_ctx_open(&ctx[i], rep));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
 	}
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_RECVBUF, 1));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	for (i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(req, m, 0));
 		nng_ctx_recv(ctx[i], aio[i]);
 	}
 	for (i = 0; i < 100; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_PASS(nng_aio_result(aio[i]));
-		TEST_CHECK((m = nng_aio_get_msg(aio[i])) != NULL);
+		NUTS_PASS(nng_aio_result(aio[i]));
+		NUTS_TRUE((m = nng_aio_get_msg(aio[i])) != NULL);
 		p = nng_msg_get_pipe(m);
 		nng_aio_set_msg(aio[i], m);
 		nng_ctx_send(ctx[i], aio[i]);
 	}
 
 	// Note that REQ socket is not reading the results.
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
 	for (i = 0; i < 100; i++) {
 		int rv;
 		nng_aio_wait(aio[i]);
 		rv = nng_aio_result(aio[i]);
 		if (rv != 0) {
-			TEST_NNG_FAIL(rv, NNG_ECLOSED);
+			NUTS_FAIL(rv, NNG_ECLOSED);
 			nng_msg_free(nng_aio_get_msg(aio[i]));
 		}
 		nng_aio_free(aio[i]);
-		TEST_NNG_PASS(nng_ctx_close(ctx[i]));
+		NUTS_PASS(nng_ctx_close(ctx[i]));
 	}
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -361,33 +348,32 @@ test_rep_close_context_send(void)
 	nng_aio *  aio[100];
 	int        i;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
 	for (i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], rep));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_ctx_open(&ctx[i], rep));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
 	}
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_RECVBUF, 1));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	for (i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(req, m, 0));
 		nng_ctx_recv(ctx[i], aio[i]);
 	}
 	for (i = 0; i < 100; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_PASS(nng_aio_result(aio[i]));
-		TEST_CHECK((m = nng_aio_get_msg(aio[i])) != NULL);
+		NUTS_PASS(nng_aio_result(aio[i]));
+		NUTS_TRUE((m = nng_aio_get_msg(aio[i])) != NULL);
 		nng_aio_set_msg(aio[i], m);
 		nng_ctx_send(ctx[i], aio[i]);
 	}
@@ -395,17 +381,17 @@ test_rep_close_context_send(void)
 	// Note that REQ socket is not reading the results.
 	for (i = 0; i < 100; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_ctx_close(ctx[i]));
+		NUTS_PASS(nng_ctx_close(ctx[i]));
 		nng_aio_wait(aio[i]);
 		rv = nng_aio_result(aio[i]);
 		if (rv != 0) {
-			TEST_NNG_FAIL(rv, NNG_ECLOSED);
+			NUTS_FAIL(rv, NNG_ECLOSED);
 			nng_msg_free(nng_aio_get_msg(aio[i]));
 		}
 		nng_aio_free(aio[i]);
 	}
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -415,19 +401,19 @@ test_rep_close_recv(void)
 	nng_socket req;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_MARRY(req, rep);
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_recv_aio(rep, aio);
-	TEST_NNG_PASS(nng_close(rep));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(rep);
+	NUTS_CLOSE(req);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
 }
 
@@ -461,28 +447,28 @@ test_rep_close_recv_cb(void)
 	struct rep_close_recv_cb_state state;
 
 	memset(&state, 0, sizeof(state));
-	TEST_NNG_PASS(nng_mtx_alloc(&state.mtx));
-	TEST_NNG_PASS(nng_cv_alloc(&state.cv, state.mtx));
+	NUTS_PASS(nng_mtx_alloc(&state.mtx));
+	NUTS_PASS(nng_cv_alloc(&state.cv, state.mtx));
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_NNG_PASS(nng_aio_alloc(&state.aio, rep_close_recv_cb, &state));
+	NUTS_MARRY(req, rep);
+	NUTS_PASS(nng_aio_alloc(&state.aio, rep_close_recv_cb, &state));
 	nng_recv_aio(rep, state.aio);
-	TEST_NNG_PASS(nng_close(rep));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(rep);
+	NUTS_CLOSE(req);
 	nng_mtx_lock(state.mtx);
 	while (!state.done) {
-		TEST_NNG_PASS(nng_cv_until(state.cv, nng_clock() + 1000));
+		NUTS_PASS(nng_cv_until(state.cv, nng_clock() + 1000));
 	}
 	nng_mtx_unlock(state.mtx);
-	TEST_CHECK(state.done != 0);
-	TEST_NNG_FAIL(nng_aio_result(state.aio), NNG_ECLOSED);
-	TEST_CHECK(nng_aio_get_msg(state.aio) == NULL);
+	NUTS_TRUE(state.done != 0);
+	NUTS_FAIL(nng_aio_result(state.aio), NNG_ECLOSED);
+	NUTS_TRUE(nng_aio_get_msg(state.aio) == NULL);
 	nng_aio_free(state.aio);
 	nng_cv_free(state.cv);
 	nng_mtx_free(state.mtx);
@@ -495,16 +481,16 @@ test_rep_ctx_recv_nonblock(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, rep));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_ctx_open(&ctx, rep));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio);
 }
 
@@ -517,19 +503,19 @@ test_rep_ctx_send_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 2000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, rep));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 2000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_ctx_open(&ctx, rep));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_SEND_STR(req, "SEND");
+	NUTS_SEND(req, "SEND");
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	// message carries over
 	msg = nng_aio_get_msg(aio);
 	nng_aio_set_msg(aio, msg);
@@ -537,9 +523,9 @@ test_rep_ctx_send_nonblock(void)
 	nng_ctx_send(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
-	TEST_NNG_PASS(nng_close(rep));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_PASS(nng_aio_result(aio));
+	NUTS_CLOSE(rep);
+	NUTS_CLOSE(req);
 	nng_aio_free(aio);
 }
 
@@ -556,29 +542,28 @@ test_rep_ctx_send_nonblock2(void)
 	// We are going to send a bunch of requests, receive them,
 	// but then see that non-block pressure exerts for some, but
 	// that at least one non-blocking send works.
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
 	for (int i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&rep_ctx[i], rep));
-		TEST_NNG_PASS(nng_aio_alloc(&rep_aio[i], NULL, NULL));
+		NUTS_PASS(nng_ctx_open(&rep_ctx[i], rep));
+		NUTS_PASS(nng_aio_alloc(&rep_aio[i], NULL, NULL));
 	}
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	for (int i = 0; i < 10; i++) {
 		nng_msg *msg;
-		TEST_NNG_PASS(nng_msg_alloc(&msg, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(msg, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_msg_alloc(&msg, 4));
+		NUTS_PASS(nng_msg_append_u32(msg, (unsigned) i | 0x80000000u));
 		nng_ctx_recv(rep_ctx[i], rep_aio[i]);
-		TEST_NNG_PASS(nng_sendmsg(req, msg, 0));
+		NUTS_PASS(nng_sendmsg(req, msg, 0));
 	}
 	for (int i = 0; i < 10; i++) {
 		nng_msg *msg;
 		nng_aio_wait(rep_aio[i]);
-		TEST_NNG_PASS(nng_aio_result(rep_aio[i]));
+		NUTS_PASS(nng_aio_result(rep_aio[i]));
 		msg = nng_aio_get_msg(rep_aio[i]);
 		nng_aio_set_timeout(rep_aio[i], 0);
 		nng_aio_set_msg(rep_aio[i], msg);
@@ -592,7 +577,7 @@ test_rep_ctx_send_nonblock2(void)
 		if (rv == 0) {
 			num_good++;
 		} else {
-			TEST_NNG_FAIL(rv, NNG_ETIMEDOUT);
+			NUTS_FAIL(rv, NNG_ETIMEDOUT);
 			nng_msg_free(nng_aio_get_msg(rep_aio[i]));
 			num_fail++;
 		}
@@ -605,8 +590,8 @@ test_rep_ctx_send_nonblock2(void)
 		nng_aio_free(rep_aio[i]);
 		nng_ctx_close(rep_ctx[i]);
 	}
-	TEST_NNG_PASS(nng_close(rep));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(rep);
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -616,24 +601,24 @@ test_rep_send_nonblock(void)
 	nng_socket req;
 	int        rv;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_SEND_STR(req, "SEND");
-	TEST_NNG_RECV_STR(rep, "SEND");
+	NUTS_SEND(req, "SEND");
+	NUTS_RECV(rep, "SEND");
 
 	// Use the nonblock flag
 	rv = nng_send(rep, "RECV", 5, NNG_FLAG_NONBLOCK);
 
-	TEST_NNG_PASS(rv);
-	TEST_NNG_RECV_STR(req, "RECV");
-	TEST_NNG_PASS(nng_close(rep));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_PASS(rv);
+	NUTS_RECV(req, "RECV");
+	NUTS_CLOSE(rep);
+	NUTS_CLOSE(req);
 }
 
 void
@@ -643,24 +628,24 @@ test_rep_recv_garbage(void)
 	nng_socket req;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, 1u));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+	NUTS_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "rep identity", test_rep_identity },
 	{ "rep send bad state", test_rep_send_bad_state },
 	{ "rep poll readable", test_rep_poll_readable },
diff --git a/src/protocol/reqrep0/req_test.c b/src/protocol/reqrep0/req_test.c
index add420de..fb78efa0 100644
--- a/src/protocol/reqrep0/req_test.c
+++ b/src/protocol/reqrep0/req_test.c
@@ -8,14 +8,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/reqrep0/rep.h>
-#include <nng/protocol/reqrep0/req.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_req_identity(void)
@@ -24,18 +17,18 @@ test_req_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_NNG_PASS(nng_req0_open(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p));
-	TEST_CHECK(p == NNG_REQ0_SELF);
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p));
-	TEST_CHECK(p == NNG_REQ0_PEER); // 49
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n));
-	TEST_CHECK(strcmp(n, NNG_REQ0_SELF_NAME) == 0);
+	NUTS_PASS(nng_req0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NNG_REQ0_SELF);
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NNG_REQ0_PEER); // 49
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, NNG_REQ0_SELF_NAME);
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n));
-	TEST_CHECK(strcmp(n, NNG_REQ0_PEER_NAME) == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, NNG_REQ0_PEER_NAME);
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -47,31 +40,31 @@ test_req_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_req0_open(&req));
 
-	TEST_NNG_PASS(nng_setopt_int(req, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(req, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(req, opt, -1), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(req, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(req, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(req, opt, -1), NNG_EINVAL);
 	// This test will fail if the NNI_MAX_MAX_TTL is changed from the
 	// builtin default of 15.
-	TEST_NNG_FAIL(nng_setopt_int(req, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(req, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(req, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(req, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_FAIL(nng_socket_set_int(req, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(req, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(req, opt, 3));
+	NUTS_PASS(nng_socket_get_int(req, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(req, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(req, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(req, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(req, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(req, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(req, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(req, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(req, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(req, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(req, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -83,17 +76,17 @@ test_req_resend_option(void)
 	size_t       sz  = sizeof(b);
 	const char * opt = NNG_OPT_REQ_RESENDTIME;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_req0_open(&req));
 
-	TEST_CHECK(nng_setopt_ms(req, opt, 10) == 0);
-	TEST_NNG_FAIL(nng_setopt(req, opt, "", 1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_getopt(req, opt, &b, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(req, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(req, opt, &b), NNG_EBADTYPE);
+	NUTS_TRUE(nng_socket_set_ms(req, opt, 10) == 0);
+	NUTS_FAIL(nng_socket_set(req, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_get(req, opt, &b, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(req, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(req, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_getopt_ms(req, opt, &d));
-	TEST_CHECK(d == 10);
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_PASS(nng_socket_get_ms(req, opt, &d));
+	NUTS_TRUE(d == 10);
+	NUTS_CLOSE(req);
 }
 
 void
@@ -102,10 +95,10 @@ test_req_recv_bad_state(void)
 	nng_socket req;
 	nng_msg *  msg = NULL;
 
-	TEST_CHECK(nng_req0_open(&req) == 0);
-	TEST_CHECK(nng_recvmsg(req, &msg, 0) == NNG_ESTATE);
-	TEST_CHECK(msg == NULL);
-	TEST_CHECK(nng_close(req) == 0);
+	NUTS_TRUE(nng_req0_open(&req) == 0);
+	NUTS_TRUE(nng_recvmsg(req, &msg, 0) == NNG_ESTATE);
+	NUTS_NULL(msg);
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -116,31 +109,31 @@ test_req_recv_garbage(void)
 	nng_msg *  m;
 	uint32_t   req_id;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
+	NUTS_PASS(nng_recvmsg(rep, &m, 0));
 
 	// The message will have a header that contains the 32-bit pipe ID,
 	// followed by the 32-bit request ID.  We will discard the request
 	// ID before sending it out.
-	TEST_CHECK(nng_msg_header_len(m) == 8);
-	TEST_NNG_PASS(nng_msg_header_chop_u32(m, &req_id));
+	NUTS_TRUE(nng_msg_header_len(m) == 8);
+	NUTS_PASS(nng_msg_header_chop_u32(m, &req_id));
 
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(req, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
+	NUTS_FAIL(nng_recvmsg(req, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 #define SECOND 1000
@@ -150,40 +143,24 @@ test_req_rep_exchange(void)
 {
 	nng_socket req;
 	nng_socket rep;
-	nng_msg *  msg = NULL;
 
-	TEST_CHECK(nng_req0_open(&req) == 0);
-	TEST_CHECK(nng_rep0_open(&rep) == 0);
-
-	TEST_CHECK(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, SECOND) == 0);
-
-	TEST_CHECK(testutil_marry(rep, req) == 0);
-
-	TEST_CHECK(nng_msg_alloc(&msg, 0) == 0);
-	TEST_CHECK(nng_msg_append(msg, "ping", 5) == 0);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "ping") == 0);
-	TEST_CHECK(nng_sendmsg(req, msg, 0) == 0);
-	msg = NULL;
-	TEST_CHECK(nng_recvmsg(rep, &msg, 0) == 0);
-	TEST_CHECK(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "ping") == 0);
-	nng_msg_trim(msg, 5);
-	TEST_CHECK(nng_msg_append(msg, "pong", 5) == 0);
-	TEST_CHECK(nng_sendmsg(rep, msg, 0) == 0);
-	msg = NULL;
-	TEST_CHECK(nng_recvmsg(req, &msg, 0) == 0);
-	TEST_CHECK(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "pong") == 0);
-	nng_msg_free(msg);
+	NUTS_TRUE(nng_req0_open(&req) == 0);
+	NUTS_TRUE(nng_rep0_open(&rep) == 0);
+
+	NUTS_TRUE(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND) == 0);
+	NUTS_TRUE(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, SECOND) == 0);
+	NUTS_TRUE(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND) == 0);
+	NUTS_TRUE(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, SECOND) == 0);
+
+	NUTS_MARRY(rep, req);
 
-	TEST_CHECK(nng_close(req) == 0);
-	TEST_CHECK(nng_close(rep) == 0);
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep, "ping");
+	NUTS_SEND(rep, "pong");
+	NUTS_RECV(req, "pong");
+
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -192,24 +169,24 @@ test_req_resend(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
 
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, 10));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, 10));
 
-	TEST_NNG_PASS(testutil_marry(rep, req));
+	NUTS_MARRY(rep, req);
 
-	TEST_NNG_SEND_STR(req, "ping");
-	TEST_NNG_RECV_STR(rep, "ping");
-	TEST_NNG_RECV_STR(rep, "ping");
-	TEST_NNG_RECV_STR(rep, "ping");
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep, "ping");
+	NUTS_RECV(rep, "ping");
+	NUTS_RECV(rep, "ping");
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -219,34 +196,34 @@ test_req_resend_reconnect(void)
 	nng_socket rep1;
 	nng_socket rep2;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep1));
-	TEST_NNG_PASS(nng_rep0_open(&rep2));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep1));
+	NUTS_PASS(nng_rep0_open(&rep2));
 
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_SENDTIMEO, SECOND));
 	// We intentionally set the retry time long; that way we only see
 	// the retry from loss of our original peer.
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, 60 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, 60 * SECOND));
 
-	TEST_NNG_PASS(testutil_marry(rep1, req));
+	NUTS_MARRY(rep1, req);
 
-	TEST_NNG_SEND_STR(req, "ping");
-	TEST_NNG_RECV_STR(rep1, "ping");
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep1, "ping");
 
-	TEST_NNG_PASS(nng_close(rep1));
-	TEST_NNG_PASS(testutil_marry(rep2, req));
+	NUTS_CLOSE(rep1);
+	NUTS_MARRY(rep2, req);
 
-	TEST_NNG_RECV_STR(rep2, "ping");
-	TEST_NNG_SEND_STR(rep2, "rep2");
-	TEST_NNG_RECV_STR(req, "rep2");
+	NUTS_RECV(rep2, "ping");
+	NUTS_SEND(rep2, "rep2");
+	NUTS_RECV(req, "rep2");
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep2));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep2);
 }
 
 void
@@ -256,33 +233,33 @@ test_req_resend_disconnect(void)
 	nng_socket rep1;
 	nng_socket rep2;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep1));
-	TEST_NNG_PASS(nng_rep0_open(&rep2));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep1));
+	NUTS_PASS(nng_rep0_open(&rep2));
 
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_SENDTIMEO, SECOND));
 	// We intentionally set the retry time long; that way we only see
 	// the retry from loss of our original peer.
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, 60 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, 60 * SECOND));
 
-	TEST_NNG_PASS(testutil_marry(rep1, req));
-	TEST_NNG_SEND_STR(req, "ping");
-	TEST_NNG_RECV_STR(rep1, "ping");
+	NUTS_MARRY(rep1, req);
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep1, "ping");
 
-	TEST_NNG_PASS(testutil_marry(rep2, req));
-	TEST_NNG_PASS(nng_close(rep1));
+	NUTS_MARRY(rep2, req);
+	NUTS_CLOSE(rep1);
 
-	TEST_NNG_RECV_STR(rep2, "ping");
-	TEST_NNG_SEND_STR(rep2, "rep2");
-	TEST_NNG_RECV_STR(req, "rep2");
+	NUTS_RECV(rep2, "ping");
+	NUTS_SEND(rep2, "rep2");
+	NUTS_RECV(req, "rep2");
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep2));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep2);
 }
 
 void
@@ -292,32 +269,32 @@ test_req_disconnect_no_retry(void)
 	nng_socket rep1;
 	nng_socket rep2;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep1));
-	TEST_NNG_PASS(nng_rep0_open(&rep2));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep1));
+	NUTS_PASS(nng_rep0_open(&rep2));
 
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_SENDTIMEO, SECOND / 10));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_SENDTIMEO, SECOND / 10));
 	// Setting the resend time to zero so we will force an error
 	// if the peer disconnects without sending us an answer.
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, 0));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, 0));
 
-	TEST_NNG_PASS(testutil_marry(rep1, req));
-	TEST_NNG_SEND_STR(req, "ping");
-	TEST_NNG_RECV_STR(rep1, "ping");
+	NUTS_MARRY(rep1, req);
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep1, "ping");
 
-	TEST_NNG_PASS(testutil_marry(rep2, req));
-	TEST_NNG_PASS(nng_close(rep1));
+	NUTS_MARRY(rep2, req);
+	NUTS_CLOSE(rep1);
 
 	nng_msg *msg = NULL;
-	TEST_NNG_FAIL(nng_recvmsg(req, &msg, 0), NNG_ECONNRESET);
-	TEST_NNG_FAIL(nng_recvmsg(rep2, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_FAIL(nng_recvmsg(req, &msg, 0), NNG_ECONNRESET);
+	NUTS_FAIL(nng_recvmsg(rep2, &msg, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep2));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep2);
 }
 
 void
@@ -328,186 +305,152 @@ test_req_disconnect_abort(void)
 	nng_socket rep2;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep1));
-	TEST_NNG_PASS(nng_rep0_open(&rep2));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, 0, 0));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep1));
+	NUTS_PASS(nng_rep0_open(&rep2));
+	NUTS_PASS(nng_aio_alloc(&aio, 0, 0));
 
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep1, NNG_OPT_SENDTIMEO, SECOND / 10));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep2, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep1, NNG_OPT_SENDTIMEO, SECOND / 10));
 	// Setting the resend time to zero so we will force an error
 	// if the peer disconnects without sending us an answer.
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, 0));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, 0));
 
-	TEST_NNG_PASS(testutil_marry(rep1, req));
-	TEST_NNG_SEND_STR(req, "ping");
-	TEST_NNG_RECV_STR(rep1, "ping");
+	NUTS_MARRY(rep1, req);
+	NUTS_SEND(req, "ping");
+	NUTS_RECV(rep1, "ping");
 	nng_recv_aio(req, aio);
 
-	TEST_NNG_PASS(testutil_marry(rep2, req));
-	TEST_NNG_PASS(nng_close(rep1));
+	NUTS_MARRY(rep2, req);
+	NUTS_CLOSE(rep1);
 
 	nng_msg *msg = NULL;
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECONNRESET);
-	TEST_NNG_FAIL(nng_recvmsg(rep2, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECONNRESET);
+	NUTS_FAIL(nng_recvmsg(rep2, &msg, 0), NNG_ETIMEDOUT);
 	nng_aio_free(aio);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep2));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep2);
 }
 
 void
 test_req_cancel(void)
 {
-	nng_msg *    abc;
-	nng_msg *    def;
-	nng_msg *    cmd;
 	nng_duration retry = SECOND;
 	nng_socket   req;
 	nng_socket   rep;
 
-	TEST_NNG_PASS(nng_rep_open(&rep));
-	TEST_NNG_PASS(nng_req_open(&req));
-
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, retry));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 16));
+	NUTS_PASS(nng_rep_open(&rep));
+	NUTS_PASS(nng_req_open(&req));
 
-	TEST_NNG_PASS(nng_msg_alloc(&abc, 0));
-	TEST_NNG_PASS(nng_msg_append(abc, "abc", 4));
-	TEST_NNG_PASS(nng_msg_alloc(&def, 0));
-	TEST_NNG_PASS(nng_msg_append(def, "def", 4));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, retry));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 16));
 
-	TEST_NNG_PASS(testutil_marry(rep, req));
+	NUTS_MARRY(rep, req);
 
 	// Send req #1 (abc).
-	TEST_CHECK(nng_sendmsg(req, abc, 0) == 0);
+	NUTS_SEND(req, "abc");
 
 	// Sleep a bit.  This is so that we ensure that our request gets
 	// to the far side.  (If we cancel too fast, then our outgoing send
 	// will be canceled before it gets to the peer.)
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	// Send the next next request ("def").  Note that
 	// the REP side server will have already buffered the receive
 	// request, and should simply be waiting for us to reply to abc.
-	TEST_NNG_PASS(nng_sendmsg(req, def, 0));
+	NUTS_SEND(req, "def");
 
 	// Receive the first request (should be abc) on the REP server.
-	TEST_NNG_PASS(nng_recvmsg(rep, &cmd, 0));
-	TEST_ASSERT(cmd != NULL);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "abc") == 0);
+	NUTS_RECV(rep, "abc");
 
 	// REP sends the reply to first command.  This will be discarded
 	// by the REQ socket.
-	TEST_NNG_PASS(nng_sendmsg(rep, cmd, 0));
+	NUTS_SEND(rep, "abc");
 
 	// Now get the next command from the REP; should be "def".
-	TEST_NNG_PASS(nng_recvmsg(rep, &cmd, 0));
-	TEST_ASSERT(cmd != NULL);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	TEST_MSG("Received body was %s", nng_msg_body(cmd));
+	NUTS_RECV(rep, "def");
 
 	// And send it back to REQ.
-	TEST_NNG_PASS(nng_sendmsg(rep, cmd, 0));
+	NUTS_SEND(rep, "def");
 
-	// Try a req command.  This should give back "def"
-	TEST_NNG_PASS(nng_recvmsg(req, &cmd, 0));
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	nng_msg_free(cmd);
+	// And we got back only the second result.
+	NUTS_RECV(req, "def");
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
 test_req_cancel_abort_recv(void)
 {
-
-	nng_msg *    abc;
-	nng_msg *    def;
-	nng_msg *    cmd;
 	nng_aio *    aio;
 	nng_duration retry = SECOND * 10; // 10s (kind of never)
 	nng_socket   req;
 	nng_socket   rep;
 
-	TEST_CHECK(nng_rep_open(&rep) == 0);
-	TEST_CHECK(nng_req_open(&req) == 0);
-	TEST_CHECK(nng_aio_alloc(&aio, NULL, NULL) == 0);
-
-	TEST_CHECK(nng_setopt_ms(req, NNG_OPT_REQ_RESENDTIME, retry) == 0);
-	TEST_CHECK(nng_setopt_int(req, NNG_OPT_SENDBUF, 16) == 0);
-	TEST_CHECK(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 5 * SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 5 * SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 5 * SECOND) == 0);
-	TEST_CHECK(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 5 * SECOND) == 0);
+	NUTS_PASS(nng_rep_open(&rep));
+	NUTS_PASS(nng_req_open(&req));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
-	TEST_CHECK(nng_msg_alloc(&abc, 0) == 0);
-	TEST_CHECK(nng_msg_append(abc, "abc", 4) == 0);
-	TEST_CHECK(nng_msg_alloc(&def, 0) == 0);
-	TEST_CHECK(nng_msg_append(def, "def", 4) == 0);
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_REQ_RESENDTIME, retry));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 16));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 5 * SECOND));
 
-	TEST_CHECK(testutil_marry(rep, req) == 0);
+	NUTS_MARRY(rep, req);
 
 	// Send req #1 (abc).
-	TEST_CHECK(nng_sendmsg(req, abc, 0) == 0);
+	NUTS_SEND(req, "abc");
 
 	// Wait for it to get ot the other side.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	nng_aio_set_timeout(aio, 5 * SECOND);
 	nng_recv_aio(req, aio);
 
 	// Give time for this recv to post properly.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	// Send the next next request ("def").  Note that
 	// the REP side server will have already buffered the receive
 	// request, and should simply be waiting for us to reply to
 	// abc.
-	TEST_CHECK(nng_sendmsg(req, def, 0) == 0);
+	NUTS_SEND(req, "def");
 
 	// Our pending I/O should have been canceled.
 	nng_aio_wait(aio);
-	TEST_CHECK(nng_aio_result(aio) == NNG_ECANCELED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
 
 	// Receive the first request (should be abc) on the REP server.
-	TEST_CHECK(nng_recvmsg(rep, &cmd, 0) == 0);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "abc") == 0);
+	NUTS_RECV(rep, "abc");
 
 	// REP sends the reply to first command.  This will be
 	// discarded by the REQ socket.
-	TEST_CHECK(nng_sendmsg(rep, cmd, 0) == 0);
+	NUTS_SEND(rep, "abc");
 
 	// Now get the next command from the REP; should be "def".
-	TEST_CHECK(nng_recvmsg(rep, &cmd, 0) == 0);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
+	NUTS_RECV(rep, "def");
 
 	// And send it back to REQ.
-	TEST_CHECK(nng_sendmsg(rep, cmd, 0) == 0);
+	NUTS_SEND(rep, "def");
 
 	// Try a req command.  This should give back "def"
-	TEST_CHECK(nng_recvmsg(req, &cmd, 0) == 0);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	nng_msg_free(cmd);
+	NUTS_RECV(req, "def");
 
 	nng_aio_free(aio);
-	TEST_CHECK(nng_close(req) == 0);
-	TEST_CHECK(nng_close(rep) == 0);
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -516,25 +459,25 @@ test_req_cancel_post_recv(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(req, rep));
-
-	TEST_NNG_SEND_STR(req, "ONE");
-	TEST_NNG_RECV_STR(rep, "ONE");
-	TEST_NNG_SEND_STR(rep, "one");
-	testutil_sleep(100); // Make sure reply arrives!
-	TEST_NNG_SEND_STR(req, "TWO");
-	TEST_NNG_RECV_STR(rep, "TWO");
-	TEST_NNG_SEND_STR(rep, "two");
-	TEST_NNG_RECV_STR(req, "two");
-
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_MARRY(req, rep);
+
+	NUTS_SEND(req, "ONE");
+	NUTS_RECV(rep, "ONE");
+	NUTS_SEND(rep, "one");
+	NUTS_SLEEP(100); // Make sure reply arrives!
+	NUTS_SEND(req, "TWO");
+	NUTS_RECV(rep, "TWO");
+	NUTS_SEND(rep, "two");
+	NUTS_RECV(req, "two");
+
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -544,18 +487,18 @@ test_req_poll_writeable(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not writable before connect.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// It should be writable now.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
 	// Submit a bunch of jobs.  Note that we have to stall a bit
 	// between each message to let it queue up.
@@ -564,12 +507,12 @@ test_req_poll_writeable(void)
 		if (rv == NNG_EAGAIN) {
 			break;
 		}
-		TEST_NNG_PASS(rv);
-		testutil_sleep(50);
+		NUTS_PASS(rv);
+		NUTS_SLEEP(50);
 	}
-	TEST_CHECK(testutil_pollfd(fd) == 0);
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -584,26 +527,26 @@ test_req_poll_contention(void)
 	nng_msg *  ctx_msg[5];
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
 
 	for (int i = 0; i < 5; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], req));
-		TEST_NNG_PASS(nng_aio_alloc(&ctx_aio[i], NULL, NULL));
-		TEST_NNG_PASS(nng_msg_alloc(&ctx_msg[i], 0));
+		NUTS_PASS(nng_ctx_open(&ctx[i], req));
+		NUTS_PASS(nng_aio_alloc(&ctx_aio[i], NULL, NULL));
+		NUTS_PASS(nng_msg_alloc(&ctx_msg[i], 0));
 	}
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not writable before connect.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	nng_aio_set_msg(aio, msg);
 	nng_send_aio(req, aio);
@@ -611,35 +554,35 @@ test_req_poll_contention(void)
 		nng_aio_set_msg(ctx_aio[i], ctx_msg[i]);
 		nng_ctx_send(ctx[i], ctx_aio[i]);
 	}
-	testutil_sleep(50); // so everything is queued steady state
+	NUTS_SLEEP(50); // so everything is queued steady state
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// It should not be writable now.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0));
+	NUTS_PASS(nng_recvmsg(rep, &msg, 0));
 	nng_msg_free(msg);
 
 	// Still not writeable...
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 	for (int i = 0; i < 5; i++) {
-		TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0));
+		NUTS_PASS(nng_recvmsg(rep, &msg, 0));
 		nng_msg_free(msg);
 	}
 	// It can take a little bit of time for the eased back-pressure
 	// to reflect across the network.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	// Should be come writeable now...
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	for (int i = 0; i < 5; i++) {
 		nng_aio_free(ctx_aio[i]);
 	}
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 void
@@ -650,28 +593,28 @@ test_req_poll_multi_pipe(void)
 	nng_socket rep1;
 	nng_socket rep2;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep1));
-	TEST_NNG_PASS(nng_rep0_open(&rep2));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep1));
+	NUTS_PASS(nng_rep0_open(&rep2));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not writable before connect.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(testutil_marry(req, rep1));
-	TEST_NNG_PASS(testutil_marry(req, rep2));
+	NUTS_MARRY(req, rep1);
+	NUTS_MARRY(req, rep2);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
-	TEST_NNG_SEND_STR(req, "ONE");
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
+	NUTS_SEND(req, "ONE");
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep1));
-	TEST_NNG_PASS(nng_close(rep2));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep1);
+	NUTS_CLOSE(rep2);
 }
 
 void
@@ -682,39 +625,39 @@ test_req_poll_readable(void)
 	nng_socket rep;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(req, rep);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append(msg, "xyz", 3));
-	TEST_NNG_PASS(nng_sendmsg(req, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0)); // recv on rep
-	TEST_NNG_PASS(nng_sendmsg(rep, msg, 0));  // echo it back
-	testutil_sleep(200); // give time for message to arrive
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "xyz", 3));
+	NUTS_PASS(nng_sendmsg(req, msg, 0));
+	NUTS_PASS(nng_recvmsg(rep, &msg, 0)); // recv on rep
+	NUTS_PASS(nng_sendmsg(rep, msg, 0));  // echo it back
+	NUTS_SLEEP(200); // give time for message to arrive
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(req, &msg, 0));
+	NUTS_PASS(nng_recvmsg(req, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// TODO verify unsolicited response
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -724,14 +667,12 @@ test_req_ctx_no_poll(void)
 	nng_socket req;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
+	NUTS_FAIL(nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_FAIL(nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -743,15 +684,15 @@ test_req_ctx_send_queued(void)
 	nng_aio *  aio[3];
 	nng_msg *  msg[3];
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 100));
 
 	for (int i = 0; i < 3; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], req));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
-		TEST_NNG_PASS(nng_msg_alloc(&msg[i], 0));
+		NUTS_PASS(nng_ctx_open(&ctx[i], req));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_msg_alloc(&msg[i], 0));
 	}
 
 	for (int i = 0; i < 3; i++) {
@@ -759,20 +700,20 @@ test_req_ctx_send_queued(void)
 		nng_ctx_send(ctx[i], aio[i]);
 	}
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	testutil_sleep(50); // Only to ensure stuff queues up
+	NUTS_SLEEP(50); // Only to ensure stuff queues up
 	for (int i = 0; i < 3; i++) {
 		nng_msg *m;
-		TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
+		NUTS_PASS(nng_recvmsg(rep, &m, 0));
 		nng_msg_free(m);
 	}
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 	for (int i = 0; i < 3; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_PASS(nng_aio_result(aio[i]));
+		NUTS_PASS(nng_aio_result(aio[i]));
 		nng_aio_free(aio[i]);
 	}
 }
@@ -785,13 +726,13 @@ test_req_ctx_send_close(void)
 	nng_aio *  aio[3];
 	nng_msg *  msg[3];
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
 	for (int i = 0; i < 3; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], req));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
-		TEST_NNG_PASS(nng_msg_alloc(&msg[i], 0));
+		NUTS_PASS(nng_ctx_open(&ctx[i], req));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_msg_alloc(&msg[i], 0));
 	}
 
 	for (int i = 0; i < 3; i++) {
@@ -805,11 +746,11 @@ test_req_ctx_send_close(void)
 
 	for (int i = 0; i < 3; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_FAIL(nng_aio_result(aio[i]), NNG_ECLOSED);
+		NUTS_FAIL(nng_aio_result(aio[i]), NNG_ECLOSED);
 		nng_aio_free(aio[i]);
 		nng_msg_free(msg[i]);
 	}
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -820,13 +761,13 @@ test_req_ctx_send_abort(void)
 	nng_aio *  aio[3];
 	nng_msg *  msg[3];
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
 	for (int i = 0; i < 3; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], req));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
-		TEST_NNG_PASS(nng_msg_alloc(&msg[i], 0));
+		NUTS_PASS(nng_ctx_open(&ctx[i], req));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_msg_alloc(&msg[i], 0));
 	}
 
 	for (int i = 0; i < 3; i++) {
@@ -840,11 +781,11 @@ test_req_ctx_send_abort(void)
 
 	for (int i = 0; i < 3; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_FAIL(nng_aio_result(aio[i]), NNG_ECANCELED);
+		NUTS_FAIL(nng_aio_result(aio[i]), NNG_ECANCELED);
 		nng_aio_free(aio[i]);
 		nng_msg_free(msg[i]);
 	}
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(req);
 }
 
 static void
@@ -855,26 +796,26 @@ test_req_ctx_send_twice(void)
 	nng_aio *  aio[2];
 	nng_msg *  msg[2];
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
 
 	for (int i = 0; i < 2; i++) {
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
-		TEST_NNG_PASS(nng_msg_alloc(&msg[i], 0));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_msg_alloc(&msg[i], 0));
 	}
 
 	for (int i = 0; i < 2; i++) {
 		nng_aio_set_msg(aio[i], msg[i]);
 		nng_ctx_send(ctx, aio[i]);
-		testutil_sleep(50);
+		NUTS_SLEEP(50);
 	}
 
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_CLOSE(req);
 	nng_aio_wait(aio[0]);
 	nng_aio_wait(aio[1]);
-	TEST_NNG_FAIL(nng_aio_result(aio[0]), NNG_ECANCELED);
-	TEST_NNG_FAIL(nng_aio_result(aio[1]), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio[0]), NNG_ECANCELED);
+	NUTS_FAIL(nng_aio_result(aio[1]), NNG_ECLOSED);
 
 	for (int i = 0; i < 2; i++) {
 		nng_aio_free(aio[i]);
@@ -891,25 +832,25 @@ test_req_ctx_recv_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	nng_aio_set_msg(aio, msg);
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio);
 }
 
@@ -921,17 +862,17 @@ test_req_ctx_send_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
 	nng_aio_set_msg(aio, msg);
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(req);
 	nng_aio_free(aio);
 	nng_msg_free(msg);
 }
@@ -945,23 +886,23 @@ test_req_ctx_recv_close_socket(void)
 	nng_aio *  aio;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, req));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_ctx_open(&ctx, req));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_MARRY(req, rep);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
 	nng_aio_set_msg(aio, m);
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 
 	nng_ctx_recv(ctx, aio);
 	nng_close(req);
 
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -970,32 +911,32 @@ test_req_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char      * addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_req0_open(&s1));
-	TEST_NNG_PASS(nng_req0_open(&s2));
+	NUTS_PASS(nng_req0_open(&s1));
+	NUTS_PASS(nng_req0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "req identity", test_req_identity },
 	{ "req ttl option", test_req_ttl_option },
 	{ "req resend option", test_req_resend_option },
diff --git a/src/protocol/reqrep0/xrep_test.c b/src/protocol/reqrep0/xrep_test.c
index 8fc36964..6f1564eb 100644
--- a/src/protocol/reqrep0/xrep_test.c
+++ b/src/protocol/reqrep0/xrep_test.c
@@ -7,14 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/reqrep0/rep.h>
-#include <nng/protocol/reqrep0/req.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_xrep_identity(void)
@@ -24,16 +17,16 @@ test_xrep_identity(void)
 	char *     n1;
 	char *     n2;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p1));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p2));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n1));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n2));
-	TEST_NNG_PASS(nng_close(s));
-	TEST_CHECK(p1 == NNG_REP0_SELF);
-	TEST_CHECK(p2 == NNG_REP0_PEER);
-	TEST_CHECK(strcmp(n1, NNG_REP0_SELF_NAME) == 0);
-	TEST_CHECK(strcmp(n2, NNG_REP0_PEER_NAME) == 0);
+	NUTS_PASS(nng_rep0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p1));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p2));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n1));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n2));
+	NUTS_CLOSE(s);
+	NUTS_TRUE(p1 == NNG_REP0_SELF);
+	NUTS_TRUE(p2 == NNG_REP0_PEER);
+	NUTS_MATCH(n1, NNG_REP0_SELF_NAME);
+	NUTS_MATCH(n2, NNG_REP0_PEER_NAME);
 	nng_strfree(n1);
 	nng_strfree(n2);
 }
@@ -44,10 +37,10 @@ test_xrep_raw(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_rep0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -56,9 +49,9 @@ test_xrep_no_context(void)
 	nng_socket s;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&s));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_rep0_open_raw(&s));
+	NUTS_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -68,24 +61,24 @@ test_xrep_poll_writeable(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_getopt_int(rep, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_get_int(rep, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// We are always writeable, even before connect.  This is so that
 	// back-pressure from a bad peer can't trash others.  We assume
 	// that peers won't send us requests faster than they can consume
 	// the answers.  If they do, they will lose their answers.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// Now it's writable.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -96,32 +89,32 @@ test_xrep_poll_readable(void)
 	nng_socket rep;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_getopt_int(rep, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_socket_get_int(rep, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(req, rep);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(req, "abc");
-	testutil_sleep(100);
+	NUTS_SEND(req, "abc");
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0));
+	NUTS_PASS(nng_recvmsg(rep, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -130,28 +123,28 @@ test_xrep_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char       *addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&s1));
-	TEST_NNG_PASS(nng_rep0_open(&s2));
+	NUTS_PASS(nng_rep0_open_raw(&s1));
+	NUTS_PASS(nng_rep0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s2));
 	nng_stats_free(stats);
 }
 
@@ -164,26 +157,26 @@ test_xrep_close_pipe_before_send(void)
 	nng_aio *  aio1;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_NNG_SEND_STR(req, "test");
+	NUTS_MARRY(req, rep);
+	NUTS_SEND(req, "test");
 
 	nng_recv_aio(rep, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_CHECK((m = nng_aio_get_msg(aio1)) != NULL);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_TRUE((m = nng_aio_get_msg(aio1)) != NULL);
 	p = nng_msg_get_pipe(m);
-	TEST_NNG_PASS(nng_pipe_close(p));
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
+	NUTS_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio1);
 }
 
@@ -195,37 +188,37 @@ test_xrep_close_pipe_during_send(void)
 	nng_pipe   p;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_RECVBUF, 1));
-
-	TEST_NNG_PASS(testutil_marry(req, rep));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, (unsigned) 0x81000000u));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-	TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 20));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_RECVBUF, 1));
+
+	NUTS_MARRY(req, rep);
+
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, (unsigned) 0x81000000u));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+	NUTS_PASS(nng_recvmsg(rep, &m, 0));
 	p = nng_msg_get_pipe(m);
 	nng_msg_free(m);
 
 	for (int i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
-		TEST_NNG_PASS(
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
+		NUTS_PASS(
 		    nng_msg_header_append_u32(m, (unsigned) i | 0x80000000u));
 		// xrep does not exert back-pressure
-		TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
+		NUTS_PASS(nng_sendmsg(rep, m, 0));
 	}
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -235,27 +228,27 @@ test_xrep_close_during_recv(void)
 	nng_socket req;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	for (unsigned i = 0; i < 100; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
 		rv = nng_sendmsg(req, m, 0);
 		if (rv == NNG_ETIMEDOUT) {
 			nng_msg_free(m);
 			break;
 		}
 	}
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -264,14 +257,14 @@ test_xrep_recv_aio_stopped(void)
 	nng_socket rep;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_stop(aio);
 	nng_recv_aio(rep, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(rep);
 	nng_aio_free(aio);
 }
 
@@ -282,21 +275,21 @@ test_xrep_send_no_header(void)
 	nng_socket req;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
+	NUTS_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -306,21 +299,21 @@ test_xrep_recv_garbage(void)
 	nng_socket req;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, 1u));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+	NUTS_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -332,29 +325,29 @@ test_xrep_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
 
-	TEST_NNG_PASS(nng_setopt_int(rep, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(rep, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(rep, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(rep, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(rep, opt, 3));
+	NUTS_PASS(nng_socket_get_int(rep, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(rep, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(rep, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_CHECK(nng_setopt(rep, opt, "", 1) == NNG_EINVAL);
+	NUTS_TRUE(nng_socket_set(rep, opt, "", 1) == NNG_EINVAL);
 	sz = 1;
-	TEST_CHECK(nng_getopt(rep, opt, &v, &sz) == NNG_EINVAL);
-	TEST_CHECK(nng_setopt_bool(rep, opt, true) == NNG_EBADTYPE);
-	TEST_CHECK(nng_getopt_bool(rep, opt, &b) == NNG_EBADTYPE);
+	NUTS_TRUE(nng_socket_get(rep, opt, &v, &sz) == NNG_EINVAL);
+	NUTS_TRUE(nng_socket_set_bool(rep, opt, true) == NNG_EBADTYPE);
+	NUTS_TRUE(nng_socket_get_bool(rep, opt, &b) == NNG_EBADTYPE);
 
-	TEST_CHECK(nng_close(rep) == 0);
+	NUTS_TRUE(nng_close(rep) == 0);
 }
 
 static void
@@ -364,65 +357,65 @@ test_xrep_ttl_drop(void)
 	nng_socket req;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_MAXTTL, 3));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_MAXTTL, 3));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// Send messages.  Note that xrep implicitly adds a hop on receive.
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000001u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS1", 6));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000002u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL2", 6));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS3", 6));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL4", 6));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000001u));
+	NUTS_PASS(nng_msg_append(m, "PASS1", 6));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000002u));
+	NUTS_PASS(nng_msg_append(m, "FAIL2", 6));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "PASS3", 6));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "FAIL4", 6));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
 
 	// So on receive we should see 80000001 and 80000003.
-	TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 12);
-	TEST_CHECK(nng_msg_len(m) == 6);
-	TEST_CHECK(strcmp(nng_msg_body(m), "PASS1") == 0);
+	NUTS_PASS(nng_recvmsg(rep, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 12);
+	NUTS_TRUE(nng_msg_len(m) == 6);
+	NUTS_TRUE(strcmp(nng_msg_body(m), "PASS1") == 0);
 	nng_msg_free(m);
 
-	TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 16); // 3 hops + ID
-	TEST_CHECK(nng_msg_len(m) == 6);
-	TEST_CHECK(strcmp(nng_msg_body(m), "PASS3") == 0);
+	NUTS_PASS(nng_recvmsg(rep, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 16); // 3 hops + ID
+	NUTS_TRUE(nng_msg_len(m) == 6);
+	NUTS_TRUE(strcmp(nng_msg_body(m), "PASS3") == 0);
 	nng_msg_free(m);
 
-	TEST_NNG_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
+	NUTS_FAIL(nng_recvmsg(rep, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "xrep identity", test_xrep_identity },
 	{ "xrep raw", test_xrep_raw },
 	{ "xrep no context", test_xrep_no_context },
diff --git a/src/protocol/reqrep0/xreq_test.c b/src/protocol/reqrep0/xreq_test.c
index 68a7c7f5..8c850cba 100644
--- a/src/protocol/reqrep0/xreq_test.c
+++ b/src/protocol/reqrep0/xreq_test.c
@@ -7,14 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/reqrep0/rep.h>
-#include <nng/protocol/reqrep0/req.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_xreq_identity(void)
@@ -24,16 +17,16 @@ test_xreq_identity(void)
 	char *     n1;
 	char *     n2;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p1));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p2));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n1));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n2));
-	TEST_NNG_PASS(nng_close(s));
-	TEST_CHECK(p1 == NNG_REQ0_SELF);
-	TEST_CHECK(p2 == NNG_REQ0_PEER);
-	TEST_CHECK(strcmp(n1, NNG_REQ0_SELF_NAME) == 0);
-	TEST_CHECK(strcmp(n2, NNG_REQ0_PEER_NAME) == 0);
+	NUTS_PASS(nng_req0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p1));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p2));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n1));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n2));
+	NUTS_CLOSE(s);
+	NUTS_TRUE(p1 == NNG_REQ0_SELF);
+	NUTS_TRUE(p2 == NNG_REQ0_PEER);
+	NUTS_MATCH(n1, NNG_REQ0_SELF_NAME);
+	NUTS_MATCH(n2, NNG_REQ0_PEER_NAME);
 	nng_strfree(n1);
 	nng_strfree(n2);
 }
@@ -44,10 +37,10 @@ test_xreq_raw(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_req0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -56,9 +49,9 @@ test_xreq_no_context(void)
 	nng_socket s;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&s));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_req0_open_raw(&s));
+	NUTS_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -68,21 +61,21 @@ test_xreq_poll_writeable(void)
 	nng_socket req;
 	nng_socket rep;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// We can't write until we have a connection.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
 	// Now it's writable.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -93,44 +86,44 @@ test_xreq_poll_readable(void)
 	nng_socket rep;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_rep0_open(&rep));
-	TEST_NNG_PASS(nng_getopt_int(req, NNG_OPT_RECVFD, &fd));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_rep0_open(&rep));
+	NUTS_PASS(nng_socket_get_int(req, NNG_OPT_RECVFD, &fd));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_CHECK(fd >= 0);
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(req, rep));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(req, rep);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	// Request ID
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0x80000000));
-	TEST_NNG_PASS(nng_sendmsg(req, msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0x80000000));
+	NUTS_PASS(nng_sendmsg(req, msg, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(rep, &msg, 0));
-	TEST_NNG_PASS(nng_sendmsg(rep, msg, 0));
+	NUTS_PASS(nng_recvmsg(rep, &msg, 0));
+	NUTS_PASS(nng_sendmsg(rep, msg, 0));
 
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(req, &msg, 0));
+	NUTS_PASS(nng_recvmsg(req, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -139,28 +132,28 @@ test_xreq_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_req0_open_raw(&s1));
-	TEST_NNG_PASS(nng_req0_open(&s2));
+	NUTS_PASS(nng_req0_open_raw(&s1));
+	NUTS_PASS(nng_req0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -170,14 +163,14 @@ test_xreq_recv_aio_stopped(void)
 	nng_socket req;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_stop(aio);
 	nng_recv_aio(req, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(req));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(req);
 	nng_aio_free(aio);
 }
 
@@ -189,33 +182,33 @@ test_xreq_recv_garbage(void)
 	nng_msg *  m;
 	uint32_t   req_id;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(req, rep));
+	NUTS_MARRY(req, rep);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000000));
-	TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000000));
+	NUTS_PASS(nng_sendmsg(req, m, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(rep, &m, 0));
+	NUTS_PASS(nng_recvmsg(rep, &m, 0));
 
 	// The message will have a header that contains the 32-bit pipe ID,
 	// followed by the 32-bit request ID.  We will discard the request
 	// ID before sending it out.
-	TEST_CHECK(nng_msg_header_len(m) == 8);
-	TEST_NNG_PASS(nng_msg_header_chop_u32(m, &req_id));
-	TEST_CHECK(req_id == 0x80000000);
+	NUTS_TRUE(nng_msg_header_len(m) == 8);
+	NUTS_PASS(nng_msg_header_chop_u32(m, &req_id));
+	NUTS_TRUE(req_id == 0x80000000);
 
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(req, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
+	NUTS_FAIL(nng_recvmsg(req, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -227,37 +220,37 @@ test_xreq_recv_header(void)
 	nng_pipe   p1, p2;
 	uint32_t   id;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry_ex(req, rep, NULL, &p1, &p2));
+	NUTS_MARRY_EX(req, rep, NULL, &p1, &p2);
 
 	// Simulate a few hops.
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x2));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x1));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x80000123u));
-
-	TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
-
-	TEST_NNG_PASS(nng_recvmsg(req, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 12);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x2);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x1);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x80000123u);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x2));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x1));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x80000123u));
+
+	NUTS_PASS(nng_sendmsg(rep, m, 0));
+
+	NUTS_PASS(nng_recvmsg(req, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 12);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x2);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x1);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x80000123u);
 
 	nng_msg_free(m);
 
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -269,26 +262,26 @@ test_xreq_close_during_recv(void)
 	nng_pipe   p1;
 	nng_pipe   p2;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry_ex(req, rep, NULL, &p1, &p2));
-	TEST_CHECK(nng_pipe_id(p1) > 0);
-	TEST_CHECK(nng_pipe_id(p2) > 0);
+	NUTS_MARRY_EX(req, rep, NULL, &p1, &p2);
+	NUTS_TRUE(nng_pipe_id(p1) > 0);
+	NUTS_TRUE(nng_pipe_id(p2) > 0);
 
 	for (unsigned i = 0; i < 20; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
-		testutil_sleep(10);
-		TEST_NNG_PASS(nng_sendmsg(rep, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_SLEEP(10);
+		NUTS_PASS(nng_sendmsg(rep, m, 0));
 	}
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -300,27 +293,27 @@ test_xreq_close_pipe_during_send(void)
 	nng_pipe   p1;
 	nng_pipe   p2;
 
-	TEST_NNG_PASS(nng_rep0_open_raw(&rep));
-	TEST_NNG_PASS(nng_req0_open_raw(&req));
-	TEST_NNG_PASS(nng_setopt_ms(rep, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(req, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(rep, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(req, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_rep0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&req));
+	NUTS_PASS(nng_socket_set_ms(rep, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(req, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(rep, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(req, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry_ex(req, rep, NULL, &p1, &p2));
-	TEST_CHECK(nng_pipe_id(p1) > 0);
-	TEST_CHECK(nng_pipe_id(p2) > 0);
+	NUTS_MARRY_EX(req, rep, NULL, &p1, &p2);
+	NUTS_TRUE(nng_pipe_id(p1) > 0);
+	NUTS_TRUE(nng_pipe_id(p2) > 0);
 
 	for (unsigned i = 0; i < 20; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
-		testutil_sleep(10);
-		TEST_NNG_PASS(nng_sendmsg(req, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_SLEEP(10);
+		NUTS_PASS(nng_sendmsg(req, m, 0));
 	}
 
-	TEST_NNG_PASS(nng_pipe_close(p1));
-	TEST_NNG_PASS(nng_close(req));
-	TEST_NNG_PASS(nng_close(rep));
+	NUTS_PASS(nng_pipe_close(p1));
+	NUTS_CLOSE(req);
+	NUTS_CLOSE(rep);
 }
 
 static void
@@ -332,32 +325,32 @@ test_xreq_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_req0_open_raw(&rep));
+	NUTS_PASS(nng_req0_open_raw(&rep));
 
-	TEST_NNG_PASS(nng_setopt_int(rep, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(rep, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(rep, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(rep, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(rep, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(rep, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(rep, opt, 3));
+	NUTS_PASS(nng_socket_get_int(rep, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(rep, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(rep, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_CHECK(nng_setopt(rep, opt, "", 1) == NNG_EINVAL);
+	NUTS_TRUE(nng_socket_set(rep, opt, "", 1) == NNG_EINVAL);
 	sz = 1;
-	TEST_CHECK(nng_getopt(rep, opt, &v, &sz) == NNG_EINVAL);
-	TEST_CHECK(nng_setopt_bool(rep, opt, true) == NNG_EBADTYPE);
-	TEST_CHECK(nng_getopt_bool(rep, opt, &b) == NNG_EBADTYPE);
+	NUTS_TRUE(nng_socket_get(rep, opt, &v, &sz) == NNG_EINVAL);
+	NUTS_TRUE(nng_socket_set_bool(rep, opt, true) == NNG_EBADTYPE);
+	NUTS_TRUE(nng_socket_get_bool(rep, opt, &b) == NNG_EBADTYPE);
 
-	TEST_CHECK(nng_close(rep) == 0);
+	NUTS_TRUE(nng_close(rep) == 0);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "xreq identity", test_xreq_identity },
 	{ "xreq raw", test_xreq_raw },
 	{ "xreq no context", test_xreq_no_context },
diff --git a/src/protocol/survey0/respond_test.c b/src/protocol/survey0/respond_test.c
index efda181b..51844c76 100644
--- a/src/protocol/survey0/respond_test.c
+++ b/src/protocol/survey0/respond_test.c
@@ -7,18 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/survey0/respond.h>
-#include <nng/protocol/survey0/survey.h>
-
-#include <acutest.h>
-#include <testutil.h>
-
-#ifndef NNI_PROTO
-#define NNI_PROTO(x, y) (((x) << 4u) | (y))
-#endif
+#include <nuts.h>
 
 void
 test_resp_identity(void)
@@ -27,18 +16,18 @@ test_resp_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_CHECK(nng_respondent0_open(&s) == 0);
-	TEST_CHECK(nng_getopt_int(s, NNG_OPT_PROTO, &p) == 0);
-	TEST_CHECK(p == NNI_PROTO(6u, 3u));
-	TEST_CHECK(nng_getopt_int(s, NNG_OPT_PEER, &p) == 0);
-	TEST_CHECK(p == NNI_PROTO(6u, 2u));
-	TEST_CHECK(nng_getopt_string(s, NNG_OPT_PROTONAME, &n) == 0);
-	TEST_CHECK(strcmp(n, "respondent") == 0);
+	NUTS_PASS(nng_respondent0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NNG_RESPONDENT0_SELF);
+	NUTS_TRUE(nng_socket_get_int(s, NNG_OPT_PEER, &p) == 0);
+	NUTS_TRUE(p == NNG_RESPONDENT0_PEER);
+	NUTS_TRUE(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n) == 0);
+	NUTS_MATCH(n, NNG_RESPONDENT0_SELF_NAME);
 	nng_strfree(n);
-	TEST_CHECK(nng_getopt_string(s, NNG_OPT_PEERNAME, &n) == 0);
-	TEST_CHECK(strcmp(n, "surveyor") == 0);
+	NUTS_TRUE(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n) == 0);
+	NUTS_MATCH(n, NNG_RESPONDENT0_PEER_NAME);
 	nng_strfree(n);
-	TEST_CHECK(nng_close(s) == 0);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -47,11 +36,11 @@ test_resp_send_bad_state(void)
 	nng_socket resp;
 	nng_msg *  msg = NULL;
 
-	TEST_CHECK(nng_respondent0_open(&resp) == 0);
-	TEST_CHECK(nng_msg_alloc(&msg, 0) == 0);
-	TEST_CHECK(nng_sendmsg(resp, msg, 0) == NNG_ESTATE);
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_FAIL(nng_sendmsg(resp, msg, 0), NNG_ESTATE);
 	nng_msg_free(msg);
-	TEST_CHECK(nng_close(resp) == 0);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -61,33 +50,33 @@ test_resp_poll_writeable(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(resp, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(resp, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not writable before connect.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Still not writable.
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// If we get a job, *then* we become writable
-	TEST_NNG_SEND_STR(surv, "abc");
-	TEST_NNG_RECV_STR(resp, "abc");
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_SEND(surv, "abc");
+	NUTS_RECV(resp, "abc");
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// And is no longer writable once we send a message
-	TEST_NNG_SEND_STR(resp, "def");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_SEND(resp, "def");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 	// Even after receiving it
-	TEST_NNG_RECV_STR(surv, "def");
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_RECV(surv, "def");
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -98,34 +87,34 @@ test_resp_poll_readable(void)
 	nng_socket resp;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(resp, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(resp, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(surv, resp);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(surv, "abc");
-	testutil_sleep(100);
+	NUTS_SEND(surv, "abc");
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(resp, &msg, 0));
+	NUTS_PASS(nng_recvmsg(resp, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// TODO verify unsolicited response
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -135,14 +124,12 @@ test_resp_context_no_poll(void)
 	nng_socket resp;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, resp));
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_ctx_open(&ctx, resp));
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -151,28 +138,28 @@ test_resp_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_respondent0_open(&s1));
-	TEST_NNG_PASS(nng_respondent0_open(&s2));
+	NUTS_PASS(nng_respondent0_open(&s1));
+	NUTS_PASS(nng_respondent0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -183,17 +170,17 @@ test_resp_double_recv(void)
 	nng_aio *  aio1;
 	nng_aio *  aio2;
 
-	TEST_NNG_PASS(nng_respondent0_open(&s1));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open(&s1));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
 
 	nng_recv_aio(s1, aio1);
 	nng_recv_aio(s1, aio2);
 
 	nng_aio_wait(aio2);
-	TEST_NNG_FAIL(nng_aio_result(aio2), NNG_ESTATE);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_FAIL(nng_aio_result(aio1), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio2), NNG_ESTATE);
+	NUTS_CLOSE(s1);
+	NUTS_FAIL(nng_aio_result(aio1), NNG_ECLOSED);
 	nng_aio_free(aio1);
 	nng_aio_free(aio2);
 }
@@ -207,26 +194,26 @@ test_resp_close_pipe_before_send(void)
 	nng_aio *  aio1;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_NNG_SEND_STR(surv, "test");
+	NUTS_MARRY(surv, resp);
+	NUTS_SEND(surv, "test");
 
 	nng_recv_aio(resp, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_CHECK((m = nng_aio_get_msg(aio1)) != NULL);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_TRUE((m = nng_aio_get_msg(aio1)) != NULL);
 	p = nng_msg_get_pipe(m);
-	TEST_NNG_PASS(nng_pipe_close(p));
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
+	NUTS_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio1);
 }
 
@@ -238,25 +225,24 @@ test_resp_close_pipe_during_send(void)
 	nng_pipe   p = NNG_PIPE_INITIALIZER;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 20));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	for (int i = 0; i < 100; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-		TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(surv, m, 0));
+		NUTS_PASS(nng_recvmsg(resp, &m, 0));
 		p  = nng_msg_get_pipe(m);
 		rv = nng_sendmsg(resp, m, 0);
 		if (rv == NNG_ETIMEDOUT) {
@@ -264,12 +250,12 @@ test_resp_close_pipe_during_send(void)
 			nng_msg_free(m);
 			break;
 		}
-		TEST_NNG_PASS(rv);
+		NUTS_PASS(rv);
 	}
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -279,16 +265,16 @@ test_resp_ctx_recv_aio_stopped(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, resp));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_ctx_open(&ctx, resp));
 
 	nng_aio_stop(aio);
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 }
 
@@ -303,54 +289,53 @@ test_resp_close_pipe_context_send(void)
 	nng_aio *  aio[10];
 	int        i;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
 	for (i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], resp));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_ctx_open(&ctx[i], resp));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
 	}
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	for (i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(surv, m, 0));
 		nng_ctx_recv(ctx[i], aio[i]);
 	}
 	for (i = 0; i < 10; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_PASS(nng_aio_result(aio[i]));
-		TEST_CHECK((m = nng_aio_get_msg(aio[i])) != NULL);
+		NUTS_PASS(nng_aio_result(aio[i]));
+		NUTS_TRUE((m = nng_aio_get_msg(aio[i])) != NULL);
 		p = nng_msg_get_pipe(m);
 		nng_aio_set_msg(aio[i], m);
 		nng_ctx_send(ctx[i], aio[i]);
 	}
 
 	// Note that SURVEYOR socket is not reading the results.
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
 	for (i = 0; i < 10; i++) {
 		int rv;
 		nng_aio_wait(aio[i]);
 		rv = nng_aio_result(aio[i]);
 		if (rv != 0) {
-			TEST_NNG_FAIL(rv, NNG_ECLOSED);
+			NUTS_FAIL(rv, NNG_ECLOSED);
 			nng_msg_free(nng_aio_get_msg(aio[i]));
 		}
 		nng_aio_free(aio[i]);
-		TEST_NNG_PASS(nng_ctx_close(ctx[i]));
+		NUTS_PASS(nng_ctx_close(ctx[i]));
 	}
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -363,33 +348,32 @@ test_resp_close_context_send(void)
 	nng_aio *  aio[10];
 	int        i;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
 	for (i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&ctx[i], resp));
-		TEST_NNG_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
+		NUTS_PASS(nng_ctx_open(&ctx[i], resp));
+		NUTS_PASS(nng_aio_alloc(&aio[i], NULL, NULL));
 	}
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	for (i = 0; i < 10; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(
-		    nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
-		TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_append_u32(m, (unsigned) i | 0x80000000u));
+		NUTS_PASS(nng_sendmsg(surv, m, 0));
 		nng_ctx_recv(ctx[i], aio[i]);
 	}
 	for (i = 0; i < 10; i++) {
 		nng_aio_wait(aio[i]);
-		TEST_NNG_PASS(nng_aio_result(aio[i]));
-		TEST_CHECK((m = nng_aio_get_msg(aio[i])) != NULL);
+		NUTS_PASS(nng_aio_result(aio[i]));
+		NUTS_TRUE((m = nng_aio_get_msg(aio[i])) != NULL);
 		nng_aio_set_msg(aio[i], m);
 		nng_ctx_send(ctx[i], aio[i]);
 	}
@@ -397,17 +381,17 @@ test_resp_close_context_send(void)
 	// Note that REQ socket is not reading the results.
 	for (i = 0; i < 10; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_ctx_close(ctx[i]));
+		NUTS_PASS(nng_ctx_close(ctx[i]));
 		nng_aio_wait(aio[i]);
 		rv = nng_aio_result(aio[i]);
 		if (rv != 0) {
-			TEST_NNG_FAIL(rv, NNG_ECLOSED);
+			NUTS_FAIL(rv, NNG_ECLOSED);
 			nng_msg_free(nng_aio_get_msg(aio[i]));
 		}
 		nng_aio_free(aio[i]);
 	}
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -417,16 +401,16 @@ test_resp_ctx_recv_nonblock(void)
 	nng_ctx    ctx;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, resp));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_ctx_open(&ctx, resp));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 }
 
@@ -439,19 +423,19 @@ test_resp_ctx_send_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, resp));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_ctx_open(&ctx, resp));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_SEND_STR(surv, "SEND");
+	NUTS_SEND(surv, "SEND");
 	nng_ctx_recv(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	// message carries over
 	msg = nng_aio_get_msg(aio);
 	nng_aio_set_msg(aio, msg);
@@ -459,9 +443,9 @@ test_resp_ctx_send_nonblock(void)
 	nng_ctx_send(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 	nng_msg_free(msg);
 }
@@ -473,21 +457,21 @@ test_resp_recv_garbage(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, 1u));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -499,29 +483,29 @@ test_resp_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_respondent0_open(&resp));
 
-	TEST_NNG_PASS(nng_setopt_int(resp, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(resp, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(resp, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_setopt_int(resp, opt, 1));
+	NUTS_FAIL(nng_setopt_int(resp, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(resp, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(resp, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_int(resp, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_setopt_int(resp, opt, 3));
+	NUTS_PASS(nng_socket_get_int(resp, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(resp, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(resp, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(resp, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt(resp, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(resp, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(resp, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(resp, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(resp, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_setopt_bool(resp, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(resp, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -531,52 +515,52 @@ test_resp_ttl_drop(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_MAXTTL, 3));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_setopt_int(resp, NNG_OPT_MAXTTL, 3));
+	NUTS_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Send messages.  Note that xrep implicitly adds a hop on receive.
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000001u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS1", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000002u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL2", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS3", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL4", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_RECV_STR(resp, "PASS1");
-	TEST_NNG_RECV_STR(resp, "PASS3");
-
-	TEST_NNG_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
-
-	TEST_NNG_PASS(nng_close(resp));
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000001u));
+	NUTS_PASS(nng_msg_append(m, "PASS1", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000002u));
+	NUTS_PASS(nng_msg_append(m, "FAIL2", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "PASS3", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "FAIL4", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_RECV(resp, "PASS1");
+	NUTS_RECV(resp, "PASS3");
+
+	NUTS_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
+
+	NUTS_CLOSE(resp);
+	NUTS_CLOSE(surv);
 }
 
 TEST_LIST = {
@@ -590,7 +574,8 @@ TEST_LIST = {
 	{ "respond close pipe before send", test_resp_close_pipe_before_send },
 	{ "respond close pipe during send", test_resp_close_pipe_during_send },
 	{ "respond recv aio ctx stopped", test_resp_ctx_recv_aio_stopped },
-	{ "respond close pipe context send", test_resp_close_pipe_context_send },
+	{ "respond close pipe context send",
+	    test_resp_close_pipe_context_send },
 	{ "respond close context send", test_resp_close_context_send },
 	{ "respond context send nonblock", test_resp_ctx_send_nonblock },
 	{ "respond context recv nonblock", test_resp_ctx_recv_nonblock },
diff --git a/src/protocol/survey0/survey_test.c b/src/protocol/survey0/survey_test.c
index 65395eee..95d27adf 100644
--- a/src/protocol/survey0/survey_test.c
+++ b/src/protocol/survey0/survey_test.c
@@ -8,14 +8,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/survey0/respond.h>
-#include <nng/protocol/survey0/survey.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_surv_identity(void)
@@ -24,18 +17,18 @@ test_surv_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p));
-	TEST_CHECK(p == NNG_SURVEYOR0_SELF);
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p));
-	TEST_CHECK(p == NNG_SURVEYOR0_PEER); // 49
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n));
-	TEST_CHECK(strcmp(n, NNG_SURVEYOR0_SELF_NAME) == 0);
+	NUTS_PASS(nng_surveyor0_open(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NNG_SURVEYOR0_SELF);
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NNG_SURVEYOR0_PEER); // 49
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, NNG_SURVEYOR0_SELF_NAME);
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n));
-	TEST_CHECK(strcmp(n, NNG_SURVEYOR0_PEER_NAME) == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, NNG_SURVEYOR0_PEER_NAME);
 	nng_strfree(n);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -47,31 +40,31 @@ test_surv_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_surveyor0_open(&surv));
 
-	TEST_NNG_PASS(nng_setopt_int(surv, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(surv, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(surv, opt, -1), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(surv, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(surv, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(surv, opt, -1), NNG_EINVAL);
 	// This test will fail if the NNI_MAX_MAX_TTL is changed from the
 	// builtin default of 15.
-	TEST_NNG_FAIL(nng_setopt_int(surv, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(surv, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(surv, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(surv, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_FAIL(nng_socket_set_int(surv, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(surv, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(surv, opt, 3));
+	NUTS_PASS(nng_socket_get_int(surv, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(surv, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(surv, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_NNG_FAIL(nng_setopt(surv, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(surv, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_NNG_FAIL(nng_getopt(surv, opt, &v, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(surv, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(surv, opt, &b), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(surv, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(surv, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(surv, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_CLOSE(surv);
 }
 
 static void
@@ -83,17 +76,17 @@ test_surv_survey_time_option(void)
 	size_t       sz  = sizeof(b);
 	const char * opt = NNG_OPT_SURVEYOR_SURVEYTIME;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_surveyor0_open(&surv));
 
-	TEST_NNG_PASS(nng_setopt_ms(surv, opt, 10));
-	TEST_NNG_FAIL(nng_setopt(surv, opt, "", 1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_getopt(surv, opt, &b, &sz), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_bool(surv, opt, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(nng_getopt_bool(surv, opt, &b), NNG_EBADTYPE);
+	NUTS_PASS(nng_socket_set_ms(surv, opt, 10));
+	NUTS_FAIL(nng_socket_set(surv, opt, "", 1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_get(surv, opt, &b, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(surv, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(surv, opt, &b), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_getopt_ms(surv, opt, &d));
-	TEST_CHECK(d == 10);
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_PASS(nng_socket_get_ms(surv, opt, &d));
+	NUTS_TRUE(d == 10);
+	NUTS_CLOSE(surv);
 }
 
 void
@@ -102,10 +95,10 @@ test_surv_recv_bad_state(void)
 	nng_socket surv;
 	nng_msg *  msg = NULL;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_FAIL(nng_recvmsg(surv, &msg, 0), NNG_ESTATE);
-	TEST_CHECK(msg == NULL);
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_FAIL(nng_recvmsg(surv, &msg, 0), NNG_ESTATE);
+	NUTS_TRUE(msg == NULL);
+	NUTS_CLOSE(surv);
 }
 
 static void
@@ -116,31 +109,31 @@ test_surv_recv_garbage(void)
 	nng_msg *  m;
 	uint32_t   surv_id;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
+	NUTS_PASS(nng_recvmsg(resp, &m, 0));
 
 	// The message will have a header that contains the 32-bit pipe ID,
 	// followed by the 32-bit request ID.  We will discard the request
 	// ID before sending it out.
-	TEST_CHECK(nng_msg_header_len(m) == 8);
-	TEST_NNG_PASS(nng_msg_header_chop_u32(m, &surv_id));
+	NUTS_TRUE(nng_msg_header_len(m) == 8);
+	NUTS_PASS(nng_msg_header_chop_u32(m, &surv_id));
 
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(surv, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
+	NUTS_FAIL(nng_recvmsg(surv, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 #define SECOND 1000
@@ -150,188 +143,138 @@ test_surv_resp_exchange(void)
 {
 	nng_socket surv;
 	nng_socket resp;
-	nng_msg *  msg = NULL;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, SECOND));
-
-	TEST_NNG_PASS(testutil_marry(resp, surv));
-
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append(msg, "ping", 5));
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "ping") == 0);
-	TEST_NNG_PASS(nng_sendmsg(surv, msg, 0));
-	msg = NULL;
-	TEST_NNG_PASS(nng_recvmsg(resp, &msg, 0));
-	TEST_CHECK(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "ping") == 0);
-	nng_msg_trim(msg, 5);
-	TEST_NNG_PASS(nng_msg_append(msg, "pong", 5));
-	TEST_NNG_PASS(nng_sendmsg(resp, msg, 0));
-	msg = NULL;
-	TEST_NNG_PASS(nng_recvmsg(surv, &msg, 0));
-	TEST_CHECK(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_CHECK(strcmp(nng_msg_body(msg), "pong") == 0);
-	nng_msg_free(msg);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, SECOND));
+
+	NUTS_MARRY(resp, surv);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_SEND(surv, "ping");
+	NUTS_RECV(resp, "ping");
+	NUTS_SEND(resp, "pong");
+	NUTS_RECV(surv, "pong");
+
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
 test_surv_cancel(void)
 {
-	nng_msg *  abc;
-	nng_msg *  def;
-	nng_msg *  cmd;
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 16));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
 
-	TEST_NNG_PASS(nng_msg_alloc(&abc, 0));
-	TEST_NNG_PASS(nng_msg_append(abc, "abc", 4));
-	TEST_NNG_PASS(nng_msg_alloc(&def, 0));
-	TEST_NNG_PASS(nng_msg_append(def, "def", 4));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, SECOND));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_SENDBUF, 16));
 
-	TEST_NNG_PASS(testutil_marry(resp, surv));
+	NUTS_MARRY(resp, surv);
 
 	// Send req #1 (abc).
-	TEST_CHECK(nng_sendmsg(surv, abc, 0) == 0);
+	NUTS_SEND(surv, "abc");
 
 	// Sleep a bit.  This is so that we ensure that our request gets
 	// to the far side.  (If we cancel too fast, then our outgoing send
 	// will be canceled before it gets to the peer.)
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	// Send the next next request ("def").  Note that
 	// the RESP side server will have already buffered the receive
 	// request, and should simply be waiting for us to reply to abc.
-	TEST_NNG_PASS(nng_sendmsg(surv, def, 0));
+	NUTS_SEND(surv, "def");
 
 	// Receive the first request (should be abc) on the REP server.
-	TEST_NNG_PASS(nng_recvmsg(resp, &cmd, 0));
-	TEST_ASSERT(cmd != NULL);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "abc") == 0);
+	NUTS_RECV(resp, "abc");
 
 	// RESP sends the reply to first command.  This will be discarded
 	// by the SURV socket.
-	TEST_NNG_PASS(nng_sendmsg(resp, cmd, 0));
+	NUTS_SEND(resp, "abc");
 
 	// Now get the next command from the REP; should be "def".
-	TEST_NNG_PASS(nng_recvmsg(resp, &cmd, 0));
-	TEST_ASSERT(cmd != NULL);
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	TEST_MSG("Received body was %s", nng_msg_body(cmd));
+	NUTS_RECV(resp, "def");
 
 	// And send it back to REQ.
-	TEST_NNG_PASS(nng_sendmsg(resp, cmd, 0));
+	NUTS_SEND(resp, "def");
 
 	// Try a req command.  This should give back "def"
-	TEST_NNG_PASS(nng_recvmsg(surv, &cmd, 0));
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	nng_msg_free(cmd);
+	NUTS_RECV(surv, "def");
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
 test_surv_cancel_abort_recv(void)
 {
-
-	nng_msg *    abc;
-	nng_msg *    def;
-	nng_msg *    cmd;
 	nng_aio *    aio;
 	nng_duration time = SECOND * 10; // 10s (kind of never)
 	nng_socket   surv;
 	nng_socket   resp;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, time));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 16));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 5 * SECOND));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, time));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_SENDBUF, 16));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 5 * SECOND));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 5 * SECOND));
 
-	TEST_NNG_PASS(nng_msg_alloc(&abc, 0));
-	TEST_NNG_PASS(nng_msg_append(abc, "abc", 4));
-	TEST_NNG_PASS(nng_msg_alloc(&def, 0));
-	TEST_NNG_PASS(nng_msg_append(def, "def", 4));
-
-	TEST_NNG_PASS(testutil_marry(resp, surv));
+	NUTS_MARRY(resp, surv);
 
 	// Send survey #1 (abc).
-	TEST_NNG_PASS(nng_sendmsg(surv, abc, 0));
+	NUTS_SEND(surv, "abc");
 
 	// Wait for it to get ot the other side.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	nng_aio_set_timeout(aio, 5 * SECOND);
 	nng_recv_aio(surv, aio);
 
 	// Give time for this recv to post properly.
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
 	// Send the next next request ("def").  Note that
 	// the respondent side server will have already buffered the receive
 	// request, and should simply be waiting for us to reply to
 	// abc.
-	TEST_NNG_PASS(nng_sendmsg(surv, def, 0));
+	NUTS_SEND(surv, "def");
 
 	// Our pending I/O should have been canceled.
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
 
 	// Receive the first request (should be abc) on the respondent.
-	TEST_NNG_PASS(nng_recvmsg(resp, &cmd, 0));
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "abc") == 0);
+	NUTS_RECV(resp, "abc");
 
 	// Respondent sends the reply to first survey.  This will be
 	// discarded by the SURV socket.
-	TEST_CHECK(nng_sendmsg(resp, cmd, 0) == 0);
+	NUTS_SEND(resp, "abc");
 
 	// Now get the next survey from the RESP; should be "def".
-	TEST_NNG_PASS(nng_recvmsg(resp, &cmd, 0));
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
+	NUTS_RECV(resp, "def");
 
 	// And send it back to REQ.
-	TEST_NNG_PASS(nng_sendmsg(resp, cmd, 0));
+	NUTS_SEND(resp, "def");
 
 	// Try a req command.  This should give back "def"
-	TEST_NNG_PASS(nng_recvmsg(surv, &cmd, 0));
-	TEST_CHECK(nng_msg_len(cmd) == 4);
-	TEST_CHECK(strcmp(nng_msg_body(cmd), "def") == 0);
-	nng_msg_free(cmd);
+	NUTS_RECV(surv, "def");
 
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -340,25 +283,25 @@ test_surv_cancel_post_recv(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-
-	TEST_NNG_SEND_STR(surv, "ONE");
-	TEST_NNG_RECV_STR(resp, "ONE");
-	TEST_NNG_SEND_STR(resp, "one");
-	testutil_sleep(100); // Make sure reply arrives!
-	TEST_NNG_SEND_STR(surv, "TWO");
-	TEST_NNG_RECV_STR(resp, "TWO");
-	TEST_NNG_SEND_STR(resp, "two");
-	TEST_NNG_RECV_STR(surv, "two");
-
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_MARRY(surv, resp);
+
+	NUTS_SEND(surv, "ONE");
+	NUTS_RECV(resp, "ONE");
+	NUTS_SEND(resp, "one");
+	NUTS_SLEEP(100); // Make sure reply arrives!
+	NUTS_SEND(surv, "TWO");
+	NUTS_RECV(resp, "TWO");
+	NUTS_SEND(resp, "two");
+	NUTS_RECV(surv, "two");
+
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -368,21 +311,21 @@ test_surv_poll_writeable(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(surv, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(surv, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Survey is broadcast, so we can always write.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Now it's writable.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 void
@@ -393,39 +336,39 @@ test_surv_poll_readable(void)
 	nng_socket resp;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(surv, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(surv, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(surv, resp);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_msg_append(msg, "xyz", 3));
-	TEST_NNG_PASS(nng_sendmsg(surv, msg, 0));
-	TEST_NNG_PASS(nng_recvmsg(resp, &msg, 0)); // recv on rep
-	TEST_NNG_PASS(nng_sendmsg(resp, msg, 0));  // echo it back
-	testutil_sleep(200); // give time for message to arrive
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "xyz", 3));
+	NUTS_PASS(nng_sendmsg(surv, msg, 0));
+	NUTS_PASS(nng_recvmsg(resp, &msg, 0)); // recv on rep
+	NUTS_PASS(nng_sendmsg(resp, msg, 0));  // echo it back
+	NUTS_SLEEP(200); // give time for message to arrive
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(surv, &msg, 0));
+	NUTS_PASS(nng_recvmsg(surv, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// TODO verify unsolicited response
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -435,14 +378,12 @@ test_surv_ctx_no_poll(void)
 	nng_socket surv;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, surv));
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_ctx_getopt_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_ctx_close(ctx));
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_ctx_open(&ctx, surv));
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_SENDFD, &fd), NNG_ENOTSUP);
+	NUTS_FAIL(nng_ctx_get_int(ctx, NNG_OPT_RECVFD, &fd), NNG_ENOTSUP);
+	NUTS_PASS(nng_ctx_close(ctx));
+	NUTS_CLOSE(surv);
 }
 
 static void
@@ -454,25 +395,25 @@ test_surv_ctx_recv_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, surv));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_ctx_open(&ctx, surv));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	nng_aio_set_msg(aio, msg);
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_recv(ctx, aio);
 
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT);
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 }
 
@@ -484,17 +425,17 @@ test_surv_ctx_send_nonblock(void)
 	nng_aio *  aio;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, surv));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_ctx_open(&ctx, surv));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 
 	nng_aio_set_msg(aio, msg);
 	nng_aio_set_timeout(aio, 0); // Instant timeout
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio)); // We never block
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_PASS(nng_aio_result(aio)); // We never block
+	NUTS_CLOSE(surv);
 	nng_aio_free(aio);
 }
 
@@ -504,16 +445,16 @@ test_surv_send_best_effort(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_MARRY(surv, resp);
 
 	for (int i = 0; i < 200; i++) {
-		TEST_NNG_SEND_STR(surv, "junk");
+		NUTS_SEND(surv, "junk");
 	}
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -524,23 +465,23 @@ test_surv_survey_timeout(void)
 	char       buf[16];
 	size_t     sz;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 50));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 50));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_SEND_STR(surv, "hello");
-	TEST_NNG_RECV_STR(resp, "hello");
+	NUTS_SEND(surv, "hello");
+	NUTS_RECV(resp, "hello");
 
 	sz = sizeof(buf);
-	TEST_NNG_FAIL(nng_recv(surv, buf, &sz, 0), NNG_ETIMEDOUT);
-	TEST_NNG_SEND_STR(resp, "world");
-	TEST_NNG_FAIL(nng_recv(surv, buf, &sz, 0), NNG_ESTATE);
+	NUTS_FAIL(nng_recv(surv, buf, &sz, 0), NNG_ETIMEDOUT);
+	NUTS_SEND(resp, "world");
+	NUTS_FAIL(nng_recv(surv, buf, &sz, 0), NNG_ESTATE);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -552,23 +493,23 @@ test_surv_ctx_recv_close_socket(void)
 	nng_aio *  aio;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_ctx_open(&ctx, surv));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_ctx_open(&ctx, surv));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_MARRY(surv, resp);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
 	nng_aio_set_msg(aio, m);
 	nng_ctx_send(ctx, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_PASS(nng_aio_result(aio));
+	NUTS_PASS(nng_aio_result(aio));
 
 	nng_ctx_recv(ctx, aio);
 	nng_close(surv);
 
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECLOSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECLOSED);
 	nng_aio_free(aio);
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -581,52 +522,52 @@ test_surv_context_multi(void)
 	nng_msg *  m;
 	int        cnt = sizeof(c) / sizeof(c[0]);
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 200));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_MARRY(surv, resp);
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 200));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	for (int i = 0; i < cnt; i++) {
-		TEST_NNG_PASS(nng_ctx_open(&c[i], surv));
+		NUTS_PASS(nng_ctx_open(&c[i], surv));
 	}
 
 	for (int i = 0; i < cnt; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-		TEST_NNG_PASS(nng_msg_append_u32(m, i));
+		NUTS_PASS(nng_msg_alloc(&m, 0));
+		NUTS_PASS(nng_msg_append_u32(m, i));
 		nng_aio_set_msg(aio, m);
 		nng_ctx_send(c[i], aio);
 		nng_aio_wait(aio);
-		TEST_NNG_PASS(nng_aio_result(aio));
+		NUTS_PASS(nng_aio_result(aio));
 	}
 
 	for (int i = 0; i < cnt; i++) {
-		TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
-		TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
+		NUTS_PASS(nng_recvmsg(resp, &m, 0));
+		NUTS_PASS(nng_sendmsg(resp, m, 0));
 	}
 
 	for (int i = cnt - 1; i >= 0; i--) {
 		uint32_t x;
 		nng_ctx_recv(c[i], aio);
 		nng_aio_wait(aio);
-		TEST_NNG_PASS(nng_aio_result(aio));
+		NUTS_PASS(nng_aio_result(aio));
 		m = nng_aio_get_msg(aio);
 		TEST_ASSERT(m != NULL);
-		TEST_NNG_PASS(nng_msg_trim_u32(m, &x));
-		TEST_CHECK(x == (uint32_t)i);
+		NUTS_PASS(nng_msg_trim_u32(m, &x));
+		NUTS_TRUE(x == (uint32_t) i);
 		nng_msg_free(m);
 	}
 
 	for (int i = 0; i < cnt; i++) {
 		nng_ctx_recv(c[i], aio);
 		nng_aio_wait(aio);
-		TEST_CHECK(nng_aio_result(aio) != 0);
+		NUTS_TRUE(nng_aio_result(aio) != 0);
 	}
 	for (int i = 0; i < cnt; i++) {
 		nng_ctx_close(c[i]);
 	}
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 }
 
@@ -636,28 +577,27 @@ test_surv_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
-
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	char *     addr;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&s1));
-	TEST_NNG_PASS(nng_surveyor0_open(&s2));
+	NUTS_ADDR(addr, "inproc");
+	NUTS_PASS(nng_surveyor0_open(&s1));
+	NUTS_PASS(nng_surveyor0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s2));
 	nng_stats_free(stats);
 }
 
diff --git a/src/protocol/survey0/xrespond_test.c b/src/protocol/survey0/xrespond_test.c
index 342c8a94..ec5e99a3 100644
--- a/src/protocol/survey0/xrespond_test.c
+++ b/src/protocol/survey0/xrespond_test.c
@@ -7,14 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/survey0/respond.h>
-#include <nng/protocol/survey0/survey.h>
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 static void
 test_xresp_identity(void)
@@ -24,16 +17,16 @@ test_xresp_identity(void)
 	char *     n1;
 	char *     n2;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PROTO, &p1));
-	TEST_NNG_PASS(nng_getopt_int(s, NNG_OPT_PEER, &p2));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PROTONAME, &n1));
-	TEST_NNG_PASS(nng_getopt_string(s, NNG_OPT_PEERNAME, &n2));
-	TEST_NNG_PASS(nng_close(s));
-	TEST_CHECK(p1 == NNG_RESPONDENT0_SELF);
-	TEST_CHECK(p2 == NNG_RESPONDENT0_PEER);
-	TEST_CHECK(strcmp(n1, NNG_RESPONDENT0_SELF_NAME) == 0);
-	TEST_CHECK(strcmp(n2, NNG_RESPONDENT0_PEER_NAME) == 0);
+	NUTS_PASS(nng_respondent0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p1));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p2));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n1));
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n2));
+	NUTS_CLOSE(s);
+	NUTS_TRUE(p1 == NNG_RESPONDENT0_SELF);
+	NUTS_TRUE(p2 == NNG_RESPONDENT0_PEER);
+	NUTS_MATCH(n1, NNG_RESPONDENT0_SELF_NAME);
+	NUTS_MATCH(n2, NNG_RESPONDENT0_PEER_NAME);
 	nng_strfree(n1);
 	nng_strfree(n2);
 }
@@ -44,10 +37,10 @@ test_xresp_raw(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_respondent0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -56,9 +49,9 @@ test_xresp_no_context(void)
 	nng_socket s;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&s));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_respondent0_open_raw(&s));
+	NUTS_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -68,24 +61,24 @@ test_xresp_poll_writeable(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_getopt_int(resp, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_socket_get_int(resp, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// We are always writeable, even before connect.  This is so that
 	// back-pressure from a bad peer can't trash others.  We assume
 	// that peers won't send us requests faster than they can consume
 	// the answers.  If they do, they will lose their answers.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Now it's writable.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -96,32 +89,32 @@ test_xresp_poll_readable(void)
 	nng_socket resp;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_getopt_int(resp, NNG_OPT_RECVFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_socket_get_int(resp, NNG_OPT_RECVFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(surv, resp);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_SEND_STR(surv, "abc");
-	testutil_sleep(100);
+	NUTS_SEND(surv, "abc");
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) == true);
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(resp, &msg, 0));
+	NUTS_PASS(nng_recvmsg(resp, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -130,28 +123,28 @@ test_xresp_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&s1));
-	TEST_NNG_PASS(nng_respondent0_open(&s2));
+	NUTS_PASS(nng_respondent0_open_raw(&s1));
+	NUTS_PASS(nng_respondent0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -164,26 +157,26 @@ test_xresp_close_pipe_before_send(void)
 	nng_aio *  aio1;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_NNG_SEND_STR(surv, "test");
+	NUTS_MARRY(surv, resp);
+	NUTS_SEND(surv, "test");
 
 	nng_recv_aio(resp, aio1);
 	nng_aio_wait(aio1);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_CHECK((m = nng_aio_get_msg(aio1)) != NULL);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_TRUE((m = nng_aio_get_msg(aio1)) != NULL);
 	p = nng_msg_get_pipe(m);
-	TEST_NNG_PASS(nng_pipe_close(p));
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
+	NUTS_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio1);
 }
 
@@ -195,37 +188,37 @@ test_xresp_close_pipe_during_send(void)
 	nng_pipe   p;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 20));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
-
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, (unsigned) 0x81000000u));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-	TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
+	NUTS_PASS(nng_respondent_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_RECVBUF, 20));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_RECVBUF, 1));
+
+	NUTS_MARRY(surv, resp);
+
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, (unsigned) 0x81000000u));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_PASS(nng_recvmsg(resp, &m, 0));
 	p = nng_msg_get_pipe(m);
 	nng_msg_free(m);
 
 	for (int i = 0; i < 100; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
-		TEST_NNG_PASS(
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
+		NUTS_PASS(
 		    nng_msg_header_append_u32(m, (unsigned) i | 0x80000000u));
 		// protocol does not exert back-pressure
-		TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
+		NUTS_PASS(nng_sendmsg(resp, m, 0));
 	}
-	TEST_NNG_PASS(nng_pipe_close(p));
+	NUTS_PASS(nng_pipe_close(p));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -235,27 +228,27 @@ test_xresp_close_during_recv(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	for (unsigned i = 0; i < 100; i++) {
 		int rv;
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
 		rv = nng_sendmsg(surv, m, 0);
 		if (rv == NNG_ETIMEDOUT) {
 			nng_msg_free(m);
 			break;
 		}
 	}
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -264,14 +257,14 @@ test_xresp_recv_aio_stopped(void)
 	nng_socket resp;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_stop(aio);
 	nng_recv_aio(resp, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(resp);
 	nng_aio_free(aio);
 }
 
@@ -282,21 +275,21 @@ test_xresp_send_no_header(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
+	NUTS_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -306,21 +299,21 @@ test_xresp_recv_garbage(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_msg_alloc(&m, 4));
+	NUTS_PASS(nng_msg_append_u32(m, 1u));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -332,29 +325,29 @@ test_xresp_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
 
-	TEST_NNG_PASS(nng_setopt_int(resp, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(resp, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(resp, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(resp, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(resp, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(resp, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(resp, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(resp, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(resp, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(resp, opt, 3));
+	NUTS_PASS(nng_socket_get_int(resp, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(resp, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(resp, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_CHECK(nng_setopt(resp, opt, "", 1) == NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(resp, opt, "", 1), NNG_EINVAL);
 	sz = 1;
-	TEST_CHECK(nng_getopt(resp, opt, &v, &sz) == NNG_EINVAL);
-	TEST_CHECK(nng_setopt_bool(resp, opt, true) == NNG_EBADTYPE);
-	TEST_CHECK(nng_getopt_bool(resp, opt, &b) == NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(resp, opt, &v, &sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(resp, opt, true), NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(resp, opt, &b), NNG_EBADTYPE);
 
-	TEST_CHECK(nng_close(resp) == 0);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -364,65 +357,65 @@ test_xresp_ttl_drop(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_MAXTTL, 3));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 200));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_MAXTTL, 3));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 200));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Send messages.  Note that xresp implicitly adds a hop on receive.
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000001u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS1", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000002u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL2", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "PASS3", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
-	TEST_NNG_PASS(nng_msg_append_u32(m, 2u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 3u));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000003u));
-	TEST_NNG_PASS(nng_msg_append(m, "FAIL4", 6));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 2 hops
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000001u));
+	NUTS_PASS(nng_msg_append(m, "PASS1", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000002u));
+	NUTS_PASS(nng_msg_append(m, "FAIL2", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 3 hops - passes
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "PASS3", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 1u)); // 4 hops -- discard!
+	NUTS_PASS(nng_msg_append_u32(m, 2u));
+	NUTS_PASS(nng_msg_append_u32(m, 3u));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000003u));
+	NUTS_PASS(nng_msg_append(m, "FAIL4", 6));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
 
 	// So on receive we should see 80000001 and 80000003.
-	TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 12);
-	TEST_CHECK(nng_msg_len(m) == 6);
-	TEST_CHECK(strcmp(nng_msg_body(m), "PASS1") == 0);
+	NUTS_PASS(nng_recvmsg(resp, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 12);
+	NUTS_TRUE(nng_msg_len(m) == 6);
+	NUTS_MATCH(nng_msg_body(m), "PASS1");
 	nng_msg_free(m);
 
-	TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 16); // 3 hops + ID
-	TEST_CHECK(nng_msg_len(m) == 6);
-	TEST_CHECK(strcmp(nng_msg_body(m), "PASS3") == 0);
+	NUTS_PASS(nng_recvmsg(resp, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 16); // 3 hops + ID
+	NUTS_TRUE(nng_msg_len(m) == 6);
+	NUTS_MATCH(nng_msg_body(m), "PASS3");
 	nng_msg_free(m);
 
-	TEST_NNG_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
+	NUTS_FAIL(nng_recvmsg(resp, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "xrespond identity", test_xresp_identity },
 	{ "xrespond raw", test_xresp_raw },
 	{ "xrespond no context", test_xresp_no_context },
diff --git a/src/protocol/survey0/xsurvey_test.c b/src/protocol/survey0/xsurvey_test.c
index ca7a2dd6..f8e9d401 100644
--- a/src/protocol/survey0/xsurvey_test.c
+++ b/src/protocol/survey0/xsurvey_test.c
@@ -7,18 +7,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/survey0/respond.h>
-#include <nng/protocol/survey0/survey.h>
-
-#include <acutest.h>
-#include <testutil.h>
-
-#ifndef NNI_PROTO
-#define NNI_PROTO(x, y) (((x) << 4u) | (y))
-#endif
+#include <nuts.h>
 
 static void
 test_xsurveyor_identity(void)
@@ -27,18 +16,18 @@ test_xsurveyor_identity(void)
 	int        p;
 	char *     n;
 
-	TEST_CHECK(nng_surveyor0_open_raw(&s) == 0);
-	TEST_CHECK(nng_getopt_int(s, NNG_OPT_PROTO, &p) == 0);
-	TEST_CHECK(p == NNI_PROTO(6u, 2u)); // 0x62
-	TEST_CHECK(nng_getopt_int(s, NNG_OPT_PEER, &p) == 0);
-	TEST_CHECK(p == NNI_PROTO(6u, 3u)); // 0x63
-	TEST_CHECK(nng_getopt_string(s, NNG_OPT_PROTONAME, &n) == 0);
-	TEST_CHECK(strcmp(n, "surveyor") == 0);
+	NUTS_PASS(nng_surveyor0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PROTO, &p));
+	NUTS_TRUE(p == NNG_SURVEYOR0_SELF); // 0x62
+	NUTS_PASS(nng_socket_get_int(s, NNG_OPT_PEER, &p));
+	NUTS_TRUE(p == NNG_SURVEYOR0_PEER); // 0x62
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PROTONAME, &n));
+	NUTS_MATCH(n, NNG_SURVEYOR0_SELF_NAME);
 	nng_strfree(n);
-	TEST_CHECK(nng_getopt_string(s, NNG_OPT_PEERNAME, &n) == 0);
-	TEST_CHECK(strcmp(n, "respondent") == 0);
+	NUTS_PASS(nng_socket_get_string(s, NNG_OPT_PEERNAME, &n));
+	NUTS_MATCH(n, NNG_SURVEYOR0_PEER_NAME);
 	nng_strfree(n);
-	TEST_CHECK(nng_close(s) == 0);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -47,10 +36,10 @@ test_xsurveyor_raw(void)
 	nng_socket s;
 	bool       b;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&s));
-	TEST_NNG_PASS(nng_getopt_bool(s, NNG_OPT_RAW, &b));
-	TEST_CHECK(b);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_surveyor0_open_raw(&s));
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_RAW, &b));
+	NUTS_TRUE(b);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -59,9 +48,9 @@ test_xsurvey_no_context(void)
 	nng_socket s;
 	nng_ctx    ctx;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&s));
-	TEST_NNG_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_surveyor0_open_raw(&s));
+	NUTS_FAIL(nng_ctx_open(&ctx, s), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -71,21 +60,21 @@ test_xsurvey_poll_writeable(void)
 	nng_socket surv;
 	nng_socket resp;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(surv, NNG_OPT_SENDFD, &fd));
-	TEST_CHECK(fd >= 0);
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(surv, NNG_OPT_SENDFD, &fd));
+	NUTS_TRUE(fd >= 0);
 
 	// Survey is broadcast, so we can always write.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
 	// Now it's writable.
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd));
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -96,44 +85,44 @@ test_xsurvey_poll_readable(void)
 	nng_socket resp;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_respondent0_open(&resp));
-	TEST_NNG_PASS(nng_getopt_int(surv, NNG_OPT_RECVFD, &fd));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_respondent0_open(&resp));
+	NUTS_PASS(nng_socket_get_int(surv, NNG_OPT_RECVFD, &fd));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_CHECK(fd >= 0);
+	NUTS_TRUE(fd >= 0);
 
 	// Not readable if not connected!
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// Even after connect (no message yet)
-	TEST_NNG_PASS(testutil_marry(surv, resp));
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_MARRY(surv, resp);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
 	// But once we send messages, it is.
 	// We have to send a request, in order to send a reply.
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
 	// Request ID
-	TEST_NNG_PASS(nng_msg_append_u32(msg, 0x80000000));
-	TEST_NNG_PASS(nng_sendmsg(surv, msg, 0));
+	NUTS_PASS(nng_msg_append_u32(msg, 0x80000000));
+	NUTS_PASS(nng_sendmsg(surv, msg, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(resp, &msg, 0));
-	TEST_NNG_PASS(nng_sendmsg(resp, msg, 0));
+	NUTS_PASS(nng_recvmsg(resp, &msg, 0));
+	NUTS_PASS(nng_sendmsg(resp, msg, 0));
 
-	testutil_sleep(100);
+	NUTS_SLEEP(100);
 
-	TEST_CHECK(testutil_pollfd(fd) == true);
+	NUTS_TRUE(nuts_poll_fd(fd) );
 
 	// and receiving makes it no longer ready
-	TEST_NNG_PASS(nng_recvmsg(surv, &msg, 0));
+	NUTS_PASS(nng_recvmsg(surv, &msg, 0));
 	nng_msg_free(msg);
-	TEST_CHECK(testutil_pollfd(fd) == false);
+	NUTS_TRUE(nuts_poll_fd(fd) == false);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -142,28 +131,28 @@ test_xsurvey_validate_peer(void)
 	nng_socket s1, s2;
 	nng_stat * stats;
 	nng_stat * reject;
-	char       addr[64];
+	char       *addr;
 
-	testutil_scratch_addr("inproc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "inproc");
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&s1));
-	TEST_NNG_PASS(nng_surveyor0_open(&s2));
+	NUTS_PASS(nng_surveyor0_open_raw(&s1));
+	NUTS_PASS(nng_surveyor0_open(&s2));
 
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, NNG_FLAG_NONBLOCK));
 
-	testutil_sleep(100);
-	TEST_NNG_PASS(nng_stats_get(&stats));
+	NUTS_SLEEP(100);
+	NUTS_PASS(nng_stats_get(&stats));
 
-	TEST_CHECK(stats != NULL);
-	TEST_CHECK((reject = nng_stat_find_socket(stats, s1)) != NULL);
-	TEST_CHECK((reject = nng_stat_find(reject, "reject")) != NULL);
+	NUTS_TRUE(stats != NULL);
+	NUTS_TRUE((reject = nng_stat_find_socket(stats, s1)) != NULL);
+	NUTS_TRUE((reject = nng_stat_find(reject, "reject")) != NULL);
 
-	TEST_CHECK(nng_stat_type(reject) == NNG_STAT_COUNTER);
-	TEST_CHECK(nng_stat_value(reject) > 0);
+	NUTS_TRUE(nng_stat_type(reject) == NNG_STAT_COUNTER);
+	NUTS_TRUE(nng_stat_value(reject) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 	nng_stats_free(stats);
 }
 
@@ -173,14 +162,14 @@ test_xsurvey_recv_aio_stopped(void)
 	nng_socket surv;
 	nng_aio *  aio;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 
 	nng_aio_stop(aio);
 	nng_recv_aio(surv, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECANCELED);
-	TEST_NNG_PASS(nng_close(surv));
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECANCELED);
+	NUTS_CLOSE(surv);
 	nng_aio_free(aio);
 }
 
@@ -192,33 +181,33 @@ test_xsurvey_recv_garbage(void)
 	nng_msg *  m;
 	uint32_t   req_id;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp));
+	NUTS_MARRY(surv, resp);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_append_u32(m, 0x80000000));
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_append_u32(m, 0x80000000));
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
 
-	TEST_NNG_PASS(nng_recvmsg(resp, &m, 0));
+	NUTS_PASS(nng_recvmsg(resp, &m, 0));
 
 	// The message will have a header that contains the 32-bit pipe ID,
 	// followed by the 32-bit request ID.  We will discard the request
 	// ID before sending it out.
-	TEST_CHECK(nng_msg_header_len(m) == 8);
-	TEST_NNG_PASS(nng_msg_header_chop_u32(m, &req_id));
-	TEST_CHECK(req_id == 0x80000000);
+	NUTS_TRUE(nng_msg_header_len(m) == 8);
+	NUTS_PASS(nng_msg_header_chop_u32(m, &req_id));
+	NUTS_TRUE(req_id == 0x80000000);
 
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
-	TEST_NNG_FAIL(nng_recvmsg(surv, &m, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
+	NUTS_FAIL(nng_recvmsg(surv, &m, 0), NNG_ETIMEDOUT);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -230,37 +219,37 @@ test_xsurvey_recv_header(void)
 	nng_pipe   p;
 	uint32_t   id;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_SENDTIMEO, 1000));
 
-	TEST_NNG_PASS(testutil_marry_ex(surv, resp, NULL, NULL, &p));
+	NUTS_MARRY_EX(surv, resp, NULL, NULL, &p);
 
 	// Simulate a few hops.
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x2));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x1));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x80000123u));
-
-	TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
-
-	TEST_NNG_PASS(nng_recvmsg(surv, &m, 0));
-	TEST_CHECK(nng_msg_header_len(m) == 12);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x2);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x1);
-	TEST_NNG_PASS(nng_msg_header_trim_u32(m, &id));
-	TEST_CHECK(id == 0x80000123u);
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p)));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x2));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x1));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x80000123u));
+
+	NUTS_PASS(nng_sendmsg(resp, m, 0));
+
+	NUTS_PASS(nng_recvmsg(surv, &m, 0));
+	NUTS_TRUE(nng_msg_header_len(m) == 12);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x2);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x1);
+	NUTS_PASS(nng_msg_header_trim_u32(m, &id));
+	NUTS_TRUE(id == 0x80000123u);
 
 	nng_msg_free(m);
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -272,26 +261,26 @@ test_xsurvey_close_during_recv(void)
 	nng_pipe   p1;
 	nng_pipe   p2;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry_ex(surv, resp, NULL, &p1, &p2));
-	TEST_CHECK(nng_pipe_id(p1) > 0);
-	TEST_CHECK(nng_pipe_id(p2) > 0);
+	NUTS_MARRY_EX(surv, resp, NULL, &p1, &p2);
+	NUTS_TRUE(nng_pipe_id(p1) > 0);
+	NUTS_TRUE(nng_pipe_id(p2) > 0);
 
 	for (unsigned i = 0; i < 20; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
-		testutil_sleep(10);
-		TEST_NNG_PASS(nng_sendmsg(resp, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, nng_pipe_id(p2)));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_SLEEP(10);
+		NUTS_PASS(nng_sendmsg(resp, m, 0));
 	}
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -303,27 +292,27 @@ test_xsurvey_close_pipe_during_send(void)
 	nng_pipe   p1;
 	nng_pipe   p2;
 
-	TEST_NNG_PASS(nng_respondent0_open_raw(&resp));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_setopt_int(resp, NNG_OPT_RECVBUF, 5));
-	TEST_NNG_PASS(nng_setopt_int(surv, NNG_OPT_SENDBUF, 20));
+	NUTS_PASS(nng_respondent0_open_raw(&resp));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_socket_set_int(resp, NNG_OPT_RECVBUF, 5));
+	NUTS_PASS(nng_socket_set_int(surv, NNG_OPT_SENDBUF, 20));
 
-	TEST_NNG_PASS(testutil_marry_ex(surv, resp, NULL, &p1, &p2));
-	TEST_CHECK(nng_pipe_id(p1) > 0);
-	TEST_CHECK(nng_pipe_id(p2) > 0);
+	NUTS_MARRY_EX(surv, resp, NULL, &p1, &p2);
+	NUTS_TRUE(nng_pipe_id(p1) > 0);
+	NUTS_TRUE(nng_pipe_id(p2) > 0);
 
 	for (unsigned i = 0; i < 20; i++) {
-		TEST_NNG_PASS(nng_msg_alloc(&m, 4));
-		TEST_NNG_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
-		testutil_sleep(10);
-		TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
+		NUTS_PASS(nng_msg_alloc(&m, 4));
+		NUTS_PASS(nng_msg_header_append_u32(m, i | 0x80000000u));
+		NUTS_SLEEP(10);
+		NUTS_PASS(nng_sendmsg(surv, m, 0));
 	}
 
-	TEST_NNG_PASS(nng_pipe_close(p1));
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp));
+	NUTS_PASS(nng_pipe_close(p1));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp);
 }
 
 static void
@@ -335,29 +324,29 @@ test_xsurvey_ttl_option(void)
 	size_t      sz;
 	const char *opt = NNG_OPT_MAXTTL;
 
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&s));
+	NUTS_PASS(nng_surveyor0_open_raw(&s));
 
-	TEST_NNG_PASS(nng_setopt_int(s, opt, 1));
-	TEST_NNG_FAIL(nng_setopt_int(s, opt, 0), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(s, opt, -1), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(s, opt, 16), NNG_EINVAL);
-	TEST_NNG_FAIL(nng_setopt_int(s, opt, 256), NNG_EINVAL);
-	TEST_NNG_PASS(nng_setopt_int(s, opt, 3));
-	TEST_NNG_PASS(nng_getopt_int(s, opt, &v));
-	TEST_CHECK(v == 3);
+	NUTS_PASS(nng_socket_set_int(s, opt, 1));
+	NUTS_FAIL(nng_socket_set_int(s, opt, 0), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(s, opt, -1), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(s, opt, 16), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_int(s, opt, 256), NNG_EINVAL);
+	NUTS_PASS(nng_socket_set_int(s, opt, 3));
+	NUTS_PASS(nng_socket_get_int(s, opt, &v));
+	NUTS_TRUE(v == 3);
 	v  = 0;
 	sz = sizeof(v);
-	TEST_NNG_PASS(nng_getopt(s, opt, &v, &sz));
-	TEST_CHECK(v == 3);
-	TEST_CHECK(sz == sizeof(v));
+	NUTS_PASS(nng_socket_get(s, opt, &v, &sz));
+	NUTS_TRUE(v == 3);
+	NUTS_TRUE(sz == sizeof(v));
 
-	TEST_CHECK(nng_setopt(s, opt, "", 1) == NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(s, opt, "", 1) , NNG_EINVAL);
 	sz = 1;
-	TEST_CHECK(nng_getopt(s, opt, &v, &sz) == NNG_EINVAL);
-	TEST_CHECK(nng_setopt_bool(s, opt, true) == NNG_EBADTYPE);
-	TEST_CHECK(nng_getopt_bool(s, opt, &b) == NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get(s, opt, &v, &sz) , NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set_bool(s, opt, true) , NNG_EBADTYPE);
+	NUTS_FAIL(nng_socket_get_bool(s, opt, &b) , NNG_EBADTYPE);
 
-	TEST_CHECK(nng_close(s) == 0);
+	NUTS_CLOSE(s);
 }
 
 static void
@@ -368,27 +357,27 @@ test_xsurvey_broadcast(void)
 	nng_socket surv;
 	nng_msg *  m;
 
-	TEST_NNG_PASS(nng_respondent0_open(&resp1));
-	TEST_NNG_PASS(nng_respondent0_open(&resp2));
-	TEST_NNG_PASS(nng_surveyor0_open_raw(&surv));
-	TEST_NNG_PASS(nng_setopt_ms(resp1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(resp2, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_setopt_ms(surv, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_respondent0_open(&resp1));
+	NUTS_PASS(nng_respondent0_open(&resp2));
+	NUTS_PASS(nng_surveyor0_open_raw(&surv));
+	NUTS_PASS(nng_socket_set_ms(resp1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(resp2, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SENDTIMEO, 100));
 
-	TEST_NNG_PASS(testutil_marry(surv, resp1));
-	TEST_NNG_PASS(testutil_marry(surv, resp2));
+	NUTS_MARRY(surv, resp1);
+	NUTS_MARRY(surv, resp2);
 
-	TEST_NNG_PASS(nng_msg_alloc(&m, 0));
-	TEST_NNG_PASS(nng_msg_header_append_u32(m, 0x80000002u));
-	TEST_NNG_PASS(nng_msg_append(m, "hello", 6));
+	NUTS_PASS(nng_msg_alloc(&m, 0));
+	NUTS_PASS(nng_msg_header_append_u32(m, 0x80000002u));
+	NUTS_PASS(nng_msg_append(m, "hello", 6));
 
-	TEST_NNG_PASS(nng_sendmsg(surv, m, 0));
-	TEST_NNG_RECV_STR(resp1, "hello");
-	TEST_NNG_RECV_STR(resp2, "hello");
+	NUTS_PASS(nng_sendmsg(surv, m, 0));
+	NUTS_RECV(resp1, "hello");
+	NUTS_RECV(resp2, "hello");
 
-	TEST_NNG_PASS(nng_close(surv));
-	TEST_NNG_PASS(nng_close(resp1));
-	TEST_NNG_PASS(nng_close(resp2));
+	NUTS_CLOSE(surv);
+	NUTS_CLOSE(resp1);
+	NUTS_CLOSE(resp2);
 }
 
 TEST_LIST = {
diff --git a/src/supplemental/tls/tls_test.c b/src/supplemental/tls/tls_test.c
index 4857c4c7..244f68ca 100644
--- a/src/supplemental/tls/tls_test.c
+++ b/src/supplemental/tls/tls_test.c
@@ -7,48 +7,37 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/supplemental/tls/tls.h>
-#include <testutil.h>
-
-#include <acutest.h>
+#include <nuts.h>
 
 void
 test_tls_config_version(void)
 {
 	nng_tls_config *cfg;
 
-	TEST_NNG_PASS(nng_tls_config_alloc(&cfg, NNG_TLS_MODE_SERVER));
+	NUTS_PASS(nng_tls_config_alloc(&cfg, NNG_TLS_MODE_SERVER));
 
 	// Verify that min ver < max ver
-	TEST_NNG_FAIL(nng_tls_config_version(cfg, NNG_TLS_1_3, NNG_TLS_1_0),
+	NUTS_FAIL(nng_tls_config_version(cfg, NNG_TLS_1_3, NNG_TLS_1_0),
 	    NNG_ENOTSUP);
 
 	// Verify that we cannot configure SSL 3.0 or older.
-	TEST_NNG_FAIL(
-	    nng_tls_config_version(cfg, NNG_TLS_1_0 - 1, NNG_TLS_1_0),
+	NUTS_FAIL(nng_tls_config_version(cfg, NNG_TLS_1_0 - 1, NNG_TLS_1_0),
 	    NNG_ENOTSUP);
 
 	// Verify that we cannot configure TLS > 1.3.
-	TEST_NNG_FAIL(
-	    nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_3 + 1),
+	NUTS_FAIL(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_3 + 1),
 	    NNG_ENOTSUP);
 
 	// Verify that we *can* configure some various ranges.
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_0));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_1));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_2));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_3));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_1));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_2));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_3));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_2, NNG_TLS_1_2));
-	TEST_NNG_PASS(nng_tls_config_version(cfg, NNG_TLS_1_2, NNG_TLS_1_3));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_0));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_1));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_2));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_0, NNG_TLS_1_3));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_1));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_2));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_1, NNG_TLS_1_3));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_2, NNG_TLS_1_2));
+	NUTS_PASS(nng_tls_config_version(cfg, NNG_TLS_1_2, NNG_TLS_1_3));
 
 	nng_tls_config_free(cfg);
 }
@@ -59,15 +48,14 @@ test_tls_conn_refused(void)
 	nng_stream_dialer *dialer;
 	nng_aio *          aio;
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio, NULL, NULL));
 	nng_aio_set_timeout(aio, 5000); // 5 sec
 
 	// port 8 is generally not used for anything.
-	TEST_NNG_PASS(
-	    nng_stream_dialer_alloc(&dialer, "tls+tcp://127.0.0.1:8"));
+	NUTS_PASS(nng_stream_dialer_alloc(&dialer, "tls+tcp://127.0.0.1:8"));
 	nng_stream_dialer_dial(dialer, aio);
 	nng_aio_wait(aio);
-	TEST_NNG_FAIL(nng_aio_result(aio), NNG_ECONNREFUSED);
+	NUTS_FAIL(nng_aio_result(aio), NNG_ECONNREFUSED);
 
 	nng_aio_free(aio);
 	nng_stream_dialer_free(dialer);
@@ -89,57 +77,59 @@ test_tls_large_message(void)
 	size_t               size = 450001;
 	void *               t1;
 	void *               t2;
+	int                  port;
 
 	// allocate messages
-	TEST_CHECK((buf1 = nng_alloc(size)) != NULL);
-	TEST_CHECK((buf2 = nng_alloc(size)) != NULL);
+	NUTS_ASSERT((buf1 = nng_alloc(size)) != NULL);
+	NUTS_ASSERT((buf2 = nng_alloc(size)) != NULL);
 
 	for (size_t i = 0; i < size; i++) {
 		buf1[i] = rand() & 0xff;
 	}
 
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
 	nng_aio_set_timeout(aio1, 5000);
 	nng_aio_set_timeout(aio2, 5000);
 
-	testutil_scratch_addr("tls+tcp", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_stream_dialer_alloc(&d, addr));
-	TEST_NNG_PASS(nng_stream_listener_alloc(&l, addr));
-
-	// set up TLS parameters
-
-	TEST_NNG_PASS(nng_tls_config_alloc(&c1, NNG_TLS_MODE_SERVER));
-	TEST_NNG_PASS(nng_tls_config_own_cert(
-	    c1, testutil_server_crt, testutil_server_key, NULL));
-
-	TEST_NNG_PASS(nng_tls_config_alloc(&c2, NNG_TLS_MODE_CLIENT));
-	TEST_NNG_PASS(nng_tls_config_ca_chain(c2, testutil_server_crt, NULL));
-	TEST_NNG_PASS(nng_tls_config_server_name(c2, "localhost"));
-
-	TEST_NNG_PASS(nng_stream_listener_set_ptr(l, NNG_OPT_TLS_CONFIG, c1));
-	TEST_NNG_PASS(nng_stream_dialer_set_ptr(d, NNG_OPT_TLS_CONFIG, c2));
+	// Allocate the listener first.  We use a wild-card port.
+	NUTS_PASS(nng_stream_listener_alloc(&l, "tls+tcp://127.0.0.1:0"));
+	NUTS_PASS(nng_tls_config_alloc(&c1, NNG_TLS_MODE_SERVER));
+	NUTS_PASS(nng_tls_config_own_cert(
+	    c1, nuts_server_crt, nuts_server_key, NULL));
+	NUTS_PASS(nng_stream_listener_set_ptr(l, NNG_OPT_TLS_CONFIG, c1));
+	NUTS_PASS(nng_stream_listener_listen(l));
+	NUTS_PASS(
+	    nng_stream_listener_get_int(l, NNG_OPT_TCP_BOUND_PORT, &port));
+	NUTS_TRUE(port > 0);
+	NUTS_TRUE(port < 65536);
+
+	snprintf(addr, sizeof (addr), "tls+tcp://127.0.0.1:%d", port);
+	NUTS_PASS(nng_stream_dialer_alloc(&d, addr));
+	NUTS_PASS(nng_tls_config_alloc(&c2, NNG_TLS_MODE_CLIENT));
+	NUTS_PASS(nng_tls_config_ca_chain(c2, nuts_server_crt, NULL));
+	NUTS_PASS(nng_tls_config_server_name(c2, "localhost"));
+
+	NUTS_PASS(nng_stream_dialer_set_ptr(d, NNG_OPT_TLS_CONFIG, c2));
 
-	TEST_NNG_PASS(nng_stream_listener_listen(l));
 	nng_stream_listener_accept(l, aio1);
 	nng_stream_dialer_dial(d, aio2);
 
 	nng_aio_wait(aio1);
 	nng_aio_wait(aio2);
 
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_NNG_PASS(nng_aio_result(aio2));
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio2));
 
-	TEST_CHECK((s1 = nng_aio_get_output(aio1, 0)) != NULL);
-	TEST_CHECK((s2 = nng_aio_get_output(aio2, 0)) != NULL);
+	NUTS_TRUE((s1 = nng_aio_get_output(aio1, 0)) != NULL);
+	NUTS_TRUE((s2 = nng_aio_get_output(aio2, 0)) != NULL);
 
-	t1 = testutil_stream_send_start(s1, buf1, size);
-	t2 = testutil_stream_recv_start(s2, buf2, size);
+	t1 = nuts_stream_send_start(s1, buf1, size);
+	t2 = nuts_stream_recv_start(s2, buf2, size);
 
-	TEST_NNG_PASS(testutil_stream_send_wait(t1));
-	TEST_NNG_PASS(testutil_stream_recv_wait(t2));
-	TEST_CHECK(memcmp(buf1, buf2, size) == 0);
+	NUTS_PASS(nuts_stream_wait(t1));
+	NUTS_PASS(nuts_stream_wait(t2));
+	NUTS_TRUE(memcmp(buf1, buf2, size) == 0);
 
 	nng_free(buf1, size);
 	nng_free(buf2, size);
diff --git a/src/supplemental/websocket/websocket_test.c b/src/supplemental/websocket/websocket_test.c
index 9a298142..9ea68017 100644
--- a/src/supplemental/websocket/websocket_test.c
+++ b/src/supplemental/websocket/websocket_test.c
@@ -12,10 +12,7 @@
 #include <nng/nng.h>
 #include <nng/supplemental/util/platform.h>
 
-#include "supplemental/sha1/sha1.h"
-
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 void
 test_websocket_wildcard(void)
@@ -36,27 +33,27 @@ test_websocket_wildcard(void)
 	char                 buf2[8];
 	char                 uri[64];
 
-	TEST_NNG_PASS(nng_stream_listener_alloc(&l, "ws://127.0.0.1:0/test"));
+	NUTS_PASS(nng_stream_listener_alloc(&l, "ws://127.0.0.1:0/test"));
 
-	TEST_NNG_PASS(nng_stream_listener_listen(l));
+	NUTS_PASS(nng_stream_listener_listen(l));
 
 	// Let's get the address we're going to use to dial -- also check
 	// that it is correct.
 	sz = sizeof(sa1);
-	TEST_NNG_PASS(nng_stream_listener_get(l, NNG_OPT_LOCADDR, &sa1, &sz));
-	TEST_CHECK(sz == sizeof(sa1));
-	TEST_CHECK(sa1.s_in.sa_port != 0);
-	TEST_CHECK(sa1.s_family == NNG_AF_INET);
-	TEST_CHECK(testutil_htonl(sa1.s_in.sa_addr) == 0x7F000001u);
+	NUTS_PASS(nng_stream_listener_get(l, NNG_OPT_LOCADDR, &sa1, &sz));
+	NUTS_TRUE(sz == sizeof(sa1));
+	NUTS_TRUE(sa1.s_in.sa_port != 0);
+	NUTS_TRUE(sa1.s_family == NNG_AF_INET);
+	NUTS_TRUE(nuts_be32(sa1.s_in.sa_addr) == 0x7F000001u);
 
 	(void) snprintf(uri, sizeof(uri), "ws://127.0.0.1:%d/test",
-	    testutil_htons(sa1.s_in.sa_port));
+	    nuts_be16(sa1.s_in.sa_port));
 
-	TEST_NNG_PASS(nng_stream_dialer_alloc(&d, uri));
-	TEST_NNG_PASS(nng_aio_alloc(&daio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&laio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_stream_dialer_alloc(&d, uri));
+	NUTS_PASS(nng_aio_alloc(&daio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&laio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
 	nng_aio_set_timeout(daio, 5000); // 5 seconds
 	nng_aio_set_timeout(laio, 5000);
 	nng_aio_set_timeout(aio1, 5000);
@@ -68,29 +65,24 @@ test_websocket_wildcard(void)
 	nng_aio_wait(laio);
 	nng_aio_wait(daio);
 
-	TEST_NNG_PASS(nng_aio_result(laio));
-	TEST_NNG_PASS(nng_aio_result(daio));
+	NUTS_PASS(nng_aio_result(laio));
+	NUTS_PASS(nng_aio_result(daio));
 	c1 = nng_aio_get_output(laio, 0);
 	c2 = nng_aio_get_output(daio, 0);
-	TEST_CHECK(c1 != NULL);
-	TEST_CHECK(c2 != NULL);
+	NUTS_TRUE(c1 != NULL);
+	NUTS_TRUE(c2 != NULL);
 
 	//  Let's compare the peer addresses
-	TEST_NNG_PASS(nng_stream_get_addr(c2, NNG_OPT_REMADDR, &sa2));
-	TEST_CHECK(sa1.s_family == sa2.s_family);
-	TEST_CHECK(sa1.s_in.sa_addr == sa2.s_in.sa_addr);
-	TEST_CHECK(sa1.s_in.sa_port == sa2.s_in.sa_port);
-
-	TEST_NNG_PASS(nng_stream_get_addr(c1, NNG_OPT_REMADDR, &sa1));
-	TEST_NNG_PASS(nng_stream_get_addr(c2, NNG_OPT_LOCADDR, &sa2));
-	TEST_CHECK_(sa1.s_family == sa2.s_family, "families match %x == %x",
-	    sa1.s_family, sa2.s_family);
-	TEST_CHECK_(sa1.s_in.sa_addr == sa2.s_in.sa_addr,
-	    "addresses match %x == %x", testutil_htonl(sa1.s_in.sa_addr),
-	    testutil_htonl(sa2.s_in.sa_addr));
-	TEST_CHECK_(sa1.s_in.sa_port == sa2.s_in.sa_port,
-	    "ports match %u == %u", testutil_htons(sa1.s_in.sa_port),
-	    testutil_htons(sa2.s_in.sa_port));
+	NUTS_PASS(nng_stream_get_addr(c2, NNG_OPT_REMADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_in.sa_addr == sa2.s_in.sa_addr);
+	NUTS_TRUE(sa1.s_in.sa_port == sa2.s_in.sa_port);
+
+	NUTS_PASS(nng_stream_get_addr(c1, NNG_OPT_REMADDR, &sa1));
+	NUTS_PASS(nng_stream_get_addr(c2, NNG_OPT_LOCADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_in.sa_addr == sa2.s_in.sa_addr);
+	NUTS_TRUE(sa1.s_in.sa_port == sa2.s_in.sa_port);
 
 	// This relies on send completing for for just 5 bytes, and on
 	// recv doing the same.  Technically this isn't/ guaranteed, but
@@ -100,23 +92,23 @@ test_websocket_wildcard(void)
 	memset(buf2, 0, 5);
 	iov.iov_buf = buf1;
 	iov.iov_len = 5;
-	TEST_NNG_PASS(nng_aio_set_iov(aio1, 1, &iov));
+	NUTS_PASS(nng_aio_set_iov(aio1, 1, &iov));
 
 	iov.iov_buf = buf2;
 	iov.iov_len = 5;
-	TEST_NNG_PASS(nng_aio_set_iov(aio2, 1, &iov));
+	NUTS_PASS(nng_aio_set_iov(aio2, 1, &iov));
 
 	nng_stream_send(c1, aio1);
 	nng_stream_recv(c2, aio2);
 	nng_aio_wait(aio1);
 	nng_aio_wait(aio2);
 
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_CHECK(nng_aio_count(aio1) == 5);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_TRUE(nng_aio_count(aio1) == 5);
 
-	TEST_NNG_PASS(nng_aio_result(aio2));
-	TEST_CHECK(nng_aio_count(aio2) == 5);
-	TEST_CHECK(memcmp(buf1, buf2, 5) == 0);
+	NUTS_PASS(nng_aio_result(aio2));
+	NUTS_TRUE(nng_aio_count(aio2) == 5);
+	NUTS_TRUE(memcmp(buf1, buf2, 5) == 0);
 
 	nng_stream_close(c1);
 	nng_stream_free(c1);
@@ -145,18 +137,18 @@ test_websocket_conn_props(void)
 	char                 uri[64];
 	bool                 on;
 	char *               str;
-	uint16_t             port = testutil_next_port();
+	uint16_t             port = nuts_next_port();
 
 	(void) snprintf(uri, sizeof(uri), "ws://127.0.0.1:%d/test", port);
 
-	TEST_NNG_PASS(nng_aio_alloc(&daio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&laio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&daio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&laio, NULL, NULL));
 	nng_aio_set_timeout(daio, 5000); // 5 seconds
 	nng_aio_set_timeout(laio, 5000);
 
-	TEST_NNG_PASS(nng_stream_listener_alloc(&l, uri));
-	TEST_NNG_PASS(nng_stream_listener_listen(l));
-	TEST_NNG_PASS(nng_stream_dialer_alloc(&d, uri));
+	NUTS_PASS(nng_stream_listener_alloc(&l, uri));
+	NUTS_PASS(nng_stream_listener_listen(l));
+	NUTS_PASS(nng_stream_dialer_alloc(&d, uri));
 
 	nng_stream_dialer_dial(d, daio);
 	nng_stream_listener_accept(l, laio);
@@ -164,64 +156,54 @@ test_websocket_conn_props(void)
 	nng_aio_wait(laio);
 	nng_aio_wait(daio);
 
-	TEST_NNG_PASS(nng_aio_result(laio));
-	TEST_NNG_PASS(nng_aio_result(daio));
+	NUTS_PASS(nng_aio_result(laio));
+	NUTS_PASS(nng_aio_result(daio));
 	c1 = nng_aio_get_output(laio, 0);
 	c2 = nng_aio_get_output(daio, 0);
-	TEST_CHECK(c1 != NULL);
-	TEST_CHECK(c2 != NULL);
+	NUTS_TRUE(c1 != NULL);
+	NUTS_TRUE(c2 != NULL);
 
 	//  Let's compare the peer addresses
-	TEST_NNG_PASS(nng_stream_get_addr(c1, NNG_OPT_LOCADDR, &sa1));
-	TEST_NNG_PASS(nng_stream_get_addr(c2, NNG_OPT_REMADDR, &sa2));
-	TEST_CHECK_(sa1.s_family == sa2.s_family, "families match %x == %x",
-	    sa1.s_family, sa2.s_family);
-	TEST_CHECK_(sa1.s_in.sa_addr == sa2.s_in.sa_addr,
-	    "addresses match %x == %x", testutil_htonl(sa1.s_in.sa_addr),
-	    testutil_htonl(sa2.s_in.sa_addr));
-	TEST_CHECK_(sa1.s_in.sa_port == sa2.s_in.sa_port,
-	    "ports match %u == %u", testutil_htons(sa1.s_in.sa_port),
-	    testutil_htons(sa2.s_in.sa_port));
-
-	TEST_NNG_PASS(nng_stream_get_addr(c1, NNG_OPT_REMADDR, &sa1));
-	TEST_NNG_PASS(nng_stream_get_addr(c2, NNG_OPT_LOCADDR, &sa2));
-	TEST_CHECK_(sa1.s_family == sa2.s_family, "families match %x == %x",
-	    sa1.s_family, sa2.s_family);
-	TEST_CHECK_(sa1.s_in.sa_addr == sa2.s_in.sa_addr,
-	    "addresses match %x == %x", testutil_htonl(sa1.s_in.sa_addr),
-	    testutil_htonl(sa2.s_in.sa_addr));
-	TEST_CHECK_(sa1.s_in.sa_port == sa2.s_in.sa_port,
-	    "ports match %u == %u", testutil_htons(sa1.s_in.sa_port),
-	    testutil_htons(sa2.s_in.sa_port));
+	NUTS_PASS(nng_stream_get_addr(c1, NNG_OPT_LOCADDR, &sa1));
+	NUTS_PASS(nng_stream_get_addr(c2, NNG_OPT_REMADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_in.sa_addr == sa2.s_in.sa_addr);
+	NUTS_TRUE(sa1.s_in.sa_port == sa2.s_in.sa_port);
+
+	NUTS_PASS(nng_stream_get_addr(c1, NNG_OPT_REMADDR, &sa1));
+	NUTS_PASS(nng_stream_get_addr(c2, NNG_OPT_LOCADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_in.sa_addr == sa2.s_in.sa_addr);
+	NUTS_TRUE(sa1.s_in.sa_port == sa2.s_in.sa_port);
 
 	on = true;
-	TEST_NNG_PASS(nng_stream_set_bool(c1, NNG_OPT_TCP_NODELAY, on));
-	TEST_NNG_PASS(nng_stream_set_bool(c2, NNG_OPT_TCP_NODELAY, on));
+	NUTS_PASS(nng_stream_set_bool(c1, NNG_OPT_TCP_NODELAY, on));
+	NUTS_PASS(nng_stream_set_bool(c2, NNG_OPT_TCP_NODELAY, on));
 
-	TEST_NNG_PASS(nng_stream_set_bool(c1, NNG_OPT_TCP_KEEPALIVE, on));
-	TEST_NNG_PASS(nng_stream_set_bool(c2, NNG_OPT_TCP_KEEPALIVE, on));
-	TEST_NNG_FAIL(nng_stream_set_string(c1, NNG_OPT_TCP_KEEPALIVE, "nope"),
+	NUTS_PASS(nng_stream_set_bool(c1, NNG_OPT_TCP_KEEPALIVE, on));
+	NUTS_PASS(nng_stream_set_bool(c2, NNG_OPT_TCP_KEEPALIVE, on));
+	NUTS_FAIL(nng_stream_set_string(c1, NNG_OPT_TCP_KEEPALIVE, "nope"),
 	    NNG_EBADTYPE);
 
 	on = false;
 	sz = sizeof(on);
-	TEST_NNG_PASS(nng_stream_get(c1, NNG_OPT_TCP_NODELAY, &on, &sz));
-	TEST_CHECK(sz == sizeof(on));
-	TEST_CHECK(on == true);
+	NUTS_PASS(nng_stream_get(c1, NNG_OPT_TCP_NODELAY, &on, &sz));
+	NUTS_TRUE(sz == sizeof(on));
+	NUTS_TRUE(on == true);
 
 	on = false;
 	sz = sizeof(on);
-	TEST_NNG_PASS(nng_stream_get(c2, NNG_OPT_TCP_KEEPALIVE, &on, &sz));
-	TEST_CHECK(sz == sizeof(on));
-	TEST_CHECK(on == true);
+	NUTS_PASS(nng_stream_get(c2, NNG_OPT_TCP_KEEPALIVE, &on, &sz));
+	NUTS_TRUE(sz == sizeof(on));
+	NUTS_TRUE(on == true);
 
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_stream_get_size(c1, NNG_OPT_TCP_NODELAY, &sz), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_stream_get_string(
+	NUTS_PASS(nng_stream_get_string(
 	    c1, NNG_OPT_WS_REQUEST_HEADER "Sec-WebSocket-Version", &str));
-	TEST_CHECK(str != NULL);
-	TEST_CHECK(strcmp(str, "13") == 0);
+	NUTS_TRUE(str != NULL);
+	NUTS_TRUE(strcmp(str, "13") == 0);
 	nng_strfree(str);
 
 	nng_stream_close(c1);
@@ -249,73 +231,69 @@ test_websocket_text_mode(void)
 	char                 txb[5];
 	char                 rxb[5];
 	bool                 on;
-	uint16_t             port = testutil_next_port();
+	uint16_t             port = nuts_next_port();
 	nng_iov              iov;
 
 	(void) snprintf(uri, sizeof(uri), "ws://127.0.0.1:%d/test", port);
 
-	TEST_NNG_PASS(nng_aio_alloc(&daio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&laio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio1, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&aio2, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&daio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&laio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio1, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&aio2, NULL, NULL));
 	nng_aio_set_timeout(daio, 5000); // 5 seconds
 	nng_aio_set_timeout(laio, 5000);
 	nng_aio_set_timeout(aio1, 5000);
 	nng_aio_set_timeout(aio2, 5000);
 
-	TEST_NNG_PASS(nng_stream_listener_alloc(&l, uri));
-	TEST_NNG_PASS(nng_stream_dialer_alloc(&d, uri));
+	NUTS_PASS(nng_stream_listener_alloc(&l, uri));
+	NUTS_PASS(nng_stream_dialer_alloc(&d, uri));
 
 	on = true;
-	TEST_NNG_PASS(nng_stream_dialer_set_bool(d, NNG_OPT_WS_SEND_TEXT, on));
-	TEST_NNG_PASS(
-	    nng_stream_listener_set_bool(l, NNG_OPT_WS_RECV_TEXT, on));
+	NUTS_PASS(nng_stream_dialer_set_bool(d, NNG_OPT_WS_SEND_TEXT, on));
+	NUTS_PASS(nng_stream_listener_set_bool(l, NNG_OPT_WS_RECV_TEXT, on));
 
-        TEST_NNG_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_SEND_TEXT, &on));
-        TEST_ASSERT(on == true);
-        TEST_NNG_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_RECV_TEXT, &on));
-        TEST_ASSERT(on == false);
+	NUTS_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_SEND_TEXT, &on));
+	NUTS_TRUE(on);
+	NUTS_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_RECV_TEXT, &on));
+	NUTS_TRUE(on == false);
 
-
-        TEST_NNG_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_SEND_TEXT, &on));
-        TEST_ASSERT(on == false);
-        TEST_NNG_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_RECV_TEXT, &on));
-        TEST_ASSERT(on == true);
+	NUTS_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_SEND_TEXT, &on));
+	NUTS_TRUE(on == false);
+	NUTS_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_RECV_TEXT, &on));
+	NUTS_TRUE(on);
 
 	on = false;
-        TEST_NNG_PASS(nng_stream_dialer_set_bool(d, NNG_OPT_WS_RECV_TEXT, on));
-        TEST_NNG_PASS(
-            nng_stream_listener_set_bool(l, NNG_OPT_WS_SEND_TEXT, on));
-        TEST_NNG_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_SEND_TEXT, &on));
-        TEST_ASSERT(on == false);
-        TEST_NNG_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_RECV_TEXT, &on));
-        TEST_ASSERT(on == false);
-
-        TEST_NNG_PASS(nng_stream_listener_listen(l));
-        nng_stream_dialer_dial(d, daio);
+	NUTS_PASS(nng_stream_dialer_set_bool(d, NNG_OPT_WS_RECV_TEXT, on));
+	NUTS_PASS(nng_stream_listener_set_bool(l, NNG_OPT_WS_SEND_TEXT, on));
+	NUTS_PASS(nng_stream_listener_get_bool(l, NNG_OPT_WS_SEND_TEXT, &on));
+	NUTS_TRUE(on == false);
+	NUTS_PASS(nng_stream_dialer_get_bool(d, NNG_OPT_WS_RECV_TEXT, &on));
+	NUTS_TRUE(on == false);
+
+	NUTS_PASS(nng_stream_listener_listen(l));
+	nng_stream_dialer_dial(d, daio);
 	nng_stream_listener_accept(l, laio);
 
 	nng_aio_wait(laio);
 	nng_aio_wait(daio);
 
-	TEST_NNG_PASS(nng_aio_result(laio));
-	TEST_NNG_PASS(nng_aio_result(daio));
+	NUTS_PASS(nng_aio_result(laio));
+	NUTS_PASS(nng_aio_result(daio));
 	c1 = nng_aio_get_output(laio, 0);
 	c2 = nng_aio_get_output(daio, 0);
-	TEST_CHECK(c1 != NULL);
-	TEST_CHECK(c2 != NULL);
+	NUTS_TRUE(c1 != NULL);
+	NUTS_TRUE(c2 != NULL);
 
-	TEST_NNG_PASS(nng_stream_get_bool(c1, NNG_OPT_WS_SEND_TEXT, &on));
-	TEST_ASSERT(on == false);
-	TEST_NNG_PASS(nng_stream_get_bool(c1, NNG_OPT_WS_RECV_TEXT, &on));
-	TEST_ASSERT(on == true);
-	TEST_NNG_PASS(
-	    nng_stream_listener_set_bool(l, NNG_OPT_WS_RECV_TEXT, on));
+	NUTS_PASS(nng_stream_get_bool(c1, NNG_OPT_WS_SEND_TEXT, &on));
+	NUTS_TRUE(on == false);
+	NUTS_PASS(nng_stream_get_bool(c1, NNG_OPT_WS_RECV_TEXT, &on));
+	NUTS_TRUE(on);
+	NUTS_PASS(nng_stream_listener_set_bool(l, NNG_OPT_WS_RECV_TEXT, on));
 
-	TEST_NNG_PASS(nng_stream_get_bool(c2, NNG_OPT_WS_SEND_TEXT, &on));
-	TEST_ASSERT(on == true);
-	TEST_NNG_PASS(nng_stream_get_bool(c2, NNG_OPT_WS_RECV_TEXT, &on));
-	TEST_ASSERT(on == false);
+	NUTS_PASS(nng_stream_get_bool(c2, NNG_OPT_WS_SEND_TEXT, &on));
+	NUTS_TRUE(on);
+	NUTS_PASS(nng_stream_get_bool(c2, NNG_OPT_WS_RECV_TEXT, &on));
+	NUTS_TRUE(on == false);
 
 	memcpy(txb, "PING", 5);
 	iov.iov_buf = txb;
@@ -329,9 +307,9 @@ test_websocket_text_mode(void)
 
 	nng_aio_wait(aio1);
 	nng_aio_wait(aio2);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_NNG_PASS(nng_aio_result(aio2));
-	TEST_ASSERT(memcmp(rxb, txb, 5) == 0);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio2));
+	NUTS_TRUE(memcmp(rxb, txb, 5) == 0);
 
 	memset(rxb, 0, 5);
 	memcpy(txb, "PONG", 5);
@@ -347,9 +325,9 @@ test_websocket_text_mode(void)
 
 	nng_aio_wait(aio1);
 	nng_aio_wait(aio2);
-	TEST_NNG_PASS(nng_aio_result(aio1));
-	TEST_NNG_PASS(nng_aio_result(aio2));
-	TEST_ASSERT(memcmp(rxb, txb, 5) == 0);
+	NUTS_PASS(nng_aio_result(aio1));
+	NUTS_PASS(nng_aio_result(aio2));
+	NUTS_TRUE(memcmp(rxb, txb, 5) == 0);
 
 	nng_stream_close(c1);
 	nng_stream_free(c1);
@@ -435,11 +413,11 @@ test_websocket_fragmentation(void)
 	state.total = 200000; // total to send
 	state.xfr   = 0;
 	state.err   = 0;
-	TEST_CHECK((recv_buf = nng_alloc(state.total)) != NULL);
-	TEST_CHECK((send_buf = nng_alloc(state.total)) != NULL);
-	TEST_NNG_PASS(nng_mtx_alloc(&state.lock));
-	TEST_NNG_PASS(nng_cv_alloc(&state.cv, state.lock));
-	TEST_NNG_PASS(nng_aio_alloc(&state.aio, frag_recv_cb, &state));
+	NUTS_TRUE((recv_buf = nng_alloc(state.total)) != NULL);
+	NUTS_TRUE((send_buf = nng_alloc(state.total)) != NULL);
+	NUTS_PASS(nng_mtx_alloc(&state.lock));
+	NUTS_PASS(nng_cv_alloc(&state.cv, state.lock));
+	NUTS_PASS(nng_aio_alloc(&state.aio, frag_recv_cb, &state));
 	nng_aio_set_timeout(state.aio, 2000);
 	state.buf = recv_buf;
 
@@ -451,20 +429,19 @@ test_websocket_fragmentation(void)
 	nni_sha1(send_buf, state.total, sum1);
 	nni_sha1_init(&state.sum);
 
-	port = testutil_next_port();
+	port = nuts_next_port();
 	(void) snprintf(url, sizeof(url), "ws://127.0.0.1:%u", port);
 
-	TEST_NNG_PASS(nng_stream_listener_alloc(&l, url));
-	TEST_NNG_PASS(nng_stream_dialer_alloc(&d, url));
-	TEST_NNG_PASS(nng_aio_alloc(&daio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&laio, NULL, NULL));
-	TEST_NNG_PASS(nng_aio_alloc(&caio, NULL, NULL));
+	NUTS_PASS(nng_stream_listener_alloc(&l, url));
+	NUTS_PASS(nng_stream_dialer_alloc(&d, url));
+	NUTS_PASS(nng_aio_alloc(&daio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&laio, NULL, NULL));
+	NUTS_PASS(nng_aio_alloc(&caio, NULL, NULL));
 
-	TEST_NNG_PASS(
-	    nng_stream_listener_set_bool(l, NNG_OPT_TCP_NODELAY, true));
-	TEST_NNG_PASS(
+	NUTS_PASS(nng_stream_listener_set_bool(l, NNG_OPT_TCP_NODELAY, true));
+	NUTS_PASS(
 	    nng_stream_listener_set_size(l, NNG_OPT_WS_SENDMAXFRAME, 1000000));
-	TEST_NNG_PASS(nng_stream_listener_listen(l));
+	NUTS_PASS(nng_stream_listener_listen(l));
 
 	nng_aio_set_timeout(laio, 2000);
 	nng_aio_set_timeout(daio, 2000);
@@ -475,8 +452,8 @@ test_websocket_fragmentation(void)
 	nng_aio_wait(laio);
 	nng_aio_wait(daio);
 
-	TEST_NNG_PASS(nng_aio_result(laio));
-	TEST_NNG_PASS(nng_aio_result(daio));
+	NUTS_PASS(nng_aio_result(laio));
+	NUTS_PASS(nng_aio_result(daio));
 	state.c = nng_aio_get_output(daio, 0);
 	c       = nng_aio_get_output(laio, 0);
 
@@ -493,11 +470,11 @@ test_websocket_fragmentation(void)
 		iov.iov_len = len;
 		iov.iov_buf = buf;
 
-		TEST_NNG_PASS(nng_aio_set_iov(caio, 1, &iov));
+		NUTS_PASS(nng_aio_set_iov(caio, 1, &iov));
 		nng_stream_send(c, caio);
 		nng_aio_wait(caio);
-		TEST_NNG_PASS(nng_aio_result(caio));
-		TEST_CHECK(nng_aio_count(caio) > 0);
+		NUTS_PASS(nng_aio_result(caio));
+		NUTS_TRUE(nng_aio_count(caio) > 0);
 		len = nng_aio_count(caio);
 
 		resid -= len;
@@ -510,13 +487,12 @@ test_websocket_fragmentation(void)
 	}
 	nng_mtx_unlock(state.lock);
 
-	TEST_NNG_PASS(state.err);
-	TEST_CHECK_(state.xfr == state.total,
-	    "send count (%d) == recv count (%d)", state.total, state.xfr);
+	NUTS_PASS(state.err);
+	NUTS_TRUE(state.xfr == state.total);
 
 	nni_sha1_final(&state.sum, sum2);
-	TEST_CHECK(memcmp(recv_buf, send_buf, state.total) == 0);
-	TEST_CHECK(memcmp(sum1, sum2, 20) == 0);
+	NUTS_TRUE(memcmp(recv_buf, send_buf, state.total) == 0);
+	NUTS_TRUE(memcmp(sum1, sum2, 20) == 0);
 
 	nng_aio_free(caio);
 	nng_stream_close(c);
@@ -535,7 +511,7 @@ test_websocket_fragmentation(void)
 	nng_stream_listener_free(l);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "websocket stream wildcard", test_websocket_wildcard },
 	{ "websocket conn properties", test_websocket_conn_props },
 	{ "websocket fragmentation", test_websocket_fragmentation },
diff --git a/src/supplemental/websocket/wssfile_test.c b/src/supplemental/websocket/wssfile_test.c
index 3f69cadc..59003123 100644
--- a/src/supplemental/websocket/wssfile_test.c
+++ b/src/supplemental/websocket/wssfile_test.c
@@ -8,16 +8,9 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/tls/tls.h>
-#include <nng/supplemental/util/platform.h>
-#include <nng/transport/ws/websocket.h>
-
 #include "core/nng_impl.h"
 
-#include "acutest.h"
-#include "testutil.h"
+#include <nuts.h>
 
 #ifdef NNG_SUPP_TLS
 // These keys are for demonstration purposes ONLY.  DO NOT USE.
@@ -106,13 +99,13 @@ init_dialer_wss_file(nng_dialer d)
 	char *tmpdir;
 	char *pth;
 
-	TEST_ASSERT((tmpdir = nni_plat_temp_dir()) != NULL);
-	TEST_ASSERT((pth = nni_file_join(tmpdir, CACERT)) != NULL);
-	nni_strfree(tmpdir);
-	TEST_NNG_PASS(nni_file_put(pth, cert, strlen(cert)));
-	TEST_NNG_PASS(nng_dialer_set_string(d, NNG_OPT_TLS_CA_FILE, pth));
+	NUTS_ASSERT((tmpdir = nni_plat_temp_dir()) != NULL);
+	NUTS_ASSERT((pth = nni_file_join(tmpdir, CACERT)) != NULL);
+	nng_strfree(tmpdir);
+	NUTS_PASS(nni_file_put(pth, cert, strlen(cert)));
+	NUTS_PASS(nng_dialer_set_string(d, NNG_OPT_TLS_CA_FILE, pth));
 	nni_file_delete(pth);
-	nni_strfree(pth);
+	nng_strfree(pth);
 }
 
 static void
@@ -122,25 +115,24 @@ init_listener_wss_file(nng_listener l)
 	char *pth;
 	char *cert_key;
 
-	TEST_ASSERT((tmpdir = nni_plat_temp_dir()) != NULL);
-	TEST_ASSERT((pth = nni_file_join(tmpdir, CERT_KEY)) != NULL);
-	nni_strfree(tmpdir);
+	NUTS_ASSERT((tmpdir = nni_plat_temp_dir()) != NULL);
+	NUTS_ASSERT((pth = nni_file_join(tmpdir, CERT_KEY)) != NULL);
+	nng_strfree(tmpdir);
 
-	TEST_NNG_PASS(nni_asprintf(&cert_key, "%s\r\n%s\r\n", cert, key));
+	NUTS_PASS(nni_asprintf(&cert_key, "%s\r\n%s\r\n", cert, key));
 
-	TEST_NNG_PASS(nni_file_put(pth, cert_key, strlen(cert_key)));
-	nni_strfree(cert_key);
-	TEST_NNG_PASS(
-	    nng_listener_set_string(l, NNG_OPT_TLS_CERT_KEY_FILE, pth));
+	NUTS_PASS(nni_file_put(pth, cert_key, strlen(cert_key)));
+	nng_strfree(cert_key);
+	NUTS_PASS(nng_listener_set_string(l, NNG_OPT_TLS_CERT_KEY_FILE, pth));
 
 	nni_file_delete(pth);
-	nni_strfree(pth);
+	nng_strfree(pth);
 }
 
 static void
 test_invalid_verify(void)
 {
-	uint16_t     port = testutil_next_port();
+	uint16_t     port = nuts_next_port();
 	nng_socket   s1;
 	nng_socket   s2;
 	nng_listener l;
@@ -149,11 +141,11 @@ test_invalid_verify(void)
 
 	(void) snprintf(addr, sizeof(addr), "wss4://:%u/test", port);
 
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_pair_open(&s2));
-	TEST_NNG_PASS(nng_listener_create(&l, s1, addr));
+	NUTS_PASS(nng_pair_open(&s1));
+	NUTS_PASS(nng_pair_open(&s2));
+	NUTS_PASS(nng_listener_create(&l, s1, addr));
 	init_listener_wss_file(l);
-	TEST_NNG_PASS(nng_listener_start(l, 0));
+	NUTS_PASS(nng_listener_start(l, 0));
 
 	nng_msleep(100);
 
@@ -164,20 +156,18 @@ test_invalid_verify(void)
 	// dependent, based on receive vs. send timing most likely.
 	// Applications shouldn't really depend that much on this.
 	int rv;
-	rv = nng_dial(s2, addr, NULL, 0);
 
-	TEST_NNG_PASS(nng_dialer_create(&d, s2, addr));
-	TEST_NNG_PASS(nng_dialer_set_int(
+	NUTS_PASS(nng_dialer_create(&d, s2, addr));
+	NUTS_PASS(nng_dialer_set_int(
 	    d, NNG_OPT_TLS_AUTH_MODE, NNG_TLS_AUTH_MODE_REQUIRED));
 	rv = nng_dialer_start(d, 0);
 
-	TEST_CHECK(rv != 0);
-	TEST_CHECK_((rv == NNG_EPEERAUTH) || (rv == NNG_ECLOSED) ||
-	        (rv == NNG_ECRYPTO),
-	    "result from dial: %d %s", rv, nng_strerror(rv));
+	NUTS_TRUE(rv != 0);
+	NUTS_TRUE((rv == NNG_EPEERAUTH) || (rv == NNG_ECLOSED) ||
+	    (rv == NNG_ECRYPTO));
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s2));
 }
 
 static void
@@ -193,43 +183,43 @@ test_no_verify(void)
 	bool         b;
 	uint16_t     port;
 
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_pair_open(&s2));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 5000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 5000));
+	NUTS_PASS(nng_pair_open(&s1));
+	NUTS_PASS(nng_pair_open(&s2));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 5000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 5000));
 
-	port = testutil_next_port();
+	port = nuts_next_port();
 	(void) snprintf(addr, sizeof(addr), "wss4://:%u/test", port);
-	TEST_NNG_PASS(nng_listener_create(&l, s1, addr));
+	NUTS_PASS(nng_listener_create(&l, s1, addr));
 	init_listener_wss_file(l);
-	TEST_NNG_PASS(nng_listener_start(l, 0));
+	NUTS_PASS(nng_listener_start(l, 0));
 
 	nng_msleep(100);
 	snprintf(addr, sizeof(addr), "wss://127.0.0.1:%u/test", port);
-	TEST_NNG_PASS(nng_dialer_create(&d, s2, addr));
+	NUTS_PASS(nng_dialer_create(&d, s2, addr));
 	init_dialer_wss_file(d);
-	TEST_NNG_PASS(nng_dialer_set_int(
+	NUTS_PASS(nng_dialer_set_int(
 	    d, NNG_OPT_TLS_AUTH_MODE, NNG_TLS_AUTH_MODE_OPTIONAL));
-	TEST_NNG_PASS(
+	NUTS_PASS(
 	    nng_dialer_set_string(d, NNG_OPT_TLS_SERVER_NAME, "example.com"));
 
-	TEST_NNG_PASS(nng_dialer_start(d, 0));
+	NUTS_PASS(nng_dialer_start(d, 0));
 	nng_msleep(100);
 
-	TEST_NNG_PASS(nng_send(s1, "hello", 6, 0));
-	TEST_NNG_PASS(nng_recvmsg(s2, &msg, 0));
-	TEST_ASSERT(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 6);
-	TEST_STREQUAL(nng_msg_body(msg), "hello");
+	NUTS_PASS(nng_send(s1, "hello", 6, 0));
+	NUTS_PASS(nng_recvmsg(s2, &msg, 0));
+	NUTS_ASSERT(msg != NULL);
+	NUTS_TRUE(nng_msg_len(msg) == 6);
+	NUTS_MATCH(nng_msg_body(msg), "hello");
 
 	p = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p) > 0);
-	TEST_NNG_PASS(nng_pipe_get_bool(p, NNG_OPT_TLS_VERIFIED, &b));
-	TEST_CHECK(b == false);
+	NUTS_TRUE(nng_pipe_id(p) > 0);
+	NUTS_PASS(nng_pipe_get_bool(p, NNG_OPT_TLS_VERIFIED, &b));
+	NUTS_TRUE(b == false);
 
 	nng_msg_free(msg);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 static void
@@ -245,39 +235,39 @@ test_verify_works(void)
 	bool         b;
 	uint16_t     port;
 
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_pair_open(&s2));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 5000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 5000));
-	port = testutil_next_port();
+	NUTS_PASS(nng_pair_open(&s1));
+	NUTS_PASS(nng_pair_open(&s2));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 5000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 5000));
+	port = nuts_next_port();
 	(void) snprintf(addr, sizeof(addr), "wss4://:%u/test", port);
-	TEST_NNG_PASS(nng_listener_create(&l, s1, addr));
+	NUTS_PASS(nng_listener_create(&l, s1, addr));
 	init_listener_wss_file(l);
-	TEST_NNG_PASS(nng_listener_start(l, 0));
+	NUTS_PASS(nng_listener_start(l, 0));
 
 	// It can take a bit for the listener to start up in clouds.
 	nng_msleep(200);
 	snprintf(addr, sizeof(addr), "wss4://localhost:%u/test", port);
-	TEST_NNG_PASS(nng_dialer_create(&d, s2, addr));
+	NUTS_PASS(nng_dialer_create(&d, s2, addr));
 	init_dialer_wss_file(d);
 
-	TEST_NNG_PASS(nng_dialer_start(d, 0));
+	NUTS_PASS(nng_dialer_start(d, 0));
 	nng_msleep(100);
 
-	TEST_NNG_PASS(nng_send(s1, "hello", 6, 0));
-	TEST_NNG_PASS(nng_recvmsg(s2, &msg, 0));
-	TEST_ASSERT(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 6);
-	TEST_STREQUAL(nng_msg_body(msg), "hello");
+	NUTS_PASS(nng_send(s1, "hello", 6, 0));
+	NUTS_PASS(nng_recvmsg(s2, &msg, 0));
+	NUTS_ASSERT(msg != NULL);
+	NUTS_TRUE(nng_msg_len(msg) == 6);
+	NUTS_MATCH(nng_msg_body(msg), "hello");
 
 	p = nng_msg_get_pipe(msg);
-	TEST_CHECK(nng_pipe_id(p) > 0);
-	TEST_NNG_PASS(nng_pipe_get_bool(p, NNG_OPT_TLS_VERIFIED, &b));
-	TEST_CHECK(b == true);
+	NUTS_TRUE(nng_pipe_id(p) > 0);
+	NUTS_PASS(nng_pipe_get_bool(p, NNG_OPT_TLS_VERIFIED, &b));
+	NUTS_TRUE(b == true);
 
 	nng_msg_free(msg);
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s2));
 }
 
 static void
@@ -285,24 +275,20 @@ test_cert_file_not_present(void)
 {
 	nng_socket   s1;
 	nng_listener l;
-	char         addr[NNG_MAXADDRLEN];
-	uint16_t     port;
 
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	port = testutil_next_port();
-	(void) snprintf(addr, sizeof(addr), "wss4://:%u/test", port);
-	TEST_NNG_PASS(nng_listener_create(&l, s1, addr));
+	NUTS_PASS(nng_pair_open(&s1));
+	NUTS_PASS(nng_listener_create(&l, s1, "wss4://:0/test"));
 
-	TEST_NNG_FAIL(nng_listener_set_string(
-	                  l, NNG_OPT_TLS_CERT_KEY_FILE, "no-such-file.pem"),
+	NUTS_FAIL(nng_listener_set_string(
+	              l, NNG_OPT_TLS_CERT_KEY_FILE, "no-such-file.pem"),
 	    NNG_ENOENT);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_close(s1));
 }
 
 #endif
 
-TEST_LIST = {
+NUTS_TESTS = {
 #ifdef NNG_SUPP_TLS
 	{ "wss file invalid verify", test_invalid_verify },
 	{ "wss file no verify", test_no_verify },
diff --git a/src/testing/CMakeLists.txt b/src/testing/CMakeLists.txt
new file mode 100644
index 00000000..221ca8f2
--- /dev/null
+++ b/src/testing/CMakeLists.txt
@@ -0,0 +1,19 @@
+#
+# Copyright 2020 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
+# file was obtained (LICENSE.txt).  A copy of the license may also be
+# found online at https://opensource.org/licenses/MIT.
+#
+
+#  Protocols.
+nng_directory(testing`)
+
+target_sources(nng_testing PRIVATE
+        certs.c
+        marry.c
+        streams.c
+        util.c)
+
+target_include_directories(nng_testing PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/src/testing/acutest.h b/src/testing/acutest.h
new file mode 100644
index 00000000..7f0fc059
--- /dev/null
+++ b/src/testing/acutest.h
@@ -0,0 +1,1645 @@
+/*
+ * Acutest -- Another C/C++ Unit Test facility
+ * <http://github.com/mity/acutest>
+ *
+ * Copyright (c) 2013-2019 Martin Mitas
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef ACUTEST_H__
+#define ACUTEST_H__
+
+
+/************************
+ *** Public interface ***
+ ************************/
+
+/* By default, "acutest.h" provides the main program entry point (function
+ * main()). However, if the test suite is composed of multiple source files
+ * which include "acutest.h", then this causes a problem of multiple main()
+ * definitions. To avoid this problem, #define macro TEST_NO_MAIN in all
+ * compilation units but one.
+ */
+
+/* Macro to specify list of unit tests in the suite.
+ * The unit test implementation MUST provide list of unit tests it implements
+ * with this macro:
+ *
+ *   TEST_LIST = {
+ *       { "test1_name", test1_func_ptr },
+ *       { "test2_name", test2_func_ptr },
+ *       ...
+ *       { 0 }
+ *   };
+ *
+ * The list specifies names of each test (must be unique) and pointer to
+ * a function implementing it. The function does not take any arguments
+ * and has no return values, i.e. every test function has to be compatible
+ * with this prototype:
+ *
+ *   void test_func(void);
+ */
+#define TEST_LIST               const struct test__ test_list__[]
+
+
+/* Macros for testing whether an unit test succeeds or fails. These macros
+ * can be used arbitrarily in functions implementing the unit tests.
+ *
+ * If any condition fails throughout execution of a test, the test fails.
+ *
+ * TEST_CHECK takes only one argument (the condition), TEST_CHECK_ allows
+ * also to specify an error message to print out if the condition fails.
+ * (It expects printf-like format string and its parameters). The macros
+ * return non-zero (condition passes) or 0 (condition fails).
+ *
+ * That can be useful when more conditions should be checked only if some
+ * preceding condition passes, as illustrated in this code snippet:
+ *
+ *   SomeStruct* ptr = allocate_some_struct();
+ *   if(TEST_CHECK(ptr != NULL)) {
+ *       TEST_CHECK(ptr->member1 < 100);
+ *       TEST_CHECK(ptr->member2 > 200);
+ *   }
+ */
+#define TEST_CHECK_(cond,...)   test_check__((cond), __FILE__, __LINE__, __VA_ARGS__)
+#define TEST_CHECK(cond)        test_check__((cond), __FILE__, __LINE__, "%s", #cond)
+
+
+/* These macros are the same as TEST_CHECK_ and TEST_CHECK except that if the
+ * condition fails, the currently executed unit test is immediately aborted.
+ *
+ * That is done either by calling abort() if the unit test is executed as a
+ * child process; or via longjmp() if the unit test is executed within the
+ * main Acutest process.
+ *
+ * As a side effect of such abortion, your unit tests may cause memory leaks,
+ * unflushed file descriptors, and other fenomena caused by the abortion.
+ *
+ * Therefore you should not use these as a general replacement for TEST_CHECK.
+ * Use it with some caution, especially if your test causes some other side
+ * effects to the outside world (e.g. communicating with some server, inserting
+ * into a database etc.).
+ */
+#define TEST_ASSERT_(cond,...)                                                 \
+    do {                                                                       \
+        if (!test_check__((cond), __FILE__, __LINE__, __VA_ARGS__))            \
+            test_abort__();                                                    \
+    } while(0)
+#define TEST_ASSERT(cond)                                                      \
+    do {                                                                       \
+        if (!test_check__((cond), __FILE__, __LINE__, "%s", #cond))            \
+            test_abort__();                                                    \
+    } while(0)
+
+
+#ifdef __cplusplus
+/* Macros to verify that the code (the 1st argument) throws exception of given
+ * type (the 2nd argument). (Note these macros are only available in C++.)
+ *
+ * TEST_EXCEPTION_ is like TEST_EXCEPTION but accepts custom printf-like
+ * message.
+ *
+ * For example:
+ *
+ *   TEST_EXCEPTION(function_that_throw(), ExpectedExceptionType);
+ *
+ * If the function_that_throw() throws ExpectedExceptionType, the check passes.
+ * If the function throws anything incompatible with ExpectedExceptionType
+ * (or if it does not thrown an exception at all), the check fails.
+ */
+#define TEST_EXCEPTION(code, exctype)                                          \
+    do {                                                                       \
+        bool exc_ok__ = false;                                                 \
+        const char *msg__ = NULL;                                              \
+        try {                                                                  \
+            code;                                                              \
+            msg__ = "No exception thrown.";                                    \
+        } catch(exctype const&) {                                              \
+            exc_ok__= true;                                                    \
+        } catch(...) {                                                         \
+            msg__ = "Unexpected exception thrown.";                            \
+        }                                                                      \
+        test_check__(exc_ok__, __FILE__, __LINE__, #code " throws " #exctype); \
+        if(msg__ != NULL)                                                      \
+            test_message__("%s", msg__);                                       \
+    } while(0)
+#define TEST_EXCEPTION_(code, exctype, ...)                                    \
+    do {                                                                       \
+        bool exc_ok__ = false;                                                 \
+        const char *msg__ = NULL;                                              \
+        try {                                                                  \
+            code;                                                              \
+            msg__ = "No exception thrown.";                                    \
+        } catch(exctype const&) {                                              \
+            exc_ok__= true;                                                    \
+        } catch(...) {                                                         \
+            msg__ = "Unexpected exception thrown.";                            \
+        }                                                                      \
+        test_check__(exc_ok__, __FILE__, __LINE__, __VA_ARGS__);               \
+        if(msg__ != NULL)                                                      \
+            test_message__("%s", msg__);                                       \
+    } while(0)
+#endif  /* #ifdef __cplusplus */
+
+
+/* Sometimes it is useful to split execution of more complex unit tests to some
+ * smaller parts and associate those parts with some names.
+ *
+ * This is especially handy if the given unit test is implemented as a loop
+ * over some vector of multiple testing inputs. Using these macros allow to use
+ * sort of subtitle for each iteration of the loop (e.g. outputting the input
+ * itself or a name associated to it), so that if any TEST_CHECK condition
+ * fails in the loop, it can be easily seen which iteration triggers the
+ * failure, without the need to manually output the iteration-specific data in
+ * every single TEST_CHECK inside the loop body.
+ *
+ * TEST_CASE allows to specify only single string as the name of the case,
+ * TEST_CASE_ provides all the power of printf-like string formatting.
+ *
+ * Note that the test cases cannot be nested. Starting a new test case ends
+ * implicitly the previous one. To end the test case explicitly (e.g. to end
+ * the last test case after exiting the loop), you may use TEST_CASE(NULL).
+ */
+#define TEST_CASE_(...)         test_case__(__VA_ARGS__)
+#define TEST_CASE(name)         test_case__("%s", name)
+
+
+/* printf-like macro for outputting an extra information about a failure.
+ *
+ * Intended use is to output some computed output versus the expected value,
+ * e.g. like this:
+ *
+ *   if(!TEST_CHECK(produced == expected)) {
+ *       TEST_MSG("Expected: %d", expected);
+ *       TEST_MSG("Produced: %d", produced);
+ *   }
+ *
+ * Note the message is only written down if the most recent use of any checking
+ * macro (like e.g. TEST_CHECK or TEST_EXCEPTION) in the current test failed.
+ * This means the above is equivalent to just this:
+ *
+ *   TEST_CHECK(produced == expected);
+ *   TEST_MSG("Expected: %d", expected);
+ *   TEST_MSG("Produced: %d", produced);
+ *
+ * The macro can deal with multi-line output fairly well. It also automatically
+ * adds a final new-line if there is none present.
+ */
+#define TEST_MSG(...)           test_message__(__VA_ARGS__)
+
+
+/* Maximal output per TEST_MSG call. Longer messages are cut.
+ * You may define another limit prior including "acutest.h"
+ */
+#ifndef TEST_MSG_MAXSIZE
+    #define TEST_MSG_MAXSIZE    1024
+#endif
+
+
+/* Macro for dumping a block of memory.
+ *
+ * Its intended use is very similar to what TEST_MSG is for, but instead of
+ * generating any printf-like message, this is for dumping raw block of a
+ * memory in a hexadecimal form:
+ *
+ * TEST_CHECK(size_produced == size_expected && memcmp(addr_produced, addr_expected, size_produced) == 0);
+ * TEST_DUMP("Expected:", addr_expected, size_expected);
+ * TEST_DUMP("Produced:", addr_produced, size_produced);
+ */
+#define TEST_DUMP(title, addr, size)    test_dump__(title, addr, size)
+
+/* Maximal output per TEST_DUMP call (in bytes to dump). Longer blocks are cut.
+ * You may define another limit prior including "acutest.h"
+ */
+#ifndef TEST_DUMP_MAXSIZE
+    #define TEST_DUMP_MAXSIZE   1024
+#endif
+
+
+/**********************
+ *** Implementation ***
+ **********************/
+
+/* The unit test files should not rely on anything below. */
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+
+#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__)
+    #define ACUTEST_UNIX__      1
+    #include <errno.h>
+    #include <libgen.h>
+    #include <unistd.h>
+    #include <sys/types.h>
+    #include <sys/wait.h>
+    #include <signal.h>
+    #include <time.h>
+
+    #if defined CLOCK_PROCESS_CPUTIME_ID  &&  defined CLOCK_MONOTONIC
+        #define ACUTEST_HAS_POSIX_TIMER__       1
+    #endif
+#endif
+
+#if defined(__gnu_linux__)
+    #define ACUTEST_LINUX__     1
+    #include <fcntl.h>
+    #include <sys/stat.h>
+#endif
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)
+    #define ACUTEST_WIN__       1
+    #include <windows.h>
+    #include <io.h>
+#endif
+
+#ifdef __cplusplus
+    #include <exception>
+#endif
+
+
+/* Note our global private identifiers end with '__' to mitigate risk of clash
+ * with the unit tests implementation. */
+
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+
+struct test__ {
+    const char* name;
+    void (*func)(void);
+};
+
+struct test_detail__ {
+    unsigned char flags;
+    double duration;
+};
+
+enum {
+    TEST_FLAG_RUN__ = 1 << 0,
+    TEST_FLAG_SUCCESS__ = 1 << 1,
+    TEST_FLAG_FAILURE__ = 1 << 2,
+};
+
+extern const struct test__ test_list__[];
+
+int test_check__(int cond, const char* file, int line, const char* fmt, ...);
+void test_case__(const char* fmt, ...);
+void test_message__(const char* fmt, ...);
+void test_dump__(const char* title, const void* addr, size_t size);
+void test_abort__(void);
+
+
+#ifndef TEST_NO_MAIN
+
+static char* test_argv0__ = NULL;
+static size_t test_list_size__ = 0;
+static struct test_detail__ *test_details__ = NULL;
+static size_t test_count__ = 0;
+static int test_no_exec__ = -1;
+static int test_no_summary__ = 0;
+static int test_tap__ = 0;
+static int test_skip_mode__ = 0;
+static int test_worker__ = 0;
+static int test_worker_index__ = 0;
+static int test_cond_failed__ = 0;
+static FILE *test_xml_output__ = NULL;
+
+static int test_stat_failed_units__ = 0;
+static int test_stat_run_units__ = 0;
+
+static const struct test__* test_current_unit__ = NULL;
+static int test_current_index__ = 0;
+static char test_case_name__[64] = "";
+static int test_current_already_logged__ = 0;
+static int test_case_current_already_logged__ = 0;
+static int test_verbose_level__ = 2;
+static int test_current_failures__ = 0;
+static int test_colorize__ = 0;
+static int test_timer__ = 0;
+
+static int test_abort_has_jmp_buf__ = 0;
+static jmp_buf test_abort_jmp_buf__;
+
+#if defined ACUTEST_WIN__
+    typedef LARGE_INTEGER test_timer_type__;
+    static LARGE_INTEGER test_timer_freq__;
+    static test_timer_type__ test_timer_start__;
+    static test_timer_type__ test_timer_end__;
+
+    static void
+    test_timer_init__(void)
+    {
+        QueryPerformanceFrequency(&test_timer_freq__);
+    }
+
+    static void
+    test_timer_get_time__(LARGE_INTEGER* ts)
+    {
+        QueryPerformanceCounter(ts);
+    }
+
+    static double
+    test_timer_diff__(LARGE_INTEGER start, LARGE_INTEGER end)
+    {
+        double duration = (double)(end.QuadPart - start.QuadPart);
+        duration /= (double)test_timer_freq__.QuadPart;
+        return duration;
+    }
+
+    static void
+    test_timer_print_diff__(void)
+    {
+        printf("%.6lf secs", test_timer_diff__(test_timer_start__, test_timer_end__));
+    }
+#elif defined ACUTEST_HAS_POSIX_TIMER__
+    static clockid_t test_timer_id__;
+    typedef struct timespec test_timer_type__;
+    static test_timer_type__ test_timer_start__;
+    static test_timer_type__ test_timer_end__;
+
+    static void
+    test_timer_init__(void)
+    {
+        if(test_timer__ == 1)
+            test_timer_id__ = CLOCK_MONOTONIC;
+        else if(test_timer__ == 2)
+            test_timer_id__ = CLOCK_PROCESS_CPUTIME_ID;
+    }
+
+    static void
+    test_timer_get_time__(struct timespec* ts)
+    {
+        clock_gettime(test_timer_id__, ts);
+    }
+
+    static double
+    test_timer_diff__(struct timespec start, struct timespec end)
+    {
+        double endns;
+        double startns;
+
+        endns = end.tv_sec;
+        endns *= 1e9;
+        endns += end.tv_nsec;
+
+        startns = start.tv_sec;
+        startns *= 1e9;
+        startns += start.tv_nsec;
+
+        return ((endns - startns)/ 1e9);
+    }
+
+    static void
+    test_timer_print_diff__(void)
+    {
+        printf("%.6lf secs",
+            test_timer_diff__(test_timer_start__, test_timer_end__));
+    }
+#else
+    typedef int test_timer_type__;
+    static test_timer_type__ test_timer_start__;
+    static test_timer_type__ test_timer_end__;
+
+    void
+    test_timer_init__(void)
+    {}
+
+    static void
+    test_timer_get_time__(int* ts)
+    {
+        (void) ts;
+    }
+
+    static double
+    test_timer_diff__(int start, int end)
+    {
+        (void) start;
+        (void) end;
+        return 0.0;
+    }
+
+    static void
+    test_timer_print_diff__(void)
+    {}
+#endif
+
+#define TEST_COLOR_DEFAULT__            0
+#define TEST_COLOR_GREEN__              1
+#define TEST_COLOR_RED__                2
+#define TEST_COLOR_DEFAULT_INTENSIVE__  3
+#define TEST_COLOR_GREEN_INTENSIVE__    4
+#define TEST_COLOR_RED_INTENSIVE__      5
+
+static int
+test_print_in_color__(int color, const char* fmt, ...)
+{
+    va_list args;
+    char buffer[256];
+    int n;
+
+    va_start(args, fmt);
+    vsnprintf(buffer, sizeof(buffer), fmt, args);
+    va_end(args);
+    buffer[sizeof(buffer)-1] = '\0';
+
+    if(!test_colorize__) {
+        return printf("%s", buffer);
+    }
+
+#if defined ACUTEST_UNIX__
+    {
+        const char* col_str;
+        switch(color) {
+            case TEST_COLOR_GREEN__:             col_str = "\033[0;32m"; break;
+            case TEST_COLOR_RED__:               col_str = "\033[0;31m"; break;
+            case TEST_COLOR_GREEN_INTENSIVE__:   col_str = "\033[1;32m"; break;
+            case TEST_COLOR_RED_INTENSIVE__:     col_str = "\033[1;31m"; break;
+            case TEST_COLOR_DEFAULT_INTENSIVE__: col_str = "\033[1m"; break;
+            default:                             col_str = "\033[0m"; break;
+        }
+        printf("%s", col_str);
+        n = printf("%s", buffer);
+        printf("\033[0m");
+        return n;
+    }
+#elif defined ACUTEST_WIN__
+    {
+        HANDLE h;
+        CONSOLE_SCREEN_BUFFER_INFO info;
+        WORD attr;
+
+        h = GetStdHandle(STD_OUTPUT_HANDLE);
+        GetConsoleScreenBufferInfo(h, &info);
+
+        switch(color) {
+            case TEST_COLOR_GREEN__:             attr = FOREGROUND_GREEN; break;
+            case TEST_COLOR_RED__:               attr = FOREGROUND_RED; break;
+            case TEST_COLOR_GREEN_INTENSIVE__:   attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
+            case TEST_COLOR_RED_INTENSIVE__:     attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+            case TEST_COLOR_DEFAULT_INTENSIVE__: attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+            default:                             attr = 0; break;
+        }
+        if(attr != 0)
+            SetConsoleTextAttribute(h, attr);
+        n = printf("%s", buffer);
+        SetConsoleTextAttribute(h, info.wAttributes);
+        return n;
+    }
+#else
+    n = printf("%s", buffer);
+    return n;
+#endif
+}
+
+static void
+test_begin_test_line__(const struct test__* test)
+{
+    if(!test_tap__) {
+        if(test_verbose_level__ >= 3) {
+            test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n", test->name);
+            test_current_already_logged__++;
+        } else if(test_verbose_level__ >= 1) {
+            int n;
+            char spaces[48];
+
+            n = test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s... ", test->name);
+            memset(spaces, ' ', sizeof(spaces));
+            if(n < (int) sizeof(spaces))
+                printf("%.*s", (int) sizeof(spaces) - n, spaces);
+        } else {
+            test_current_already_logged__ = 1;
+        }
+    }
+}
+
+static void
+test_finish_test_line__(int result)
+{
+    if(test_tap__) {
+        const char* str = (result == 0) ? "ok" : "not ok";
+
+        printf("%s %u - %s\n", str, test_current_index__ + 1, test_current_unit__->name);
+
+        if(result == 0  &&  test_timer__) {
+            printf("# Duration: ");
+            test_timer_print_diff__();
+            printf("\n");
+        }
+    } else {
+        int color = (result == 0) ? TEST_COLOR_GREEN_INTENSIVE__ : TEST_COLOR_RED_INTENSIVE__;
+        const char* str = (result == 0) ? "OK" : "FAILED";
+        printf("[ ");
+        test_print_in_color__(color, str);
+        printf(" ]");
+
+        if(result == 0  &&  test_timer__) {
+            printf("  ");
+            test_timer_print_diff__();
+        }
+
+        printf("\n");
+    }
+}
+
+static void
+test_line_indent__(int level)
+{
+    static const char spaces[] = "                ";
+    int n = level * 2;
+
+    if(test_tap__  &&  n > 0) {
+        n--;
+        printf("#");
+    }
+
+    while(n > 16) {
+        printf("%s", spaces);
+        n -= 16;
+    }
+    printf("%.*s", n, spaces);
+}
+
+int
+test_check__(int cond, const char* file, int line, const char* fmt, ...)
+{
+    const char *result_str;
+    int result_color;
+    int verbose_level;
+
+    if(cond) {
+        result_str = "ok";
+        result_color = TEST_COLOR_GREEN__;
+        verbose_level = 3;
+    } else {
+        if(!test_current_already_logged__  &&  test_current_unit__ != NULL)
+            test_finish_test_line__(-1);
+
+        result_str = "failed";
+        result_color = TEST_COLOR_RED__;
+        verbose_level = 2;
+        test_current_failures__++;
+        test_current_already_logged__++;
+    }
+
+    if(test_verbose_level__ >= verbose_level) {
+        va_list args;
+
+        if(!test_case_current_already_logged__  &&  test_case_name__[0]) {
+            test_line_indent__(1);
+            test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Case %s:\n", test_case_name__);
+            test_current_already_logged__++;
+            test_case_current_already_logged__++;
+        }
+
+        test_line_indent__(test_case_name__[0] ? 2 : 1);
+        if(file != NULL) {
+            if(test_verbose_level__ < 3) {
+#ifdef ACUTEST_WIN__
+                const char* lastsep1 = strrchr(file, '\\');
+                const char* lastsep2 = strrchr(file, '/');
+                if(lastsep1 == NULL)
+                    lastsep1 = file-1;
+                if(lastsep2 == NULL)
+                    lastsep2 = file-1;
+                file = (lastsep1 > lastsep2 ? lastsep1 : lastsep2) + 1;
+#else
+                const char* lastsep = strrchr(file, '/');
+                if(lastsep != NULL)
+                    file = lastsep+1;
+#endif
+            }
+            printf("%s:%d: Check ", file, line);
+        }
+
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+
+        printf("... ");
+        test_print_in_color__(result_color, result_str);
+        printf("\n");
+        test_current_already_logged__++;
+    }
+
+    test_cond_failed__ = (cond == 0);
+    return !test_cond_failed__;
+}
+
+void
+test_case__(const char* fmt, ...)
+{
+    va_list args;
+
+    if(test_verbose_level__ < 2)
+        return;
+
+    if(test_case_name__[0]) {
+        test_case_current_already_logged__ = 0;
+        test_case_name__[0] = '\0';
+    }
+
+    if(fmt == NULL)
+        return;
+
+    va_start(args, fmt);
+    vsnprintf(test_case_name__, sizeof(test_case_name__) - 1, fmt, args);
+    va_end(args);
+    test_case_name__[sizeof(test_case_name__) - 1] = '\0';
+
+    if(test_verbose_level__ >= 3) {
+        test_line_indent__(1);
+        test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Case %s:\n", test_case_name__);
+        test_current_already_logged__++;
+        test_case_current_already_logged__++;
+    }
+}
+
+void
+test_message__(const char* fmt, ...)
+{
+    char buffer[TEST_MSG_MAXSIZE];
+    char* line_beg;
+    char* line_end;
+    va_list args;
+
+    if(test_verbose_level__ < 2)
+        return;
+
+    /* We allow extra message only when something is already wrong in the
+     * current test. */
+    if(test_current_unit__ == NULL  ||  !test_cond_failed__)
+        return;
+
+    va_start(args, fmt);
+    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
+    va_end(args);
+    buffer[TEST_MSG_MAXSIZE-1] = '\0';
+
+    line_beg = buffer;
+    while(1) {
+        line_end = strchr(line_beg, '\n');
+        if(line_end == NULL)
+            break;
+        test_line_indent__(test_case_name__[0] ? 3 : 2);
+        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
+        line_beg = line_end + 1;
+    }
+    if(line_beg[0] != '\0') {
+        test_line_indent__(test_case_name__[0] ? 3 : 2);
+        printf("%s\n", line_beg);
+    }
+}
+
+void
+test_dump__(const char* title, const void* addr, size_t size)
+{
+    static const size_t BYTES_PER_LINE = 16;
+    size_t line_beg;
+    size_t truncate = 0;
+
+    if(test_verbose_level__ < 2)
+        return;
+
+    /* We allow extra message only when something is already wrong in the
+     * current test. */
+    if(test_current_unit__ == NULL  ||  !test_cond_failed__)
+        return;
+
+    if(size > TEST_DUMP_MAXSIZE) {
+        truncate = size - TEST_DUMP_MAXSIZE;
+        size = TEST_DUMP_MAXSIZE;
+    }
+
+    test_line_indent__(test_case_name__[0] ? 3 : 2);
+    printf((title[strlen(title)-1] == ':') ? "%s\n" : "%s:\n", title);
+
+    for(line_beg = 0; line_beg < size; line_beg += BYTES_PER_LINE) {
+        size_t line_end = line_beg + BYTES_PER_LINE;
+        size_t off;
+
+        test_line_indent__(test_case_name__[0] ? 4 : 3);
+        printf("%08lx: ", (unsigned long)line_beg);
+        for(off = line_beg; off < line_end; off++) {
+            if(off < size)
+                printf(" %02x", ((unsigned char*)addr)[off]);
+            else
+                printf("   ");
+        }
+
+        printf("  ");
+        for(off = line_beg; off < line_end; off++) {
+            unsigned char byte = ((unsigned char*)addr)[off];
+            if(off < size)
+                printf("%c", (iscntrl(byte) ? '.' : byte));
+            else
+                break;
+        }
+
+        printf("\n");
+    }
+
+    if(truncate > 0) {
+        test_line_indent__(test_case_name__[0] ? 4 : 3);
+        printf("           ... (and more %u bytes)\n", (unsigned) truncate);
+    }
+}
+
+void
+test_abort__(void)
+{
+    if(test_abort_has_jmp_buf__)
+        longjmp(test_abort_jmp_buf__, 1);
+    else
+        abort();
+}
+
+static void
+test_list_names__(void)
+{
+    const struct test__* test;
+
+    printf("Unit tests:\n");
+    for(test = &test_list__[0]; test->func != NULL; test++)
+        printf("  %s\n", test->name);
+}
+
+static void
+test_remember__(int i)
+{
+    if(test_details__[i].flags & TEST_FLAG_RUN__)
+        return;
+
+    test_details__[i].flags |= TEST_FLAG_RUN__;
+    test_count__++;
+}
+
+static void
+test_set_success__(int i, int success)
+{
+    test_details__[i].flags |= success ? TEST_FLAG_SUCCESS__ : TEST_FLAG_FAILURE__;
+}
+
+static void
+test_set_duration__(int i, double duration)
+{
+    test_details__[i].duration = duration;
+}
+
+static int
+test_name_contains_word__(const char* name, const char* pattern)
+{
+    static const char word_delim[] = " \t-_.";
+    const char* substr;
+    size_t pattern_len;
+    int starts_on_word_boundary;
+    int ends_on_word_boundary;
+
+    pattern_len = strlen(pattern);
+
+    substr = strstr(name, pattern);
+    while(substr != NULL) {
+        starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
+        ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL);
+
+        if(starts_on_word_boundary && ends_on_word_boundary)
+            return 1;
+
+        substr = strstr(substr+1, pattern);
+    }
+
+    return 0;
+}
+
+static int
+test_lookup__(const char* pattern)
+{
+    int i;
+    int n = 0;
+
+    /* Try exact match. */
+    for(i = 0; i < (int) test_list_size__; i++) {
+        if(strcmp(test_list__[i].name, pattern) == 0) {
+            test_remember__(i);
+            n++;
+            break;
+        }
+    }
+    if(n > 0)
+        return n;
+
+    /* Try word match. */
+    for(i = 0; i < (int) test_list_size__; i++) {
+        if(test_name_contains_word__(test_list__[i].name, pattern)) {
+            test_remember__(i);
+            n++;
+        }
+    }
+    if(n > 0)
+        return n;
+
+    /* Try relaxed match. */
+    for(i = 0; i < (int) test_list_size__; i++) {
+        if(strstr(test_list__[i].name, pattern) != NULL) {
+            test_remember__(i);
+            n++;
+        }
+    }
+
+    return n;
+}
+
+
+/* Called if anything goes bad in Acutest, or if the unit test ends in other
+ * way then by normal returning from its function (e.g. exception or some
+ * abnormal child process termination). */
+static void
+test_error__(const char* fmt, ...)
+{
+    va_list args;
+
+    if(test_verbose_level__ == 0)
+        return;
+
+    if(test_verbose_level__ <= 2  &&  !test_current_already_logged__  &&  test_current_unit__ != NULL) {
+        if(test_tap__) {
+            test_finish_test_line__(-1);
+        } else {
+            printf("[ ");
+            test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED");
+            printf(" ]\n");
+        }
+    }
+
+    if(test_verbose_level__ >= 2) {
+        test_line_indent__(1);
+        if(test_verbose_level__ >= 3)
+            test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "ERROR: ");
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+        printf("\n");
+    }
+
+    if(test_verbose_level__ >= 3) {
+        printf("\n");
+    }
+}
+
+/* Call directly the given test unit function. */
+static int
+test_do_run__(const struct test__* test, int index)
+{
+    test_current_unit__ = test;
+    test_current_index__ = index;
+    test_current_failures__ = 0;
+    test_current_already_logged__ = 0;
+    test_cond_failed__ = 0;
+
+    test_begin_test_line__(test);
+
+#ifdef __cplusplus
+    try {
+#endif
+
+        /* This is good to do for case the test unit e.g. crashes. */
+        fflush(stdout);
+        fflush(stderr);
+
+        if(!test_worker__) {
+            test_abort_has_jmp_buf__ = 1;
+            if(setjmp(test_abort_jmp_buf__) != 0)
+                goto aborted;
+        }
+
+        test_timer_get_time__(&test_timer_start__);
+        test->func();
+aborted:
+        test_abort_has_jmp_buf__ = 0;
+        test_timer_get_time__(&test_timer_end__);
+
+        if(test_verbose_level__ >= 3) {
+            test_line_indent__(1);
+            if(test_current_failures__ == 0) {
+                test_print_in_color__(TEST_COLOR_GREEN_INTENSIVE__, "SUCCESS: ");
+                printf("All conditions have passed.\n");
+
+                if(test_timer__) {
+                    test_line_indent__(1);
+                    printf("Duration: ");
+                    test_timer_print_diff__();
+                    printf("\n");
+                }
+            } else {
+                test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED: ");
+                printf("%d condition%s %s failed.\n",
+                        test_current_failures__,
+                        (test_current_failures__ == 1) ? "" : "s",
+                        (test_current_failures__ == 1) ? "has" : "have");
+            }
+            printf("\n");
+        } else if(test_verbose_level__ >= 1 && test_current_failures__ == 0) {
+            test_finish_test_line__(0);
+        }
+
+        test_case__(NULL);
+        test_current_unit__ = NULL;
+        return (test_current_failures__ == 0) ? 0 : -1;
+
+#ifdef __cplusplus
+    } catch(std::exception& e) {
+        const char* what = e.what();
+        test_check__(0, NULL, 0, "Threw std::exception");
+        if(what != NULL)
+            test_message__("std::exception::what(): %s", what);
+        return -1;
+    } catch(...) {
+        test_check__(0, NULL, 0, "Threw an exception");
+        return -1;
+    }
+#endif
+}
+
+/* Trigger the unit test. If possible (and not suppressed) it starts a child
+ * process who calls test_do_run__(), otherwise it calls test_do_run__()
+ * directly. */
+static void
+test_run__(const struct test__* test, int index, int master_index)
+{
+    int failed = 1;
+    test_timer_type__ start, end;
+
+    test_current_unit__ = test;
+    test_current_already_logged__ = 0;
+    test_timer_get_time__(&start);
+
+    if(!test_no_exec__) {
+
+#if defined(ACUTEST_UNIX__)
+
+        pid_t pid;
+        int exit_code;
+
+        /* Make sure the child starts with empty I/O buffers. */
+        fflush(stdout);
+        fflush(stderr);
+
+        pid = fork();
+        if(pid == (pid_t)-1) {
+            test_error__("Cannot fork. %s [%d]", strerror(errno), errno);
+            failed = 1;
+        } else if(pid == 0) {
+            /* Child: Do the test. */
+            test_worker__ = 1;
+            failed = (test_do_run__(test, index) != 0);
+            exit(failed ? 1 : 0);
+        } else {
+            /* Parent: Wait until child terminates and analyze its exit code. */
+            waitpid(pid, &exit_code, 0);
+            if(WIFEXITED(exit_code)) {
+                switch(WEXITSTATUS(exit_code)) {
+                    case 0:   failed = 0; break;   /* test has passed. */
+                    case 1:   /* noop */ break;    /* "normal" failure. */
+                    default:  test_error__("Unexpected exit code [%d]", WEXITSTATUS(exit_code));
+                }
+            } else if(WIFSIGNALED(exit_code)) {
+                char tmp[32];
+                const char* signame;
+                switch(WTERMSIG(exit_code)) {
+                    case SIGINT:  signame = "SIGINT"; break;
+                    case SIGHUP:  signame = "SIGHUP"; break;
+                    case SIGQUIT: signame = "SIGQUIT"; break;
+                    case SIGABRT: signame = "SIGABRT"; break;
+                    case SIGKILL: signame = "SIGKILL"; break;
+                    case SIGSEGV: signame = "SIGSEGV"; break;
+                    case SIGILL:  signame = "SIGILL"; break;
+                    case SIGTERM: signame = "SIGTERM"; break;
+                    default:      sprintf(tmp, "signal %d", WTERMSIG(exit_code)); signame = tmp; break;
+                }
+                test_error__("Test interrupted by %s", signame);
+            } else {
+                test_error__("Test ended in an unexpected way [%d]", exit_code);
+            }
+        }
+
+#elif defined(ACUTEST_WIN__)
+
+        char buffer[512] = {0};
+        STARTUPINFOA startupInfo;
+        PROCESS_INFORMATION processInfo;
+        DWORD exitCode;
+
+        /* Windows has no fork(). So we propagate all info into the child
+         * through a command line arguments. */
+        _snprintf(buffer, sizeof(buffer)-1,
+                 "%s --worker=%d %s --no-exec --no-summary %s --verbose=%d --color=%s -- \"%s\"",
+                 test_argv0__, index, test_timer__ ? "--timer" : "",
+                 test_tap__ ? "--tap" : "", test_verbose_level__,
+                 test_colorize__ ? "always" : "never",
+                 test->name);
+        memset(&startupInfo, 0, sizeof(startupInfo));
+        startupInfo.cb = sizeof(STARTUPINFO);
+        if(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo)) {
+            WaitForSingleObject(processInfo.hProcess, INFINITE);
+            GetExitCodeProcess(processInfo.hProcess, &exitCode);
+            CloseHandle(processInfo.hThread);
+            CloseHandle(processInfo.hProcess);
+            failed = (exitCode != 0);
+        } else {
+            test_error__("Cannot create unit test subprocess [%ld].", GetLastError());
+            failed = 1;
+        }
+
+#else
+
+        /* A platform where we don't know how to run child process. */
+        failed = (test_do_run__(test, index) != 0);
+
+#endif
+
+    } else {
+        /* Child processes suppressed through --no-exec. */
+        failed = (test_do_run__(test, index) != 0);
+    }
+    test_timer_get_time__(&end);
+
+    test_current_unit__ = NULL;
+
+    test_stat_run_units__++;
+    if(failed)
+        test_stat_failed_units__++;
+
+    test_set_success__(master_index, !failed);
+    test_set_duration__(master_index, test_timer_diff__(start, end));
+}
+
+#if defined(ACUTEST_WIN__)
+/* Callback for SEH events. */
+static LONG CALLBACK
+test_seh_exception_filter__(EXCEPTION_POINTERS *ptrs)
+{
+    test_check__(0, NULL, 0, "Unhandled SEH exception");
+    test_message__("Exception code:    0x%08lx", ptrs->ExceptionRecord->ExceptionCode);
+    test_message__("Exception address: 0x%p", ptrs->ExceptionRecord->ExceptionAddress);
+
+    fflush(stdout);
+    fflush(stderr);
+
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+#endif
+
+
+#define TEST_CMDLINE_OPTFLAG_OPTIONALARG__      0x0001
+#define TEST_CMDLINE_OPTFLAG_REQUIREDARG__      0x0002
+
+#define TEST_CMDLINE_OPTID_NONE__               0
+#define TEST_CMDLINE_OPTID_UNKNOWN__            (-0x7fffffff + 0)
+#define TEST_CMDLINE_OPTID_MISSINGARG__         (-0x7fffffff + 1)
+#define TEST_CMDLINE_OPTID_BOGUSARG__           (-0x7fffffff + 2)
+
+typedef struct TEST_CMDLINE_OPTION__ {
+    char shortname;
+    const char* longname;
+    int id;
+    unsigned flags;
+} TEST_CMDLINE_OPTION__;
+
+static int
+test_cmdline_handle_short_opt_group__(const TEST_CMDLINE_OPTION__* options,
+                    const char* arggroup,
+                    int (*callback)(int /*optval*/, const char* /*arg*/))
+{
+    const TEST_CMDLINE_OPTION__* opt;
+    int i;
+    int ret = 0;
+
+    for(i = 0; arggroup[i] != '\0'; i++) {
+        for(opt = options; opt->id != 0; opt++) {
+            if(arggroup[i] == opt->shortname)
+                break;
+        }
+
+        if(opt->id != 0  &&  !(opt->flags & TEST_CMDLINE_OPTFLAG_REQUIREDARG__)) {
+            ret = callback(opt->id, NULL);
+        } else {
+            /* Unknown option. */
+            char badoptname[3];
+            badoptname[0] = '-';
+            badoptname[1] = arggroup[i];
+            badoptname[2] = '\0';
+            ret = callback((opt->id != 0 ? TEST_CMDLINE_OPTID_MISSINGARG__ : TEST_CMDLINE_OPTID_UNKNOWN__),
+                            badoptname);
+        }
+
+        if(ret != 0)
+            break;
+    }
+
+    return ret;
+}
+
+#define TEST_CMDLINE_AUXBUF_SIZE__  32
+
+static int
+test_cmdline_read__(const TEST_CMDLINE_OPTION__* options, int argc, char** argv,
+                    int (*callback)(int /*optval*/, const char* /*arg*/))
+{
+
+    const TEST_CMDLINE_OPTION__* opt;
+    char auxbuf[TEST_CMDLINE_AUXBUF_SIZE__+1];
+    int after_doubledash = 0;
+    int i = 1;
+    int ret = 0;
+
+    auxbuf[TEST_CMDLINE_AUXBUF_SIZE__] = '\0';
+
+    while(i < argc) {
+        if(after_doubledash  ||  strcmp(argv[i], "-") == 0) {
+            /* Non-option argument. */
+            ret = callback(TEST_CMDLINE_OPTID_NONE__, argv[i]);
+        } else if(strcmp(argv[i], "--") == 0) {
+            /* End of options. All the remaining members are non-option arguments. */
+            after_doubledash = 1;
+        } else if(argv[i][0] != '-') {
+            /* Non-option argument. */
+            ret = callback(TEST_CMDLINE_OPTID_NONE__, argv[i]);
+        } else {
+            for(opt = options; opt->id != 0; opt++) {
+                if(opt->longname != NULL  &&  strncmp(argv[i], "--", 2) == 0) {
+                    size_t len = strlen(opt->longname);
+                    if(strncmp(argv[i]+2, opt->longname, len) == 0) {
+                        /* Regular long option. */
+                        if(argv[i][2+len] == '\0') {
+                            /* with no argument provided. */
+                            if(!(opt->flags & TEST_CMDLINE_OPTFLAG_REQUIREDARG__))
+                                ret = callback(opt->id, NULL);
+                            else
+                                ret = callback(TEST_CMDLINE_OPTID_MISSINGARG__, argv[i]);
+                            break;
+                        } else if(argv[i][2+len] == '=') {
+                            /* with an argument provided. */
+                            if(opt->flags & (TEST_CMDLINE_OPTFLAG_OPTIONALARG__ | TEST_CMDLINE_OPTFLAG_REQUIREDARG__)) {
+                                ret = callback(opt->id, argv[i]+2+len+1);
+                            } else {
+                                sprintf(auxbuf, "--%s", opt->longname);
+                                ret = callback(TEST_CMDLINE_OPTID_BOGUSARG__, auxbuf);
+                            }
+                            break;
+                        } else {
+                            continue;
+                        }
+                    }
+                } else if(opt->shortname != '\0'  &&  argv[i][0] == '-') {
+                    if(argv[i][1] == opt->shortname) {
+                        /* Regular short option. */
+                        if(opt->flags & TEST_CMDLINE_OPTFLAG_REQUIREDARG__) {
+                            if(argv[i][2] != '\0')
+                                ret = callback(opt->id, argv[i]+2);
+                            else if(i+1 < argc)
+                                ret = callback(opt->id, argv[++i]);
+                            else
+                                ret = callback(TEST_CMDLINE_OPTID_MISSINGARG__, argv[i]);
+                            break;
+                        } else {
+                            ret = callback(opt->id, NULL);
+
+                            /* There might be more (argument-less) short options
+                             * grouped together. */
+                            if(ret == 0  &&  argv[i][2] != '\0')
+                                ret = test_cmdline_handle_short_opt_group__(options, argv[i]+2, callback);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if(opt->id == 0) {  /* still not handled? */
+                if(argv[i][0] != '-') {
+                    /* Non-option argument. */
+                    ret = callback(TEST_CMDLINE_OPTID_NONE__, argv[i]);
+                } else {
+                    /* Unknown option. */
+                    char* badoptname = argv[i];
+
+                    if(strncmp(badoptname, "--", 2) == 0) {
+                        /* Strip any argument from the long option. */
+                        char* assignment = strchr(badoptname, '=');
+                        if(assignment != NULL) {
+                            size_t len = assignment - badoptname;
+                            if(len > TEST_CMDLINE_AUXBUF_SIZE__)
+                                len = TEST_CMDLINE_AUXBUF_SIZE__;
+                            strncpy(auxbuf, badoptname, len);
+                            auxbuf[len] = '\0';
+                            badoptname = auxbuf;
+                        }
+                    }
+
+                    ret = callback(TEST_CMDLINE_OPTID_UNKNOWN__, badoptname);
+                }
+            }
+        }
+
+        if(ret != 0)
+            return ret;
+        i++;
+    }
+
+    return ret;
+}
+
+static void
+test_help__(void)
+{
+    printf("Usage: %s [options] [test...]\n", test_argv0__);
+    printf("\n");
+    printf("Run the specified unit tests; or if the option '--skip' is used, run all\n");
+    printf("tests in the suite but those listed.  By default, if no tests are specified\n");
+    printf("on the command line, all unit tests in the suite are run.\n");
+    printf("\n");
+    printf("Options:\n");
+    printf("  -s, --skip            Execute all unit tests but the listed ones\n");
+    printf("      --exec[=WHEN]     If supported, execute unit tests as child processes\n");
+    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
+#if defined ACUTEST_WIN__
+    printf("  -t, --timer           Measure test duration\n");
+#elif defined ACUTEST_HAS_POSIX_TIMER__
+    printf("  -t, --timer           Measure test duration (real time)\n");
+    printf("      --timer=TIMER     Measure test duration, using given timer\n");
+    printf("                          (TIMER is one of 'real', 'cpu')\n");
+#endif
+    printf("  -E, --no-exec         Same as --exec=never\n");
+    printf("      --no-summary      Suppress printing of test results summary\n");
+    printf("      --tap             Produce TAP-compliant output\n");
+    printf("                          (See https://testanything.org/)\n");
+    printf("  -x, --xml-output=FILE Enable XUnit output to the given file\n");
+    printf("  -l, --list            List unit tests in the suite and exit\n");
+    printf("  -v, --verbose         Make output more verbose\n");
+    printf("      --verbose=LEVEL   Set verbose level to LEVEL:\n");
+    printf("                          0 ... Be silent\n");
+    printf("                          1 ... Output one line per test (and summary)\n");
+    printf("                          2 ... As 1 and failed conditions (this is default)\n");
+    printf("                          3 ... As 1 and all conditions (and extended summary)\n");
+    printf("      --color[=WHEN]    Enable colorized output\n");
+    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
+    printf("      --no-color        Same as --color=never\n");
+    printf("  -h, --help            Display this help and exit\n");
+
+    if(test_list_size__ < 16) {
+        printf("\n");
+        test_list_names__();
+    }
+}
+
+static const TEST_CMDLINE_OPTION__ test_cmdline_options__[] = {
+    { 's',  "skip",         's', 0 },
+    {  0,   "exec",         'e', TEST_CMDLINE_OPTFLAG_OPTIONALARG__ },
+    { 'E',  "no-exec",      'E', 0 },
+#if defined ACUTEST_WIN__
+    { 't',  "timer",        't', 0 },
+#elif defined ACUTEST_HAS_POSIX_TIMER__
+    { 't',  "timer",        't', TEST_CMDLINE_OPTFLAG_OPTIONALARG__ },
+#endif
+    {  0,   "no-summary",   'S', 0 },
+    {  0,   "tap",          'T', 0 },
+    { 'l',  "list",         'l', 0 },
+    { 'v',  "verbose",      'v', TEST_CMDLINE_OPTFLAG_OPTIONALARG__ },
+    {  0,   "color",        'c', TEST_CMDLINE_OPTFLAG_OPTIONALARG__ },
+    {  0,   "no-color",     'C', 0 },
+    { 'h',  "help",         'h', 0 },
+    {  0,   "worker",       'w', TEST_CMDLINE_OPTFLAG_REQUIREDARG__ },  /* internal */
+    { 'x',  "xml-output",   'x', TEST_CMDLINE_OPTFLAG_REQUIREDARG__ },
+    {  0,   NULL,            0,  0 }
+};
+
+static int
+test_cmdline_callback__(int id, const char* arg)
+{
+    switch(id) {
+        case 's':
+            test_skip_mode__ = 1;
+            break;
+
+        case 'e':
+            if(arg == NULL || strcmp(arg, "always") == 0) {
+                test_no_exec__ = 0;
+            } else if(strcmp(arg, "never") == 0) {
+                test_no_exec__ = 1;
+            } else if(strcmp(arg, "auto") == 0) {
+                /*noop*/
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --exec.\n", test_argv0__, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+                exit(2);
+            }
+            break;
+
+        case 'E':
+            test_no_exec__ = 1;
+            break;
+
+        case 't':
+#if defined ACUTEST_WIN__  ||  defined ACUTEST_HAS_POSIX_TIMER__
+            if(arg == NULL || strcmp(arg, "real") == 0) {
+                test_timer__ = 1;
+    #ifndef ACUTEST_WIN__
+            } else if(strcmp(arg, "cpu") == 0) {
+                test_timer__ = 2;
+    #endif
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --timer.\n", test_argv0__, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+                exit(2);
+            }
+#endif
+            break;
+
+        case 'S':
+            test_no_summary__ = 1;
+            break;
+
+        case 'T':
+            test_tap__ = 1;
+            break;
+
+        case 'l':
+            test_list_names__();
+            exit(0);
+
+        case 'v':
+            test_verbose_level__ = (arg != NULL ? atoi(arg) : test_verbose_level__+1);
+            break;
+
+        case 'c':
+            if(arg == NULL || strcmp(arg, "always") == 0) {
+                test_colorize__ = 1;
+            } else if(strcmp(arg, "never") == 0) {
+                test_colorize__ = 0;
+            } else if(strcmp(arg, "auto") == 0) {
+                /*noop*/
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --color.\n", test_argv0__, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+                exit(2);
+            }
+            break;
+
+        case 'C':
+            test_colorize__ = 0;
+            break;
+
+        case 'h':
+            test_help__();
+            exit(0);
+
+        case 'w':
+            test_worker__ = 1;
+            test_worker_index__ = atoi(arg);
+            break;
+        case 'x':
+            test_xml_output__ = fopen(arg, "w");
+            if (!test_xml_output__) {
+                fprintf(stderr, "Unable to open '%s': %s\n", arg, strerror(errno));
+                exit(2);
+            }
+            break;
+
+        case 0:
+            if(test_lookup__(arg) == 0) {
+                fprintf(stderr, "%s: Unrecognized unit test '%s'\n", test_argv0__, arg);
+                fprintf(stderr, "Try '%s --list' for list of unit tests.\n", test_argv0__);
+                exit(2);
+            }
+            break;
+
+        case TEST_CMDLINE_OPTID_UNKNOWN__:
+            fprintf(stderr, "Unrecognized command line option '%s'.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+            exit(2);
+
+        case TEST_CMDLINE_OPTID_MISSINGARG__:
+            fprintf(stderr, "The command line option '%s' requires an argument.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+            exit(2);
+
+        case TEST_CMDLINE_OPTID_BOGUSARG__:
+            fprintf(stderr, "The command line option '%s' does not expect an argument.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", test_argv0__);
+            exit(2);
+    }
+
+    return 0;
+}
+
+
+#ifdef ACUTEST_LINUX__
+static int
+test_is_tracer_present__(void)
+{
+    char buf[256+32+1];
+    int tracer_present = 0;
+    int fd;
+    ssize_t n_read;
+
+    fd = open("/proc/self/status", O_RDONLY);
+    if(fd == -1)
+        return 0;
+
+    n_read = read(fd, buf, sizeof(buf)-1);
+    while(n_read > 0) {
+        static const char pattern[] = "TracerPid:";
+        const char* field;
+
+        buf[n_read] = '\0';
+        field = strstr(buf, pattern);
+        if(field != NULL  &&  field < buf + sizeof(buf) - 32) {
+            pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
+            tracer_present = (tracer_pid != 0);
+            break;
+        }
+
+        if(n_read == sizeof(buf)-1) {
+            memmove(buf, buf + sizeof(buf)-1 - 32, 32);
+            n_read = read(fd, buf+32, sizeof(buf)-1-32);
+            if(n_read > 0)
+                n_read += 32;
+        }
+    }
+
+    close(fd);
+    return tracer_present;
+}
+#endif
+
+int
+main(int argc, char** argv)
+{
+    int i;
+    test_argv0__ = argv[0];
+
+#if defined ACUTEST_UNIX__
+    test_colorize__ = isatty(STDOUT_FILENO);
+#elif defined ACUTEST_WIN__
+ #if defined __BORLANDC__
+    test_colorize__ = isatty(_fileno(stdout));
+ #else
+    test_colorize__ = _isatty(_fileno(stdout));
+ #endif
+#else
+    test_colorize__ = 0;
+#endif
+
+    test_timer_init__();
+
+    /* Count all test units */
+    test_list_size__ = 0;
+    for(i = 0; test_list__[i].func != NULL; i++)
+        test_list_size__++;
+
+    test_details__ = (struct test_detail__*)calloc(test_list_size__, sizeof(struct test_detail__));
+    if(test_details__ == NULL) {
+        fprintf(stderr, "Out of memory.\n");
+        exit(2);
+    }
+
+    /* Parse options */
+    test_cmdline_read__(test_cmdline_options__, argc, argv, test_cmdline_callback__);
+
+#if defined(ACUTEST_WIN__)
+    SetUnhandledExceptionFilter(test_seh_exception_filter__);
+#endif
+
+    /* By default, we want to run all tests. */
+    if(test_count__ == 0) {
+        for(i = 0; test_list__[i].func != NULL; i++)
+            test_remember__(i);
+    }
+
+    /* Guess whether we want to run unit tests as child processes. */
+    if(test_no_exec__ < 0) {
+        test_no_exec__ = 0;
+
+        if(test_count__ <= 1) {
+            test_no_exec__ = 1;
+        } else {
+#ifdef ACUTEST_WIN__
+            if(IsDebuggerPresent())
+                test_no_exec__ = 1;
+#endif
+#ifdef ACUTEST_LINUX__
+            if(test_is_tracer_present__())
+                test_no_exec__ = 1;
+#endif
+        }
+    }
+
+    if(test_tap__) {
+        /* TAP requires we know test result ("ok", "not ok") before we output
+         * anything about the test, and this gets problematic for larger verbose
+         * levels. */
+        if(test_verbose_level__ > 2)
+            test_verbose_level__ = 2;
+
+        /* TAP harness should provide some summary. */
+        test_no_summary__ = 1;
+
+        if(!test_worker__)
+            printf("1..%d\n", (int) test_count__);
+    }
+
+    int index = test_worker_index__;
+    for(i = 0; test_list__[i].func != NULL; i++) {
+        int run = (test_details__[i].flags & TEST_FLAG_RUN__);
+        if (test_skip_mode__) /* Run all tests except those listed. */
+            run = !run;
+        if(run)
+            test_run__(&test_list__[i], index++, i);
+    }
+
+    /* Write a summary */
+    if(!test_no_summary__ && test_verbose_level__ >= 1) {
+        if(test_verbose_level__ >= 3) {
+            test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Summary:\n");
+
+            printf("  Count of all unit tests:     %4d\n", (int) test_list_size__);
+            printf("  Count of run unit tests:     %4d\n", test_stat_run_units__);
+            printf("  Count of failed unit tests:  %4d\n", test_stat_failed_units__);
+            printf("  Count of skipped unit tests: %4d\n", (int) test_list_size__ - test_stat_run_units__);
+        }
+
+        if(test_stat_failed_units__ == 0) {
+            test_print_in_color__(TEST_COLOR_GREEN_INTENSIVE__, "SUCCESS:");
+            printf(" All unit tests have passed.\n");
+        } else {
+            test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED:");
+            printf(" %d of %d unit tests %s failed.\n",
+                    test_stat_failed_units__, test_stat_run_units__,
+                    (test_stat_failed_units__ == 1) ? "has" : "have");
+        }
+
+        if(test_verbose_level__ >= 3)
+            printf("\n");
+    }
+
+    if (test_xml_output__) {
+#if defined ACUTEST_UNIX__
+        char *suite_name = basename(argv[0]);
+#elif defined ACUTEST_WIN__
+        char suite_name[_MAX_FNAME];
+        _splitpath(argv[0], NULL, NULL, suite_name, NULL);
+#else
+        const char *suite_name = argv[0];
+#endif
+        fprintf(test_xml_output__, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+        fprintf(test_xml_output__, "<testsuite name=\"%s\" tests=\"%d\" errors=\"%d\" failures=\"%d\" skip=\"%d\">\n",
+            suite_name, (int)test_list_size__, test_stat_failed_units__, test_stat_failed_units__,
+            (int)test_list_size__ - test_stat_run_units__);
+        for(i = 0; test_list__[i].func != NULL; i++) {
+            struct test_detail__ *details = &test_details__[i];
+            fprintf(test_xml_output__, "  <testcase name=\"%s\" time=\"%.2f\">\n", test_list__[i].name, details->duration);
+            if (details->flags & TEST_FLAG_FAILURE__)
+                fprintf(test_xml_output__, "    <failure />\n");
+            if (!(details->flags & TEST_FLAG_FAILURE__) && !(details->flags & TEST_FLAG_SUCCESS__))
+                fprintf(test_xml_output__, "    <skipped />\n");
+            fprintf(test_xml_output__, "  </testcase>\n");
+        }
+        fprintf(test_xml_output__, "</testsuite>\n");
+        fclose(test_xml_output__);
+    }
+
+    free((void*) test_details__);
+
+    return (test_stat_failed_units__ == 0) ? 0 : 1;
+}
+
+
+#endif  /* #ifndef TEST_NO_MAIN */
+
+#ifdef __cplusplus
+    }  /* extern "C" */
+#endif
+
+
+#endif  /* #ifndef ACUTEST_H__ */
diff --git a/src/testing/certs.c b/src/testing/certs.c
new file mode 100644
index 00000000..e2ed94a0
--- /dev/null
+++ b/src/testing/certs.c
@@ -0,0 +1,126 @@
+//
+// 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.
+//
+
+// TLS certificates.  These are pre-generated, and should not be used outside
+// of these test cases.  They are all using RSA 2048 with SHA256.
+// All certs are signed by the root key (making the root self-signed).
+// They all expire in about 100 years -- so we don't have to worry about
+// expiration.
+//
+// The server cert uses CN 127.0.0.1.
+//
+// Country = XX
+// State = Utopia
+// Locality = Paradise
+// Organization = NNG Tests, Inc.
+//
+
+const char *nuts_server_key =
+    "-----BEGIN RSA PRIVATE KEY-----\n"
+    "MIIEowIBAAKCAQEAyPdnRbMrQj9902TGQsmMbG6xTSl9XKbJr55BcnyZifsrqA7B\n"
+    "bNSkndVw9Qq+OJQIDBTfRhGdG+o9j3h6SDVvIb62fWtwJ5Fe0eUmeYwPc1PKQzOm\n"
+    "MFlMYekXiZsx60yu5LeuUhGlb84+csImH+m3NbutInPJcStSq0WfSV6VNk6DN353\n"
+    "5ex66zV2Ms6ikys1vCC434YqIpe1VxUh+IC2widJcLDCxmmJt3TOlx5f9OcKMkxu\n"
+    "H4fMAzgjIEpIrUjdb19CGNVvsNrEEB2CShBMgBdqMaAnKFxpKgfzS0JFulxRGNtp\n"
+    "srweki+j+a4sJXTv40kELkRQS6uB6wWZNjcPywIDAQABAoIBAQCGSUsot+BgFCzv\n"
+    "5JbWafb7Pbwb421xS8HZJ9Zzue6e1McHNVTqc+zLyqQAGX2iMMhvykKnf32L+anJ\n"
+    "BKgxOANaeSVYCUKYLfs+JfDfp0druMGexhR2mjT/99FSkfF5WXREQLiq/j+dxiLU\n"
+    "bActq+5QaWf3bYddp6VF7O/TBvCNqBfD0+S0o0wtBdvxXItrKPTD5iKr9JfLWdAt\n"
+    "YNAk2QgFywFtY5zc2wt4queghF9GHeBzzZCuVj9QvPA4WdVq0mePaPTmvTYQUD0j\n"
+    "GT6X5j9JhqCwfh7trb/HfkmLHwwc62zPDFps+Dxao80+vss5b/EYZ4zY3S/K3vpG\n"
+    "f/e42S2BAoGBAP51HQYFJGC/wsNtOcX8RtXnRo8eYmyboH6MtBFrZxWl6ERigKCN\n"
+    "5Tjni7EI3nwi3ONg0ENPFkoQ8h0bcVFS7iW5kz5te73WaOFtpkU9rmuFDUz37eLP\n"
+    "d+JLZ5Kwfn2FM9HoiSAZAHowE0MIlmmIEXSnFtqA2zzorPQLO/4QlR+VAoGBAMov\n"
+    "R0yaHg3qPlxmCNyLXKiGaGNzvsvWjYw825uCGmVZfhzDhOiCFMaMb51BS5Uw/gwm\n"
+    "zHxmJjoqak8JjxaQ1qKPoeY1TJ5ps1+TRq9Wzm2/zGqJHOXnRPlqwBQ6AFllAMgt\n"
+    "Rlp5uqb8QJ+YEo6/1kdGhw9kZWCZEEue6MNQjxnfAoGARLkUkZ+p54di7qz9QX+V\n"
+    "EghYgibOpk6R1hviNiIvwSUByhZgbvxjwC6pB7NBg31W8wIevU8K0g4plbrnq/Md\n"
+    "5opsPhwLo4XY5albkq/J/7f7k6ISWYN2+WMsIe4Q+42SJUsMXeLiwh1h1mTnWrEp\n"
+    "JbxK69CJZbXhoDe4iDGqVNECgYAjlgS3n9ywWE1XmAHxR3osk1OmRYYMfJv3VfLV\n"
+    "QSYCNqkyyNsIzXR4qdkvVYHHJZNhcibFsnkB/dsuRCFyOFX+0McPLMxqiXIv3U0w\n"
+    "qVe2C28gRTfX40fJmpdqN/c9xMBJe2aJoClRIM8DCBIkG/HMI8a719DcGrS6iqKv\n"
+    "VeuKAwKBgEgD+KWW1KtoSjCBlS0NP8HjC/Rq7j99YhKE6b9h2slIa7JTO8RZKCa0\n"
+    "qbuomdUeJA3R8h+5CFkEKWqO2/0+dUdLNOjG+CaTFHaUJevzHOzIjpn+VsfCLV13\n"
+    "yupGzHG+tGtdrWgLn9Dzdp67cDfSnsSh+KODPECAAFfo+wPvD8DS\n"
+    "-----END RSA PRIVATE KEY-----\n";
+
+const char *nuts_server_crt =
+    "-----BEGIN CERTIFICATE-----\n"
+    "MIIDRzCCAi8CFCOIJGs6plMawgBYdDuCRV7UuJuyMA0GCSqGSIb3DQEBCwUAMF8x\n"
+    "CzAJBgNVBAYTAlhYMQ8wDQYDVQQIDAZVdG9waWExETAPBgNVBAcMCFBhcmFkaXNl\n"
+    "MRgwFgYDVQQKDA9OTkcgVGVzdHMsIEluYy4xEjAQBgNVBAMMCWxvY2FsaG9zdDAg\n"
+    "Fw0yMDA1MjMyMzMxMTlaGA8yMTIwMDQyOTIzMzExOVowXzELMAkGA1UEBhMCWFgx\n"
+    "DzANBgNVBAgMBlV0b3BpYTERMA8GA1UEBwwIUGFyYWRpc2UxGDAWBgNVBAoMD05O\n"
+    "RyBUZXN0cywgSW5jLjESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0B\n"
+    "AQEFAAOCAQ8AMIIBCgKCAQEAyPdnRbMrQj9902TGQsmMbG6xTSl9XKbJr55BcnyZ\n"
+    "ifsrqA7BbNSkndVw9Qq+OJQIDBTfRhGdG+o9j3h6SDVvIb62fWtwJ5Fe0eUmeYwP\n"
+    "c1PKQzOmMFlMYekXiZsx60yu5LeuUhGlb84+csImH+m3NbutInPJcStSq0WfSV6V\n"
+    "Nk6DN3535ex66zV2Ms6ikys1vCC434YqIpe1VxUh+IC2widJcLDCxmmJt3TOlx5f\n"
+    "9OcKMkxuH4fMAzgjIEpIrUjdb19CGNVvsNrEEB2CShBMgBdqMaAnKFxpKgfzS0JF\n"
+    "ulxRGNtpsrweki+j+a4sJXTv40kELkRQS6uB6wWZNjcPywIDAQABMA0GCSqGSIb3\n"
+    "DQEBCwUAA4IBAQA86Fqrd4aiih6R3fwiMLwV6IQJv+u5rQeqA4D0xu6v6siP42SJ\n"
+    "YMaI2DkNGrWdSFVSHUK/efceCrhnMlW7VM8I1cyl2F/qKMfnT72cxqqquiKtQKdT\n"
+    "NDTzv61QMUP9n86HxMzGS7jg0Pknu55BsIRNK6ndDvI3D/K/rzZs4xbqWSSfNfQs\n"
+    "fNFBbOuDrkS6/1h3p8SY1uPM18WLVv3GO2T3aeNMHn7YJAKSn+sfaxzAPyPIK3UT\n"
+    "W8ecGQSHOqBJJQELyUfMu7lx/FCYKUhN7/1uhU5Qf1pCR8hkIMegtqr64yVBNMOn\n"
+    "248fuiHbs9BRknuA/PqjxIDDZTwtDrfVSO/S\n"
+    "-----END CERTIFICATE-----\n";
+
+const char *nuts_client_key =
+    "-----BEGIN RSA PRIVATE KEY-----\n"
+    "MIIEowIBAAKCAQEArohAOr7gv5aNpTEviOPPBJ2fArUX2EajMEtU9tF8H/TTlcMB\n"
+    "oy+vYoyNe56jc7CWUfO0S54rg0XaQ7HTI5EWueSR9wrEVK4q+Zg6x1dwr4k5SxD5\n"
+    "NcStDXzUjiCi9ygZRxpOUz8jRhKZFENuCdLxSN7E2vuOIU9IR5FpatMlsD33rTOX\n"
+    "Pgyx7qNpBj63ZCzY3b09zWBAXc/sLd1mxjlNP/LbtVLrFeIT1j6Gv0UgzxIcEjQ3\n"
+    "vybV/EYK7THn7jLhudEa+7fC9jfzwozbuszfEje/U0h0/DF4coGyIQTfDh6Wmk3x\n"
+    "5YB2QaI/0jwn8cwracKGtNO+vLqV4yUWZxf5xwIDAQABAoIBADXIEJrJpPIEz6Me\n"
+    "0/oH0QwoEg7AhReFNNY18HmaNfiW9fhJPiDuGcpxa0uzp8SHntqkEWPX2qq6BLcl\n"
+    "fd2Q4QLpdz08GSHLBb0h9sLko/nDfF8wXMr/zx+/3rPpRK6KsbdiWM54P0NhicBf\n"
+    "wvHOCcIdu2WLbNHA35IGMgjUBeIXxAsje63RBS3Dd6RnASxF7bbC/GXiUouQnos1\n"
+    "VSLoR6fLQQYlrMOAJU3ruPvMRwkrgaHQ1jl3PL4ilZMuvt7LSAi/KUDKMLRHdLNe\n"
+    "tMPITE5CvQ/rBhiUHMsTn1Xb2/jmSuJieJtG2fEDmLFuYZMUFMg1XfQ+ZC9cDCGI\n"
+    "wiEYUbkCgYEA1NoKnHp7Zmc2AK1J78uYByEwr8z2nAYZNq5LFeKuCd4rky6v385x\n"
+    "IjIYhvPLiGXw/lDfF1T15lHHo2FDAQqDa2rbEe+ycDC7Qa3eJjcsN284n1RM2pl+\n"
+    "iNyyhS09YVadelBxWsMqnwdDlf5lrSa7DW1+/u/z2iAw8lGka8XpFpsCgYEA0emd\n"
+    "sYqNivonQFEqJxi2kGTBjX8HNEjeF9tTLuAAg0hjhbW4i1v3JsekW9thbG436THa\n"
+    "4zWUBmcaEwx0iTD1dqM+d+PbN/4vxoRx9kWQJicfR+sa6eJiwL5UmiqDdX4to5z9\n"
+    "MbahemNBzYybr7lcvw+RbL91Fr/z3GooDM9rxkUCgYAuF8mUeTGfy1n2a5BHTV9u\n"
+    "q9FPQKNmxitPnA7GfoARwvrMtJ+BZ8M4FIEbOFArCWhWqkylUNCvP6ZryvQnlY9A\n"
+    "A7PM/os1oFfssSoaPHhmyL8KQcciz3qHSMOf81wHaCpSAnmJnhnstjX8lUqPZIO9\n"
+    "NKj7rBqycaYn02Y3sHP5YQKBgQDQxOQNW5uCiWDYWuDtmWqZGVxW+euUWJRqbbvB\n"
+    "dw+LgkdZCG7OS1z3uL8CjKHMUaJRzz+/kd3ysEACifStLYAzyg+q9XdlrOyfJ8Kg\n"
+    "CHdhOq+lu3I9Aubsg19pJLcx95g0jUJUWysmqekcIagFkPlpHHaqDZDKW4aRxRKo\n"
+    "CvNJcQKBgA9DB8OzHA/gp8TztxUZu8hAVfehLxVORquFvMRF0cr8uxjbu/6sDhzc\n"
+    "TRUkXRUe4DGxxMzAd+1SF/IWlcuZlfcuZrytH1hbjmrN8H30y+yGXFsSGCI/rudk\n"
+    "rLXNS+vWEeuOV8lQuQY0fkokmxnmhkPDMXra5/3KrVMzm3ZNF5N8\n"
+    "-----END RSA PRIVATE KEY-----\n";
+
+const char *nuts_client_crt =
+    "-----BEGIN CERTIFICATE-----\n"
+    "MIIDdzCCAl8CFEzqJgxMn+OTdw7RjLtz8FlhrQ0HMA0GCSqGSIb3DQEBCwUAMHcx\n"
+    "CzAJBgNVBAYTAlhYMQ8wDQYDVQQIDAZVdG9waWExETAPBgNVBAcMCFBhcmFkaXNl\n"
+    "MRgwFgYDVQQKDA9OTkcgVGVzdHMsIEluYy4xFDASBgNVBAsMC0NsaWVudCBDZXJ0\n"
+    "MRQwEgYDVQQDDAtUZXN0IENsaWVudDAgFw0yMDA1MjMxODQ1MjZaGA8yMTIwMDQy\n"
+    "OTE4NDUyNlowdzELMAkGA1UEBhMCWFgxDzANBgNVBAgMBlV0b3BpYTERMA8GA1UE\n"
+    "BwwIUGFyYWRpc2UxGDAWBgNVBAoMD05ORyBUZXN0cywgSW5jLjEUMBIGA1UECwwL\n"
+    "Q2xpZW50IENlcnQxFDASBgNVBAMMC1Rlc3QgQ2xpZW50MIIBIjANBgkqhkiG9w0B\n"
+    "AQEFAAOCAQ8AMIIBCgKCAQEAoHWEJXvfaHDM33AyYbJHggKOllgcvwscEnsXztIt\n"
+    "OK+0jO6SRFSbtye1cjtrkGVCYBjeWMcOdEiNB0pw3PceVpF/Q9ifCuaSYsJA3sPH\n"
+    "wi/A3G7ZTe2KCH1i26I4zyw1Bn5AzkaDDXsaht2S9PEqIBCbWo/V1pWiv4QdYmLT\n"
+    "/UFYJDxFpFC3iKVC+BDv9yzziyaFXOYsQJXcaq8ZRD79bNV5NFfzUih8RoasIdD4\n"
+    "LoamBSbbr5XzstTISus+wu1JDKgKkYMJhLGA/tdU/eOKuTDx89yO4ba23W74xeqW\n"
+    "JYe0wPy+krmeB5M7UA7jIvg1JXhYACxujhieMp7wcC3FPwIDAQABMA0GCSqGSIb3\n"
+    "DQEBCwUAA4IBAQCMTQ89YnD19bCGIdUl/z6w2yx1x1kvTYHT+SzhUprsgiuS3KT1\n"
+    "RZNhjf5U3Yu+B6SrJCLuylv+L2zQfmHogp3lV7bayOA7r/rVy5fdmHS+Ei1w6LDL\n"
+    "t8jayiRMPG4VCgaG486yI73PFpK5DXnyFqSd23TlWvNoNeVag5gjlhzG+mHZBSB2\n"
+    "ExpGY3SPxrKSzDqIITVPVgzjW25N8qtgLXC6HODDiViNYq1nmuoS4O80NIYAPPs6\n"
+    "sxUMa5kT+zc17q57ZcgNq/sSGI3BU4b/E/8ntIwiui2xWSf/4JR6xtanih8uY5Pu\n"
+    "QTgg9qTtFgtu4WWUP7JhreoINTw6O4/g5Z18\n"
+    "-----END CERTIFICATE-----\n";
diff --git a/src/testing/marry.c b/src/testing/marry.c
new file mode 100644
index 00000000..c0328df9
--- /dev/null
+++ b/src/testing/marry.c
@@ -0,0 +1,312 @@
+//
+// 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.
+//
+
+#ifdef _WIN32
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <io.h>
+#include <windows.h>
+#include <winsock2.h>
+#else
+#include <fcntl.h>
+#include <poll.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#endif
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define TEST_NO_MAIN
+#include "nuts.h"
+
+void
+nuts_scratch_addr(const char *scheme, size_t sz, char *addr)
+{
+	if ((strcmp(scheme, "inproc") == 0) ||
+	    (strcmp(scheme, "abstract") == 0)) {
+		(void) snprintf(addr, sz, "%s://nuts%04x%04x%04x%04x", scheme,
+		    nng_random(), nng_random(), nng_random(), nng_random());
+		return;
+	}
+
+	if ((strncmp(scheme, "tcp", 3) == 0) ||
+	    (strncmp(scheme, "tls", 3) == 0)) {
+		(void) snprintf(
+		    addr, sz, "%s://127.0.0.1:%u", scheme, nuts_next_port());
+		return;
+	}
+
+	if (strncmp(scheme, "ws", 2) == 0) {
+		(void) snprintf(addr, sz,
+		    "%s://127.0.0.1:%u/nuts%04x%04x%04x%04x", scheme,
+		    nuts_next_port(), nng_random(), nng_random(), nng_random(),
+		    nng_random());
+		return;
+	}
+
+	if ((strncmp(scheme, "ipc", 3) == 0) ||
+	    (strncmp(scheme, "unix", 4) == 0)) {
+#ifdef _WIN32
+		// Windows doesn't place IPC names in the filesystem.
+		(void) snprintf(addr, sz, "%s://nuts%04x%04x%04x%04x", scheme,
+		    nng_random(), nng_random(), nng_random(), nng_random());
+		return;
+#else
+		char *tmpdir;
+
+		if (((tmpdir = getenv("TMPDIR")) == NULL) &&
+		    ((tmpdir = getenv("TEMP")) == NULL) &&
+		    ((tmpdir = getenv("TMP")) == NULL)) {
+			tmpdir = "/tmp";
+		}
+
+		(void) snprintf(addr, sz, "%s://%s/nuts%04x%04x%04x%04x",
+		    scheme, tmpdir, nng_random(), nng_random(), nng_random(),
+		    nng_random());
+		return;
+#endif
+	}
+
+	// We should not be here.
+	abort();
+}
+
+// nuts_next_port returns a "next" allocation port.
+// Ports are chosen by starting from a random point within a
+// range (normally 38000-40000, but other good places to choose
+// might be 36000-37000, 42000-43000, 45000-47000, 48000-49000.
+// These are non-ephemeral ports.  Successive calls to this function
+// will return the next port in the range (wrapping).  This works even
+// across process boundaries, as the range is tracked in a file named
+// by $TEST_PORT_FILE.  The range of ports can be configured by using
+// $TEST_PORT_RANGE (the range is specified as "lo:hi" where the actual
+// port will be in the range [lo,hi).
+uint16_t
+nuts_next_port(void)
+{
+	char *   name;
+	FILE *   f;
+	uint16_t port;
+	uint16_t base;
+	uint16_t end;
+	char *   str;
+#ifdef _WIN32
+	OVERLAPPED olp;
+	HANDLE     h;
+#endif
+
+	if ((name = getenv("NUTS_PORT_FILE")) == NULL) {
+		name = ".nuts_ports";
+	}
+	if (((str = getenv("NUTS_PORT_RANGE")) == NULL) ||
+	    ((sscanf(str, "%hu:%hu", &base, &end)) != 1) ||
+	    ((int) end - (int) base) < 1) {
+		base = 38000;
+		end  = 40000;
+	}
+
+	if (((f = fopen(name, "r+")) == NULL) &&
+	    ((f = fopen(name, "w+")) == NULL)) {
+		return (0);
+	}
+	(void) fseek(f, 0, SEEK_SET);
+
+#ifdef _WIN32
+	h = (HANDLE) _get_osfhandle(_fileno(f));
+
+	// This contains the offset information for LockFileEx.
+	ZeroMemory(&olp, sizeof(olp));
+
+	if (LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK, 0, MAXDWORD, MAXDWORD,
+	        &olp) == FALSE) {
+		fclose(f);
+		return (0);
+	}
+#else
+	if (lockf(fileno(f), 0, F_LOCK) != 0) {
+		(void) fclose(f);
+		return (0);
+	}
+#endif
+	if (fscanf(f, "%hu", &port) != 1) {
+		unsigned seed = (unsigned) time(NULL);
+
+#ifdef _WIN32
+		port = base + rand_s(&seed) % (end - base);
+#else
+		port = base + rand_r(&seed) % (end - base);
+#endif
+	}
+	port++;
+	if ((port < base) || (port >= (base + end))) {
+		port = base;
+	}
+
+#ifdef _WIN32
+	fseek(f, 0, SEEK_SET);
+	SetEndOfFile(h);
+	(void) fprintf(f, "%u", port);
+	ZeroMemory(&olp, sizeof(olp));
+	(void) UnlockFileEx(h, 0, MAXDWORD, MAXDWORD, &olp);
+#else
+	fseek(f, 0, SEEK_SET);
+	if (ftruncate(fileno(f), 0) != 0) {
+		(void) fclose(f);
+		return (0);
+	}
+
+	(void) fprintf(f, "%u", port);
+	(void) lockf(fileno(f), 0, F_ULOCK);
+
+#endif
+	(void) fclose(f);
+	return (port);
+}
+
+struct marriage_notice {
+	nng_mtx *mx;
+	nng_cv * cv;
+	int      s1;
+	int      s2;
+	int      cnt1;
+	int      cnt2;
+	nng_pipe p1;
+	nng_pipe p2;
+};
+
+static void
+married(nng_pipe p, nng_pipe_ev ev, void *arg)
+{
+	struct marriage_notice *notice = arg;
+	(void) ev;
+
+	nng_mtx_lock(notice->mx);
+	if (nng_socket_id(nng_pipe_socket(p)) == notice->s1) {
+		notice->cnt1++;
+		notice->p1 = p;
+	} else if (nng_socket_id(nng_pipe_socket(p)) == notice->s2) {
+		notice->cnt2++;
+		notice->p2 = p;
+	}
+	nng_cv_wake(notice->cv);
+	nng_mtx_unlock(notice->mx);
+}
+
+int
+nuts_marry(nng_socket s1, nng_socket s2)
+{
+	return (nuts_marry_ex(s1, s2, NULL, NULL, NULL));
+}
+
+// NB: This function is always called with sufficient space to
+// hold the resulting expansion.
+static void
+replace_port_zero(const char *addr, char *buf, int port)
+{
+	int  i;
+	int  j;
+	bool colon;
+	char c;
+
+	for (i = 0, j = 0; (c = addr[i]) != '\0'; i++) {
+
+		if (colon && c == '0') {
+			char num[16];
+			(void) snprintf(num, sizeof(num), "%d", port);
+			memcpy(&buf[j], num, strlen(num));
+			j += (int) strlen(num);
+			colon = false;
+			continue;
+		}
+		colon    = c == ':';
+		buf[j++] = c;
+	}
+	buf[j] = '\0';
+}
+
+int
+nuts_marry_ex(
+    nng_socket s1, nng_socket s2, const char *url, nng_pipe *p1, nng_pipe *p2)
+{
+	struct marriage_notice note;
+	nng_time               timeout;
+	int                    rv;
+	char                   addr[64];
+	nng_listener           l;
+	int                    port;
+
+	if (url == NULL) {
+		(void) snprintf(addr, sizeof(addr),
+		    "inproc://marry%04x%04x%04x%04x", nng_random(),
+		    nng_random(), nng_random(), nng_random());
+		url = addr;
+	}
+
+	note.cnt1 = 0;
+	note.cnt2 = 0;
+	note.s1   = nng_socket_id(s1);
+	note.s2   = nng_socket_id(s2);
+	timeout   = nng_clock() + 1000; // 1 second
+
+	if (((rv = nng_mtx_alloc(&note.mx)) != 0) ||
+	    ((rv = nng_cv_alloc(&note.cv, note.mx)) != 0) ||
+	    ((rv = nng_pipe_notify(
+	          s1, NNG_PIPE_EV_ADD_POST, married, &note)) != 0) ||
+	    ((rv = nng_pipe_notify(
+	          s2, NNG_PIPE_EV_ADD_POST, married, &note)) != 0) ||
+	    ((rv = nng_listen(s1, url, &l, 0)) != 0)) {
+		goto done;
+	}
+
+	// If a TCP port of zero was selected, let's ask for the actual
+	// port bound.
+	if ((strstr(url, ":0") != NULL) &&
+	    (nng_listener_get_int(l, NNG_OPT_TCP_BOUND_PORT, &port) == 0) &&
+	    (port > 0)) {
+		replace_port_zero(url, addr, port);
+		url = addr;
+	}
+	if ((rv = nng_dial(s2, url, NULL, 0)) != 0) {
+		goto done;
+	}
+
+	nng_mtx_lock(note.mx);
+	while ((note.cnt1 == 0) || (note.cnt2 == 0)) {
+		if ((rv = nng_cv_until(note.cv, timeout)) != 0) {
+			break;
+		}
+	}
+	nng_mtx_unlock(note.mx);
+	if (p1 != NULL) {
+		*p1 = note.p1;
+	}
+	if (p2 != NULL) {
+		*p2 = note.p2;
+	}
+
+done:
+	nng_pipe_notify(s1, NNG_PIPE_EV_ADD_POST, NULL, NULL);
+	nng_pipe_notify(s2, NNG_PIPE_EV_ADD_POST, NULL, NULL);
+	if (note.cv != NULL) {
+		nng_cv_free(note.cv);
+	}
+	if (note.mx != NULL) {
+		nng_mtx_free(note.mx);
+	}
+	return (rv);
+}
diff --git a/src/testing/nuts.h b/src/testing/nuts.h
new file mode 100644
index 00000000..2ed8744c
--- /dev/null
+++ b/src/testing/nuts.h
@@ -0,0 +1,206 @@
+//
+// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
+//
+// 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.
+//
+
+// NUTS - NNG Unit Test Support
+//
+// This is the NNG testing support library.  It is used in the NNG
+// project to support the various unit tests.  It should not be used
+// in other projects, and no guarantees are made about interface
+// stability, etc.
+
+#ifndef NNG_TESTING_NUTS_H
+#define NNG_TESTING_NUTS_H
+
+#include "acutest.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+// The following headers are provided for test code convenience.
+#include <nng/nng.h>
+#include <nng/protocol/bus0/bus.h>
+#include <nng/protocol/pair0/pair.h>
+#include <nng/protocol/pair1/pair.h>
+#include <nng/protocol/pipeline0/pull.h>
+#include <nng/protocol/pipeline0/push.h>
+#include <nng/protocol/pubsub0/pub.h>
+#include <nng/protocol/pubsub0/sub.h>
+#include <nng/protocol/reqrep0/rep.h>
+#include <nng/protocol/reqrep0/req.h>
+#include <nng/protocol/survey0/respond.h>
+#include <nng/protocol/survey0/survey.h>
+#include <nng/supplemental/tls/tls.h>
+#include <nng/supplemental/util/platform.h>
+#include <nng/transport/ws/websocket.h>
+#include <supplemental/sha1/sha1.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// nuts_clock returns the current time in milliseconds.
+// The reference clock may be any point in the past (typically since
+// the program started running.)
+extern uint64_t nuts_clock(void);
+
+// nuts_poll_fd tests if the given file descriptor polls as readable.
+extern bool nuts_poll_fd(int);
+
+// nuts_be16 converts native and big-endian words.
+extern uint16_t nuts_be16(uint16_t);
+
+// nuts_be32 converts native and big-endian double-words.
+extern uint32_t nuts_be32(uint32_t);
+
+// nuts_sleep sleeps the specified number of milliseconds.
+extern void nuts_sleep(int);
+
+// nuts_next_port returns a new port number (presumably unique)
+extern uint16_t nuts_next_port(void);
+
+// nuts_scratch_addr makes a scratch address for the given scheme.
+// The address buffer must be supplied, and the size should be at least
+// 64 bytes to ensure no truncation occurs.
+extern void nuts_scratch_addr(const char *, size_t, char *);
+
+// nuts_marry connects two sockets using inproc.  It uses socket
+// pipe hooks to ensure that it does not return before both sockets
+// are fully connected.
+extern int nuts_marry(nng_socket, nng_socket);
+
+// nuts_marry_ex is like nuts_marry, but returns the pipes that
+// were connected, and includes an optional URL.  The pipe pointers and the
+// URL may be NULL if not needed.  If a port number is part of the URL
+// and is zero (i.e. if the URL contains :0) then listen is done first,
+// and the actual bound port will be used for the client.
+extern int nuts_marry_ex(
+    nng_socket, nng_socket, const char *, nng_pipe *, nng_pipe *);
+
+// nuts_stream_send_start and nuts_stream_recv_start are used
+// to initiate transfers asynchronously.  They return a token which can
+// be used with nuts_stream_wait, which will return the result of
+// the operation (0 on success, an NNG error number otherwise.)
+extern void *nuts_stream_send_start(nng_stream *, void *, size_t);
+extern void *nuts_stream_recv_start(nng_stream *, void *, size_t);
+extern int   nuts_stream_wait(void *);
+
+// These are TLS certificates.  The client and server are signed with the
+// root.  The server uses CN 127.0.0.1.  Other details are bogus, but
+// designed to prevent accidental use elsewhere.
+extern const char *nuts_server_key;
+extern const char *nuts_server_crt;
+extern const char *nuts_client_key;
+extern const char *nuts_client_crt;
+
+// NUTS_SUCCESS tests for NNG success.  It reports the failure if it
+// did not.
+#define NUTS_PASS(cond)                                              \
+	do {                                                         \
+		int result_ = (cond);                                \
+		TEST_CHECK_(result_ == 0, "%s succeeds", #cond);     \
+		TEST_MSG("%s: expected success, got %s (%d)", #cond, \
+		    nng_strerror(result_), result_);                 \
+	} while (0)
+
+// NUTS_ERROR tests for a specific NNG error code.
+#define NUTS_FAIL(cond, expect)                                             \
+	do {                                                                \
+		int result_ = (cond);                                       \
+		TEST_CHECK_(result_ == (expect), "%s fails with %s", #cond, \
+		    nng_strerror(expect));                                  \
+		TEST_MSG("%s: expected %s (%d), got %s (%d)", #cond,        \
+		    nng_strerror(expect), expect, nng_strerror(result_),    \
+		    result_);                                               \
+	} while (0)
+
+#define NUTS_SEND(sock, string) \
+	NUTS_PASS(nng_send(sock, string, strlen(string) + 1, 0))
+
+#define NUTS_RECV(sock, string)                                             \
+	do {                                                                \
+		char   buf_[64];                                            \
+		size_t sz_ = sizeof(buf_);                                  \
+		int    rv_ = nng_recv(sock, &buf_, &sz_, 0);                \
+		TEST_CHECK_(                                                \
+		    rv_ == 0, "nng_recv (%d %s)", rv_, nng_strerror(rv_));  \
+		TEST_CHECK_(sz_ == strlen(string) + 1, "length %d want %d", \
+		    sz_, strlen(string) + 1);                               \
+		buf_[sizeof(buf_) - 1] = '\0';                              \
+		TEST_CHECK_(                                                \
+		    strcmp(string, buf_) == 0, "%s == %s", string, buf_);   \
+	} while (0)
+
+#define NUTS_MATCH(s1, s2)                                            \
+	do {                                                          \
+		TEST_CHECK_(strcmp(s1, s2) == 0, "%s == %s", s1, s2); \
+	} while (0)
+
+#define NUTS_NULL(x)                                       \
+	do {                                               \
+		TEST_CHECK_((x) == NULL, "%p == NULL", x); \
+	} while (0)
+
+#define NUTS_ADDR(var, scheme)                                             \
+	do {                                                               \
+		static char nuts_addr_[64];                                \
+		nuts_scratch_addr(scheme, sizeof(nuts_addr_), nuts_addr_); \
+		(var) = nuts_addr_;                                        \
+	} while (0)
+
+#define NUTS_OPEN(sock) NUTS_PASS(nng_pair1_open(&(sock)))
+
+#define NUTS_CLOSE(sock) NUTS_PASS(nng_close(sock))
+
+#define NUTS_SLEEP(ms) nuts_sleep(ms)
+
+#define NUTS_CLOCK(var)               \
+	do {                          \
+		(var) = nuts_clock(); \
+	} while (0)
+
+#define NUTS_BEFORE(when)                                                   \
+	do {                                                                \
+		uint64_t nuts_t0_ = (when);                                 \
+		uint64_t nuts_t1_ = nuts_clock();                           \
+		TEST_CHECK_(nuts_t1_ < nuts_t0_,                            \
+		    "time before, deadline %lld, current %lld, delta %lld", \
+		    (long long) nuts_t0_, (long long) nuts_t1_,             \
+		    (long long) nuts_t0_ - (long long) nuts_t1_);           \
+	} while (0)
+
+#define NUTS_AFTER(when)                                                   \
+	do {                                                               \
+		uint64_t nuts_t0_ = (when);                                \
+		uint64_t nuts_t1_ = nuts_clock();                          \
+		TEST_CHECK_(nuts_t1_ >= nuts_t0_,                          \
+		    "time after, deadline %lld, current %lld, delta %lld", \
+		    (long long) nuts_t0_, (long long) nuts_t1_,            \
+		    (long long) nuts_t0_ - (long long) nuts_t1_);          \
+	} while (0)
+
+#define NUTS_MARRY(s1, s2) NUTS_PASS(nuts_marry(s1, s2))
+#define NUTS_MARRY_EX(s1, s2, url, p1, p2) \
+	NUTS_PASS(nuts_marry_ex(s1, s2, url, p1, p2))
+
+// Redefine some macros from acutest.h for consistency.
+#define NUTS_TRUE TEST_CHECK
+#define NUTS_ASSERT TEST_ASSERT
+#define NUTS_CASE TEST_CASE
+#define NUTS_MSG TEST_MSG
+
+#define NUTS_TESTS TEST_LIST
+
+#define NUTS_PROTO(x, y) (((x) << 4u) | (y))
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // NNG_TEST_NUTS_H
diff --git a/src/testing/streams.c b/src/testing/streams.c
new file mode 100644
index 00000000..d718ab76
--- /dev/null
+++ b/src/testing/streams.c
@@ -0,0 +1,146 @@
+//
+// 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.
+//
+
+#define TEST_NO_MAIN
+
+#include <nng/nng.h>
+#include <nng/supplemental/util/platform.h>
+
+typedef struct {
+	uint8_t *   base;
+	size_t      rem;
+	nng_iov     iov;
+	nng_aio *   upper_aio;
+	nng_aio *   lower_aio;
+	nng_stream *s;
+	void (*submit)(nng_stream *, nng_aio *);
+} stream_xfr_t;
+
+static void
+stream_xfr_free(stream_xfr_t *x)
+{
+	if (x == NULL) {
+		return;
+	}
+	if (x->upper_aio != NULL) {
+		nng_aio_free(x->upper_aio);
+	}
+	if (x->lower_aio != NULL) {
+		nng_aio_free(x->lower_aio);
+	}
+	nng_free(x, sizeof(*x));
+}
+
+static void
+stream_xfr_start(stream_xfr_t *x)
+{
+	nng_iov iov;
+	iov.iov_buf = x->base;
+	iov.iov_len = x->rem;
+
+	nng_aio_set_iov(x->lower_aio, 1, &iov);
+	x->submit(x->s, x->lower_aio);
+}
+
+static void
+stream_xfr_cb(void *arg)
+{
+	stream_xfr_t *x = arg;
+	int           rv;
+	size_t        n;
+
+	rv = nng_aio_result(x->lower_aio);
+	if (rv != 0) {
+		nng_aio_finish(x->upper_aio, rv);
+		return;
+	}
+	n = nng_aio_count(x->lower_aio);
+
+	x->rem -= n;
+	x->base += n;
+
+	if (x->rem == 0) {
+		nng_aio_finish(x->upper_aio, 0);
+		return;
+	}
+
+	stream_xfr_start(x);
+}
+
+static stream_xfr_t *
+stream_xfr_alloc(nng_stream *s, void (*submit)(nng_stream *, nng_aio *),
+    void *buf, size_t size)
+{
+	stream_xfr_t *x;
+
+	if ((x = nng_alloc(size)) == NULL) {
+		return (NULL);
+	}
+	if (nng_aio_alloc(&x->upper_aio, NULL, NULL) != 0) {
+		stream_xfr_free(x);
+		return (NULL);
+	}
+	if (nng_aio_alloc(&x->lower_aio, stream_xfr_cb, x) != 0) {
+		stream_xfr_free(x);
+		return (NULL);
+	}
+
+	// Upper should not take more than 30 seconds, lower not more than 5.
+	nng_aio_set_timeout(x->upper_aio, 30000);
+	nng_aio_set_timeout(x->lower_aio, 5000);
+
+	nng_aio_begin(x->upper_aio);
+
+	x->s      = s;
+	x->rem    = size;
+	x->base   = buf;
+	x->submit = submit;
+
+	return (x);
+}
+
+int
+nuts_stream_wait(stream_xfr_t *x)
+{
+	int rv;
+	if (x == NULL) {
+		return (NNG_ENOMEM);
+	}
+	nng_aio_wait(x->upper_aio);
+	rv = nng_aio_result(x->upper_aio);
+	stream_xfr_free(x);
+	return (rv);
+}
+
+void *
+nuts_stream_recv_start(nng_stream *s, void *buf, size_t size)
+{
+	stream_xfr_t *x;
+
+	x = stream_xfr_alloc(s, nng_stream_recv, buf, size);
+	if (x == NULL) {
+		return (x);
+	}
+	stream_xfr_start(x);
+	return (x);
+}
+
+void *
+nuts_stream_send_start(nng_stream *s, void *buf, size_t size)
+{
+	stream_xfr_t *x;
+
+	x = stream_xfr_alloc(s, nng_stream_send, buf, size);
+	if (x == NULL) {
+		return (x);
+	}
+	stream_xfr_start(x);
+	return (x);
+}
diff --git a/src/testing/util.c b/src/testing/util.c
new file mode 100644
index 00000000..eeb70b4f
--- /dev/null
+++ b/src/testing/util.c
@@ -0,0 +1,164 @@
+//
+// 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.
+//
+
+#define TEST_NO_MAIN
+
+#ifdef _WIN32
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+#include <winsock2.h>
+// order counts
+#include <mswsock.h>
+#define poll WSAPoll
+#include <io.h>
+#else
+#include <fcntl.h>
+#include <poll.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#endif
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if !defined(_WIN32) && !defined(CLOCK_MONOTONIC)
+#include <poll.h>
+#endif
+
+#include "nuts.h"
+
+uint64_t
+nuts_clock(void)
+{
+#ifdef _WIN32
+	return (GetTickCount64());
+#elif defined(CLOCK_MONTONIC)
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	uint64_t val;
+
+	val = ts.tv_sec;
+	val *= 1000;
+	val += ts.tv_nsec / 1000000;
+	return (val);
+#else
+	static time_t  epoch;
+	struct timeval tv;
+
+	if (epoch == 0) {
+		epoch = time(NULL);
+	}
+	gettimeofday(&tv, NULL);
+
+	if (tv.tv_sec < epoch) {
+		// Broken clock.
+		// This will force all other timing tests to fail
+		return (0);
+	}
+	tv.tv_sec -= epoch;
+	return (
+	    ((uint64_t)(tv.tv_sec) * 1000) + (uint64_t)(tv.tv_usec / 1000));
+#endif
+
+#ifdef _WIN32
+#else
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+}
+
+bool
+nuts_poll_fd(int fd)
+{
+#ifdef _WIN32
+	struct pollfd pfd;
+	pfd.fd      = (SOCKET) fd;
+	pfd.events  = POLLRDNORM;
+	pfd.revents = 0;
+
+	switch (WSAPoll(&pfd, 1, 0)) {
+	case 0:
+		return (false);
+	case 1:
+		return (true);
+	}
+#else
+	struct pollfd pfd;
+
+	pfd.fd      = fd;
+	pfd.events  = POLLRDNORM;
+	pfd.revents = 0;
+
+	switch (poll(&pfd, 1, 0)) {
+	case 0:
+		return (false);
+	case 1:
+		return (true);
+	}
+#endif
+	return (false);
+}
+
+static bool
+is_little_endian(void)
+{
+	uint16_t num = 0x1;
+	uint8_t *ptr = (uint8_t *) (void *) (&num);
+	return (ptr[0] == 1);
+}
+
+uint16_t
+nuts_be16(uint16_t in)
+{
+	if (is_little_endian()) {
+		in = ((in / 0x100) + ((in % 0x100) * 0x100));
+	}
+	return (in);
+}
+
+uint32_t
+nuts_be32(uint32_t in)
+{
+	if (is_little_endian()) {
+		in = ((in >> 24u) & 0xffu) | ((in >> 8u) & 0xff00u) |
+		    ((in << 8u) & 0xff0000u) | ((in << 24u) & 0xff000000u);
+	}
+	return (in);
+}
+
+void
+nuts_sleep(int msec)
+{
+#ifdef _WIN32
+	Sleep(msec);
+#elif defined(CLOCK_MONOTONIC)
+	struct timespec ts;
+
+	ts.tv_sec  = msec / 1000;
+	ts.tv_nsec = (msec % 1000) * 1000000;
+
+	// Do this in a loop, so that interrupts don't actually wake us.
+	while (ts.tv_sec || ts.tv_nsec) {
+		if (nanosleep(&ts, &ts) == 0) {
+			break;
+		}
+	}
+#else
+	poll(NULL, 0, msec);
+#endif
+}
diff --git a/src/transport/ipc/ipc_test.c b/src/transport/ipc/ipc_test.c
index 3240b21d..2fb4afa3 100644
--- a/src/transport/ipc/ipc_test.c
+++ b/src/transport/ipc/ipc_test.c
@@ -8,13 +8,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <nng/nng.h>
-#include <nng/protocol/pair0/pair.h>
-#include <nng/supplemental/util/platform.h>
-
-#include <testutil.h>
-
-#include <acutest.h>
+#include <nuts.h>
 
 #ifdef NNG_PLATFORM_POSIX
 #include <sys/stat.h>
@@ -33,15 +27,14 @@ test_path_too_long(void)
 	addr[255] = 0;
 	memcpy(addr, "ipc://", strlen("ipc://"));
 
-	TEST_ASSERT(strlen(addr) == 255);
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_FAIL(nng_listen(s1, addr, NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
-	    nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK), NNG_EADDRINVAL);
+	NUTS_ASSERT(strlen(addr) == 255);
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_FAIL(nng_listen(s1, addr, NULL, 0), NNG_EADDRINVAL);
+	NUTS_FAIL(nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK), NNG_EADDRINVAL);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -49,16 +42,14 @@ test_ipc_dialer_perms(void)
 {
 	nng_socket s;
 	nng_dialer d;
-	char       addr[64];
+	char *     addr;
 
-	testutil_scratch_addr("ipc", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s));
-	TEST_NNG_PASS(nng_dialer_create(&d, s, addr));
-	TEST_NNG_FAIL(
+	NUTS_ADDR(addr, "ipc");
+	NUTS_OPEN(s);
+	NUTS_PASS(nng_dialer_create(&d, s, addr));
+	NUTS_FAIL(
 	    nng_dialer_set_int(d, NNG_OPT_IPC_PERMISSIONS, 0444), NNG_ENOTSUP);
-
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 void
@@ -68,26 +59,24 @@ test_ipc_dialer_properties(void)
 	nng_dialer   d;
 	nng_sockaddr sa;
 	size_t       z;
-	char         addr[64];
+	char         *addr;
 
-	testutil_scratch_addr("ipc", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s));
-	TEST_NNG_PASS(nng_dial(s, addr, &d, NNG_FLAG_NONBLOCK));
+	NUTS_ADDR(addr, "ipc");
+	NUTS_OPEN(s);
+	NUTS_PASS(nng_dial(s, addr, &d, NNG_FLAG_NONBLOCK));
 	// Dialers don't have local addresses.
-	TEST_NNG_FAIL(
-	    nng_dialer_get_addr(d, NNG_OPT_LOCADDR, &sa), NNG_ENOTSUP);
+	NUTS_FAIL(nng_dialer_get_addr(d, NNG_OPT_LOCADDR, &sa), NNG_ENOTSUP);
 
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dialer_set(d, NNG_OPT_LOCADDR, &sa, sizeof(sa)), NNG_ENOTSUP);
 
 	z = 8192;
-	TEST_NNG_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, z));
+	NUTS_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, z));
 	z = 0;
-	TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &z));
-	TEST_CHECK(z == 8192);
-	TEST_NNG_FAIL(nng_dialer_set_bool(d, NNG_OPT_RAW, true), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &z));
+	NUTS_TRUE(z == 8192);
+	NUTS_FAIL(nng_dialer_set_bool(d, NNG_OPT_RAW, true), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -95,40 +84,38 @@ test_ipc_listener_perms(void)
 {
 	nng_socket   s;
 	nng_listener l;
-	char         addr[64];
+	char         *addr;
 
 #ifndef _WIN32
 	char *      path;
 	struct stat st;
 #endif
 
-	testutil_scratch_addr("ipc", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s));
-	TEST_NNG_PASS(nng_listener_create(&l, s, addr));
+	NUTS_ADDR(addr, "ipc");
+	NUTS_OPEN(s);
+	NUTS_PASS(nng_listener_create(&l, s, addr));
 
 #ifdef _WIN32
-	TEST_NNG_FAIL(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444),
+	NUTS_FAIL(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444),
 	    NNG_ENOTSUP);
 #else
 	path = &addr[strlen("ipc://")];
 
 	// Attempt to set invalid permissions fails.
-	TEST_NNG_FAIL(
-	    nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, S_IFREG),
+	NUTS_FAIL(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, S_IFREG),
 	    NNG_EINVAL);
 
-	TEST_NNG_PASS(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444));
-	TEST_NNG_PASS(nng_listener_start(l, 0));
-	TEST_CHECK(stat(path, &st) == 0);
-	TEST_CHECK((st.st_mode & 0777) == 0444);
+	NUTS_PASS(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444));
+	NUTS_PASS(nng_listener_start(l, 0));
+	NUTS_TRUE(stat(path, &st) == 0);
+	NUTS_TRUE((st.st_mode & 0777) == 0444);
 
 	// Now that it's running, we cannot set it.
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0644), NNG_EBUSY);
 #endif
 
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 void
@@ -138,26 +125,24 @@ test_ipc_listener_properties(void)
 	nng_listener l;
 	nng_sockaddr sa;
 	size_t       z;
-	char         addr[64];
+	char         *addr;
 
-	testutil_scratch_addr("ipc", sizeof(addr), addr);
+	NUTS_ADDR(addr, "ipc");
+	NUTS_OPEN(s);
+	NUTS_PASS(nng_listen(s, addr, &l, 0));
+	NUTS_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
+	NUTS_TRUE(sa.s_ipc.sa_family == NNG_AF_IPC);
+	NUTS_MATCH(sa.s_ipc.sa_path, addr + strlen("ipc://"));
 
-	TEST_NNG_PASS(nng_pair0_open(&s));
-	TEST_NNG_PASS(nng_listen(s, addr, &l, 0));
-	TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
-	TEST_CHECK(sa.s_ipc.sa_family == NNG_AF_IPC);
-	TEST_STREQUAL(sa.s_ipc.sa_path, addr + strlen("ipc://"));
-
-	TEST_NNG_FAIL(nng_listener_set(l, NNG_OPT_LOCADDR, &sa, sizeof(sa)),
+	NUTS_FAIL(nng_listener_set(l, NNG_OPT_LOCADDR, &sa, sizeof(sa)),
 	    NNG_EREADONLY);
 	z = 8192;
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, z));
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, z));
 	z = 0;
-	TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &z));
-	TEST_CHECK(z == 8192);
-	TEST_NNG_FAIL(
-	    nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &z));
+	NUTS_TRUE(z == 8192);
+	NUTS_FAIL(nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -169,29 +154,28 @@ test_ipc_recv_max(void)
 	nng_socket   s1;
 	nng_listener l;
 	size_t       sz;
-	char         addr[64];
-
-	testutil_scratch_addr("ipc", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s0));
-	TEST_NNG_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
-	TEST_NNG_PASS(nng_listener_create(&l, s0, addr));
-	TEST_NNG_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 200);
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
-	TEST_NNG_PASS(nng_listener_start(l, 0));
-
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_dial(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_send(s1, msg, 95, 0));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_recv(s0, rcvbuf, &sz, 0));
-	TEST_CHECK(sz == 95);
-	TEST_NNG_PASS(nng_send(s1, msg, 150, 0));
-	TEST_NNG_FAIL(nng_recv(s0, rcvbuf, &sz, 0), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(s0));
-	TEST_NNG_PASS(nng_close(s1));
+	char         *addr;
+
+	NUTS_ADDR(addr, "ipc");
+	NUTS_OPEN(s0);
+	NUTS_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
+	NUTS_PASS(nng_listener_create(&l, s0, addr));
+	NUTS_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 200);
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
+	NUTS_PASS(nng_listener_start(l, 0));
+
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_dial(s1, addr, NULL, 0));
+	NUTS_PASS(nng_send(s1, msg, 95, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_recv(s0, rcvbuf, &sz, 0));
+	NUTS_TRUE(sz == 95);
+	NUTS_PASS(nng_send(s1, msg, 150, 0));
+	NUTS_FAIL(nng_recv(s0, rcvbuf, &sz, 0), NNG_ETIMEDOUT);
+	NUTS_CLOSE(s0);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -200,27 +184,27 @@ test_abstract_sockets(void)
 #ifdef NNG_HAVE_ABSTRACT_SOCKETS
 	nng_socket   s1;
 	nng_socket   s2;
-	char         addr[64];
+	char         *addr;
 	nng_pipe     p1;
 	nng_pipe     p2;
 	nng_sockaddr sa1;
 	nng_sockaddr sa2;
 	char *       prefix = "abstract://";
-	testutil_scratch_addr("abstract", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	TEST_NNG_PASS(testutil_marry_ex(s1, s2, addr, &p1, &p2));
-	TEST_NNG_PASS(nng_pipe_get_addr(p1, NNG_OPT_REMADDR, &sa1));
-	TEST_NNG_PASS(nng_pipe_get_addr(p2, NNG_OPT_LOCADDR, &sa2));
-	TEST_CHECK(sa1.s_family == sa2.s_family);
-	TEST_CHECK(sa1.s_family == NNG_AF_ABSTRACT);
-	TEST_CHECK(sa1.s_abstract.sa_len == strlen(addr) - strlen(prefix));
-	TEST_CHECK(sa2.s_abstract.sa_len == strlen(addr) - strlen(prefix));
-	TEST_NNG_SEND_STR(s1, "ping");
-	TEST_NNG_RECV_STR(s2, "ping");
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+
+	NUTS_ADDR(addr, "abstract");
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_MARRY_EX(s1, s2, addr, &p1, &p2);
+	NUTS_PASS(nng_pipe_get_addr(p1, NNG_OPT_REMADDR, &sa1));
+	NUTS_PASS(nng_pipe_get_addr(p2, NNG_OPT_LOCADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_family == NNG_AF_ABSTRACT);
+	NUTS_TRUE(sa1.s_abstract.sa_len == strlen(addr) - strlen(prefix));
+	NUTS_TRUE(sa2.s_abstract.sa_len == strlen(addr) - strlen(prefix));
+	NUTS_SEND(s1, "ping");
+	NUTS_RECV(s2, "ping");
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 #endif
 }
 
@@ -238,36 +222,36 @@ test_abstract_auto_bind(void)
 
 	snprintf(addr, sizeof(addr), "abstract://");
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_listen(s1, addr, &l, 0));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_listen(s1, addr, &l, 0));
 
-	TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
+	NUTS_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
 	// Under linux there are either 8 or 5 hex characters.
-	TEST_CHECK(sa.s_family == NNG_AF_ABSTRACT);
-	TEST_CHECK(sa.s_abstract.sa_len < 10);
+	NUTS_TRUE(sa.s_family == NNG_AF_ABSTRACT);
+	NUTS_TRUE(sa.s_abstract.sa_len < 10);
 
 	len = sa.s_abstract.sa_len;
 	memcpy(name, sa.s_abstract.sa_name, len);
 	name[len] = '\0';
-	TEST_CHECK(strlen(name) == len);
+	NUTS_TRUE(strlen(name) == len);
 
 	(void) snprintf(addr, sizeof(addr), "abstract://%s", name);
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 
 	// first send the ping
-	TEST_NNG_SEND_STR(s1, "ping");
-	TEST_NNG_RECV_STR(s2, "ping");
+	NUTS_SEND(s1, "ping");
+	NUTS_RECV(s2, "ping");
 
-	TEST_NNG_SEND_STR(s2, "pong");
-	TEST_NNG_RECV_STR(s1, "pong");
+	NUTS_SEND(s2, "pong");
+	NUTS_RECV(s1, "pong");
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 #endif
 }
 
@@ -283,15 +267,14 @@ test_abstract_too_long(void)
 	addr[255] = 0;
 	memcpy(addr, "abstract://", strlen("abstract://"));
 
-	TEST_ASSERT(strlen(addr) == 255);
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_FAIL(nng_listen(s1, addr, NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
-	    nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK), NNG_EADDRINVAL);
+	NUTS_ASSERT(strlen(addr) == 255);
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_FAIL(nng_listen(s1, addr, NULL, 0), NNG_EADDRINVAL);
+	NUTS_FAIL(nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK), NNG_EADDRINVAL);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 #endif
 }
 
@@ -313,37 +296,37 @@ test_abstract_null(void)
 	snprintf(name, sizeof(name), "a%%00b_%s", rng);
 	snprintf(addr, sizeof(addr), "abstract://%s", name);
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_listen(s1, addr, &l, 0));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_listen(s1, addr, &l, 0));
 
-	TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
+	NUTS_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
 	// Under linux there are either 8 or 5 hex characters.
-	TEST_CHECK(sa.s_family == NNG_AF_ABSTRACT);
-	TEST_CHECK(sa.s_abstract.sa_len < 32);
+	NUTS_TRUE(sa.s_family == NNG_AF_ABSTRACT);
+	NUTS_TRUE(sa.s_abstract.sa_len < 32);
 	len = sa.s_abstract.sa_len;
-	TEST_CHECK(len == 20);
-	TEST_CHECK(sa.s_abstract.sa_name[0] == 'a');
-	TEST_CHECK(sa.s_abstract.sa_name[1] == '\0');
-	TEST_CHECK(sa.s_abstract.sa_name[2] == 'b');
-	TEST_CHECK(sa.s_abstract.sa_name[3] == '_');
-	TEST_CHECK(memcmp(&sa.s_abstract.sa_name[4], rng, 16) == 0);
+	NUTS_TRUE(len == 20);
+	NUTS_TRUE(sa.s_abstract.sa_name[0] == 'a');
+	NUTS_TRUE(sa.s_abstract.sa_name[1] == '\0');
+	NUTS_TRUE(sa.s_abstract.sa_name[2] == 'b');
+	NUTS_TRUE(sa.s_abstract.sa_name[3] == '_');
+	NUTS_TRUE(memcmp(&sa.s_abstract.sa_name[4], rng, 16) == 0);
 
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 
 	// first send the ping
-	TEST_NNG_SEND_STR(s1, "1234");
-	TEST_NNG_RECV_STR(s2, "1234");
+	NUTS_SEND(s1, "1234");
+	NUTS_RECV(s2, "1234");
 
-	TEST_NNG_SEND_STR(s2, "5678");
-	TEST_NNG_RECV_STR(s1, "5678");
+	NUTS_SEND(s2, "5678");
+	NUTS_RECV(s1, "5678");
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 #endif
 }
 
@@ -368,31 +351,31 @@ test_unix_alias(void)
 	snprintf(addr1, sizeof(addr1), "ipc:///tmp/%s", rng);
 	snprintf(addr2, sizeof(addr2), "unix:///tmp/%s", rng);
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
-	TEST_NNG_PASS(nng_listen(s1, addr1, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, addr2, NULL, 0));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000));
+	NUTS_PASS(nng_listen(s1, addr1, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr2, NULL, 0));
 
 	// first send the ping
-	TEST_NNG_SEND_STR(s1, "ping");
-	TEST_NNG_PASS(nng_recvmsg(s2, &msg, 0));
-	TEST_ASSERT(msg != NULL);
-	TEST_CHECK(nng_msg_len(msg) == 5);
-	TEST_STREQUAL(nng_msg_body(msg), "ping");
+	NUTS_SEND(s1, "ping");
+	NUTS_PASS(nng_recvmsg(s2, &msg, 0));
+	NUTS_ASSERT(msg != NULL);
+	NUTS_TRUE(nng_msg_len(msg) == 5);
+	NUTS_MATCH(nng_msg_body(msg), "ping");
 	p = nng_msg_get_pipe(msg);
-	TEST_NNG_PASS(nng_pipe_get_addr(p, NNG_OPT_REMADDR, &sa1));
-	TEST_NNG_PASS(nng_pipe_get_addr(p, NNG_OPT_REMADDR, &sa2));
-	TEST_CHECK(sa1.s_family == sa2.s_family);
-	TEST_CHECK(sa1.s_family == NNG_AF_IPC);
-	TEST_STREQUAL(sa1.s_ipc.sa_path, sa2.s_ipc.sa_path);
+	NUTS_PASS(nng_pipe_get_addr(p, NNG_OPT_REMADDR, &sa1));
+	NUTS_PASS(nng_pipe_get_addr(p, NNG_OPT_REMADDR, &sa2));
+	NUTS_TRUE(sa1.s_family == sa2.s_family);
+	NUTS_TRUE(sa1.s_family == NNG_AF_IPC);
+	NUTS_MATCH(sa1.s_ipc.sa_path, sa2.s_ipc.sa_path);
 	nng_msg_free(msg);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 #endif
 }
 
diff --git a/src/transport/tcp/tcp_test.c b/src/transport/tcp/tcp_test.c
index 88b77ab4..d23227d7 100644
--- a/src/transport/tcp/tcp_test.c
+++ b/src/transport/tcp/tcp_test.c
@@ -10,12 +10,8 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <nng/nng.h>
-#include <nng/protocol/pair0/pair.h>
-#include <nng/supplemental/util/platform.h>
 
-#include <acutest.h>
-#include <testutil.h>
+#include <nuts.h>
 
 // TCP tests.
 
@@ -25,11 +21,10 @@ test_tcp_wild_card_connect_fail(void)
 	nng_socket s;
 	char       addr[NNG_MAXADDRLEN];
 
-	TEST_NNG_PASS(nng_pair0_open(&s));
-	(void) snprintf(
-	    addr, sizeof(addr), "tcp://*:%u", testutil_next_port());
-	TEST_NNG_FAIL(nng_dial(s, addr, NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_OPEN(s);
+	(void) snprintf(addr, sizeof(addr), "tcp://*:%u", nuts_next_port());
+	NUTS_FAIL(nng_dial(s, addr, NULL, 0), NNG_EADDRINVAL);
+	NUTS_CLOSE(s);
 }
 
 void
@@ -40,17 +35,16 @@ test_tcp_wild_card_bind(void)
 	char       addr[NNG_MAXADDRLEN];
 	uint16_t   port;
 
-	port = testutil_next_port();
+	port = nuts_next_port();
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 	(void) snprintf(addr, sizeof(addr), "tcp4://*:%u", port);
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	// reset port back one
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 	(void) snprintf(addr, sizeof(addr), "tcp://127.0.0.1:%u", port);
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
-	TEST_NNG_PASS(nng_close(s2));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_CLOSE(s2);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -62,17 +56,16 @@ test_tcp_local_address_connect(void)
 	char       addr[NNG_MAXADDRLEN];
 	uint16_t   port;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	port = testutil_next_port();
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	port = nuts_next_port();
 	(void) snprintf(addr, sizeof(addr), "tcp://127.0.0.1:%u", port);
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
-	// reset port back one
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 	(void) snprintf(
 	    addr, sizeof(addr), "tcp://127.0.0.1;127.0.0.1:%u", port);
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
-	TEST_NNG_PASS(nng_close(s2));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_CLOSE(s2);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -84,19 +77,19 @@ test_tcp_port_zero_bind(void)
 	nng_listener l;
 	char *       addr;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair_open(&s2));
-	TEST_NNG_PASS(nng_listen(s1, "tcp://127.0.0.1:0", &l, 0));
-	TEST_NNG_PASS(nng_listener_get_string(l, NNG_OPT_URL, &addr));
-	TEST_CHECK(memcmp(addr, "tcp://", 6) == 0);
-	TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
-	TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET);
-	TEST_CHECK(sa.s_in.sa_port != 0);
-	TEST_CHECK(sa.s_in.sa_addr = testutil_htonl(0x7f000001));
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_PASS(nng_listen(s1, "tcp://127.0.0.1:0", &l, 0));
+	NUTS_PASS(nng_listener_get_string(l, NNG_OPT_URL, &addr));
+	NUTS_TRUE(memcmp(addr, "tcp://", 6) == 0);
+	NUTS_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa));
+	NUTS_TRUE(sa.s_in.sa_family == NNG_AF_INET);
+	NUTS_TRUE(sa.s_in.sa_port != 0);
+	NUTS_TRUE(sa.s_in.sa_addr = nuts_be32(0x7f000001));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 	nng_strfree(addr);
-	TEST_NNG_PASS(nng_close(s2));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s2);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -104,10 +97,10 @@ test_tcp_bad_local_interface(void)
 {
 	nng_socket s1;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_FAIL(nng_dial(s1, "tcp://bogus1;127.0.0.1:80", NULL, 0),
+	NUTS_OPEN(s1);
+	NUTS_FAIL(nng_dial(s1, "tcp://bogus1;127.0.0.1:80", NULL, 0),
 	    NNG_EADDRINVAL);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -115,10 +108,10 @@ test_tcp_non_local_address(void)
 {
 	nng_socket s1;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_FAIL(nng_dial(s1, "tcp://8.8.8.8;127.0.0.1:80", NULL, 0),
+	NUTS_OPEN(s1);
+	NUTS_FAIL(nng_dial(s1, "tcp://8.8.8.8;127.0.0.1:80", NULL, 0),
 	    NNG_EADDRINVAL);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -126,18 +119,18 @@ test_tcp_malformed_address(void)
 {
 	nng_socket s1;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_FAIL(
+	NUTS_OPEN(s1);
+	NUTS_FAIL(
 	    nng_dial(s1, "tcp://127.0.0.1", NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dial(s1, "tcp://127.0.0.1.32", NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dial(s1, "tcp://127.0.x.1.32", NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listen(s1, "tcp://127.0.0.1.32", NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listen(s1, "tcp://127.0.x.1.32", NULL, 0), NNG_EADDRINVAL);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -148,58 +141,58 @@ test_tcp_no_delay_option(void)
 	nng_listener l;
 	bool         v;
 	int          x;
-	char         addr[64];
+	char         *addr;
 
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
+	NUTS_ADDR(addr, "tcp");
 
-	TEST_NNG_PASS(nng_pair0_open(&s));
+	NUTS_OPEN(s);
 #ifndef NNG_ELIDE_DEPRECATED
-	TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == true);
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v);
 #endif
-	TEST_NNG_PASS(nng_dialer_create(&d, s, addr));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == true);
-	TEST_NNG_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_NODELAY, false));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == false);
-	TEST_NNG_FAIL(
+	NUTS_PASS(nng_dialer_create(&d, s, addr));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v);
+	NUTS_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_NODELAY, false));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v == false);
+	NUTS_FAIL(
 	    nng_dialer_get_int(d, NNG_OPT_TCP_NODELAY, &x), NNG_EBADTYPE);
 	x = 0;
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dialer_set_int(d, NNG_OPT_TCP_NODELAY, x), NNG_EBADTYPE);
 	// This assumes sizeof (bool) != sizeof (int)
 	if (sizeof(bool) != sizeof(int)) {
-		TEST_NNG_FAIL(
+		NUTS_FAIL(
 		    nng_dialer_set(d, NNG_OPT_TCP_NODELAY, &x, sizeof(x)),
 		    NNG_EINVAL);
 	}
 
-	TEST_NNG_PASS(nng_listener_create(&l, s, addr));
-	TEST_NNG_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == true);
+	NUTS_PASS(nng_listener_create(&l, s, addr));
+	NUTS_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v == true);
 	x = 0;
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listener_set_int(l, NNG_OPT_TCP_NODELAY, x), NNG_EBADTYPE);
 	// This assumes sizeof (bool) != sizeof (int)
-	TEST_NNG_FAIL(nng_listener_set(l, NNG_OPT_TCP_NODELAY, &x, sizeof(x)),
+	NUTS_FAIL(nng_listener_set(l, NNG_OPT_TCP_NODELAY, &x, sizeof(x)),
 	    NNG_EINVAL);
 
-	TEST_NNG_PASS(nng_dialer_close(d));
-	TEST_NNG_PASS(nng_listener_close(l));
+	NUTS_PASS(nng_dialer_close(d));
+	NUTS_PASS(nng_listener_close(l));
 
 	// Make sure socket wide defaults apply.
 #ifndef NNG_ELIDE_DEPRECATED
-	TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, true));
+	NUTS_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, true));
 	v = false;
-	TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == true);
-	TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, false));
-	TEST_NNG_PASS(nng_dialer_create(&d, s, addr));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
-	TEST_CHECK(v == false);
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v);
+	NUTS_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, false));
+	NUTS_PASS(nng_dialer_create(&d, s, addr));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v));
+	NUTS_TRUE(v == false);
 #endif
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 void
@@ -210,48 +203,48 @@ test_tcp_keep_alive_option(void)
 	nng_listener l;
 	bool         v;
 	int          x;
-	char         addr[64];
+	char         *addr;
 
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
-	TEST_NNG_PASS(nng_pair0_open(&s));
+	NUTS_ADDR(addr, "tcp");
+	NUTS_OPEN(s);
 #ifndef NNG_ELIDE_DEPRECATED
-	TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == false);
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v == false);
 #endif
-	TEST_NNG_PASS(nng_dialer_create(&d, s, addr));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == false);
-	TEST_NNG_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_KEEPALIVE, true));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == true);
-	TEST_NNG_FAIL(
+	NUTS_PASS(nng_dialer_create(&d, s, addr));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v == false);
+	NUTS_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_KEEPALIVE, true));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v);
+	NUTS_FAIL(
 	    nng_dialer_get_int(d, NNG_OPT_TCP_KEEPALIVE, &x), NNG_EBADTYPE);
 	x = 1;
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dialer_set_int(d, NNG_OPT_TCP_KEEPALIVE, x), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_listener_create(&l, s, addr));
-	TEST_NNG_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == false);
+	NUTS_PASS(nng_listener_create(&l, s, addr));
+	NUTS_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v == false);
 	x = 1;
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listener_set_int(l, NNG_OPT_TCP_KEEPALIVE, x), NNG_EBADTYPE);
 
-	TEST_NNG_PASS(nng_dialer_close(d));
-	TEST_NNG_PASS(nng_listener_close(l));
+	NUTS_PASS(nng_dialer_close(d));
+	NUTS_PASS(nng_listener_close(l));
 
 	// Make sure socket wide defaults apply.
 #ifndef NNG_ELIDE_DEPRECATED
-	TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, false));
+	NUTS_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, false));
 	v = true;
-	TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == false);
-	TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, true));
-	TEST_NNG_PASS(nng_dialer_create(&d, s, addr));
-	TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
-	TEST_CHECK(v == true);
+	NUTS_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v == false);
+	NUTS_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, true));
+	NUTS_PASS(nng_dialer_create(&d, s, addr));
+	NUTS_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v));
+	NUTS_TRUE(v);
 #endif
-	TEST_NNG_PASS(nng_close(s));
+	NUTS_CLOSE(s);
 }
 
 void
@@ -263,32 +256,32 @@ test_tcp_recv_max(void)
 	nng_socket   s1;
 	nng_listener l;
 	size_t       sz;
-	char         addr[64];
-
-	testutil_scratch_addr("tcp", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s0));
-	TEST_NNG_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
-	TEST_NNG_PASS(nng_listener_create(&l, s0, addr));
-	TEST_NNG_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 200);
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
-	TEST_NNG_PASS(nng_listener_start(l, 0));
-
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_dial(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_send(s1, msg, 95, 0));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_recv(s0, buf, &sz, 0));
-	TEST_CHECK(sz == 95);
-	TEST_NNG_PASS(nng_send(s1, msg, 150, 0));
-	TEST_NNG_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(s0));
-	TEST_NNG_PASS(nng_close(s1));
+	char         *addr;
+
+	NUTS_ADDR(addr, "tcp");
+
+	NUTS_OPEN(s0);
+	NUTS_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
+	NUTS_PASS(nng_listener_create(&l, s0, addr));
+	NUTS_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 200);
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
+	NUTS_PASS(nng_listener_start(l, 0));
+
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_dial(s1, addr, NULL, 0));
+	NUTS_PASS(nng_send(s1, msg, 95, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_recv(s0, buf, &sz, 0));
+	NUTS_TRUE(sz == 95);
+	NUTS_PASS(nng_send(s1, msg, 150, 0));
+	NUTS_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT);
+	NUTS_PASS(nng_close(s0));
+	NUTS_CLOSE(s1);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 
 	{ "tcp wild card connect fail", test_tcp_wild_card_connect_fail },
 	{ "tcp wild card bind", test_tcp_wild_card_bind },
diff --git a/src/transport/ws/ws_test.c b/src/transport/ws/ws_test.c
index f8f122a1..7cbcd9d7 100644
--- a/src/transport/ws/ws_test.c
+++ b/src/transport/ws/ws_test.c
@@ -8,11 +8,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <testutil.h>
-
-#include <nng/protocol/pair0/pair.h>
-
-#include <acutest.h>
+#include <nuts.h>
 
 static void
 test_ws_url_path_filters(void)
@@ -21,19 +17,19 @@ test_ws_url_path_filters(void)
 	nng_socket s2;
 	char       addr[NNG_MAXADDRLEN];
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	testutil_scratch_addr("ws", sizeof(addr), addr);
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
+	nuts_scratch_addr("ws", sizeof(addr), addr);
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 
 	// Now try we just remove the last character for now.
 	// This will make the path different.
 	addr[strlen(addr) - 1] = '\0';
-	TEST_NNG_FAIL(nng_dial(s2, addr, NULL, 0), NNG_ECONNREFUSED);
+	NUTS_FAIL(nng_dial(s2, addr, NULL, 0), NNG_ECONNREFUSED);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 static void
@@ -53,43 +49,43 @@ test_wild_card_port(void)
 	int          port2;
 	int          port3;
 	char         ws_url[128];
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
-	TEST_NNG_PASS(nng_pair0_open(&s3));
-	TEST_NNG_PASS(nng_pair0_open(&s4));
-	TEST_NNG_PASS(nng_pair0_open(&s5));
-	TEST_NNG_PASS(nng_pair0_open(&s6));
-	TEST_NNG_PASS(nng_listen(s1, "ws://127.0.0.1:0/one", &l1, 0));
-	TEST_NNG_PASS(
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
+	NUTS_OPEN(s3);
+	NUTS_OPEN(s4);
+	NUTS_OPEN(s5);
+	NUTS_OPEN(s6);
+	NUTS_PASS(nng_listen(s1, "ws://127.0.0.1:0/one", &l1, 0));
+	NUTS_PASS(
 	    nng_listener_get_int(l1, NNG_OPT_TCP_BOUND_PORT, &port1));
-	TEST_CHECK(port1 != 0);
+	NUTS_TRUE(port1 != 0);
 	snprintf(ws_url, sizeof(ws_url), "ws4://127.0.0.1:%d/two", port1);
-	TEST_NNG_PASS(nng_listen(s2, ws_url, &l2, 0));
-	TEST_NNG_PASS(
+	NUTS_PASS(nng_listen(s2, ws_url, &l2, 0));
+	NUTS_PASS(
 	    nng_listener_get_int(l2, NNG_OPT_TCP_BOUND_PORT, &port2));
-	TEST_CHECK(port1 != 0);
-	TEST_CHECK(port1 == port2);
+	NUTS_TRUE(port1 != 0);
+	NUTS_TRUE(port1 == port2);
 	// Now try a different wild card port.
-	TEST_NNG_PASS(nng_listen(s3, "ws4://127.0.0.1:0/three", &l3, 0));
-	TEST_NNG_PASS(
+	NUTS_PASS(nng_listen(s3, "ws4://127.0.0.1:0/three", &l3, 0));
+	NUTS_PASS(
 	    nng_listener_get_int(l3, NNG_OPT_TCP_BOUND_PORT, &port3));
-	TEST_CHECK(port3 != 0);
-	TEST_CHECK(port3 != port1);
+	NUTS_TRUE(port3 != 0);
+	NUTS_TRUE(port3 != port1);
 
 	// Let's make sure can dial to each.
 	snprintf(ws_url, sizeof(ws_url), "ws://127.0.0.1:%d/one", port1);
-	TEST_NNG_PASS(nng_dial(s4, ws_url, NULL, 0));
+	NUTS_PASS(nng_dial(s4, ws_url, NULL, 0));
 	snprintf(ws_url, sizeof(ws_url), "ws://127.0.0.1:%d/two", port2);
-	TEST_NNG_PASS(nng_dial(s6, ws_url, NULL, 0));
+	NUTS_PASS(nng_dial(s6, ws_url, NULL, 0));
 	snprintf(ws_url, sizeof(ws_url), "ws://127.0.0.1:%d/three", port3);
-	TEST_NNG_PASS(nng_dial(s6, ws_url, NULL, 0));
-
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
-	TEST_NNG_PASS(nng_close(s3));
-	TEST_NNG_PASS(nng_close(s4));
-	TEST_NNG_PASS(nng_close(s5));
-	TEST_NNG_PASS(nng_close(s6));
+	NUTS_PASS(nng_dial(s6, ws_url, NULL, 0));
+
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
+	NUTS_CLOSE(s3);
+	NUTS_CLOSE(s4);
+	NUTS_CLOSE(s5);
+	NUTS_CLOSE(s6);
 }
 
 static void
@@ -100,21 +96,21 @@ test_wild_card_host(void)
 	char       addr[NNG_MAXADDRLEN];
 	uint16_t   port;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	port = testutil_next_port();
+	port = nuts_next_port();
 
 	// we use ws4 to ensure 127.0.0.1 binding
 	snprintf(addr, sizeof(addr), "ws4://*:%u/test", port);
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 	nng_msleep(100);
 
 	snprintf(addr, sizeof(addr), "ws://127.0.0.1:%u/test", port);
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 static void
@@ -125,21 +121,21 @@ test_empty_host(void)
 	char       addr[NNG_MAXADDRLEN];
 	uint16_t   port;
 
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_pair0_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	port = testutil_next_port();
+	port = nuts_next_port();
 
 	// we use ws4 to ensure 127.0.0.1 binding
 	snprintf(addr, sizeof(addr), "ws4://:%u/test", port);
-	TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0));
+	NUTS_PASS(nng_listen(s1, addr, NULL, 0));
 	nng_msleep(100);
 
 	snprintf(addr, sizeof(addr), "ws://127.0.0.1:%u/test", port);
-	TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0));
+	NUTS_PASS(nng_dial(s2, addr, NULL, 0));
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
@@ -151,29 +147,28 @@ test_ws_recv_max(void)
 	nng_socket   s1;
 	nng_listener l;
 	size_t       sz;
-	char         addr[64];
-
-	testutil_scratch_addr("ws", sizeof(addr), addr);
-
-	TEST_NNG_PASS(nng_pair0_open(&s0));
-	TEST_NNG_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
-	TEST_NNG_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
-	TEST_NNG_PASS(nng_listener_create(&l, s0, addr));
-	TEST_NNG_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 200);
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
-	TEST_NNG_PASS(nng_listener_start(l, 0));
-
-	TEST_NNG_PASS(nng_pair0_open(&s1));
-	TEST_NNG_PASS(nng_dial(s1, addr, NULL, 0));
-	TEST_NNG_PASS(nng_send(s1, msg, 95, 0));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
-	TEST_NNG_PASS(nng_recv(s0, buf, &sz, 0));
-	TEST_CHECK(sz == 95);
-	TEST_NNG_PASS(nng_send(s1, msg, 150, 0));
-	TEST_NNG_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT);
-	TEST_NNG_PASS(nng_close(s0));
-	TEST_NNG_PASS(nng_close(s1));
+	char         *addr;
+
+	NUTS_ADDR(addr, "ws");
+	NUTS_OPEN(s0);
+	NUTS_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100));
+	NUTS_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200));
+	NUTS_PASS(nng_listener_create(&l, s0, addr));
+	NUTS_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 200);
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100));
+	NUTS_PASS(nng_listener_start(l, 0));
+
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_dial(s1, addr, NULL, 0));
+	NUTS_PASS(nng_send(s1, msg, 95, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
+	NUTS_PASS(nng_recv(s0, buf, &sz, 0));
+	NUTS_TRUE(sz == 95);
+	NUTS_PASS(nng_send(s1, msg, 150, 0));
+	NUTS_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT);
+	NUTS_CLOSE(s0);
+	NUTS_CLOSE(s1);
 }
 
 TEST_LIST = {