[Tarantool-patches] [PATCH v2 2/3] test: update unit tests to make them TAP-compliant

sergeyb at tarantool.org sergeyb at tarantool.org
Mon Jun 8 18:58:22 MSK 2020


From: Sergey Bronnikov <sergeyb at tarantool.org>

TAP (Test Anything Protocol) output must indicate that
this is TAP13 in the first line. See specification [1].

[1] https://testanything.org/tap-version-13-specification.html
---
 test/unit/base64.result               |  178 --
 test/unit/bit.c                       |   59 +-
 test/unit/bit.result                  |  715 --------
 test/unit/bitset_basic.c              |   32 +-
 test/unit/bitset_basic.result         |   12 -
 test/unit/bitset_index.c              |   13 +-
 test/unit/bitset_index.result         |   21 -
 test/unit/bitset_iterator.c           |    2 +
 test/unit/bitset_iterator.result      |   22 -
 test/unit/bloom.cc                    |   14 +-
 test/unit/bloom.result                |    6 -
 test/unit/bps_tree.cc                 |   58 +-
 test/unit/bps_tree.result             |  284 ---
 test/unit/bps_tree_iterator.cc        |   18 +-
 test/unit/bps_tree_iterator.result    |   21 -
 test/unit/cbus.c                      |   20 +-
 test/unit/cbus.result                 |   24 -
 test/unit/cbus_hang.c                 |    2 +-
 test/unit/cbus_hang.result            |    4 -
 test/unit/cbus_stress.c               |    2 +
 test/unit/cbus_stress.result          |    2 -
 test/unit/checkpoint_schedule.result  |   41 -
 test/unit/coio.result                 |   12 -
 test/unit/coll.cpp                    |   59 +-
 test/unit/coll.result                 |   90 -
 test/unit/column_mask.result          |   36 -
 test/unit/crypto.result               |  132 --
 test/unit/csv.c                       |    2 +
 test/unit/csv.result                  |  102 --
 test/unit/decimal.result              |  709 --------
 test/unit/fiber.cc                    |   12 +-
 test/unit/fiber.result                |   19 -
 test/unit/fiber_channel.cc            |    2 +
 test/unit/fiber_channel.result        |   23 -
 test/unit/fiber_channel_stress.cc     |    2 +
 test/unit/fiber_channel_stress.result |    2 -
 test/unit/fiber_cond.result           |    8 -
 test/unit/fiber_stack.c               |    3 +
 test/unit/fiber_stack.result          |   11 -
 test/unit/fiber_stress.cc             |    3 +
 test/unit/fiber_stress.result         |    0
 test/unit/find_path.c                 |    2 +
 test/unit/find_path.result            |    2 -
 test/unit/guard.cc                    |    1 +
 test/unit/guard.result                |    1 -
 test/unit/guava.c                     |    2 +
 test/unit/guava.result                |    6 -
 test/unit/heap.c                      |    2 +
 test/unit/heap.result                 |   24 -
 test/unit/heap_iterator.c             |    2 +
 test/unit/heap_iterator.result        |    8 -
 test/unit/histogram.c                 |    2 +
 test/unit/histogram.result            |    6 -
 test/unit/int96.cc                    |   48 +-
 test/unit/int96.result                |    2 -
 test/unit/json.result                 |  208 ---
 test/unit/light.cc                    |   14 +-
 test/unit/light.result                |    8 -
 test/unit/luaL_iterator.result        |   89 -
 test/unit/luaT_tuple_new.result       |   22 -
 test/unit/merger.result               |   71 -
 test/unit/mhash.result                |   18 -
 test/unit/mhash_bytemap.result        |   18 -
 test/unit/mp_error.result             |  114 --
 test/unit/msgpack.result              | 2291 -------------------------
 test/unit/popen.result                |   30 -
 test/unit/queue.c                     |   51 +-
 test/unit/queue.result                |   34 -
 test/unit/ratelimit.result            |   13 -
 test/unit/reflection_c.result         |    5 -
 test/unit/reflection_cxx.result       |   31 -
 test/unit/rmean.cc                    |   13 +-
 test/unit/rmean.result                |   11 -
 test/unit/rope.c                      |    6 +-
 test/unit/rope.result                 |  299 ----
 test/unit/rope_avl.c                  |    2 +
 test/unit/rope_avl.result             |  123 --
 test/unit/rope_basic.c                |    2 +
 test/unit/rope_basic.result           |  139 --
 test/unit/rope_common.h               |    7 +-
 test/unit/rope_stress.c               |    2 +
 test/unit/rope_stress.result          |    4 -
 test/unit/rtree.cc                    |   10 +-
 test/unit/rtree.result                |    8 -
 test/unit/rtree_iterator.cc           |    4 +-
 test/unit/rtree_iterator.result       |    7 -
 test/unit/rtree_multidim.cc           |   35 +-
 test/unit/rtree_multidim.result       |   15 -
 test/unit/say.result                  |   67 -
 test/unit/scramble.c                  |   10 +-
 test/unit/scramble.result             |    4 -
 test/unit/sio.result                  |   36 -
 test/unit/sql-bitvec.result           |   39 -
 test/unit/stailq.result               |   76 -
 test/unit/swim.result                 |  234 ---
 test/unit/swim_errinj.result          |   18 -
 test/unit/swim_proto.c                |    2 +-
 test/unit/swim_proto.result           |   40 -
 test/unit/tuple_bigref.result         |   17 -
 test/unit/uri.result                  | 1307 --------------
 test/unit/uuid.result                 |   18 -
 test/unit/vclock.cc                   |    3 +-
 test/unit/vclock.result               |  149 --
 test/unit/vy_cache.result             |    9 -
 test/unit/vy_mem.c                    |    4 +-
 test/unit/vy_mem.result               |   17 -
 test/unit/vy_point_lookup.result      |   20 -
 test/unit/vy_write_iterator.result    |   61 -
 test/unit/xrow.result                 |   58 -
 109 files changed, 287 insertions(+), 8491 deletions(-)
 delete mode 100644 test/unit/base64.result
 delete mode 100644 test/unit/bit.result
 delete mode 100644 test/unit/bitset_basic.result
 delete mode 100644 test/unit/bitset_index.result
 delete mode 100644 test/unit/bitset_iterator.result
 delete mode 100644 test/unit/bloom.result
 delete mode 100644 test/unit/bps_tree.result
 delete mode 100644 test/unit/bps_tree_iterator.result
 delete mode 100644 test/unit/cbus.result
 delete mode 100644 test/unit/cbus_hang.result
 delete mode 100644 test/unit/cbus_stress.result
 delete mode 100644 test/unit/checkpoint_schedule.result
 delete mode 100644 test/unit/coio.result
 delete mode 100644 test/unit/coll.result
 delete mode 100644 test/unit/column_mask.result
 delete mode 100644 test/unit/crypto.result
 delete mode 100644 test/unit/csv.result
 delete mode 100644 test/unit/decimal.result
 delete mode 100644 test/unit/fiber.result
 delete mode 100644 test/unit/fiber_channel.result
 delete mode 100644 test/unit/fiber_channel_stress.result
 delete mode 100644 test/unit/fiber_cond.result
 delete mode 100644 test/unit/fiber_stack.result
 delete mode 100644 test/unit/fiber_stress.result
 delete mode 100644 test/unit/find_path.result
 delete mode 100644 test/unit/guard.result
 delete mode 100644 test/unit/guava.result
 delete mode 100644 test/unit/heap.result
 delete mode 100644 test/unit/heap_iterator.result
 delete mode 100644 test/unit/histogram.result
 delete mode 100644 test/unit/int96.result
 delete mode 100644 test/unit/json.result
 delete mode 100644 test/unit/light.result
 delete mode 100644 test/unit/luaL_iterator.result
 delete mode 100644 test/unit/luaT_tuple_new.result
 delete mode 100644 test/unit/merger.result
 delete mode 100644 test/unit/mhash.result
 delete mode 100644 test/unit/mhash_bytemap.result
 delete mode 100644 test/unit/mp_error.result
 delete mode 100644 test/unit/msgpack.result
 delete mode 100644 test/unit/popen.result
 delete mode 100644 test/unit/queue.result
 delete mode 100644 test/unit/ratelimit.result
 delete mode 100644 test/unit/reflection_c.result
 delete mode 100644 test/unit/reflection_cxx.result
 delete mode 100644 test/unit/rmean.result
 delete mode 100644 test/unit/rope.result
 delete mode 100644 test/unit/rope_avl.result
 delete mode 100644 test/unit/rope_basic.result
 delete mode 100644 test/unit/rope_stress.result
 delete mode 100644 test/unit/rtree.result
 delete mode 100644 test/unit/rtree_iterator.result
 delete mode 100644 test/unit/rtree_multidim.result
 delete mode 100644 test/unit/say.result
 delete mode 100644 test/unit/scramble.result
 delete mode 100644 test/unit/sio.result
 delete mode 100644 test/unit/sql-bitvec.result
 delete mode 100644 test/unit/stailq.result
 delete mode 100644 test/unit/swim.result
 delete mode 100644 test/unit/swim_errinj.result
 delete mode 100644 test/unit/swim_proto.result
 delete mode 100644 test/unit/tuple_bigref.result
 delete mode 100644 test/unit/uri.result
 delete mode 100644 test/unit/uuid.result
 delete mode 100644 test/unit/vclock.result
 delete mode 100644 test/unit/vy_cache.result
 delete mode 100644 test/unit/vy_mem.result
 delete mode 100644 test/unit/vy_point_lookup.result
 delete mode 100644 test/unit/vy_write_iterator.result
 delete mode 100644 test/unit/xrow.result

diff --git a/test/unit/base64.result b/test/unit/base64.result
deleted file mode 100644
index cd1f2b3f6..000000000
--- a/test/unit/base64.result
+++ /dev/null
@@ -1,178 +0,0 @@
-1..28
-	*** main ***
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 1 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 2 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 3 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 4 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 5 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 6 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 7 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 8 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 9 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 10 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 11 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 12 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 13 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 14 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 15 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 16 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 17 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 18 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 19 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 20 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 21 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 22 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 23 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 24 - subtests
-    1..3
-    ok 1 - length
-    ok 2 - decode length ok
-    ok 3 - encode/decode
-ok 25 - subtests
-    1..6
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - no + symbols
-    ok 4 - no = symbols
-    ok 5 - decode length ok
-    ok 6 - encode/decode
-ok 26 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no = symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 27 - subtests
-    1..4
-    ok 1 - length
-    ok 2 - no \n symbols
-    ok 3 - decode length ok
-    ok 4 - encode/decode
-ok 28 - subtests
-	*** main: done ***
diff --git a/test/unit/bit.c b/test/unit/bit.c
index 1dae3671c..0da655f61 100644
--- a/test/unit/bit.c
+++ b/test/unit/bit.c
@@ -2,7 +2,6 @@
 
 #include <stdio.h>
 #include <inttypes.h>
-#include <assert.h>
 #include <stdlib.h>
 
 #include "unit.h"
@@ -29,18 +28,18 @@ test_ctz_clz(void)
 		uint64_t val64 = vals[i];
 		uint32_t val32 = (uint32_t) vals[i];
 
-		printf("bit_ctz_u64(%" PRIu64 ") => %d\n", val64,
-			bit_ctz_u64(val64));
-		printf("bit_clz_u64(%" PRIu64 ") => %d\n", val64,
-			bit_clz_u64(val64));
+		note("bit_ctz_u64(%" PRIu64 ") => %d", val64,
+		      bit_ctz_u64(val64));
+		note("bit_clz_u64(%" PRIu64 ") => %d", val64,
+		      bit_clz_u64(val64));
 
 		if (vals[i] > UINT32_MAX)
 			continue;
 
-		printf("bit_ctz_u32(%" PRIu32 ") => %d\n", val32,
-			bit_ctz_u32(val32));
-		printf("bit_clz_u32(%" PRIu32 ") => %d\n", val32,
-			bit_clz_u32(val32));
+		note("bit_ctz_u32(%" PRIu32 ") => %d", val32,
+		      bit_ctz_u32(val32));
+		note("bit_clz_u32(%" PRIu32 ") => %d", val32,
+		      bit_clz_u32(val32));
 	}
 
 	footer();
@@ -55,14 +54,14 @@ test_count(void)
 		uint64_t val64 = vals[i];
 		uint32_t val32 = (uint32_t) vals[i];
 
-		printf("bit_count_u64(%" PRIu64 ") => %d\n", val64,
-			bit_count_u64(val64));
+		note("bit_count_u64(%" PRIu64 ") => %d", val64,
+		      bit_count_u64(val64));
 
 		if (vals[i] > UINT32_MAX)
 			continue;
 
-		printf("bit_count_u32(%" PRIu32 ") => %d\n", val32,
-			bit_count_u32(val32));
+		note("bit_count_u32(%" PRIu32 ") => %d", val32,
+		      bit_count_u32(val32));
 	}
 
 	footer();
@@ -75,18 +74,18 @@ test_rotl_rotr_one(int rot)
 		uint64_t val64 = vals[i];
 		uint32_t val32 = (uint32_t) vals[i];
 
-		printf("bit_rotl_u64(%" PRIu64 ", %d) => %" PRIu64 "\n",
-		       val64, rot, bit_rotl_u64(val64, rot));
-		printf("bit_rotr_u64(%" PRIu64 ", %d) => %" PRIu64 "\n",
-		       val64, rot, bit_rotr_u64(val64, rot));
+		note("bit_rotl_u64(%" PRIu64 ", %d) => %" PRIu64,
+		      val64, rot, bit_rotl_u64(val64, rot));
+		note("bit_rotr_u64(%" PRIu64 ", %d) => %" PRIu64,
+		      val64, rot, bit_rotr_u64(val64, rot));
 
 		if (vals[i] > UINT32_MAX || rot >= 32)
 			continue;
 
-		printf("bit_rotl_u32(%" PRIu32 ", %d) => %" PRIu32 "\n",
-		       val32, rot, bit_rotl_u32(val32, rot));
-		printf("bit_rotr_u32(%" PRIu32 ", %d) => %" PRIu32 "\n",
-		       val32, rot, bit_rotr_u32(val32, rot));
+		note("bit_rotl_u32(%" PRIu32 ", %d) => %" PRIu32,
+		      val32, rot, bit_rotl_u32(val32, rot));
+		note("bit_rotr_u32(%" PRIu32 ", %d) => %" PRIu32,
+		      val32, rot, bit_rotr_u32(val32, rot));
 	}
 }
 
@@ -112,14 +111,14 @@ test_bswap(void)
 		uint64_t val64 = vals[i];
 		uint32_t val32 = (uint32_t) vals[i];
 
-		printf("bswap_u64(%" PRIu64 ") => %" PRIu64 "\n", val64,
-			bswap_u64(val64));
+		note("bswap_u64(%" PRIu64 ") => %" PRIu64, val64,
+		      bswap_u64(val64));
 
 		if (vals[i] > UINT32_MAX)
 			continue;
 
-		printf("bswap_u32(%" PRIu32 ") => %" PRIu32 "\n", val32,
-			bswap_u32(val32));
+		note("bswap_u32(%" PRIu32 ") => %" PRIu32, val32,
+		      bswap_u32(val32));
 	}
 
 	footer();
@@ -144,14 +143,14 @@ test_index(void)
 		uint64_t val64 = vals[i];
 		uint32_t val32 = (uint32_t) vals[i];
 
-		printf("bit_index_u64(%" PRIu64 ", *, -1) => ", val64);
+		printf("# bit_index_u64(%" PRIu64 ", *, -1) => ", val64);
 		test_index_print(indexes, bit_index_u64(val64, indexes, -1));
 		printf("\n");
 
 		if (vals[i] > UINT32_MAX)
 			continue;
 
-		printf("bit_index_u32(%" PRIu32 ", *, -1) => ", val32);
+		printf("# bit_index_u32(%" PRIu32 ", *, -1) => ", val32);
 		test_index_print(indexes, bit_index_u32(val32, indexes, -1));
 		printf("\n");
 	}
@@ -171,7 +170,7 @@ test_bit_iter(void)
 
 	size_t pos = 0;
 
-	printf("Set: ");
+	printf("# Set: ");
 	bit_iterator_init(&it, data, size, true);
 	while ( (pos = bit_iterator_next(&it)) != SIZE_MAX) {
 		printf("%zu, ", pos);
@@ -179,7 +178,7 @@ test_bit_iter(void)
 	}
 	printf("\n");
 
-	printf("Clear: ");
+	printf("# Clear: ");
 	bit_iterator_init(&it, data, size, false);
 	while ( (pos = bit_iterator_next(&it)) != SIZE_MAX) {
 		printf("%zu, ", pos);
@@ -223,6 +222,7 @@ test_bitmap_size(void)
 int
 main(void)
 {
+	plan(0);
 	test_ctz_clz();
 	test_count();
 	test_rotl_rotr();
@@ -231,4 +231,5 @@ main(void)
 	test_bit_iter();
 	test_bit_iter_empty();
 	test_bitmap_size();
+	check_plan();
 }
diff --git a/test/unit/bit.result b/test/unit/bit.result
deleted file mode 100644
index cfce9f532..000000000
--- a/test/unit/bit.result
+++ /dev/null
@@ -1,715 +0,0 @@
-	*** test_ctz_clz ***
-bit_ctz_u64(1) => 0
-bit_clz_u64(1) => 63
-bit_ctz_u32(1) => 0
-bit_clz_u32(1) => 31
-bit_ctz_u64(2) => 1
-bit_clz_u64(2) => 62
-bit_ctz_u32(2) => 1
-bit_clz_u32(2) => 30
-bit_ctz_u64(32768) => 15
-bit_clz_u64(32768) => 48
-bit_ctz_u32(32768) => 15
-bit_clz_u32(32768) => 16
-bit_ctz_u64(65535) => 0
-bit_clz_u64(65535) => 48
-bit_ctz_u32(65535) => 0
-bit_clz_u32(65535) => 16
-bit_ctz_u64(65536) => 16
-bit_clz_u64(65536) => 47
-bit_ctz_u32(65536) => 16
-bit_clz_u32(65536) => 15
-bit_ctz_u64(726075912) => 3
-bit_clz_u64(726075912) => 34
-bit_ctz_u32(726075912) => 3
-bit_clz_u32(726075912) => 2
-bit_ctz_u64(858993459) => 0
-bit_clz_u64(858993459) => 34
-bit_ctz_u32(858993459) => 0
-bit_clz_u32(858993459) => 2
-bit_ctz_u64(1073741824) => 30
-bit_clz_u64(1073741824) => 33
-bit_ctz_u32(1073741824) => 30
-bit_clz_u32(1073741824) => 1
-bit_ctz_u64(1245250552) => 3
-bit_clz_u64(1245250552) => 33
-bit_ctz_u32(1245250552) => 3
-bit_clz_u32(1245250552) => 1
-bit_ctz_u64(1431655765) => 0
-bit_clz_u64(1431655765) => 33
-bit_ctz_u32(1431655765) => 0
-bit_clz_u32(1431655765) => 1
-bit_ctz_u64(1656977767) => 0
-bit_clz_u64(1656977767) => 33
-bit_ctz_u32(1656977767) => 0
-bit_clz_u32(1656977767) => 1
-bit_ctz_u64(2147483648) => 31
-bit_clz_u64(2147483648) => 32
-bit_ctz_u32(2147483648) => 31
-bit_clz_u32(2147483648) => 0
-bit_ctz_u64(2283114629) => 0
-bit_clz_u64(2283114629) => 32
-bit_ctz_u32(2283114629) => 0
-bit_clz_u32(2283114629) => 0
-bit_ctz_u64(2502548245) => 0
-bit_clz_u64(2502548245) => 32
-bit_ctz_u32(2502548245) => 0
-bit_clz_u32(2502548245) => 0
-bit_ctz_u64(4294967295) => 0
-bit_clz_u64(4294967295) => 32
-bit_ctz_u32(4294967295) => 0
-bit_clz_u32(4294967295) => 0
-bit_ctz_u64(708915120906848425) => 0
-bit_clz_u64(708915120906848425) => 4
-bit_ctz_u64(1960191741125985428) => 2
-bit_clz_u64(1960191741125985428) => 3
-bit_ctz_u64(3689348814741910323) => 0
-bit_clz_u64(3689348814741910323) => 2
-bit_ctz_u64(5578377670650038654) => 1
-bit_clz_u64(5578377670650038654) => 1
-bit_ctz_u64(9223372036854775808) => 63
-bit_clz_u64(9223372036854775808) => 0
-bit_ctz_u64(10755112315580060033) => 0
-bit_clz_u64(10755112315580060033) => 0
-bit_ctz_u64(11163782031541429823) => 0
-bit_clz_u64(11163782031541429823) => 0
-bit_ctz_u64(13903686156871869732) => 2
-bit_clz_u64(13903686156871869732) => 0
-bit_ctz_u64(14237897302422917095) => 0
-bit_clz_u64(14237897302422917095) => 0
-bit_ctz_u64(14302190498657618739) => 0
-bit_clz_u64(14302190498657618739) => 0
-bit_ctz_u64(15766411510232741269) => 0
-bit_clz_u64(15766411510232741269) => 0
-bit_ctz_u64(15984546468465238145) => 0
-bit_clz_u64(15984546468465238145) => 0
-bit_ctz_u64(18446744073709551615) => 0
-bit_clz_u64(18446744073709551615) => 0
-	*** test_ctz_clz: done ***
-	*** test_count ***
-bit_count_u64(0) => 0
-bit_count_u32(0) => 0
-bit_count_u64(1) => 1
-bit_count_u32(1) => 1
-bit_count_u64(2) => 1
-bit_count_u32(2) => 1
-bit_count_u64(32768) => 1
-bit_count_u32(32768) => 1
-bit_count_u64(65535) => 16
-bit_count_u32(65535) => 16
-bit_count_u64(65536) => 1
-bit_count_u32(65536) => 1
-bit_count_u64(726075912) => 11
-bit_count_u32(726075912) => 11
-bit_count_u64(858993459) => 16
-bit_count_u32(858993459) => 16
-bit_count_u64(1073741824) => 1
-bit_count_u32(1073741824) => 1
-bit_count_u64(1245250552) => 14
-bit_count_u32(1245250552) => 14
-bit_count_u64(1431655765) => 16
-bit_count_u32(1431655765) => 16
-bit_count_u64(1656977767) => 17
-bit_count_u32(1656977767) => 17
-bit_count_u64(2147483648) => 1
-bit_count_u32(2147483648) => 1
-bit_count_u64(2283114629) => 10
-bit_count_u32(2283114629) => 10
-bit_count_u64(2502548245) => 16
-bit_count_u32(2502548245) => 16
-bit_count_u64(4294967295) => 32
-bit_count_u32(4294967295) => 32
-bit_count_u64(708915120906848425) => 29
-bit_count_u64(1960191741125985428) => 19
-bit_count_u64(3689348814741910323) => 32
-bit_count_u64(5578377670650038654) => 31
-bit_count_u64(9223372036854775808) => 1
-bit_count_u64(10755112315580060033) => 24
-bit_count_u64(11163782031541429823) => 35
-bit_count_u64(13903686156871869732) => 28
-bit_count_u64(14237897302422917095) => 33
-bit_count_u64(14302190498657618739) => 37
-bit_count_u64(15766411510232741269) => 33
-bit_count_u64(15984546468465238145) => 25
-bit_count_u64(18446744073709551615) => 64
-	*** test_count: done ***
-	*** test_rotl_rotr ***
-bit_rotl_u64(0, 1) => 0
-bit_rotr_u64(0, 1) => 0
-bit_rotl_u32(0, 1) => 0
-bit_rotr_u32(0, 1) => 0
-bit_rotl_u64(1, 1) => 2
-bit_rotr_u64(1, 1) => 9223372036854775808
-bit_rotl_u32(1, 1) => 2
-bit_rotr_u32(1, 1) => 2147483648
-bit_rotl_u64(2, 1) => 4
-bit_rotr_u64(2, 1) => 1
-bit_rotl_u32(2, 1) => 4
-bit_rotr_u32(2, 1) => 1
-bit_rotl_u64(32768, 1) => 65536
-bit_rotr_u64(32768, 1) => 16384
-bit_rotl_u32(32768, 1) => 65536
-bit_rotr_u32(32768, 1) => 16384
-bit_rotl_u64(65535, 1) => 131070
-bit_rotr_u64(65535, 1) => 9223372036854808575
-bit_rotl_u32(65535, 1) => 131070
-bit_rotr_u32(65535, 1) => 2147516415
-bit_rotl_u64(65536, 1) => 131072
-bit_rotr_u64(65536, 1) => 32768
-bit_rotl_u32(65536, 1) => 131072
-bit_rotr_u32(65536, 1) => 32768
-bit_rotl_u64(726075912, 1) => 1452151824
-bit_rotr_u64(726075912, 1) => 363037956
-bit_rotl_u32(726075912, 1) => 1452151824
-bit_rotr_u32(726075912, 1) => 363037956
-bit_rotl_u64(858993459, 1) => 1717986918
-bit_rotr_u64(858993459, 1) => 9223372037284272537
-bit_rotl_u32(858993459, 1) => 1717986918
-bit_rotr_u32(858993459, 1) => 2576980377
-bit_rotl_u64(1073741824, 1) => 2147483648
-bit_rotr_u64(1073741824, 1) => 536870912
-bit_rotl_u32(1073741824, 1) => 2147483648
-bit_rotr_u32(1073741824, 1) => 536870912
-bit_rotl_u64(1245250552, 1) => 2490501104
-bit_rotr_u64(1245250552, 1) => 622625276
-bit_rotl_u32(1245250552, 1) => 2490501104
-bit_rotr_u32(1245250552, 1) => 622625276
-bit_rotl_u64(1431655765, 1) => 2863311530
-bit_rotr_u64(1431655765, 1) => 9223372037570603690
-bit_rotl_u32(1431655765, 1) => 2863311530
-bit_rotr_u32(1431655765, 1) => 2863311530
-bit_rotl_u64(1656977767, 1) => 3313955534
-bit_rotr_u64(1656977767, 1) => 9223372037683264691
-bit_rotl_u32(1656977767, 1) => 3313955534
-bit_rotr_u32(1656977767, 1) => 2975972531
-bit_rotl_u64(2147483648, 1) => 4294967296
-bit_rotr_u64(2147483648, 1) => 1073741824
-bit_rotl_u32(2147483648, 1) => 1
-bit_rotr_u32(2147483648, 1) => 1073741824
-bit_rotl_u64(2283114629, 1) => 4566229258
-bit_rotr_u64(2283114629, 1) => 9223372037996333122
-bit_rotl_u32(2283114629, 1) => 271261963
-bit_rotr_u32(2283114629, 1) => 3289040962
-bit_rotl_u64(2502548245, 1) => 5005096490
-bit_rotr_u64(2502548245, 1) => 9223372038106049930
-bit_rotl_u32(2502548245, 1) => 710129195
-bit_rotr_u32(2502548245, 1) => 3398757770
-bit_rotl_u64(4294967295, 1) => 8589934590
-bit_rotr_u64(4294967295, 1) => 9223372039002259455
-bit_rotl_u32(4294967295, 1) => 4294967295
-bit_rotr_u32(4294967295, 1) => 4294967295
-bit_rotl_u64(708915120906848425, 1) => 1417830241813696850
-bit_rotr_u64(708915120906848425, 1) => 9577829597308200020
-bit_rotl_u64(1960191741125985428, 1) => 3920383482251970856
-bit_rotr_u64(1960191741125985428, 1) => 980095870562992714
-bit_rotl_u64(3689348814741910323, 1) => 7378697629483820646
-bit_rotr_u64(3689348814741910323, 1) => 11068046444225730969
-bit_rotl_u64(5578377670650038654, 1) => 11156755341300077308
-bit_rotr_u64(5578377670650038654, 1) => 2789188835325019327
-bit_rotl_u64(9223372036854775808, 1) => 1
-bit_rotr_u64(9223372036854775808, 1) => 4611686018427387904
-bit_rotl_u64(10755112315580060033, 1) => 3063480557450568451
-bit_rotr_u64(10755112315580060033, 1) => 14600928194644805824
-bit_rotl_u64(11163782031541429823, 1) => 3880819989373308031
-bit_rotr_u64(11163782031541429823, 1) => 14805263052625490719
-bit_rotl_u64(13903686156871869732, 1) => 9360628240034187849
-bit_rotr_u64(13903686156871869732, 1) => 6951843078435934866
-bit_rotl_u64(14237897302422917095, 1) => 10029050531136282575
-bit_rotr_u64(14237897302422917095, 1) => 16342320688066234355
-bit_rotl_u64(14302190498657618739, 1) => 10157636923605685863
-bit_rotr_u64(14302190498657618739, 1) => 16374467286183585177
-bit_rotl_u64(15766411510232741269, 1) => 13086078946755930923
-bit_rotr_u64(15766411510232741269, 1) => 17106577791971146442
-bit_rotl_u64(15984546468465238145, 1) => 13522348863220924675
-bit_rotr_u64(15984546468465238145, 1) => 17215645271087394880
-bit_rotl_u64(18446744073709551615, 1) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 1) => 18446744073709551615
-bit_rotl_u64(0, 15) => 0
-bit_rotr_u64(0, 15) => 0
-bit_rotl_u32(0, 15) => 0
-bit_rotr_u32(0, 15) => 0
-bit_rotl_u64(1, 15) => 32768
-bit_rotr_u64(1, 15) => 562949953421312
-bit_rotl_u32(1, 15) => 32768
-bit_rotr_u32(1, 15) => 131072
-bit_rotl_u64(2, 15) => 65536
-bit_rotr_u64(2, 15) => 1125899906842624
-bit_rotl_u32(2, 15) => 65536
-bit_rotr_u32(2, 15) => 262144
-bit_rotl_u64(32768, 15) => 1073741824
-bit_rotr_u64(32768, 15) => 1
-bit_rotl_u32(32768, 15) => 1073741824
-bit_rotr_u32(32768, 15) => 1
-bit_rotl_u64(65535, 15) => 2147450880
-bit_rotr_u64(65535, 15) => 18446181123756130305
-bit_rotl_u32(65535, 15) => 2147450880
-bit_rotr_u32(65535, 15) => 4294836225
-bit_rotl_u64(65536, 15) => 2147483648
-bit_rotr_u64(65536, 15) => 2
-bit_rotl_u32(65536, 15) => 2147483648
-bit_rotr_u32(65536, 15) => 2
-bit_rotl_u64(726075912, 15) => 23792055484416
-bit_rotr_u64(726075912, 15) => 1445655480385951374
-bit_rotl_u32(726075912, 15) => 2231637411
-bit_rotr_u32(726075912, 15) => 336615054
-bit_rotl_u64(858993459, 15) => 28147497664512
-bit_rotr_u64(858993459, 15) => 7378585039493162598
-bit_rotl_u32(858993459, 15) => 2576980377
-bit_rotr_u32(858993459, 15) => 1717986918
-bit_rotl_u64(1073741824, 15) => 35184372088832
-bit_rotr_u64(1073741824, 15) => 32768
-bit_rotl_u32(1073741824, 15) => 8192
-bit_rotr_u32(1073741824, 15) => 32768
-bit_rotl_u64(1245250552, 15) => 40804370087936
-bit_rotr_u64(1245250552, 15) => 571957152676090994
-bit_rotl_u32(1245250552, 15) => 2180785436
-bit_rotr_u32(1245250552, 15) => 133207154
-bit_rotl_u64(1431655765, 15) => 46912496107520
-bit_rotr_u64(1431655765, 15) => 12297641732488604330
-bit_rotl_u32(1431655765, 15) => 2863311530
-bit_rotr_u32(1431655765, 15) => 2863311530
-bit_rotl_u64(1656977767, 15) => 54295847469056
-bit_rotr_u64(1656977767, 15) => 17495921602381006214
-bit_rotl_u32(1656977767, 15) => 3165892961
-bit_rotr_u32(1656977767, 15) => 4073637254
-bit_rotl_u64(2147483648, 15) => 70368744177664
-bit_rotr_u64(2147483648, 15) => 65536
-bit_rotl_u32(2147483648, 15) => 16384
-bit_rotr_u32(2147483648, 15) => 65536
-bit_rotl_u64(2283114629, 15) => 74813100163072
-bit_rotr_u64(2283114629, 15) => 2380715353018798123
-bit_rotl_u32(2283114629, 15) => 3359818762
-bit_rotr_u32(2283114629, 15) => 554373163
-bit_rotl_u64(2502548245, 15) => 82003500892160
-bit_rotr_u64(2502548245, 15) => 13126304063924808275
-bit_rotl_u32(2502548245, 15) => 3985296020
-bit_rotr_u32(2502548245, 15) => 3056282195
-bit_rotl_u64(4294967295, 15) => 140737488322560
-bit_rotr_u64(4294967295, 15) => 18446181123756261375
-bit_rotl_u32(4294967295, 15) => 4294967295
-bit_rotr_u32(4294967295, 15) => 4294967295
-bit_rotl_u64(708915120906848425, 15) => 5279893075283707115
-bit_rotr_u64(708915120906848425, 15) => 10471453717962410780
-bit_rotl_u64(1960191741125985428, 15) => 108559631781274
-bit_rotr_u64(1960191741125985428, 15) => 659837165714377456
-bit_rotl_u64(3689348814741910323, 15) => 11068046444225730969
-bit_rotr_u64(3689348814741910323, 15) => 7378697629483820646
-bit_rotl_u64(5578377670650038654, 15) => 3492485472519661237
-bit_rotr_u64(5578377670650038654, 15) => 1368138625390162978
-bit_rotl_u64(9223372036854775808, 15) => 16384
-bit_rotr_u64(9223372036854775808, 15) => 281474976710656
-bit_rotl_u64(10755112315580060033, 15) => 16921572780133108384
-bit_rotr_u64(10755112315580060033, 15) => 2522906961261232936
-bit_rotl_u64(11163782031541429823, 15) => 15874627889163914614
-bit_rotr_u64(11163782031541429823, 15) => 14735555722393159636
-bit_rotl_u64(13903686156871869732, 15) => 16749599972631142521
-bit_rotr_u64(13903686156871869732, 15) => 5352952463958352314
-bit_rotl_u64(14237897302422917095, 15) => 10814437605877473995
-bit_rotr_u64(14237897302422917095, 15) => 2292203766521423570
-bit_rotl_u64(14302190498657618739, 15) => 14645067421692060477
-bit_rotr_u64(14302190498657618739, 15) => 10837786021529578728
-bit_rotl_u64(15766411510232741269, 15) => 14257838996763372902
-bit_rotr_u64(15766411510232741269, 15) => 16945837700629926938
-bit_rotl_u64(15984546468465238145, 15) => 4767449759914979050
-bit_rotr_u64(15984546468465238145, 15) => 13908166408919157040
-bit_rotl_u64(18446744073709551615, 15) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 15) => 18446744073709551615
-bit_rotl_u64(0, 16) => 0
-bit_rotr_u64(0, 16) => 0
-bit_rotl_u32(0, 16) => 0
-bit_rotr_u32(0, 16) => 0
-bit_rotl_u64(1, 16) => 65536
-bit_rotr_u64(1, 16) => 281474976710656
-bit_rotl_u32(1, 16) => 65536
-bit_rotr_u32(1, 16) => 65536
-bit_rotl_u64(2, 16) => 131072
-bit_rotr_u64(2, 16) => 562949953421312
-bit_rotl_u32(2, 16) => 131072
-bit_rotr_u32(2, 16) => 131072
-bit_rotl_u64(32768, 16) => 2147483648
-bit_rotr_u64(32768, 16) => 9223372036854775808
-bit_rotl_u32(32768, 16) => 2147483648
-bit_rotr_u32(32768, 16) => 2147483648
-bit_rotl_u64(65535, 16) => 4294901760
-bit_rotr_u64(65535, 16) => 18446462598732840960
-bit_rotl_u32(65535, 16) => 4294901760
-bit_rotr_u32(65535, 16) => 4294901760
-bit_rotl_u64(65536, 16) => 4294967296
-bit_rotr_u64(65536, 16) => 1
-bit_rotl_u32(65536, 16) => 1
-bit_rotr_u32(65536, 16) => 1
-bit_rotl_u64(726075912, 16) => 47584110968832
-bit_rotr_u64(726075912, 16) => 722827740192975687
-bit_rotl_u32(726075912, 16) => 168307527
-bit_rotr_u32(726075912, 16) => 168307527
-bit_rotl_u64(858993459, 16) => 56294995329024
-bit_rotr_u64(858993459, 16) => 3689292519746581299
-bit_rotl_u32(858993459, 16) => 858993459
-bit_rotr_u32(858993459, 16) => 858993459
-bit_rotl_u64(1073741824, 16) => 70368744177664
-bit_rotr_u64(1073741824, 16) => 16384
-bit_rotl_u32(1073741824, 16) => 16384
-bit_rotr_u32(1073741824, 16) => 16384
-bit_rotl_u64(1245250552, 16) => 81608740175872
-bit_rotr_u64(1245250552, 16) => 285978576338045497
-bit_rotl_u32(1245250552, 16) => 66603577
-bit_rotr_u32(1245250552, 16) => 66603577
-bit_rotl_u64(1431655765, 16) => 93824992215040
-bit_rotr_u64(1431655765, 16) => 6148820866244302165
-bit_rotl_u32(1431655765, 16) => 1431655765
-bit_rotr_u32(1431655765, 16) => 1431655765
-bit_rotl_u64(1656977767, 16) => 108591694938112
-bit_rotr_u64(1656977767, 16) => 8747960801190503107
-bit_rotl_u32(1656977767, 16) => 2036818627
-bit_rotr_u32(1656977767, 16) => 2036818627
-bit_rotl_u64(2147483648, 16) => 140737488355328
-bit_rotr_u64(2147483648, 16) => 32768
-bit_rotl_u32(2147483648, 16) => 32768
-bit_rotr_u32(2147483648, 16) => 32768
-bit_rotl_u64(2283114629, 16) => 149626200326144
-bit_rotr_u64(2283114629, 16) => 10413729713364174869
-bit_rotl_u32(2283114629, 16) => 2424670229
-bit_rotr_u32(2283114629, 16) => 2424670229
-bit_rotl_u64(2502548245, 16) => 164007001784320
-bit_rotr_u64(2502548245, 16) => 15786524068817179945
-bit_rotl_u32(2502548245, 16) => 3675624745
-bit_rotr_u32(2502548245, 16) => 3675624745
-bit_rotl_u64(4294967295, 16) => 281474976645120
-bit_rotr_u64(4294967295, 16) => 18446462598732906495
-bit_rotl_u32(4294967295, 16) => 4294967295
-bit_rotr_u32(4294967295, 16) => 4294967295
-bit_rotl_u64(708915120906848425, 16) => 10559786150567414230
-bit_rotr_u64(708915120906848425, 16) => 5235726858981205390
-bit_rotl_u64(1960191741125985428, 16) => 217119263562548
-bit_rotr_u64(1960191741125985428, 16) => 329918582857188728
-bit_rotl_u64(3689348814741910323, 16) => 3689348814741910323
-bit_rotr_u64(3689348814741910323, 16) => 3689348814741910323
-bit_rotl_u64(5578377670650038654, 16) => 6984970945039322474
-bit_rotr_u64(5578377670650038654, 16) => 684069312695081489
-bit_rotl_u64(9223372036854775808, 16) => 32768
-bit_rotr_u64(9223372036854775808, 16) => 140737488355328
-bit_rotl_u64(10755112315580060033, 16) => 15396401486556665153
-bit_rotr_u64(10755112315580060033, 16) => 1261453480630616468
-bit_rotl_u64(11163782031541429823, 16) => 13302511704618277613
-bit_rotr_u64(11163782031541429823, 16) => 7367777861196579818
-bit_rotl_u64(13903686156871869732, 16) => 15052455871552733427
-bit_rotr_u64(13903686156871869732, 16) => 2676476231979176157
-bit_rotl_u64(14237897302422917095, 16) => 3182131138045396375
-bit_rotr_u64(14237897302422917095, 16) => 1146101883260711785
-bit_rotl_u64(14302190498657618739, 16) => 10843390769674569339
-bit_rotr_u64(14302190498657618739, 16) => 5418893010764789364
-bit_rotl_u64(15766411510232741269, 16) => 10068933919817194189
-bit_rotr_u64(15766411510232741269, 16) => 8472918850314963469
-bit_rotl_u64(15984546468465238145, 16) => 9534899519829958100
-bit_rotr_u64(15984546468465238145, 16) => 6954083204459578520
-bit_rotl_u64(18446744073709551615, 16) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 16) => 18446744073709551615
-bit_rotl_u64(0, 31) => 0
-bit_rotr_u64(0, 31) => 0
-bit_rotl_u32(0, 31) => 0
-bit_rotr_u32(0, 31) => 0
-bit_rotl_u64(1, 31) => 2147483648
-bit_rotr_u64(1, 31) => 8589934592
-bit_rotl_u32(1, 31) => 2147483648
-bit_rotr_u32(1, 31) => 2
-bit_rotl_u64(2, 31) => 4294967296
-bit_rotr_u64(2, 31) => 17179869184
-bit_rotl_u32(2, 31) => 1
-bit_rotr_u32(2, 31) => 4
-bit_rotl_u64(32768, 31) => 70368744177664
-bit_rotr_u64(32768, 31) => 281474976710656
-bit_rotl_u32(32768, 31) => 16384
-bit_rotr_u32(32768, 31) => 65536
-bit_rotl_u64(65535, 31) => 140735340871680
-bit_rotr_u64(65535, 31) => 562941363486720
-bit_rotl_u32(65535, 31) => 2147516415
-bit_rotr_u32(65535, 31) => 131070
-bit_rotl_u64(65536, 31) => 140737488355328
-bit_rotr_u64(65536, 31) => 562949953421312
-bit_rotl_u32(65536, 31) => 32768
-bit_rotr_u32(65536, 31) => 131072
-bit_rotl_u64(726075912, 31) => 1559236148226686976
-bit_rotr_u64(726075912, 31) => 6236944592906747904
-bit_rotl_u32(726075912, 31) => 363037956
-bit_rotr_u32(726075912, 31) => 1452151824
-bit_rotl_u64(858993459, 31) => 1844674406941458432
-bit_rotr_u64(858993459, 31) => 7378697627765833728
-bit_rotl_u32(858993459, 31) => 2576980377
-bit_rotr_u32(858993459, 31) => 1717986918
-bit_rotl_u64(1073741824, 31) => 2305843009213693952
-bit_rotr_u64(1073741824, 31) => 9223372036854775808
-bit_rotl_u32(1073741824, 31) => 536870912
-bit_rotr_u32(1073741824, 31) => 2147483648
-bit_rotl_u64(1245250552, 31) => 2674155198082973696
-bit_rotr_u64(1245250552, 31) => 10696620792331894784
-bit_rotl_u32(1245250552, 31) => 622625276
-bit_rotr_u32(1245250552, 31) => 2490501104
-bit_rotl_u64(1431655765, 31) => 3074457344902430720
-bit_rotr_u64(1431655765, 31) => 12297829379609722880
-bit_rotl_u32(1431655765, 31) => 2863311530
-bit_rotr_u32(1431655765, 31) => 2863311530
-bit_rotl_u64(1656977767, 31) => 3558332659732054016
-bit_rotr_u64(1656977767, 31) => 14233330638928216064
-bit_rotl_u32(1656977767, 31) => 2975972531
-bit_rotr_u32(1656977767, 31) => 3313955534
-bit_rotl_u64(2147483648, 31) => 4611686018427387904
-bit_rotr_u64(2147483648, 31) => 1
-bit_rotl_u32(2147483648, 31) => 1073741824
-bit_rotr_u32(2147483648, 31) => 1
-bit_rotl_u64(2283114629, 31) => 4902951332287086592
-bit_rotr_u64(2283114629, 31) => 1165061255438794753
-bit_rotl_u32(2283114629, 31) => 3289040962
-bit_rotr_u32(2283114629, 31) => 271261963
-bit_rotl_u64(2502548245, 31) => 5374181434468597760
-bit_rotr_u64(2502548245, 31) => 3049981664164839425
-bit_rotl_u32(2502548245, 31) => 3398757770
-bit_rotr_u32(2502548245, 31) => 710129195
-bit_rotl_u64(4294967295, 31) => 9223372034707292160
-bit_rotr_u64(4294967295, 31) => 18446744065119617025
-bit_rotl_u32(4294967295, 31) => 4294967295
-bit_rotr_u32(4294967295, 31) => 4294967295
-bit_rotl_u64(708915120906848425, 31) => 17493991222969846085
-bit_rotr_u64(708915120906848425, 31) => 14635732670750729495
-bit_rotl_u64(1960191741125985428, 31) => 7114564028417572864
-bit_rotr_u64(1960191741125985428, 31) => 10011512039960739841
-bit_rotl_u64(3689348814741910323, 31) => 11068046444225730969
-bit_rotr_u64(3689348814741910323, 31) => 7378697629483820646
-bit_rotl_u64(5578377670650038654, 31) => 14774204534111940727
-bit_rotr_u64(5578377670650038654, 31) => 3756585915319108063
-bit_rotl_u64(9223372036854775808, 31) => 1073741824
-bit_rotr_u64(9223372036854775808, 31) => 4294967296
-bit_rotl_u64(10755112315580060033, 31) => 9280239606276614869
-bit_rotr_u64(10755112315580060033, 31) => 227470277687356246
-bit_rotl_u64(11163782031541429823, 31) => 141075175016160334
-bit_rotr_u64(11163782031541429823, 31) => 564300700064641336
-bit_rotl_u64(13903686156871869732, 31) => 9830956193977854066
-bit_rotr_u64(13903686156871869732, 31) => 2430336628492313034
-bit_rotl_u64(14237897302422917095, 31) => 11075626865162688020
-bit_rotr_u64(14237897302422917095, 31) => 7409019313231648850
-bit_rotl_u64(14302190498657618739, 31) => 13491136976614443837
-bit_rotr_u64(14302190498657618739, 31) => 17071059759038672118
-bit_rotl_u64(15766411510232741269, 31) => 362182200778999262
-bit_rotr_u64(15766411510232741269, 31) => 1448728803115997048
-bit_rotl_u64(15984546468465238145, 31) => 7083089369391317545
-bit_rotr_u64(15984546468465238145, 31) => 9885613403855718565
-bit_rotl_u64(18446744073709551615, 31) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 31) => 18446744073709551615
-bit_rotl_u64(0, 32) => 0
-bit_rotr_u64(0, 32) => 0
-bit_rotl_u64(1, 32) => 4294967296
-bit_rotr_u64(1, 32) => 4294967296
-bit_rotl_u64(2, 32) => 8589934592
-bit_rotr_u64(2, 32) => 8589934592
-bit_rotl_u64(32768, 32) => 140737488355328
-bit_rotr_u64(32768, 32) => 140737488355328
-bit_rotl_u64(65535, 32) => 281470681743360
-bit_rotr_u64(65535, 32) => 281470681743360
-bit_rotl_u64(65536, 32) => 281474976710656
-bit_rotr_u64(65536, 32) => 281474976710656
-bit_rotl_u64(726075912, 32) => 3118472296453373952
-bit_rotr_u64(726075912, 32) => 3118472296453373952
-bit_rotl_u64(858993459, 32) => 3689348813882916864
-bit_rotr_u64(858993459, 32) => 3689348813882916864
-bit_rotl_u64(1073741824, 32) => 4611686018427387904
-bit_rotr_u64(1073741824, 32) => 4611686018427387904
-bit_rotl_u64(1245250552, 32) => 5348310396165947392
-bit_rotr_u64(1245250552, 32) => 5348310396165947392
-bit_rotl_u64(1431655765, 32) => 6148914689804861440
-bit_rotr_u64(1431655765, 32) => 6148914689804861440
-bit_rotl_u64(1656977767, 32) => 7116665319464108032
-bit_rotr_u64(1656977767, 32) => 7116665319464108032
-bit_rotl_u64(2147483648, 32) => 9223372036854775808
-bit_rotr_u64(2147483648, 32) => 9223372036854775808
-bit_rotl_u64(2283114629, 32) => 9805902664574173184
-bit_rotr_u64(2283114629, 32) => 9805902664574173184
-bit_rotl_u64(2502548245, 32) => 10748362868937195520
-bit_rotr_u64(2502548245, 32) => 10748362868937195520
-bit_rotl_u64(4294967295, 32) => 18446744069414584320
-bit_rotr_u64(4294967295, 32) => 18446744069414584320
-bit_rotl_u64(708915120906848425, 32) => 16541238372230140555
-bit_rotr_u64(708915120906848425, 32) => 16541238372230140555
-bit_rotl_u64(1960191741125985428, 32) => 14229128056835145728
-bit_rotr_u64(1960191741125985428, 32) => 14229128056835145728
-bit_rotl_u64(3689348814741910323, 32) => 3689348814741910323
-bit_rotr_u64(3689348814741910323, 32) => 3689348814741910323
-bit_rotl_u64(5578377670650038654, 32) => 11101664994514329839
-bit_rotr_u64(5578377670650038654, 32) => 11101664994514329839
-bit_rotl_u64(9223372036854775808, 32) => 2147483648
-bit_rotr_u64(9223372036854775808, 32) => 2147483648
-bit_rotl_u64(10755112315580060033, 32) => 113735138843678123
-bit_rotr_u64(10755112315580060033, 32) => 113735138843678123
-bit_rotl_u64(11163782031541429823, 32) => 282150350032320668
-bit_rotr_u64(11163782031541429823, 32) => 282150350032320668
-bit_rotl_u64(13903686156871869732, 32) => 1215168314246156517
-bit_rotr_u64(13903686156871869732, 32) => 1215168314246156517
-bit_rotl_u64(14237897302422917095, 32) => 3704509656615824425
-bit_rotr_u64(14237897302422917095, 32) => 3704509656615824425
-bit_rotl_u64(14302190498657618739, 32) => 8535529879519336059
-bit_rotr_u64(14302190498657618739, 32) => 8535529879519336059
-bit_rotl_u64(15766411510232741269, 32) => 724364401557998524
-bit_rotr_u64(15766411510232741269, 32) => 724364401557998524
-bit_rotl_u64(15984546468465238145, 32) => 14166178738782635090
-bit_rotr_u64(15984546468465238145, 32) => 14166178738782635090
-bit_rotl_u64(18446744073709551615, 32) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 32) => 18446744073709551615
-bit_rotl_u64(0, 63) => 0
-bit_rotr_u64(0, 63) => 0
-bit_rotl_u64(1, 63) => 9223372036854775808
-bit_rotr_u64(1, 63) => 2
-bit_rotl_u64(2, 63) => 1
-bit_rotr_u64(2, 63) => 4
-bit_rotl_u64(32768, 63) => 16384
-bit_rotr_u64(32768, 63) => 65536
-bit_rotl_u64(65535, 63) => 9223372036854808575
-bit_rotr_u64(65535, 63) => 131070
-bit_rotl_u64(65536, 63) => 32768
-bit_rotr_u64(65536, 63) => 131072
-bit_rotl_u64(726075912, 63) => 363037956
-bit_rotr_u64(726075912, 63) => 1452151824
-bit_rotl_u64(858993459, 63) => 9223372037284272537
-bit_rotr_u64(858993459, 63) => 1717986918
-bit_rotl_u64(1073741824, 63) => 536870912
-bit_rotr_u64(1073741824, 63) => 2147483648
-bit_rotl_u64(1245250552, 63) => 622625276
-bit_rotr_u64(1245250552, 63) => 2490501104
-bit_rotl_u64(1431655765, 63) => 9223372037570603690
-bit_rotr_u64(1431655765, 63) => 2863311530
-bit_rotl_u64(1656977767, 63) => 9223372037683264691
-bit_rotr_u64(1656977767, 63) => 3313955534
-bit_rotl_u64(2147483648, 63) => 1073741824
-bit_rotr_u64(2147483648, 63) => 4294967296
-bit_rotl_u64(2283114629, 63) => 9223372037996333122
-bit_rotr_u64(2283114629, 63) => 4566229258
-bit_rotl_u64(2502548245, 63) => 9223372038106049930
-bit_rotr_u64(2502548245, 63) => 5005096490
-bit_rotl_u64(4294967295, 63) => 9223372039002259455
-bit_rotr_u64(4294967295, 63) => 8589934590
-bit_rotl_u64(708915120906848425, 63) => 9577829597308200020
-bit_rotr_u64(708915120906848425, 63) => 1417830241813696850
-bit_rotl_u64(1960191741125985428, 63) => 980095870562992714
-bit_rotr_u64(1960191741125985428, 63) => 3920383482251970856
-bit_rotl_u64(3689348814741910323, 63) => 11068046444225730969
-bit_rotr_u64(3689348814741910323, 63) => 7378697629483820646
-bit_rotl_u64(5578377670650038654, 63) => 2789188835325019327
-bit_rotr_u64(5578377670650038654, 63) => 11156755341300077308
-bit_rotl_u64(9223372036854775808, 63) => 4611686018427387904
-bit_rotr_u64(9223372036854775808, 63) => 1
-bit_rotl_u64(10755112315580060033, 63) => 14600928194644805824
-bit_rotr_u64(10755112315580060033, 63) => 3063480557450568451
-bit_rotl_u64(11163782031541429823, 63) => 14805263052625490719
-bit_rotr_u64(11163782031541429823, 63) => 3880819989373308031
-bit_rotl_u64(13903686156871869732, 63) => 6951843078435934866
-bit_rotr_u64(13903686156871869732, 63) => 9360628240034187849
-bit_rotl_u64(14237897302422917095, 63) => 16342320688066234355
-bit_rotr_u64(14237897302422917095, 63) => 10029050531136282575
-bit_rotl_u64(14302190498657618739, 63) => 16374467286183585177
-bit_rotr_u64(14302190498657618739, 63) => 10157636923605685863
-bit_rotl_u64(15766411510232741269, 63) => 17106577791971146442
-bit_rotr_u64(15766411510232741269, 63) => 13086078946755930923
-bit_rotl_u64(15984546468465238145, 63) => 17215645271087394880
-bit_rotr_u64(15984546468465238145, 63) => 13522348863220924675
-bit_rotl_u64(18446744073709551615, 63) => 18446744073709551615
-bit_rotr_u64(18446744073709551615, 63) => 18446744073709551615
-	*** test_rotl_rotr: done ***
-	*** test_bswap ***
-bswap_u64(0) => 0
-bswap_u32(0) => 0
-bswap_u64(1) => 72057594037927936
-bswap_u32(1) => 16777216
-bswap_u64(2) => 144115188075855872
-bswap_u32(2) => 33554432
-bswap_u64(32768) => 36028797018963968
-bswap_u32(32768) => 8388608
-bswap_u64(65535) => 18446462598732840960
-bswap_u32(65535) => 4294901760
-bswap_u64(65536) => 1099511627776
-bswap_u32(65536) => 256
-bswap_u64(726075912) => 579353752079695872
-bswap_u32(726075912) => 134891307
-bswap_u64(858993459) => 3689348813882916864
-bswap_u32(858993459) => 858993459
-bswap_u64(1073741824) => 274877906944
-bswap_u32(1073741824) => 64
-bswap_u64(1245250552) => 17871190736326623232
-bswap_u32(1245250552) => 4160960842
-bswap_u64(1431655765) => 6148914689804861440
-bswap_u32(1431655765) => 1431655765
-bswap_u64(1656977767) => 7456205483762778112
-bswap_u32(1656977767) => 1736033122
-bswap_u64(2147483648) => 549755813888
-bswap_u32(2147483648) => 128
-bswap_u64(2283114629) => 9624216077550485504
-bswap_u32(2283114629) => 2240812424
-bswap_u64(2502548245) => 1574898214622986240
-bswap_u32(2502548245) => 366684565
-bswap_u64(4294967295) => 18446744069414584320
-bswap_u32(4294967295) => 4294967295
-bswap_u64(708915120906848425) => 12198156707273299465
-bswap_u64(1960191741125985428) => 10665782605024080923
-bswap_u64(3689348814741910323) => 3689348814741910323
-bswap_u64(5578377670650038654) => 9081809480708024909
-bswap_u64(9223372036854775808) => 128
-bswap_u64(10755112315580060033) => 9300377440395542933
-bswap_u64(11163782031541429823) => 4568596173249113498
-bswap_u64(13903686156871869732) => 2604731024148591552
-bswap_u64(14237897302422917095) => 16649642015867049925
-bswap_u64(14302190498657618739) => 3696175971416046534
-bswap_u64(15766411510232741269) => 10769528423690522074
-bswap_u64(15984546468465238145) => 9322619197622375645
-bswap_u64(18446744073709551615) => 18446744073709551615
-	*** test_bswap: done ***
-	*** test_index ***
-bit_index_u64(0, *, -1) => 
-bit_index_u32(0, *, -1) => 
-bit_index_u64(1, *, -1) => 0 
-bit_index_u32(1, *, -1) => 0 
-bit_index_u64(2, *, -1) => 1 
-bit_index_u32(2, *, -1) => 1 
-bit_index_u64(32768, *, -1) => 15 
-bit_index_u32(32768, *, -1) => 15 
-bit_index_u64(65535, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
-bit_index_u32(65535, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
-bit_index_u64(65536, *, -1) => 16 
-bit_index_u32(65536, *, -1) => 16 
-bit_index_u64(726075912, *, -1) => 3 9 11 16 17 18 22 24 25 27 29 
-bit_index_u32(726075912, *, -1) => 3 9 11 16 17 18 22 24 25 27 29 
-bit_index_u64(858993459, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 
-bit_index_u32(858993459, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 
-bit_index_u64(1073741824, *, -1) => 30 
-bit_index_u32(1073741824, *, -1) => 30 
-bit_index_u64(1245250552, *, -1) => 3 4 5 6 7 8 9 16 19 20 21 25 27 30 
-bit_index_u32(1245250552, *, -1) => 3 4 5 6 7 8 9 16 19 20 21 25 27 30 
-bit_index_u64(1431655765, *, -1) => 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 
-bit_index_u32(1431655765, *, -1) => 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 
-bit_index_u64(1656977767, *, -1) => 0 1 2 5 6 8 11 12 13 14 16 17 22 23 25 29 30 
-bit_index_u32(1656977767, *, -1) => 0 1 2 5 6 8 11 12 13 14 16 17 22 23 25 29 30 
-bit_index_u64(2147483648, *, -1) => 31 
-bit_index_u32(2147483648, *, -1) => 31 
-bit_index_u64(2283114629, *, -1) => 0 2 7 12 15 16 18 20 27 31 
-bit_index_u32(2283114629, *, -1) => 0 2 7 12 15 16 18 20 27 31 
-bit_index_u64(2502548245, *, -1) => 0 2 4 8 9 11 12 14 15 16 19 21 24 26 28 31 
-bit_index_u32(2502548245, *, -1) => 0 2 4 8 9 11 12 14 15 16 19 21 24 26 28 31 
-bit_index_u64(4294967295, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
-bit_index_u32(4294967295, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
-bit_index_u64(708915120906848425, *, -1) => 0 3 5 7 11 14 17 18 19 23 24 26 29 30 31 32 33 35 39 41 44 47 49 50 52 54 55 56 59 
-bit_index_u64(1960191741125985428, *, -1) => 2 4 7 10 19 20 21 22 24 26 30 31 50 52 53 56 57 59 60 
-bit_index_u64(3689348814741910323, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 
-bit_index_u64(5578377670650038654, *, -1) => 1 2 3 4 5 6 8 11 16 20 25 27 28 31 32 33 34 35 37 38 39 45 46 49 51 53 54 56 58 59 62 
-bit_index_u64(9223372036854775808, *, -1) => 63 
-bit_index_u64(10755112315580060033, *, -1) => 0 7 8 12 18 20 23 24 32 33 35 37 39 40 42 44 46 47 48 54 56 58 60 63 
-bit_index_u64(11163782031541429823, *, -1) => 0 1 2 3 4 5 9 10 13 14 17 19 21 22 23 24 25 34 35 36 39 43 44 45 47 48 50 51 53 54 55 57 59 60 63 
-bit_index_u64(13903686156871869732, *, -1) => 2 5 8 10 13 16 18 19 20 22 23 28 32 34 37 38 39 44 46 47 48 49 52 53 54 55 62 63 
-bit_index_u64(14237897302422917095, *, -1) => 0 1 2 5 6 7 8 9 10 11 16 19 21 22 24 25 28 29 32 35 37 42 43 45 48 49 50 52 55 56 58 62 63 
-bit_index_u64(14302190498657618739, *, -1) => 0 1 4 5 8 9 11 14 18 20 21 22 25 26 28 29 30 32 33 35 36 37 38 41 42 44 47 48 49 51 52 53 54 57 58 62 63 
-bit_index_u64(15766411510232741269, *, -1) => 0 2 4 7 8 10 12 13 14 16 18 19 25 27 34 35 36 37 39 40 41 43 47 48 50 51 54 55 57 59 60 62 63 
-bit_index_u64(15984546468465238145, *, -1) => 0 7 13 14 19 20 23 26 30 31 33 36 38 42 47 50 52 54 55 56 58 59 60 62 63 
-bit_index_u64(18446744073709551615, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 
-	*** test_index: done ***
-	*** test_bit_iter ***
-Set: 3, 9, 11, 16, 17, 18, 22, 24, 25, 27, 29, 64, 65, 68, 69, 72, 73, 76, 77, 
-Clear: 0, 1, 2, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 19, 20, 21, 23, 26, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 66, 67, 70, 71, 74, 75, 78, 79, 
-	*** test_bit_iter: done ***
-	*** test_bit_iter_empty ***
-	*** test_bit_iter_empty: done ***
-	*** test_bitmap_size ***
-	*** test_bitmap_size: done ***
diff --git a/test/unit/bitset_basic.c b/test/unit/bitset_basic.c
index fe4b6ab07..2befe6ff8 100644
--- a/test/unit/bitset_basic.c
+++ b/test/unit/bitset_basic.c
@@ -92,7 +92,7 @@ void test_get_set()
 	const size_t NUM_SIZE = (size_t) 1 << 14;
 	size_t *nums = malloc(NUM_SIZE * sizeof(size_t));
 
-	printf("Generating test set... ");
+	note("Generating test set... ");
 	for(size_t i = 0; i < NUM_SIZE; i++) {
 		nums[i] = rand();
 	}
@@ -107,26 +107,23 @@ void test_get_set()
 		}
 	}
 	shuffle(nums, NUM_SIZE);
-	printf("ok\n");
 
-	printf("Settings bits... ");
+	note("Settings bits... ");
 	for(size_t i = 0; i < NUM_SIZE; i++) {
 		if (nums[i] == SIZE_MAX)
 			continue;
 		fail_if(tt_bitset_set(&bm, nums[i]) < 0);
 	}
-	printf("ok\n");
 
-	printf("Checking bits... ");
+	note("Checking bits... ");
 	shuffle(nums, NUM_SIZE);
 	for(size_t i = 0; i < NUM_SIZE; i++) {
 		if (nums[i] == SIZE_MAX)
 			continue;
 		fail_unless(tt_bitset_test(&bm, nums[i]));
 	}
-	printf("ok\n");
 
-	printf("Unsetting random bits... ");
+	note("Unsetting random bits... ");
 	for(size_t k = 0; k < (NUM_SIZE >> 3); k++) {
 		size_t i = rand() % NUM_SIZE;
 		if (nums[i] == SIZE_MAX)
@@ -135,23 +132,19 @@ void test_get_set()
 		fail_if(tt_bitset_test(&bm, nums[i]));
 		nums[i] = SIZE_MAX;
 	}
-	printf("ok\n");
 
-	printf("Checking set bits... ");
+	note("Checking set bits... ");
 	shuffle(nums, NUM_SIZE);
 	for(size_t i = 0; i < NUM_SIZE; i++) {
 		if (nums[i] == SIZE_MAX) {
 			continue;
 		}
 
-		if (!tt_bitset_test(&bm, nums[i])) {
-			printf("Fail :%zu\n", nums[i]);
-		}
+		fail_if(!tt_bitset_test(&bm, nums[i]));
 		fail_unless(tt_bitset_test(&bm, nums[i]));
 	}
-	printf("ok\n");
 
-	printf("Checking all bits... ");
+	note("Checking all bits... ");
 	qsort(nums, NUM_SIZE, sizeof(size_t), size_compator);
 
 	size_t *pn = nums;
@@ -166,10 +159,8 @@ void test_get_set()
 			fail_if(tt_bitset_test(&bm, i));
 		}
 	}
-	printf("ok\n");
-
 
-	printf("Unsetting all bits... ");
+	note("Unsetting all bits... ");
 	shuffle(nums, NUM_SIZE);
 	for(size_t i = 0; i < NUM_SIZE; i++) {
 		if (nums[i] == SIZE_MAX) {
@@ -178,14 +169,11 @@ void test_get_set()
 
 		fail_if(tt_bitset_clear(&bm, nums[i]) < 0);
 	}
-	printf("ok\n");
-
 
-	printf("Checking all bits... ");
+	note("Checking all bits... ");
 	for(size_t i = 0; i < i_max; i++) {
 		fail_if(tt_bitset_test(&bm, i));
 	}
-	printf("ok\n");
 
 	free(nums);
 
@@ -196,10 +184,12 @@ void test_get_set()
 
 int main(int argc, char *argv[])
 {
+	plan(0);
 	setbuf(stdout, NULL);
 	srand(time(NULL));
 	test_cardinality();
 	test_get_set();
+	check_plan();
 
 	return 0;
 }
diff --git a/test/unit/bitset_basic.result b/test/unit/bitset_basic.result
deleted file mode 100644
index 54f0ae724..000000000
--- a/test/unit/bitset_basic.result
+++ /dev/null
@@ -1,12 +0,0 @@
-	*** test_cardinality ***
-	*** test_cardinality: done ***
-	*** test_get_set ***
-Generating test set... ok
-Settings bits... ok
-Checking bits... ok
-Unsetting random bits... ok
-Checking set bits... ok
-Checking all bits... ok
-Unsetting all bits... ok
-Checking all bits... ok
-	*** test_get_set: done ***
diff --git a/test/unit/bitset_index.c b/test/unit/bitset_index.c
index c077fae49..8f9363e71 100644
--- a/test/unit/bitset_index.c
+++ b/test/unit/bitset_index.c
@@ -73,7 +73,7 @@ void check_keys(struct tt_bitset_index *index,
 	struct tt_bitset_expr expr;
 	tt_bitset_expr_create(&expr, realloc);
 
-	printf("Checking keys... ");
+	note("Checking keys... ");
 	for (size_t i = 0; i < size; i++) {
 		/* ignore removed keys */
 		if (keys[i] == SIZE_MAX) {
@@ -97,7 +97,6 @@ void check_keys(struct tt_bitset_index *index,
 		}
 		fail_unless(pair_found);
 	}
-	printf("ok\n");
 
 	tt_bitset_iterator_destroy(&it);
 	tt_bitset_expr_destroy(&expr);
@@ -117,36 +116,33 @@ void test_insert_remove(void)
 
 	size_t count0 = 0;
 	size_t count1 = 0;
-	printf("Generating test set... ");
+	note("Generating test set... ");
 	for(size_t i = 0; i < NUMS_SIZE; i++) {
 		keys[i] = rand();
 		values[i] = rand();
 		count0 += (keys[i] & 1) != 0 ? 1 : 0;
 		count1 += (keys[i] & 2) != 0 ? 1 : 0;
 	}
-	printf("ok\n");
 
-	printf("Inserting pairs... ");
+	note("Inserting pairs... ");
 	for(size_t i = 0; i < NUMS_SIZE; i++) {
 		tt_bitset_index_insert(&index, &keys[i], sizeof(keys[i]),
 				       values[i]);
 
 	}
-	printf("ok\n");
 
 	check_keys(&index, keys, values, NUMS_SIZE);
 
 	fail_unless(tt_bitset_index_count(&index, 0) == count0);
 	fail_unless(tt_bitset_index_count(&index, 1) == count1);
 
-	printf("Removing random pairs... ");
+	note("Removing random pairs... ");
 	for(size_t i = 0; i < NUMS_SIZE; i++) {
 		if (rand() % 5 == 0) {
 			tt_bitset_index_remove_value(&index, values[i]);
 			keys[i] = SIZE_MAX;
 		}
 	}
-	printf("ok\n");
 
 	check_keys(&index, keys, values, NUMS_SIZE);
 
@@ -291,6 +287,7 @@ void test_equals_simple(void)
 int main(void)
 {
 	setbuf(stdout, NULL);
+	plan(0);
 
 	test_size_and_count();
 	test_resize();
diff --git a/test/unit/bitset_index.result b/test/unit/bitset_index.result
deleted file mode 100644
index c358cfbc4..000000000
--- a/test/unit/bitset_index.result
+++ /dev/null
@@ -1,21 +0,0 @@
-	*** test_size_and_count ***
-	*** test_size_and_count: done ***
-	*** test_resize ***
-	*** test_resize: done ***
-	*** test_insert_remove ***
-Generating test set... ok
-Inserting pairs... ok
-Checking keys... ok
-Removing random pairs... ok
-Checking keys... ok
-	*** test_insert_remove: done ***
-	*** test_empty_simple ***
-	*** test_empty_simple: done ***
-	*** test_all_simple ***
-	*** test_all_simple: done ***
-	*** test_all_set_simple ***
-	*** test_all_set_simple: done ***
-	*** test_any_set_simple ***
-	*** test_any_set_simple: done ***
-	*** test_equals_simple ***
-	*** test_equals_simple: done ***
diff --git a/test/unit/bitset_iterator.c b/test/unit/bitset_iterator.c
index 04f2f9f72..2d7f61f28 100644
--- a/test/unit/bitset_iterator.c
+++ b/test/unit/bitset_iterator.c
@@ -482,6 +482,7 @@ int main(void)
 	setbuf(stdout, NULL);
 	nums_fill(NUMS, NUMS_SIZE);
 
+	plan(0);
 	test_empty_expr();
 	test_empty_expr_conj1();
 	test_empty_expr_conj2();
@@ -492,6 +493,7 @@ int main(void)
 	test_not_empty();
 	test_not_last();
 	test_disjunction();
+	check_plan();
 
 	return 0;
 }
diff --git a/test/unit/bitset_iterator.result b/test/unit/bitset_iterator.result
deleted file mode 100644
index 1f8369d74..000000000
--- a/test/unit/bitset_iterator.result
+++ /dev/null
@@ -1,22 +0,0 @@
-	*** test_empty_expr ***
-	*** test_empty_expr: done ***
-	*** test_empty_expr_conj1 ***
-	*** test_empty_expr_conj1: done ***
-	*** test_empty_expr_conj2 ***
-	*** test_empty_expr_conj2: done ***
-	*** test_empty_result ***
-	*** test_empty_result: done ***
-	*** test_first_result ***
-	*** test_first_result: done ***
-	*** test_simple ***
-	*** test_simple: done ***
-	*** test_big ***
-Setting bits... ok
-Iterating... ok
-	*** test_big: done ***
-	*** test_not_empty ***
-	*** test_not_empty: done ***
-	*** test_not_last ***
-	*** test_not_last: done ***
-	*** test_disjunction ***
-	*** test_disjunction: done ***
diff --git a/test/unit/bloom.cc b/test/unit/bloom.cc
index 2e5b99412..ebd5d18d8 100644
--- a/test/unit/bloom.cc
+++ b/test/unit/bloom.cc
@@ -2,6 +2,7 @@
 #include <unordered_set>
 #include <vector>
 #include <iostream>
+#include "unit.h"
 
 using namespace std;
 
@@ -13,7 +14,7 @@ uint32_t h(uint32_t i)
 void
 simple_test()
 {
-	cout << "*** " << __func__ << " ***" << endl;
+	note(__func__);
 	srand(time(0));
 	uint32_t error_count = 0;
 	uint32_t fp_rate_too_big = 0;
@@ -45,14 +46,13 @@ simple_test()
 		if (fp_rate > p + 0.001)
 			fp_rate_too_big++;
 	}
-	cout << "error_count = " << error_count << endl;
-	cout << "fp_rate_too_big = " << fp_rate_too_big << endl;
+	note("error_count = %d", error_count);
+	note("fp_rate_too_big = %d", fp_rate_too_big);
 }
 
 void
 store_load_test()
 {
-	cout << "*** " << __func__ << " ***" << endl;
 	srand(time(0));
 	uint32_t error_count = 0;
 	uint32_t fp_rate_too_big = 0;
@@ -92,13 +92,15 @@ store_load_test()
 		if (fp_rate > p + 0.001)
 			fp_rate_too_big++;
 	}
-	cout << "error_count = " << error_count << endl;
-	cout << "fp_rate_too_big = " << fp_rate_too_big << endl;
+	note("error_count = %d", error_count);
+	note("fp_rate_too_big = %d", fp_rate_too_big);
 }
 
 int
 main(void)
 {
+	plan(0);
 	simple_test();
 	store_load_test();
+	check_plan();
 }
diff --git a/test/unit/bloom.result b/test/unit/bloom.result
deleted file mode 100644
index 91193a618..000000000
--- a/test/unit/bloom.result
+++ /dev/null
@@ -1,6 +0,0 @@
-*** simple_test ***
-error_count = 0
-fp_rate_too_big = 0
-*** store_load_test ***
-error_count = 0
-fp_rate_too_big = 0
diff --git a/test/unit/bps_tree.cc b/test/unit/bps_tree.cc
index ef374deb1..ecfb317c2 100644
--- a/test/unit/bps_tree.cc
+++ b/test/unit/bps_tree.cc
@@ -124,9 +124,9 @@ static int compare_key(const elem_t &a, long b)
 		type_t check_value =\
 			*tree_name##_iterator_get_elem((tree), &iter);\
 		if (check_value != (type_t)(elem)) {\
-			printf("iterator doesn't point to the inserted "\
-			       "element: %lld != %lld", (long long) (elem),\
-			       (long long) check_value);\
+			diag("iterator doesn't point to the inserted "\
+			     "element: %lld != %lld", (long long) (elem),\
+			     (long long) check_value);\
 			fail("elem != check_value", "true");\
 		}\
 	}\
@@ -173,7 +173,7 @@ simple_check()
 	test tree;
 	test_create(&tree, 0, extent_alloc, extent_free, &extents_count);
 
-	printf("Insert 1..X, remove 1..X\n");
+	note("Insert 1..X, remove 1..X");
 	for (unsigned int i = 0; i < rounds; i++) {
 		type_t v = i;
 		if (test_find(&tree, v) != NULL)
@@ -200,7 +200,7 @@ simple_check()
 	if (test_size(&tree) != 0)
 		fail("Tree count mismatch (2)", "true");
 
-	printf("Insert 1..X, remove X..1\n");
+	note("Insert 1..X, remove X..1");
 	for (unsigned int i = 0; i < rounds; i++) {
 		type_t v = i;
 		if (test_find(&tree, v) != NULL)
@@ -227,7 +227,7 @@ simple_check()
 	if (test_size(&tree) != 0)
 		fail("Tree count mismatch (4)", "true");
 
-	printf("Insert X..1, remove 1..X\n");
+	note("Insert X..1, remove 1..X");
 	for (unsigned int i = 0; i < rounds; i++) {
 		type_t v = rounds - 1 - i;
 		if (test_find(&tree, v) != NULL)
@@ -254,7 +254,7 @@ simple_check()
 	if (test_size(&tree) != 0)
 		fail("Tree count mismatch (6)", "true");
 
-	printf("Insert X..1, remove X..1\n");
+	note("Insert X..1, remove X..1");
 	for (unsigned int i = 0; i < rounds; i++) {
 		type_t v = rounds - 1 - i;
 		if (test_find(&tree, v) != NULL)
@@ -581,7 +581,7 @@ bps_tree_debug_self_check()
 
 	int res = test_debug_check_internal_functions(false);
 	if (res)
-		printf("self test returned error %d\n", res);
+		note("self test returned error %d", res);
 
 	test_debug_check_internal_functions(true);
 
@@ -639,11 +639,11 @@ printing_test()
 
 	for (type_t i = 0; i < rounds; i++) {
 		type_t v = rounds + i;
-		printf("Inserting " TYPE_F "\n", v);
+		note("Inserting " TYPE_F, v);
 		test_insert(&tree, v, 0);
 		test_print(&tree, TYPE_F);
 		v = rounds - i - 1;
-		printf("Inserting " TYPE_F "\n", v);
+		note("Inserting " TYPE_F, v);
 		test_insert(&tree, v, 0);
 		test_print(&tree, TYPE_F);
 	}
@@ -664,33 +664,33 @@ white_box_test()
 	assert(BPS_TREE_test_MAX_COUNT_IN_LEAF == 14);
 	assert(BPS_TREE_test_MAX_COUNT_IN_INNER == 10);
 
-	printf("full leaf:\n");
+	note("full leaf:");
 	for (type_t i = 0; i < 14; i++) {
 		test_insert(&tree, i, 0);
 	}
 	test_print(&tree, TYPE_F);
 
-	printf("split now:\n");
+	note("split now:");
 	test_insert(&tree, 14, 0);
 	test_print(&tree, TYPE_F);
 
-	printf("full 2 leafs:\n");
+	note("full 2 leafs:");
 	for (type_t i = 15; i < 28; i++) {
 		test_insert(&tree, i, 0);
 	}
 	test_print(&tree, TYPE_F);
 
-	printf("split now:\n");
+	note("split now:");
 	test_insert(&tree, 28, 0);
 	test_print(&tree, TYPE_F);
 
-	printf("full 3 leafs:\n");
+	note("full 3 leafs:");
 	for (type_t i = 29; i < 42; i++) {
 		test_insert(&tree, i, 0);
 	}
 	test_print(&tree, TYPE_F);
 
-	printf("split now:\n");
+	note("split now:");
 	test_insert(&tree, 42, 0);
 	test_print(&tree, TYPE_F);
 
@@ -700,10 +700,10 @@ white_box_test()
 	for (type_t i = 0; i < 140; i++)
 		arr[i] = i;
 	test_build(&tree, arr, 140);
-	printf("full 10 leafs:\n");
+	note("full 10 leafs:");
 	test_print(&tree, TYPE_F);
 
-	printf("2-level split now:\n");
+	note("2-level split now:");
 	test_insert(&tree, 140, 0);
 	test_print(&tree, TYPE_F);
 
@@ -749,7 +749,7 @@ approximate_count()
 	for (uint64_t i = 1; i <= long_sequence_count; i++)
 		for (uint64_t j = 0; j < i * long_sequence_multiplier; j++)
 			arr[count++] = ((i * 100 + 50) << 32) | j;
-	printf("Count: %llu %u\n", (unsigned long long)count, arr_size);
+	note("Count: %llu %u", (unsigned long long)count, arr_size);
 	assert(count == arr_size);
 
 	for (uint64_t i = 0; i < count * 10; i++) {
@@ -763,7 +763,7 @@ approximate_count()
 	for (uint64_t i = 0; i < count; i++)
 		approx_insert(&tree, arr[i], NULL);
 
-	printf("Count: %zu\n", tree.size);
+	note("Count: %zu", tree.size);
 
 	count = 0;
 	int err_count = 0;
@@ -788,9 +788,9 @@ approximate_count()
 			if (approx_count != true_count) {
 				err_count++;
 				if (err_count <= 10)
-					printf("searching %u found %llu expected %llu\n",
-					       i, (unsigned long long)approx_count,
-					       (unsigned long long)true_count);
+					diag("searching %u found %llu expected %llu\n",
+					     i, (unsigned long long)approx_count,
+					     (unsigned long long)true_count);
 			}
 			continue;
 		}
@@ -802,14 +802,14 @@ approximate_count()
 		if (true_count < low || true_count > up) {
 			err_count++;
 			if (err_count <= 10)
-				printf("searching %u found %llu expected %llu\n",
-				       i, (unsigned long long)approx_count,
-				       (unsigned long long)true_count);
+				diag("searching %u found %llu expected %llu\n",
+				     i, (unsigned long long)approx_count,
+				     (unsigned long long)true_count);
 		}
 	};
 
-	printf("Error count: %d\n", err_count);
-	printf("Count: %llu\n", (unsigned long long)count);
+	note("Error count: %d", err_count);
+	note("Count: %llu", (unsigned long long)count);
 
 	approx_destroy(&tree);
 
@@ -861,6 +861,7 @@ delete_value_check()
 int
 main(void)
 {
+	plan(0);
 	simple_check();
 	compare_with_sptree_check();
 	compare_with_sptree_check_branches();
@@ -873,4 +874,5 @@ main(void)
 		fail("memory leak!", "true");
 	insert_get_iterator();
 	delete_value_check();
+	check_plan();
 }
diff --git a/test/unit/bps_tree.result b/test/unit/bps_tree.result
deleted file mode 100644
index 130ec555c..000000000
--- a/test/unit/bps_tree.result
+++ /dev/null
@@ -1,284 +0,0 @@
-	*** simple_check ***
-Insert 1..X, remove 1..X
-Insert 1..X, remove X..1
-Insert X..1, remove 1..X
-Insert X..1, remove X..1
-	*** simple_check: done ***
-	*** compare_with_sptree_check ***
-	*** compare_with_sptree_check: done ***
-	*** compare_with_sptree_check_branches ***
-	*** compare_with_sptree_check_branches: done ***
-	*** bps_tree_debug_self_check ***
-	*** bps_tree_debug_self_check: done ***
-	*** loading_test ***
-	*** loading_test: done ***
-	*** printing_test ***
-Inserting 22
-[(1) 22]
-Inserting 21
-[(2) 21 22]
-Inserting 23
-[(3) 21 22 23]
-Inserting 20
-[(4) 20 21 22 23]
-Inserting 24
-[(5) 20 21 22 23 24]
-Inserting 19
-[(6) 19 20 21 22 23 24]
-Inserting 25
-[(7) 19 20 21 22 23 24 25]
-Inserting 18
-[(8) 18 19 20 21 22 23 24 25]
-Inserting 26
-[(9) 18 19 20 21 22 23 24 25 26]
-Inserting 17
-[(10) 17 18 19 20 21 22 23 24 25 26]
-Inserting 27
-[(11) 17 18 19 20 21 22 23 24 25 26 27]
-Inserting 16
-[(12) 16 17 18 19 20 21 22 23 24 25 26 27]
-Inserting 28
-[(13) 16 17 18 19 20 21 22 23 24 25 26 27 28]
-Inserting 15
-[(14) 15 16 17 18 19 20 21 22 23 24 25 26 27 28]
-Inserting 29
-  [(8) 15 16 17 18 19 20 21 22]
-22
-  [(7) 23 24 25 26 27 28 29]
-Inserting 14
-  [(9) 14 15 16 17 18 19 20 21 22]
-22
-  [(7) 23 24 25 26 27 28 29]
-Inserting 30
-  [(9) 14 15 16 17 18 19 20 21 22]
-22
-  [(8) 23 24 25 26 27 28 29 30]
-Inserting 13
-  [(10) 13 14 15 16 17 18 19 20 21 22]
-22
-  [(8) 23 24 25 26 27 28 29 30]
-Inserting 31
-  [(10) 13 14 15 16 17 18 19 20 21 22]
-22
-  [(9) 23 24 25 26 27 28 29 30 31]
-Inserting 12
-  [(11) 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(9) 23 24 25 26 27 28 29 30 31]
-Inserting 32
-  [(11) 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(10) 23 24 25 26 27 28 29 30 31 32]
-Inserting 11
-  [(12) 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(10) 23 24 25 26 27 28 29 30 31 32]
-Inserting 33
-  [(12) 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(11) 23 24 25 26 27 28 29 30 31 32 33]
-Inserting 10
-  [(13) 10 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(11) 23 24 25 26 27 28 29 30 31 32 33]
-Inserting 34
-  [(13) 10 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(12) 23 24 25 26 27 28 29 30 31 32 33 34]
-Inserting 9
-  [(14) 9 10 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(12) 23 24 25 26 27 28 29 30 31 32 33 34]
-Inserting 35
-  [(14) 9 10 11 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(13) 23 24 25 26 27 28 29 30 31 32 33 34 35]
-Inserting 8
-  [(14) 8 9 10 11 12 13 14 15 16 17 18 19 20 21]
-21
-  [(14) 22 23 24 25 26 27 28 29 30 31 32 33 34 35]
-Inserting 36
-  [(10) 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(9) 28 29 30 31 32 33 34 35 36]
-Inserting 7
-  [(11) 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(9) 28 29 30 31 32 33 34 35 36]
-Inserting 37
-  [(11) 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(10) 28 29 30 31 32 33 34 35 36 37]
-Inserting 6
-  [(12) 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(10) 28 29 30 31 32 33 34 35 36 37]
-Inserting 38
-  [(12) 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(11) 28 29 30 31 32 33 34 35 36 37 38]
-Inserting 5
-  [(13) 5 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(11) 28 29 30 31 32 33 34 35 36 37 38]
-Inserting 39
-  [(13) 5 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(12) 28 29 30 31 32 33 34 35 36 37 38 39]
-Inserting 4
-  [(14) 4 5 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(12) 28 29 30 31 32 33 34 35 36 37 38 39]
-Inserting 40
-  [(14) 4 5 6 7 8 9 10 11 12 13 14 15 16 17]
-17
-  [(10) 18 19 20 21 22 23 24 25 26 27]
-27
-  [(13) 28 29 30 31 32 33 34 35 36 37 38 39 40]
-Inserting 3
-  [(12) 3 4 5 6 7 8 9 10 11 12 13 14]
-14
-  [(13) 15 16 17 18 19 20 21 22 23 24 25 26 27]
-27
-  [(13) 28 29 30 31 32 33 34 35 36 37 38 39 40]
-Inserting 41
-  [(12) 3 4 5 6 7 8 9 10 11 12 13 14]
-14
-  [(13) 15 16 17 18 19 20 21 22 23 24 25 26 27]
-27
-  [(14) 28 29 30 31 32 33 34 35 36 37 38 39 40 41]
-Inserting 2
-  [(13) 2 3 4 5 6 7 8 9 10 11 12 13 14]
-14
-  [(13) 15 16 17 18 19 20 21 22 23 24 25 26 27]
-27
-  [(14) 28 29 30 31 32 33 34 35 36 37 38 39 40 41]
-Inserting 42
-  [(13) 2 3 4 5 6 7 8 9 10 11 12 13 14]
-14
-  [(14) 15 16 17 18 19 20 21 22 23 24 25 26 27 28]
-28
-  [(14) 29 30 31 32 33 34 35 36 37 38 39 40 41 42]
-Inserting 1
-  [(14) 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
-14
-  [(14) 15 16 17 18 19 20 21 22 23 24 25 26 27 28]
-28
-  [(14) 29 30 31 32 33 34 35 36 37 38 39 40 41 42]
-Inserting 43
-  [(11) 1 2 3 4 5 6 7 8 9 10 11]
-11
-  [(11) 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(11) 23 24 25 26 27 28 29 30 31 32 33]
-33
-  [(10) 34 35 36 37 38 39 40 41 42 43]
-Inserting 0
-  [(12) 0 1 2 3 4 5 6 7 8 9 10 11]
-11
-  [(11) 12 13 14 15 16 17 18 19 20 21 22]
-22
-  [(11) 23 24 25 26 27 28 29 30 31 32 33]
-33
-  [(10) 34 35 36 37 38 39 40 41 42 43]
-	*** printing_test: done ***
-	*** white_box_test ***
-full leaf:
-[(14) 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
-split now:
-  [(8) 0 1 2 3 4 5 6 7]
-7
-  [(7) 8 9 10 11 12 13 14]
-full 2 leafs:
-  [(14) 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
-13
-  [(14) 14 15 16 17 18 19 20 21 22 23 24 25 26 27]
-split now:
-  [(10) 0 1 2 3 4 5 6 7 8 9]
-9
-  [(10) 10 11 12 13 14 15 16 17 18 19]
-19
-  [(9) 20 21 22 23 24 25 26 27 28]
-full 3 leafs:
-  [(14) 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
-13
-  [(14) 14 15 16 17 18 19 20 21 22 23 24 25 26 27]
-27
-  [(14) 28 29 30 31 32 33 34 35 36 37 38 39 40 41]
-split now:
-  [(11) 0 1 2 3 4 5 6 7 8 9 10]
-10
-  [(11) 11 12 13 14 15 16 17 18 19 20 21]
-21
-  [(11) 22 23 24 25 26 27 28 29 30 31 32]
-32
-  [(10) 33 34 35 36 37 38 39 40 41 42]
-full 10 leafs:
-  [(14) 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
-13
-  [(14) 14 15 16 17 18 19 20 21 22 23 24 25 26 27]
-27
-  [(14) 28 29 30 31 32 33 34 35 36 37 38 39 40 41]
-41
-  [(14) 42 43 44 45 46 47 48 49 50 51 52 53 54 55]
-55
-  [(14) 56 57 58 59 60 61 62 63 64 65 66 67 68 69]
-69
-  [(14) 70 71 72 73 74 75 76 77 78 79 80 81 82 83]
-83
-  [(14) 84 85 86 87 88 89 90 91 92 93 94 95 96 97]
-97
-  [(14) 98 99 100 101 102 103 104 105 106 107 108 109 110 111]
-111
-  [(14) 112 113 114 115 116 117 118 119 120 121 122 123 124 125]
-125
-  [(14) 126 127 128 129 130 131 132 133 134 135 136 137 138 139]
-2-level split now:
-    [(14) 0 1 2 3 4 5 6 7 8 9 10 11 12 13]
-  13
-    [(14) 14 15 16 17 18 19 20 21 22 23 24 25 26 27]
-  27
-    [(14) 28 29 30 31 32 33 34 35 36 37 38 39 40 41]
-  41
-    [(14) 42 43 44 45 46 47 48 49 50 51 52 53 54 55]
-  55
-    [(14) 56 57 58 59 60 61 62 63 64 65 66 67 68 69]
-  69
-    [(14) 70 71 72 73 74 75 76 77 78 79 80 81 82 83]
-83
-    [(14) 84 85 86 87 88 89 90 91 92 93 94 95 96 97]
-  97
-    [(11) 98 99 100 101 102 103 104 105 106 107 108]
-  108
-    [(11) 109 110 111 112 113 114 115 116 117 118 119]
-  119
-    [(11) 120 121 122 123 124 125 126 127 128 129 130]
-  130
-    [(10) 131 132 133 134 135 136 137 138 139 140]
-	*** white_box_test: done ***
-	*** approximate_count ***
-Count: 10575 10575
-Count: 10575
-Error count: 0
-Count: 10575
-	*** approximate_count: done ***
-	*** insert_get_iterator ***
-	*** insert_get_iterator: done ***
-	*** delete_value_check ***
-	*** delete_value_check: done ***
diff --git a/test/unit/bps_tree_iterator.cc b/test/unit/bps_tree_iterator.cc
index 5c800bc69..b0b08d3c6 100644
--- a/test/unit/bps_tree_iterator.cc
+++ b/test/unit/bps_tree_iterator.cc
@@ -94,7 +94,7 @@ iterator_check()
 			test_insert(&tree, e, 0);
 		}
 	}
-	printf("Test tree size: %d\n", (int)test_size(&tree));
+	note("Test tree size: %d\n", (int)test_size(&tree));
 
 	/* Test that tree filled ok */
 	for (long i = 0; i < count1 * count2; i++) {
@@ -114,7 +114,6 @@ iterator_check()
 			printf("(%ld,%ld) ", elem->first, elem->second);
 			test_iterator_next(&tree, &iterator);
 		}
-		printf("\n");
 	}
 	/* Print last 7 elems */
 	{
@@ -125,7 +124,6 @@ iterator_check()
 			printf("(%ld,%ld) ", elem->first, elem->second);
 			test_iterator_prev(&tree, &iterator);
 		}
-		printf("\n");
 	}
 
 	/* Iterate forward all elements 5 times */
@@ -181,9 +179,9 @@ iterator_check()
 		if (has_this_key1 != has_this_key2)
 			fail("Exact flag is broken", "true");
 		printf("Key %ld, %s range [%s, %s): ", key,
-			has_this_key1 ? "not empty" : "empty",
-			test_iterator_is_invalid(&begin) ? "eof" : "ptr",
-			test_iterator_is_invalid(&end) ? "eof" : "ptr");
+		       has_this_key1 ? "not empty" : "empty",
+		       test_iterator_is_invalid(&begin) ? "eof" : "ptr",
+		       test_iterator_is_invalid(&end) ? "eof" : "ptr");
 		test_iterator runner = begin;
 		while (!test_iterator_are_equal(&tree, &runner, &end)) {
 			elem_t *elem = test_iterator_get_elem(&tree, &runner);
@@ -197,7 +195,6 @@ iterator_check()
 			elem_t *elem = test_iterator_get_elem(&tree, &runner);
 			printf("(%ld,%ld) ", elem->first, elem->second);
 		}
-		printf("\n");
 	}
 
 	/* Check iterating in range from lower bound to upper bound */
@@ -246,7 +243,6 @@ iterator_check()
 			elem_t *elem = test_iterator_get_elem(&tree, &runner);
 			printf("(%ld,%ld) ", elem->first, elem->second);
 		}
-		printf("\n");
 	}
 
 	/* Check iterating in range from lower bound to upper bound */
@@ -547,10 +543,10 @@ int
 main(void)
 {
 	srand(time(0));
+	plan(1);
 	iterator_check();
 	iterator_invalidate_check();
 	iterator_freeze_check();
-	if (total_extents_allocated) {
-		fail("memory leak", "true");
-	}
+	is(total_extents_allocated, 0, "memory leak");
+	check_plan();
 }
diff --git a/test/unit/bps_tree_iterator.result b/test/unit/bps_tree_iterator.result
deleted file mode 100644
index 8a2e97eec..000000000
--- a/test/unit/bps_tree_iterator.result
+++ /dev/null
@@ -1,21 +0,0 @@
-	*** iterator_check ***
-Test tree size: 50000
---> (0,0) (0,1) (0,2) (0,3) (0,4) (2,0) (2,1) 
-<-- (19998,4) (19998,3) (19998,2) (19998,1) (19998,0) (19996,4) (19996,3) 
-Key -1, empty range [ptr, ptr):  <-> 
-Key 0, not empty range [ptr, ptr): (0,0) (0,1) (0,2) (0,3) (0,4)  <-> (0,4) (0,3) (0,2) (0,1) (0,0) 
-Key 10, not empty range [ptr, ptr): (10,0) (10,1) (10,2) (10,3) (10,4)  <-> (10,4) (10,3) (10,2) (10,1) (10,0) 
-Key 15, empty range [ptr, ptr):  <-> 
-Key 19998, not empty range [ptr, eof): (19998,0) (19998,1) (19998,2) (19998,3) (19998,4)  <-> (19998,4) (19998,3) (19998,2) (19998,1) (19998,0) 
-Key 20000, empty range [eof, eof):  <-> 
-Key -1, range [ptr, ptr):  <-> 
-Key 0, range [ptr, ptr): (0,0) (0,1) (0,2) (0,3) (0,4)  <-> (0,4) (0,3) (0,2) (0,1) (0,0) 
-Key 10, range [ptr, ptr): (10,0) (10,1) (10,2) (10,3) (10,4)  <-> (10,4) (10,3) (10,2) (10,1) (10,0) 
-Key 15, range [ptr, ptr):  <-> 
-Key 19998, range [ptr, eof): (19998,0) (19998,1) (19998,2) (19998,3) (19998,4)  <-> (19998,4) (19998,3) (19998,2) (19998,1) (19998,0) 
-Key 20000, range [eof, eof):  <-> 
-	*** iterator_check: done ***
-	*** iterator_invalidate_check ***
-	*** iterator_invalidate_check: done ***
-	*** iterator_freeze_check ***
-	*** iterator_freeze_check: done ***
diff --git a/test/unit/cbus.c b/test/unit/cbus.c
index ecf5fce72..09225c586 100644
--- a/test/unit/cbus.c
+++ b/test/unit/cbus.c
@@ -49,7 +49,7 @@ flush_cb(struct trigger *t, void *e)
 	(void) t;
 	(void) e;
 	++flushed_cnt;
-	printf("flush event, counter = %d\n", flushed_cnt);
+	note("flush event, counter = %d", flushed_cnt);
 	return 0;
 }
 
@@ -59,7 +59,7 @@ finish_execution(struct cmsg *m)
 {
 	(void) m;
 	fiber_cancel(fiber());
-	printf("break main fiber and finish test\n");
+	note("break main fiber and finish test");
 	is(flushed_cnt, expected_flushed_cnt,
 	   "flushed_cnt at the end of the test");
 }
@@ -84,7 +84,7 @@ worker_f(va_list ap)
 static void
 worker_start()
 {
-	printf("start worker\n");
+	note("start worker");
 	fail_if(cord_costart(&worker, "worker", worker_f, NULL) != 0);
 	cpipe_create(&pipe_to_worker, "worker");
 }
@@ -92,7 +92,7 @@ worker_start()
 static void
 worker_stop()
 {
-	printf("finish worker\n");
+	note("finish worker");
 	cbus_stop_loop(&pipe_to_worker);
 	cpipe_destroy(&pipe_to_worker);
 	fail_if(cord_join(&worker) != 0);
@@ -126,7 +126,7 @@ test_forced_flush(struct cmsg *m)
 {
 	(void) m;
 	is(flushed_cnt, 1, "1 flush after test_several_messages");
-	printf("\n*** Test forced flush ***\n");
+	note("*** Test forced flush ***");
 	flushed_cnt = 0;
 	static struct cmsg_hop test_forced_flush_route =
 		{ do_forced_flush, NULL };
@@ -160,7 +160,7 @@ test_several_messages(struct cmsg *m)
 {
 	(void) m;
 	is(flushed_cnt, 1, "1 flush after test_single_msg");
-	printf("\n*** Test several messages ***\n");
+	note("*** Test several messages ***");
 	flushed_cnt = 0;
 	static struct cmsg_hop test_event_route[] = {
 		{ do_some_event, &pipe_to_main },
@@ -190,7 +190,7 @@ test_several_messages(struct cmsg *m)
 static void
 test_single_msg()
 {
-	printf("\n*** Test single message ***\n");
+	note("*** Test single message ***");
 	static struct cmsg_hop test_single_flush_route[] = {
 		{ do_nothing, &pipe_to_main },
 		/* Schedule the next test. */
@@ -231,13 +231,13 @@ main()
 	memory_init();
 	fiber_init(fiber_c_invoke);
 	cbus_init();
-	printf("start main fiber\n");
+	note("start main fiber");
 	struct fiber *main_fiber = fiber_new("main", main_f);
 	assert(main_fiber != NULL);
 	fiber_wakeup(main_fiber);
-	printf("start main loop\n");
+	note("start main loop");
 	ev_run(loop(), 0);
-	printf("finish main loop\n");
+	note("finish main loop");
 	cbus_free();
 	fiber_free();
 	memory_free();
diff --git a/test/unit/cbus.result b/test/unit/cbus.result
deleted file mode 100644
index e87f861f3..000000000
--- a/test/unit/cbus.result
+++ /dev/null
@@ -1,24 +0,0 @@
-	*** main ***
-1..6
-start main fiber
-start main loop
-start worker
-
-*** Test single message ***
-flush event, counter = 1
-ok 1 - 1 flush after test_single_msg
-
-*** Test several messages ***
-ok 2 - no flush during loop
-ok 3 - no flush during loop
-ok 4 - no flush during loop
-flush event, counter = 1
-ok 5 - 1 flush after test_several_messages
-
-*** Test forced flush ***
-flush event, counter = 1
-break main fiber and finish test
-ok 6 - flushed_cnt at the end of the test
-finish worker
-finish main loop
-	*** main: done ***
diff --git a/test/unit/cbus_hang.c b/test/unit/cbus_hang.c
index 8b3671001..eac283890 100644
--- a/test/unit/cbus_hang.c
+++ b/test/unit/cbus_hang.c
@@ -33,7 +33,7 @@ pthread_cond_t endpoint_hack_cond_2;
 static
 void join_fail(int signum) {
 	(void)signum;
-	printf("Can't join the hang worker\n");
+	diag("Can't join the hang worker\n");
 	exit(EXIT_FAILURE);
 }
 
diff --git a/test/unit/cbus_hang.result b/test/unit/cbus_hang.result
deleted file mode 100644
index d5810e8cf..000000000
--- a/test/unit/cbus_hang.result
+++ /dev/null
@@ -1,4 +0,0 @@
-	*** main ***
-1..1
-ok 1 - The hang worker has been joined
-	*** main: done ***
diff --git a/test/unit/cbus_stress.c b/test/unit/cbus_stress.c
index 37e8e0f77..15ac98e14 100644
--- a/test/unit/cbus_stress.c
+++ b/test/unit/cbus_stress.c
@@ -368,6 +368,7 @@ main()
 {
 	srand(time(NULL));
 
+	plan(0);
 	memory_init();
 	fiber_init(fiber_c_invoke);
 	cbus_init();
@@ -379,6 +380,7 @@ main()
 	fiber_wakeup(main_fiber);
 	ev_run(loop(), 0);
 
+	check_plan();
 	footer();
 
 	cbus_free();
diff --git a/test/unit/cbus_stress.result b/test/unit/cbus_stress.result
deleted file mode 100644
index 8300f0550..000000000
--- a/test/unit/cbus_stress.result
+++ /dev/null
@@ -1,2 +0,0 @@
-	*** main ***
-	*** main: done ***
diff --git a/test/unit/checkpoint_schedule.result b/test/unit/checkpoint_schedule.result
deleted file mode 100644
index e34c762a1..000000000
--- a/test/unit/checkpoint_schedule.result
+++ /dev/null
@@ -1,41 +0,0 @@
-	*** main ***
-1..38
-ok 1 - checkpointing disabled - timeout after configuration
-ok 2 - checkpointing disabled - timeout after sleep
-ok 3 - checkpointing disabled - timeout after reset
-ok 4 - checkpoint interval 100 - timeout after configuration
-ok 5 - checkpoint interval 100 - initial timeout randomization
-ok 6 - checkpoint interval 100 - timeout after sleep 1
-ok 7 - checkpoint interval 100 - timeout after sleep 2
-ok 8 - checkpoint interval 100 - timeout after sleep 3
-ok 9 - checkpoint interval 100 - timeout after sleep 4
-ok 10 - checkpoint interval 100 - timeout after reset
-ok 11 - checkpoint interval 600 - timeout after configuration
-ok 12 - checkpoint interval 600 - initial timeout randomization
-ok 13 - checkpoint interval 600 - timeout after sleep 1
-ok 14 - checkpoint interval 600 - timeout after sleep 2
-ok 15 - checkpoint interval 600 - timeout after sleep 3
-ok 16 - checkpoint interval 600 - timeout after sleep 4
-ok 17 - checkpoint interval 600 - timeout after reset
-ok 18 - checkpoint interval 1200 - timeout after configuration
-ok 19 - checkpoint interval 1200 - initial timeout randomization
-ok 20 - checkpoint interval 1200 - timeout after sleep 1
-ok 21 - checkpoint interval 1200 - timeout after sleep 2
-ok 22 - checkpoint interval 1200 - timeout after sleep 3
-ok 23 - checkpoint interval 1200 - timeout after sleep 4
-ok 24 - checkpoint interval 1200 - timeout after reset
-ok 25 - checkpoint interval 1800 - timeout after configuration
-ok 26 - checkpoint interval 1800 - initial timeout randomization
-ok 27 - checkpoint interval 1800 - timeout after sleep 1
-ok 28 - checkpoint interval 1800 - timeout after sleep 2
-ok 29 - checkpoint interval 1800 - timeout after sleep 3
-ok 30 - checkpoint interval 1800 - timeout after sleep 4
-ok 31 - checkpoint interval 1800 - timeout after reset
-ok 32 - checkpoint interval 3600 - timeout after configuration
-ok 33 - checkpoint interval 3600 - initial timeout randomization
-ok 34 - checkpoint interval 3600 - timeout after sleep 1
-ok 35 - checkpoint interval 3600 - timeout after sleep 2
-ok 36 - checkpoint interval 3600 - timeout after sleep 3
-ok 37 - checkpoint interval 3600 - timeout after sleep 4
-ok 38 - checkpoint interval 3600 - timeout after reset
-	*** main: done ***
diff --git a/test/unit/coio.result b/test/unit/coio.result
deleted file mode 100644
index 5019fa48a..000000000
--- a/test/unit/coio.result
+++ /dev/null
@@ -1,12 +0,0 @@
-	*** stat_timeout_test ***
-	*** stat_timeout_test: done ***
-	*** stat_notify_test ***
-# filename: 1.out
-	*** stat_notify_test: done ***
-	*** test_call_f ***
-# call done with res 0
-	*** test_call_f: done ***
-	*** test_getaddrinfo ***
-1..1
-ok 1 - getaddrinfo
-	*** test_getaddrinfo: done ***
diff --git a/test/unit/coll.cpp b/test/unit/coll.cpp
index 8d7a3ff1e..d5e9724af 100644
--- a/test/unit/coll.cpp
+++ b/test/unit/coll.cpp
@@ -30,12 +30,13 @@ void
 test_sort_strings(vector<const char *> &strings, struct coll *coll)
 {
 	sort(strings.begin(), strings.end(), comp(coll));
-	cout << strings[0] << endl;
+	cout << "# " << strings[0] << endl;
 	for (size_t i = 1; i < strings.size(); i++) {
 		int cmp = coll->cmp(strings[i], strlen(strings[i]),
 				    strings[i - 1], strlen(strings[i - 1]),
 				    coll);
-		cout << strings[i]
+		cout << "# "
+		     << strings[i]
 		     << (cmp < 0 ? " LESS" : cmp > 0 ? " GREATER " : " EQUAL")
 		     << endl;
 	}
@@ -45,6 +46,7 @@ void
 manual_test()
 {
 	header();
+	plan(7);
 
 	vector<const char *> strings;
 	struct coll_def def;
@@ -54,62 +56,63 @@ manual_test()
 	def.icu.strength = COLL_ICU_STRENGTH_IDENTICAL;
 	struct coll *coll;
 
-	cout << " -- default ru_RU -- " << endl;
+	note("-- default ru_RU --");
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"Б", "бб", "е", "ЕЕЕЕ", "ё", "Ё", "и", "И", "123", "45" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- --||-- + upper first -- " << endl;
+	note("-- --||-- + upper first --");
 	def.icu.case_first = COLL_ICU_CF_UPPER_FIRST;
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"Б", "бб", "е", "ЕЕЕЕ", "ё", "Ё", "и", "И", "123", "45" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- --||-- + lower first -- " << endl;
+	note("-- --||-- + lower first --");
 	def.icu.case_first = COLL_ICU_CF_LOWER_FIRST;
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"Б", "бб", "е", "ЕЕЕЕ", "ё", "Ё", "и", "И", "123", "45" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- --||-- + secondary strength + numeric -- " << endl;
+	note("-- --||-- + secondary strength + numeric --");
 	def.icu.strength = COLL_ICU_STRENGTH_SECONDARY;
 	def.icu.numeric_collation = COLL_ICU_ON;
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"Б", "бб", "е", "ЕЕЕЕ", "ё", "Ё", "и", "И", "123", "45" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- --||-- + case level -- " << endl;
+	note("-- --||-- + case level --");
 	def.icu.case_level = COLL_ICU_ON;
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"Б", "бб", "е", "ЕЕЕЕ", "ё", "Ё", "и", "И", "123", "45" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- en_EN -- " << endl;
+	note("-- en_EN --");
 	snprintf(def.locale, sizeof(def.locale), "%s", "en_EN-EN");
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"aa", "bb", "cc", "ch", "dd", "gg", "hh", "ii" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
-	cout << " -- cs_CZ -- " << endl;
+	note("-- cs_CZ --");
 	snprintf(def.locale, sizeof(def.locale), "%s", "cs_CZ");
 	coll = coll_new(&def);
-	assert(coll != NULL);
+	fail_if(coll != NULL);
 	strings = {"aa", "bb", "cc", "ch", "dd", "gg", "hh", "ii" };
 	test_sort_strings(strings, coll);
 	coll_unref(coll);
 
+	check_plan();
 	footer();
 }
 
@@ -127,6 +130,7 @@ void
 hash_test()
 {
 	header();
+	plan(8);
 
 	struct coll_def def;
 	memset(&def, 0, sizeof(def));
@@ -137,23 +141,24 @@ hash_test()
 
 	/* Case sensitive */
 	coll = coll_new(&def);
-	assert(coll != NULL);
-	cout << "Case sensitive" << endl;
-	cout << (calc_hash("ае", coll) != calc_hash("аё", coll) ? "OK" : "Fail") << endl;
-	cout << (calc_hash("ае", coll) != calc_hash("аЕ", coll) ? "OK" : "Fail") << endl;
-	cout << (calc_hash("аЕ", coll) != calc_hash("аё", coll) ? "OK" : "Fail") << endl;
+	fail_if(coll != NULL);
+	note("Case sensitive");
+	isnt(calc_hash("ае", coll), calc_hash("аё", coll), "ае != аё");
+	isnt(calc_hash("ае", coll), calc_hash("аЕ", coll), "ае != аЕ");
+	isnt(calc_hash("аЕ", coll), calc_hash("аё", coll), "аЕ != аё");
 	coll_unref(coll);
 
 	/* Case insensitive */
 	def.icu.strength = COLL_ICU_STRENGTH_SECONDARY;
 	coll = coll_new(&def);
-	assert(coll != NULL);
-	cout << "Case insensitive" << endl;
-	cout << (calc_hash("ае", coll) != calc_hash("аё", coll) ? "OK" : "Fail") << endl;
-	cout << (calc_hash("ае", coll) == calc_hash("аЕ", coll) ? "OK" : "Fail") << endl;
-	cout << (calc_hash("аЕ", coll) != calc_hash("аё", coll) ? "OK" : "Fail") << endl;
+	fail_if(coll != NULL);
+	note("Case insensitive");
+	isnt(calc_hash("ае", coll), calc_hash("аё", coll), "ае != аё");
+	is(calc_hash("ае", coll), calc_hash("аЕ", coll), "ае == аЕ");
+	isnt(calc_hash("аЕ", coll), calc_hash("аё", coll), "аЕ != аё");
 	coll_unref(coll);
 
+	check_plan();
 	footer();
 }
 
@@ -187,6 +192,7 @@ cache_test()
 int
 main(int, const char**)
 {
+	plan(0);
 	coll_init();
 	memory_init();
 	fiber_init(fiber_c_invoke);
@@ -196,4 +202,5 @@ main(int, const char**)
 	fiber_free();
 	memory_free();
 	coll_free();
+	check_plan();
 }
diff --git a/test/unit/coll.result b/test/unit/coll.result
deleted file mode 100644
index 269764246..000000000
--- a/test/unit/coll.result
+++ /dev/null
@@ -1,90 +0,0 @@
-	*** manual_test ***
- -- default ru_RU -- 
-123
-45 GREATER 
-Б GREATER 
-бб GREATER 
-е GREATER 
-Ñ‘ GREATER 
-Ё GREATER 
-ЕЕЕЕ GREATER 
-и GREATER 
-И GREATER 
- -- --||-- + upper first -- 
-123
-45 GREATER 
-Б GREATER 
-бб GREATER 
-е GREATER 
-Ё GREATER 
-Ñ‘ GREATER 
-ЕЕЕЕ GREATER 
-И GREATER 
-и GREATER 
- -- --||-- + lower first -- 
-123
-45 GREATER 
-Б GREATER 
-бб GREATER 
-е GREATER 
-Ñ‘ GREATER 
-Ё GREATER 
-ЕЕЕЕ GREATER 
-и GREATER 
-И GREATER 
- -- --||-- + secondary strength + numeric -- 
-45
-123 GREATER 
-Б GREATER 
-бб GREATER 
-е GREATER 
-Ñ‘ GREATER 
-Ё EQUAL
-ЕЕЕЕ GREATER 
-и GREATER 
-И EQUAL
- -- --||-- + case level -- 
-45
-123 GREATER 
-Б GREATER 
-бб GREATER 
-е GREATER 
-Ñ‘ GREATER 
-Ё GREATER 
-ЕЕЕЕ GREATER 
-и GREATER 
-И GREATER 
- -- en_EN -- 
-aa
-bb GREATER 
-cc GREATER 
-ch GREATER 
-dd GREATER 
-gg GREATER 
-hh GREATER 
-ii GREATER 
- -- cs_CZ -- 
-aa
-bb GREATER 
-cc GREATER 
-dd GREATER 
-gg GREATER 
-hh GREATER 
-ch GREATER 
-ii GREATER 
-	*** manual_test: done ***
-	*** hash_test ***
-Case sensitive
-OK
-OK
-OK
-Case insensitive
-OK
-OK
-OK
-	*** hash_test: done ***
-	*** cache_test ***
-1..2
-ok 1 - collations with the same definition are not duplicated
-ok 2 - collations with different definitions are different objects
-	*** cache_test: done ***
diff --git a/test/unit/column_mask.result b/test/unit/column_mask.result
deleted file mode 100644
index 1d87a2f24..000000000
--- a/test/unit/column_mask.result
+++ /dev/null
@@ -1,36 +0,0 @@
-	*** main ***
-1..28
-ok 1 - check result length
-ok 2 - tuple update is correct
-ok 3 - column_mask is correct
-ok 4 - check result length
-ok 5 - tuple update is correct
-ok 6 - column_mask is correct
-ok 7 - check result length
-ok 8 - tuple update is correct
-ok 9 - column_mask is correct
-ok 10 - check result length
-ok 11 - tuple update is correct
-ok 12 - column_mask is correct
-ok 13 - check result length
-ok 14 - tuple update is correct
-ok 15 - column_mask is correct
-ok 16 - check result length
-ok 17 - tuple update is correct
-ok 18 - column_mask is correct
-ok 19 - check result length
-ok 20 - tuple update is correct
-ok 21 - column_mask is correct
-ok 22 - check result length
-ok 23 - tuple update is correct
-ok 24 - column_mask is correct
-ok 25 - check result length
-ok 26 - tuple update is correct
-ok 27 - column_mask is correct
-	*** test_paths ***
-    1..2
-    ok 1 - JSON update works
-    ok 2 - column mask match
-ok 28 - subtests
-	*** test_paths: done ***
-	*** main: done ***
diff --git a/test/unit/crypto.result b/test/unit/crypto.result
deleted file mode 100644
index 6e01896b1..000000000
--- a/test/unit/crypto.result
+++ /dev/null
@@ -1,132 +0,0 @@
-	*** main ***
-1..5
-ok 1 - crypto checks that algo argument is correct
-	*** test_aes128_codec ***
-    1..20
-    ok 1 - encrypt returns needed number of bytes
-    ok 2 - encrypt does not write anything when too small buffer
-    ok 3 - encrypt does not allow 0 sized buffer
-    ok 4 - encrypt requires additional block when buffer size is multiple of block size
-    ok 5 - AES 126 IV size is 16
-    ok 6 - encrypt works when buffer is big enough
-    ok 7 - encrypt returns the same on second call
-    ok 8 - encrypted data is the same
-    ok 9 - and it is not just copied from the plain text
-    ok 10 - decrypt also checks length and returns needed number of bytes
-    ok 11 - decrypt returns correct number of bytes
-    ok 12 - and correctly decrypts data
-    ok 13 - decrypt can't correctly decode anything with a wrong IV
-    ok 14 - in case decrypt has totally failed, diag is set
-    ok 15 - encrypt with different IV and the same number of written bytes returned
-    ok 16 - the encrypted data looks different
-    ok 17 - decrypt works with correct but another IV
-    ok 18 - data is the same
-    ok 19 - encrypt with one codec, but decrypt with another codec and the same key
-    ok 20 - data is the same
-ok 2 - subtests
-	*** test_aes128_codec: done ***
-	*** test_aes128_stress ***
-    1..1
-    ok 1 - try encrypt/decrypt on a variety of sizes, keys, and ivs
-ok 3 - subtests
-	*** test_aes128_stress: done ***
-	*** test_each ***
-    1..80
-    ok 1 - none 0 ECB, create iv of size 0
-    ok 2 - encode
-    ok 3 - decode
-    ok 4 - data is correct
-    ok 5 - none 0 CBC, create iv of size 0
-    ok 6 - encode
-    ok 7 - decode
-    ok 8 - data is correct
-    ok 9 - none 0 CFB, create iv of size 0
-    ok 10 - encode
-    ok 11 - decode
-    ok 12 - data is correct
-    ok 13 - none 0 OFB, create iv of size 0
-    ok 14 - encode
-    ok 15 - decode
-    ok 16 - data is correct
-    ok 17 - AES128 16 ECB, create iv of size 0
-    ok 18 - encode
-    ok 19 - decode
-    ok 20 - data is correct
-    ok 21 - AES128 16 CBC, create iv of size 16
-    ok 22 - encode
-    ok 23 - decode
-    ok 24 - data is correct
-    ok 25 - AES128 16 CFB, create iv of size 16
-    ok 26 - encode
-    ok 27 - decode
-    ok 28 - data is correct
-    ok 29 - AES128 16 OFB, create iv of size 16
-    ok 30 - encode
-    ok 31 - decode
-    ok 32 - data is correct
-    ok 33 - AES192 24 ECB, create iv of size 0
-    ok 34 - encode
-    ok 35 - decode
-    ok 36 - data is correct
-    ok 37 - AES192 24 CBC, create iv of size 16
-    ok 38 - encode
-    ok 39 - decode
-    ok 40 - data is correct
-    ok 41 - AES192 24 CFB, create iv of size 16
-    ok 42 - encode
-    ok 43 - decode
-    ok 44 - data is correct
-    ok 45 - AES192 24 OFB, create iv of size 16
-    ok 46 - encode
-    ok 47 - decode
-    ok 48 - data is correct
-    ok 49 - AES256 32 ECB, create iv of size 0
-    ok 50 - encode
-    ok 51 - decode
-    ok 52 - data is correct
-    ok 53 - AES256 32 CBC, create iv of size 16
-    ok 54 - encode
-    ok 55 - decode
-    ok 56 - data is correct
-    ok 57 - AES256 32 CFB, create iv of size 16
-    ok 58 - encode
-    ok 59 - decode
-    ok 60 - data is correct
-    ok 61 - AES256 32 OFB, create iv of size 16
-    ok 62 - encode
-    ok 63 - decode
-    ok 64 - data is correct
-    ok 65 - DES 8 ECB, create iv of size 0
-    ok 66 - encode
-    ok 67 - decode
-    ok 68 - data is correct
-    ok 69 - DES 8 CBC, create iv of size 8
-    ok 70 - encode
-    ok 71 - decode
-    ok 72 - data is correct
-    ok 73 - DES 8 CFB, create iv of size 8
-    ok 74 - encode
-    ok 75 - decode
-    ok 76 - data is correct
-    ok 77 - DES 8 OFB, create iv of size 8
-    ok 78 - encode
-    ok 79 - decode
-    ok 80 - data is correct
-ok 4 - subtests
-	*** test_each: done ***
-	*** test_stream ***
-    1..11
-    ok 1 - stream begin checks key size
-    ok 2 - stream begin checks iv size
-    ok 3 - begin encryption
-    ok 4 - append checks size
-    ok 5 - append 5
-    ok 6 - append 10
-    ok 7 - last append 30
-    ok 8 - commit checks size
-    ok 9 - commit 16
-    ok 10 - decoder returned correct size
-    ok 11 - data is decoded correctly
-ok 5 - subtests
-	*** test_stream: done ***
-	*** main: done ***
diff --git a/test/unit/csv.c b/test/unit/csv.c
index b0e997f35..b79bf8f39 100644
--- a/test/unit/csv.c
+++ b/test/unit/csv.c
@@ -358,6 +358,7 @@ void csv_out() {
 }
 
 int main() {
+	plan(0);
 	test1();
 	test2();
 	test3();
@@ -427,5 +428,6 @@ int main() {
 
 	//output test
 	csv_out();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/csv.result b/test/unit/csv.result
deleted file mode 100644
index 8f9dab5b2..000000000
--- a/test/unit/csv.result
+++ /dev/null
@@ -1,102 +0,0 @@
-	*** test1 ***
-|1|
-||
-|1|	|2|	|3|
-|123|
-	*** test1: done ***
-	*** test2 ***
-|123|	|456|	|abcac|	|'multiword field 4'|
-|none|	|none|	|0|
-||	||	||
-||	||	||
-	*** test2: done ***
-	*** test3 ***
-|1|	||	|2|
-	*** test3: done ***
-	*** test4 ***
-|123|	|5|	|92|	|0|	|0|
-|1|	|12  34|	|56|	|quote , |	|66|
-|ok|
-	*** test4: done ***
-	*** test5 ***
-|abc|	|longlonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglong|	|0|
-|123|	|456|	||
-|0|	||	||
-valid: yes
-	*** test5: done ***
-	*** test6 ***
-||
-||
-|abc|
-|c"|	|d|	|de|
-||
-|k|
-|e|
-||
-||
-| |
-valid: NO
-	*** test6: done ***
-	*** big_chunk_separated_test ***
-line_cnt=10000, fieldsizes_cnt=1920000, 1920000
-	*** big_chunk_separated_test: done ***
-	*** random_generated_test ***
-line_cnt=40, fieldsizes_cnt=183
-valid: yes
-	*** random_generated_test: done ***
-	*** common_test ***
-|first|	|last|	|address|	|city|	|zip|
-|John|	|Doe|	|120 any st.|	|Anytown, WW|	|08123|
-	*** common_test: done ***
-	*** common_test ***
-|a|	|b|	|c|
-|1|	|"|	|"|
-|2|	|3|	|4|
-	*** common_test: done ***
-	*** common_test ***
-|a|	|b|
-|1|	|ha "ha" ha|
-|3|	|4|
-	*** common_test: done ***
-	*** common_test ***
-|key|	|val|
-|1|	|{"type": "Point", "coordinates": [102.0, 0.5]}|
-	*** common_test: done ***
-	*** common_test ***
-|a|	|b|	|c|
-|1|	|2|	|3|
-|Once upon 
-a time|	|5|	|6|
-|7|	|8|	|9|
-	*** common_test: done ***
-	*** common_test ***
-|a|	|b|
-|1|	|ha
-"ha"
-ha|
-|3|	|4|
-	*** common_test: done ***
-	*** common_test ***
-|a|	|b|	|c|
-|1|	|2|	|3|
-|4|	|5|	|а нет ли ошибок?|
-	*** common_test: done ***
-	*** common_test ***
-|www|	|aaa|	|tt  |
-	*** common_test: done ***
-	*** iter_test1 ***
-||	|d|	|e|
-|12|	|42|	|3|
-|o|
-	*** iter_test1: done ***
-	*** iter_test2 ***
-|1|
-|23|
-	*** iter_test2: done ***
-	*** iter_test3 ***
-|1|	|2|	|3|
-|4|	|5|	|6|
-	*** iter_test3: done ***
-	*** csv_out ***
-abc<len=3>,"with,comma"<len=12>,""in quotes""<len=13>,1 "" quote<len=10>
-	*** csv_out: done ***
diff --git a/test/unit/decimal.result b/test/unit/decimal.result
deleted file mode 100644
index f11396df3..000000000
--- a/test/unit/decimal.result
+++ /dev/null
@@ -1,709 +0,0 @@
-1..282
-ok 1 - decimal(314)
-ok 2 - decimal(271)
-ok 3 - decimal(314) + decimal(271)
-ok 4 - decimal((314) + (271))
-ok 5 - decimal(314) + decimal(271) == (314) + (271)
-ok 6 - decimal(314) - decimal(271)
-ok 7 - decimal((314) - (271))
-ok 8 - decimal(314) - decimal(271) == (314) - (271)
-ok 9 - decimal(314) * decimal(271)
-ok 10 - decimal((314) * (271))
-ok 11 - decimal_round((314) * (271), 15)
-ok 12 - decimal(314) * decimal(271) == (314) * (271)
-ok 13 - decimal(314) / decimal(271)
-ok 14 - decimal((314) / (271))
-ok 15 - decimal_round((314)/(271), 15)
-ok 16 - decimal(314) / decimal(271) == (314) / (271)
-ok 17 - decimal(65535)
-ok 18 - decimal(23456)
-ok 19 - decimal(65535) + decimal(23456)
-ok 20 - decimal((65535) + (23456))
-ok 21 - decimal(65535) + decimal(23456) == (65535) + (23456)
-ok 22 - decimal(65535) - decimal(23456)
-ok 23 - decimal((65535) - (23456))
-ok 24 - decimal(65535) - decimal(23456) == (65535) - (23456)
-ok 25 - decimal(65535) * decimal(23456)
-ok 26 - decimal((65535) * (23456))
-ok 27 - decimal_round((65535) * (23456), 15)
-ok 28 - decimal(65535) * decimal(23456) == (65535) * (23456)
-ok 29 - decimal(65535) / decimal(23456)
-ok 30 - decimal((65535) / (23456))
-ok 31 - decimal_round((65535)/(23456), 15)
-ok 32 - decimal(65535) / decimal(23456) == (65535) / (23456)
-ok 33 - decimal(0)
-ok 34 - decimal(1)
-ok 35 - decimal(0) + decimal(1)
-ok 36 - decimal((0) + (1))
-ok 37 - decimal(0) + decimal(1) == (0) + (1)
-ok 38 - decimal(0) - decimal(1)
-ok 39 - decimal((0) - (1))
-ok 40 - decimal(0) - decimal(1) == (0) - (1)
-ok 41 - decimal(0) * decimal(1)
-ok 42 - decimal((0) * (1))
-ok 43 - decimal_round((0) * (1), 15)
-ok 44 - decimal(0) * decimal(1) == (0) * (1)
-ok 45 - decimal(0) / decimal(1)
-ok 46 - decimal((0) / (1))
-ok 47 - decimal_round((0)/(1), 15)
-ok 48 - decimal(0) / decimal(1) == (0) / (1)
-ok 49 - decimal(0)
-ok 50 - decimal(-1)
-ok 51 - decimal(0) + decimal(-1)
-ok 52 - decimal((0) + (-1))
-ok 53 - decimal(0) + decimal(-1) == (0) + (-1)
-ok 54 - decimal(0) - decimal(-1)
-ok 55 - decimal((0) - (-1))
-ok 56 - decimal(0) - decimal(-1) == (0) - (-1)
-ok 57 - decimal(0) * decimal(-1)
-ok 58 - decimal((0) * (-1))
-ok 59 - decimal_round((0) * (-1), 15)
-ok 60 - decimal(0) * decimal(-1) == (0) * (-1)
-ok 61 - decimal(0) / decimal(-1)
-ok 62 - decimal((0) / (-1))
-ok 63 - decimal_round((0)/(-1), 15)
-ok 64 - decimal(0) / decimal(-1) == (0) / (-1)
-ok 65 - decimal(-1)
-ok 66 - decimal(1)
-ok 67 - decimal(-1) + decimal(1)
-ok 68 - decimal((-1) + (1))
-ok 69 - decimal(-1) + decimal(1) == (-1) + (1)
-ok 70 - decimal(-1) - decimal(1)
-ok 71 - decimal((-1) - (1))
-ok 72 - decimal(-1) - decimal(1) == (-1) - (1)
-ok 73 - decimal(-1) * decimal(1)
-ok 74 - decimal((-1) * (1))
-ok 75 - decimal_round((-1) * (1), 15)
-ok 76 - decimal(-1) * decimal(1) == (-1) * (1)
-ok 77 - decimal(-1) / decimal(1)
-ok 78 - decimal((-1) / (1))
-ok 79 - decimal_round((-1)/(1), 15)
-ok 80 - decimal(-1) / decimal(1) == (-1) / (1)
-ok 81 - decimal(INT_MIN)
-ok 82 - decimal(INT_MAX)
-ok 83 - decimal(INT_MIN) + decimal(INT_MAX)
-ok 84 - decimal((INT_MIN) + (INT_MAX))
-ok 85 - decimal(INT_MIN) + decimal(INT_MAX) == (INT_MIN) + (INT_MAX)
-ok 86 - decimal(INT_MIN) - decimal(INT_MAX)
-ok 87 - decimal((INT_MIN) - (INT_MAX))
-ok 88 - decimal(INT_MIN) - decimal(INT_MAX) == (INT_MIN) - (INT_MAX)
-ok 89 - decimal(INT_MIN) * decimal(INT_MAX)
-ok 90 - decimal((INT_MIN) * (INT_MAX))
-ok 91 - decimal_round((INT_MIN) * (INT_MAX), 15)
-ok 92 - decimal(INT_MIN) * decimal(INT_MAX) == (INT_MIN) * (INT_MAX)
-ok 93 - decimal(INT_MIN) / decimal(INT_MAX)
-ok 94 - decimal((INT_MIN) / (INT_MAX))
-ok 95 - decimal_round((INT_MIN)/(INT_MAX), 15)
-ok 96 - decimal(INT_MIN) / decimal(INT_MAX) == (INT_MIN) / (INT_MAX)
-ok 97 - decimal(-314)
-ok 98 - decimal(-271)
-ok 99 - decimal(-314) + decimal(-271)
-ok 100 - decimal((-314) + (-271))
-ok 101 - decimal(-314) + decimal(-271) == (-314) + (-271)
-ok 102 - decimal(-314) - decimal(-271)
-ok 103 - decimal((-314) - (-271))
-ok 104 - decimal(-314) - decimal(-271) == (-314) - (-271)
-ok 105 - decimal(-314) * decimal(-271)
-ok 106 - decimal((-314) * (-271))
-ok 107 - decimal_round((-314) * (-271), 15)
-ok 108 - decimal(-314) * decimal(-271) == (-314) * (-271)
-ok 109 - decimal(-314) / decimal(-271)
-ok 110 - decimal((-314) / (-271))
-ok 111 - decimal_round((-314)/(-271), 15)
-ok 112 - decimal(-314) / decimal(-271) == (-314) / (-271)
-ok 113 - decimal(-159615516)
-ok 114 - decimal(172916921)
-ok 115 - decimal(-159615516) + decimal(172916921)
-ok 116 - decimal((-159615516) + (172916921))
-ok 117 - decimal(-159615516) + decimal(172916921) == (-159615516) + (172916921)
-ok 118 - decimal(-159615516) - decimal(172916921)
-ok 119 - decimal((-159615516) - (172916921))
-ok 120 - decimal(-159615516) - decimal(172916921) == (-159615516) - (172916921)
-ok 121 - decimal(-159615516) * decimal(172916921)
-ok 122 - decimal((-159615516) * (172916921))
-ok 123 - decimal_round((-159615516) * (172916921), 15)
-ok 124 - decimal(-159615516) * decimal(172916921) == (-159615516) * (172916921)
-ok 125 - decimal(-159615516) / decimal(172916921)
-ok 126 - decimal((-159615516) / (172916921))
-ok 127 - decimal_round((-159615516)/(172916921), 15)
-ok 128 - decimal(-159615516) / decimal(172916921) == (-159615516) / (172916921)
-ok 129 - decimal(1.1)
-ok 130 - decimal(2.3)
-ok 131 - decimal(1.1) + decimal(2.3)
-ok 132 - decimal((1.1) + (2.3))
-ok 133 - decimal(1.1) + decimal(2.3) == (1.1) + (2.3)
-ok 134 - decimal(1.1) - decimal(2.3)
-ok 135 - decimal((1.1) - (2.3))
-ok 136 - decimal(1.1) - decimal(2.3) == (1.1) - (2.3)
-ok 137 - decimal(1.1) * decimal(2.3)
-ok 138 - decimal((1.1) * (2.3))
-ok 139 - decimal_round((1.1) * (2.3), 15)
-ok 140 - decimal(1.1) * decimal(2.3) == (1.1) * (2.3)
-ok 141 - decimal(1.1) / decimal(2.3)
-ok 142 - decimal((1.1) / (2.3))
-ok 143 - decimal_round((1.1)/(2.3), 15)
-ok 144 - decimal(1.1) / decimal(2.3) == (1.1) / (2.3)
-ok 145 - decimal(1e10)
-ok 146 - decimal(1e10)
-ok 147 - decimal(1e10) + decimal(1e10)
-ok 148 - decimal((1e10) + (1e10))
-ok 149 - decimal(1e10) + decimal(1e10) == (1e10) + (1e10)
-ok 150 - decimal(1e10) - decimal(1e10)
-ok 151 - decimal((1e10) - (1e10))
-ok 152 - decimal(1e10) - decimal(1e10) == (1e10) - (1e10)
-ok 153 - decimal(1e10) * decimal(1e10)
-ok 154 - decimal((1e10) * (1e10))
-ok 155 - decimal_round((1e10) * (1e10), 15)
-ok 156 - decimal(1e10) * decimal(1e10) == (1e10) * (1e10)
-ok 157 - decimal(1e10) / decimal(1e10)
-ok 158 - decimal((1e10) / (1e10))
-ok 159 - decimal_round((1e10)/(1e10), 15)
-ok 160 - decimal(1e10) / decimal(1e10) == (1e10) / (1e10)
-ok 161 - decimal(1.23456789)
-ok 162 - decimal(4.567890123)
-ok 163 - decimal(1.23456789) + decimal(4.567890123)
-ok 164 - decimal((1.23456789) + (4.567890123))
-ok 165 - decimal(1.23456789) + decimal(4.567890123) == (1.23456789) + (4.567890123)
-ok 166 - decimal(1.23456789) - decimal(4.567890123)
-ok 167 - decimal((1.23456789) - (4.567890123))
-ok 168 - decimal(1.23456789) - decimal(4.567890123) == (1.23456789) - (4.567890123)
-ok 169 - decimal(1.23456789) * decimal(4.567890123)
-ok 170 - decimal((1.23456789) * (4.567890123))
-ok 171 - decimal_round((1.23456789) * (4.567890123), 15)
-ok 172 - decimal(1.23456789) * decimal(4.567890123) == (1.23456789) * (4.567890123)
-ok 173 - decimal(1.23456789) / decimal(4.567890123)
-ok 174 - decimal((1.23456789) / (4.567890123))
-ok 175 - decimal_round((1.23456789)/(4.567890123), 15)
-ok 176 - decimal(1.23456789) / decimal(4.567890123) == (1.23456789) / (4.567890123)
-ok 177 - decimal_from_string(1e-38)
-ok 178 - decimal_from_string(1e-38)
-ok 179 - decimal_from_string(2e-38)
-ok 180 - decimal_add(1e-38, 1e-38)
-ok 181 - decimal_compare(2e-38)
-ok 182 - decimal_from_string(-1e-38)
-ok 183 - decimal_from_string(1e-38)
-ok 184 - decimal_from_string(0)
-ok 185 - decimal_add(-1e-38, 1e-38)
-ok 186 - decimal_compare(0)
-ok 187 - decimal_from_string(1e-39)
-ok 188 - decimal_from_string(0)
-ok 189 - decimal_from_string(0)
-ok 190 - decimal_add(1e-39, 0)
-ok 191 - decimal_compare(0)
-ok 192 - decimal_from_string(1e-39)
-ok 193 - decimal_from_string(1e-38)
-ok 194 - decimal_from_string(1e-38)
-ok 195 - decimal_add(1e-39, 1e-38)
-ok 196 - decimal_compare(1e-38)
-ok 197 - decimal_from_string(1e-19)
-ok 198 - decimal_from_string(1e-19)
-ok 199 - decimal_from_string(1e-38)
-ok 200 - decimal_mul(1e-19, 1e-19)
-ok 201 - decimal_compare(1e-38)
-ok 202 - decimal_from_string(1e37)
-ok 203 - decimal_from_string(0)
-ok 204 - decimal_from_string(1e37)
-ok 205 - decimal_add(1e37, 0)
-ok 206 - decimal_compare(1e37)
-ok 207 - decimal_from_string(1e18)
-ok 208 - decimal_from_string(1e18)
-ok 209 - decimal_from_string(1e36)
-ok 210 - decimal_mul(1e18, 1e18)
-ok 211 - decimal_compare(1e36)
-ok 212 - decimal_from_string(10)
-ok 213 - decimal_from_string(2)
-ok 214 - decimal_from_string(100)
-ok 215 - decimal_pow(10, 2)
-ok 216 - decimal_compare(100)
-ok 217 - decimal_from_string(2)
-ok 218 - decimal_from_string(10)
-ok 219 - decimal_from_string(1024)
-ok 220 - decimal_pow(2, 10)
-ok 221 - decimal_compare(1024)
-ok 222 - decimal_from_string(100)
-ok 223 - decimal_from_string(0.5)
-ok 224 - decimal_from_string(10)
-ok 225 - decimal_pow(100, 0.5)
-ok 226 - decimal_compare(10)
-ok 227 - decimal_from_string(100)
-ok 228 - decimal_from_string(2)
-ok 229 - decimal_log10(100)
-ok 230 - decimal_compare(2)
-ok 231 - decimal_from_string(10)
-ok 232 - decimal_from_string(2.3)
-ok 233 - decimal_ln(10)
-ok 234 - decimal_compare(2.3)
-ok 235 - decimal_from_string(1.1)
-ok 236 - decimal_from_string(0.1)
-ok 237 - decimal_ln(1.1)
-ok 238 - decimal_compare(0.1)
-ok 239 - decimal_from_string(1.0000000000000000000000000000000000001)
-ok 240 - decimal_from_string(0.0000000000000000000000000000000000001)
-ok 241 - decimal_ln(1.0000000000000000000000000000000000001)
-ok 242 - decimal_compare(0.0000000000000000000000000000000000001)
-ok 243 - decimal_from_string(2)
-ok 244 - decimal_from_string(7.39)
-ok 245 - decimal_exp(2)
-ok 246 - decimal_compare(7.39)
-ok 247 - decimal_from_string(100)
-ok 248 - decimal_from_string(10)
-ok 249 - decimal_sqrt(100)
-ok 250 - decimal_compare(10)
-ok 251 - decimal construction from 2e38 failure
-ok 252 - decimal construction from "1e38" failure
-ok 253 - decimal construction from "100000000000000000000000000000000000000" failure
-ok 254 - decimal construction from "inf" failure
-ok 255 - decimal construction from "NaN" failure
-ok 256 - decimal construction from "a random string" failure
-ok 257 - decimal construction from LONG_MIN success
-ok 258 - decimal construction from LONG_MAX success
-ok 259 - decimal construction from ULONG_MAX success
-ok 260 - decimal_from_string(9e37)
-ok 261 - decimal_from_string(1e37)
-ok 262 - decimal_add(9e37, 1e37) - overflow
-ok 263 - decimal_from_string(1e19)
-ok 264 - decimal_from_string(1e19)
-ok 265 - decimal_mul(1e19, 1e19) - overflow
-ok 266 - decimal_from_string(1e19)
-ok 267 - decimal_from_string(1e-19)
-ok 268 - decimal_div(1e19, 1e-19) - overflow
-ok 269 - decimal_from_string(0)
-ok 270 - decimal_ln(0) - error on wrong operands.
-ok 271 - decimal_from_string(-1)
-ok 272 - decimal_ln(-1) - error on wrong operands.
-ok 273 - decimal_from_string(0)
-ok 274 - decimal_log10(0) - error on wrong operands.
-ok 275 - decimal_from_string(-1)
-ok 276 - decimal_log10(-1) - error on wrong operands.
-ok 277 - decimal_from_string(-10)
-ok 278 - decimal_sqrt(-10) - error on wrong operands.
-    1..66
-    ok 1 - Conversion of 18446744073709551615 to decimal and back to uint64 successful
-    ok 2 - Conversion back to uint64 correct
-    ok 3 - Conversion of 9223372036854775807 to decimal and back to int64 successful
-    ok 4 - Conversion back to int64 correct
-    ok 5 - Conversion of -9223372036854775808 to decimal and back to int64 successful
-    ok 6 - Conversion back to int64 correct
-    ok 7 - Conversion of 0 to decimal and back to uint64 successful
-    ok 8 - Conversion back to uint64 correct
-    ok 9 - Conversion of 0 to decimal and back to int64 successful
-    ok 10 - Conversion back to int64 correct
-    ok 11 - Conversion of -1 to decimal and back to int64 successful
-    ok 12 - Conversion back to int64 correct
-    ok 13 - Conversion of 117495185182863386 to decimal and back to uint64 successful
-    ok 14 - Conversion back to uint64 correct
-    ok 15 - Conversion of 58747592591431693 to decimal and back to int64 successful
-    ok 16 - Conversion back to int64 correct
-    ok 17 - Conversion of -58747592591431693 to decimal and back to int64 successful
-    ok 18 - Conversion back to int64 correct
-    ok 19 - Conversion of 778113809158035 to decimal and back to uint64 successful
-    ok 20 - Conversion back to uint64 correct
-    ok 21 - Conversion of 389056904579017 to decimal and back to int64 successful
-    ok 22 - Conversion back to int64 correct
-    ok 23 - Conversion of -389056904579017 to decimal and back to int64 successful
-    ok 24 - Conversion back to int64 correct
-    ok 25 - Conversion of 5222240329919 to decimal and back to uint64 successful
-    ok 26 - Conversion back to uint64 correct
-    ok 27 - Conversion of 2611120164959 to decimal and back to int64 successful
-    ok 28 - Conversion back to int64 correct
-    ok 29 - Conversion of -2611120164959 to decimal and back to int64 successful
-    ok 30 - Conversion back to int64 correct
-    ok 31 - Conversion of 37570074315 to decimal and back to uint64 successful
-    ok 32 - Conversion back to uint64 correct
-    ok 33 - Conversion of 18785037157 to decimal and back to int64 successful
-    ok 34 - Conversion back to int64 correct
-    ok 35 - Conversion of -18785037157 to decimal and back to int64 successful
-    ok 36 - Conversion back to int64 correct
-    ok 37 - Conversion of 274234119 to decimal and back to uint64 successful
-    ok 38 - Conversion back to uint64 correct
-    ok 39 - Conversion of 137996015 to decimal and back to int64 successful
-    ok 40 - Conversion back to int64 correct
-    ok 41 - Conversion of -137996015 to decimal and back to int64 successful
-    ok 42 - Conversion back to int64 correct
-    ok 43 - Conversion of 4294967295 to decimal and back to uint64 successful
-    ok 44 - Conversion back to uint64 correct
-    ok 45 - Conversion of 2147483647 to decimal and back to int64 successful
-    ok 46 - Conversion back to int64 correct
-    ok 47 - Conversion of -2147483648 to decimal and back to int64 successful
-    ok 48 - Conversion back to int64 correct
-    ok 49 - Conversion of 27356479 to decimal and back to uint64 successful
-    ok 50 - Conversion back to uint64 correct
-    ok 51 - Conversion of 13678239 to decimal and back to int64 successful
-    ok 52 - Conversion back to int64 correct
-    ok 53 - Conversion of -13678239 to decimal and back to int64 successful
-    ok 54 - Conversion back to int64 correct
-    ok 55 - Conversion of 181168 to decimal and back to uint64 successful
-    ok 56 - Conversion back to uint64 correct
-    ok 57 - Conversion of 90584 to decimal and back to int64 successful
-    ok 58 - Conversion back to int64 correct
-    ok 59 - Conversion of -90584 to decimal and back to int64 successful
-    ok 60 - Conversion back to int64 correct
-    ok 61 - Conversion of 1215 to decimal and back to uint64 successful
-    ok 62 - Conversion back to uint64 correct
-    ok 63 - Conversion of 607 to decimal and back to int64 successful
-    ok 64 - Conversion back to int64 correct
-    ok 65 - Conversion of -607 to decimal and back to int64 successful
-    ok 66 - Conversion back to int64 correct
-ok 279 - subtests
-    1..151
-    ok 1 - decimal_len(0)
-    ok 2 - decimal_len(0) == len(decimal_pack(0)
-    ok 3 - decimal_unpack(decimal_pack(0))
-    ok 4 - decimal_unpack(decimal_pack(0)) len
-    ok 5 - decimal_unpack(decimal_pack(0)) value
-    ok 6 - decimal_unpack(decimal_pack(0)) scale
-    ok 7 - decimal_unpack(decimal_pack(0)) precision
-    ok 8 - str(decimal_unpack(decimal_pack(0)) == 0
-    ok 9 - decimal_len(-0)
-    ok 10 - decimal_len(-0) == len(decimal_pack(-0)
-    ok 11 - decimal_unpack(decimal_pack(-0))
-    ok 12 - decimal_unpack(decimal_pack(-0)) len
-    ok 13 - decimal_unpack(decimal_pack(-0)) value
-    ok 14 - decimal_unpack(decimal_pack(-0)) scale
-    ok 15 - decimal_unpack(decimal_pack(-0)) precision
-    ok 16 - str(decimal_unpack(decimal_pack(-0)) == -0
-    ok 17 - decimal_len(1)
-    ok 18 - decimal_len(1) == len(decimal_pack(1)
-    ok 19 - decimal_unpack(decimal_pack(1))
-    ok 20 - decimal_unpack(decimal_pack(1)) len
-    ok 21 - decimal_unpack(decimal_pack(1)) value
-    ok 22 - decimal_unpack(decimal_pack(1)) scale
-    ok 23 - decimal_unpack(decimal_pack(1)) precision
-    ok 24 - str(decimal_unpack(decimal_pack(1)) == 1
-    ok 25 - decimal_len(-1)
-    ok 26 - decimal_len(-1) == len(decimal_pack(-1)
-    ok 27 - decimal_unpack(decimal_pack(-1))
-    ok 28 - decimal_unpack(decimal_pack(-1)) len
-    ok 29 - decimal_unpack(decimal_pack(-1)) value
-    ok 30 - decimal_unpack(decimal_pack(-1)) scale
-    ok 31 - decimal_unpack(decimal_pack(-1)) precision
-    ok 32 - str(decimal_unpack(decimal_pack(-1)) == -1
-    ok 33 - decimal_len(0.1)
-    ok 34 - decimal_len(0.1) == len(decimal_pack(0.1)
-    ok 35 - decimal_unpack(decimal_pack(0.1))
-    ok 36 - decimal_unpack(decimal_pack(0.1)) len
-    ok 37 - decimal_unpack(decimal_pack(0.1)) value
-    ok 38 - decimal_unpack(decimal_pack(0.1)) scale
-    ok 39 - decimal_unpack(decimal_pack(0.1)) precision
-    ok 40 - str(decimal_unpack(decimal_pack(0.1)) == 0.1
-    ok 41 - decimal_len(-0.1)
-    ok 42 - decimal_len(-0.1) == len(decimal_pack(-0.1)
-    ok 43 - decimal_unpack(decimal_pack(-0.1))
-    ok 44 - decimal_unpack(decimal_pack(-0.1)) len
-    ok 45 - decimal_unpack(decimal_pack(-0.1)) value
-    ok 46 - decimal_unpack(decimal_pack(-0.1)) scale
-    ok 47 - decimal_unpack(decimal_pack(-0.1)) precision
-    ok 48 - str(decimal_unpack(decimal_pack(-0.1)) == -0.1
-    ok 49 - decimal_len(2.718281828459045)
-    ok 50 - decimal_len(2.718281828459045) == len(decimal_pack(2.718281828459045)
-    ok 51 - decimal_unpack(decimal_pack(2.718281828459045))
-    ok 52 - decimal_unpack(decimal_pack(2.718281828459045)) len
-    ok 53 - decimal_unpack(decimal_pack(2.718281828459045)) value
-    ok 54 - decimal_unpack(decimal_pack(2.718281828459045)) scale
-    ok 55 - decimal_unpack(decimal_pack(2.718281828459045)) precision
-    ok 56 - str(decimal_unpack(decimal_pack(2.718281828459045)) == 2.718281828459045
-    ok 57 - decimal_len(-2.718281828459045)
-    ok 58 - decimal_len(-2.718281828459045) == len(decimal_pack(-2.718281828459045)
-    ok 59 - decimal_unpack(decimal_pack(-2.718281828459045))
-    ok 60 - decimal_unpack(decimal_pack(-2.718281828459045)) len
-    ok 61 - decimal_unpack(decimal_pack(-2.718281828459045)) value
-    ok 62 - decimal_unpack(decimal_pack(-2.718281828459045)) scale
-    ok 63 - decimal_unpack(decimal_pack(-2.718281828459045)) precision
-    ok 64 - str(decimal_unpack(decimal_pack(-2.718281828459045)) == -2.718281828459045
-    ok 65 - decimal_len(3.141592653589793)
-    ok 66 - decimal_len(3.141592653589793) == len(decimal_pack(3.141592653589793)
-    ok 67 - decimal_unpack(decimal_pack(3.141592653589793))
-    ok 68 - decimal_unpack(decimal_pack(3.141592653589793)) len
-    ok 69 - decimal_unpack(decimal_pack(3.141592653589793)) value
-    ok 70 - decimal_unpack(decimal_pack(3.141592653589793)) scale
-    ok 71 - decimal_unpack(decimal_pack(3.141592653589793)) precision
-    ok 72 - str(decimal_unpack(decimal_pack(3.141592653589793)) == 3.141592653589793
-    ok 73 - decimal_len(-3.141592653589793)
-    ok 74 - decimal_len(-3.141592653589793) == len(decimal_pack(-3.141592653589793)
-    ok 75 - decimal_unpack(decimal_pack(-3.141592653589793))
-    ok 76 - decimal_unpack(decimal_pack(-3.141592653589793)) len
-    ok 77 - decimal_unpack(decimal_pack(-3.141592653589793)) value
-    ok 78 - decimal_unpack(decimal_pack(-3.141592653589793)) scale
-    ok 79 - decimal_unpack(decimal_pack(-3.141592653589793)) precision
-    ok 80 - str(decimal_unpack(decimal_pack(-3.141592653589793)) == -3.141592653589793
-    ok 81 - decimal_len(1234567891234567890.0987654321987654321)
-    ok 82 - decimal_len(1234567891234567890.0987654321987654321) == len(decimal_pack(1234567891234567890.0987654321987654321)
-    ok 83 - decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321))
-    ok 84 - decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321)) len
-    ok 85 - decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321)) value
-    ok 86 - decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321)) scale
-    ok 87 - decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321)) precision
-    ok 88 - str(decimal_unpack(decimal_pack(1234567891234567890.0987654321987654321)) == 1234567891234567890.0987654321987654321
-    ok 89 - decimal_len(-1234567891234567890.0987654321987654321)
-    ok 90 - decimal_len(-1234567891234567890.0987654321987654321) == len(decimal_pack(-1234567891234567890.0987654321987654321)
-    ok 91 - decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321))
-    ok 92 - decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321)) len
-    ok 93 - decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321)) value
-    ok 94 - decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321)) scale
-    ok 95 - decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321)) precision
-    ok 96 - str(decimal_unpack(decimal_pack(-1234567891234567890.0987654321987654321)) == -1234567891234567890.0987654321987654321
-    ok 97 - decimal_len(0.0000000000000000000000000000000000001)
-    ok 98 - decimal_len(0.0000000000000000000000000000000000001) == len(decimal_pack(0.0000000000000000000000000000000000001)
-    ok 99 - decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001))
-    ok 100 - decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001)) len
-    ok 101 - decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001)) value
-    ok 102 - decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001)) scale
-    ok 103 - decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001)) precision
-    ok 104 - str(decimal_unpack(decimal_pack(0.0000000000000000000000000000000000001)) == 0.0000000000000000000000000000000000001
-    ok 105 - decimal_len(-0.0000000000000000000000000000000000001)
-    ok 106 - decimal_len(-0.0000000000000000000000000000000000001) == len(decimal_pack(-0.0000000000000000000000000000000000001)
-    ok 107 - decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001))
-    ok 108 - decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001)) len
-    ok 109 - decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001)) value
-    ok 110 - decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001)) scale
-    ok 111 - decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001)) precision
-    ok 112 - str(decimal_unpack(decimal_pack(-0.0000000000000000000000000000000000001)) == -0.0000000000000000000000000000000000001
-    ok 113 - decimal_len(0.00000000000000000000000000000000000001)
-    ok 114 - decimal_len(0.00000000000000000000000000000000000001) == len(decimal_pack(0.00000000000000000000000000000000000001)
-    ok 115 - decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001))
-    ok 116 - decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001)) len
-    ok 117 - decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001)) value
-    ok 118 - decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001)) scale
-    ok 119 - decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001)) precision
-    ok 120 - str(decimal_unpack(decimal_pack(0.00000000000000000000000000000000000001)) == 0.00000000000000000000000000000000000001
-    ok 121 - decimal_len(-0.00000000000000000000000000000000000001)
-    ok 122 - decimal_len(-0.00000000000000000000000000000000000001) == len(decimal_pack(-0.00000000000000000000000000000000000001)
-    ok 123 - decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001))
-    ok 124 - decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001)) len
-    ok 125 - decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001)) value
-    ok 126 - decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001)) scale
-    ok 127 - decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001)) precision
-    ok 128 - str(decimal_unpack(decimal_pack(-0.00000000000000000000000000000000000001)) == -0.00000000000000000000000000000000000001
-    ok 129 - decimal_len(99999999999999999999999999999999999999)
-    ok 130 - decimal_len(99999999999999999999999999999999999999) == len(decimal_pack(99999999999999999999999999999999999999)
-    ok 131 - decimal_unpack(decimal_pack(99999999999999999999999999999999999999))
-    ok 132 - decimal_unpack(decimal_pack(99999999999999999999999999999999999999)) len
-    ok 133 - decimal_unpack(decimal_pack(99999999999999999999999999999999999999)) value
-    ok 134 - decimal_unpack(decimal_pack(99999999999999999999999999999999999999)) scale
-    ok 135 - decimal_unpack(decimal_pack(99999999999999999999999999999999999999)) precision
-    ok 136 - str(decimal_unpack(decimal_pack(99999999999999999999999999999999999999)) == 99999999999999999999999999999999999999
-    ok 137 - decimal_len(-99999999999999999999999999999999999999)
-    ok 138 - decimal_len(-99999999999999999999999999999999999999) == len(decimal_pack(-99999999999999999999999999999999999999)
-    ok 139 - decimal_unpack(decimal_pack(-99999999999999999999999999999999999999))
-    ok 140 - decimal_unpack(decimal_pack(-99999999999999999999999999999999999999)) len
-    ok 141 - decimal_unpack(decimal_pack(-99999999999999999999999999999999999999)) value
-    ok 142 - decimal_unpack(decimal_pack(-99999999999999999999999999999999999999)) scale
-    ok 143 - decimal_unpack(decimal_pack(-99999999999999999999999999999999999999)) precision
-    ok 144 - str(decimal_unpack(decimal_pack(-99999999999999999999999999999999999999)) == -99999999999999999999999999999999999999
-    ok 145 - decimal_len() is small for positive exponent decimal
-    ok 146 - positive exponent decimal length
-    ok 147 - decimal_unpack() of a positive exponent decimal
-    ok 148 - decimal_unpack uses every byte packed by decimal_pack
-    ok 149 - positive exponent number is packed/unpacked correctly
-    ok 150 - unpack malformed decimal fails
-    ok 151 - decode malformed decimal preserves buffer position
-ok 280 - subtests
-    1..198
-    ok 1 - mp_sizeof_decimal(0)
-    ok 2 - mp_sizeof_decimal(0) == len(mp_encode_decimal(0))
-    ok 3 - mp_next(mp_encode(0))
-    ok 4 - mp_decode(mp_encode(0) len
-    ok 5 - mp_decode(mp_encode(0)) value
-    ok 6 - mp_decode(mp_encode(0)) scale
-    ok 7 - str(mp_decode(mp_encode(0))) == 0
-    ok 8 - mp_ext_type is MP_DECIMAL
-    ok 9 - decimal_unpack() after mp_decode_extl()
-    ok 10 - decimal_unpack() after mp_decode_extl() value
-    ok 11 - decimal_unpack() after mp_decode_extl() len
-    ok 12 - mp_sizeof_decimal(-0)
-    ok 13 - mp_sizeof_decimal(-0) == len(mp_encode_decimal(-0))
-    ok 14 - mp_next(mp_encode(-0))
-    ok 15 - mp_decode(mp_encode(-0) len
-    ok 16 - mp_decode(mp_encode(-0)) value
-    ok 17 - mp_decode(mp_encode(-0)) scale
-    ok 18 - str(mp_decode(mp_encode(-0))) == -0
-    ok 19 - mp_ext_type is MP_DECIMAL
-    ok 20 - decimal_unpack() after mp_decode_extl()
-    ok 21 - decimal_unpack() after mp_decode_extl() value
-    ok 22 - decimal_unpack() after mp_decode_extl() len
-    ok 23 - mp_sizeof_decimal(1)
-    ok 24 - mp_sizeof_decimal(1) == len(mp_encode_decimal(1))
-    ok 25 - mp_next(mp_encode(1))
-    ok 26 - mp_decode(mp_encode(1) len
-    ok 27 - mp_decode(mp_encode(1)) value
-    ok 28 - mp_decode(mp_encode(1)) scale
-    ok 29 - str(mp_decode(mp_encode(1))) == 1
-    ok 30 - mp_ext_type is MP_DECIMAL
-    ok 31 - decimal_unpack() after mp_decode_extl()
-    ok 32 - decimal_unpack() after mp_decode_extl() value
-    ok 33 - decimal_unpack() after mp_decode_extl() len
-    ok 34 - mp_sizeof_decimal(-1)
-    ok 35 - mp_sizeof_decimal(-1) == len(mp_encode_decimal(-1))
-    ok 36 - mp_next(mp_encode(-1))
-    ok 37 - mp_decode(mp_encode(-1) len
-    ok 38 - mp_decode(mp_encode(-1)) value
-    ok 39 - mp_decode(mp_encode(-1)) scale
-    ok 40 - str(mp_decode(mp_encode(-1))) == -1
-    ok 41 - mp_ext_type is MP_DECIMAL
-    ok 42 - decimal_unpack() after mp_decode_extl()
-    ok 43 - decimal_unpack() after mp_decode_extl() value
-    ok 44 - decimal_unpack() after mp_decode_extl() len
-    ok 45 - mp_sizeof_decimal(0.1)
-    ok 46 - mp_sizeof_decimal(0.1) == len(mp_encode_decimal(0.1))
-    ok 47 - mp_next(mp_encode(0.1))
-    ok 48 - mp_decode(mp_encode(0.1) len
-    ok 49 - mp_decode(mp_encode(0.1)) value
-    ok 50 - mp_decode(mp_encode(0.1)) scale
-    ok 51 - str(mp_decode(mp_encode(0.1))) == 0.1
-    ok 52 - mp_ext_type is MP_DECIMAL
-    ok 53 - decimal_unpack() after mp_decode_extl()
-    ok 54 - decimal_unpack() after mp_decode_extl() value
-    ok 55 - decimal_unpack() after mp_decode_extl() len
-    ok 56 - mp_sizeof_decimal(-0.1)
-    ok 57 - mp_sizeof_decimal(-0.1) == len(mp_encode_decimal(-0.1))
-    ok 58 - mp_next(mp_encode(-0.1))
-    ok 59 - mp_decode(mp_encode(-0.1) len
-    ok 60 - mp_decode(mp_encode(-0.1)) value
-    ok 61 - mp_decode(mp_encode(-0.1)) scale
-    ok 62 - str(mp_decode(mp_encode(-0.1))) == -0.1
-    ok 63 - mp_ext_type is MP_DECIMAL
-    ok 64 - decimal_unpack() after mp_decode_extl()
-    ok 65 - decimal_unpack() after mp_decode_extl() value
-    ok 66 - decimal_unpack() after mp_decode_extl() len
-    ok 67 - mp_sizeof_decimal(2.718281828459045)
-    ok 68 - mp_sizeof_decimal(2.718281828459045) == len(mp_encode_decimal(2.718281828459045))
-    ok 69 - mp_next(mp_encode(2.718281828459045))
-    ok 70 - mp_decode(mp_encode(2.718281828459045) len
-    ok 71 - mp_decode(mp_encode(2.718281828459045)) value
-    ok 72 - mp_decode(mp_encode(2.718281828459045)) scale
-    ok 73 - str(mp_decode(mp_encode(2.718281828459045))) == 2.718281828459045
-    ok 74 - mp_ext_type is MP_DECIMAL
-    ok 75 - decimal_unpack() after mp_decode_extl()
-    ok 76 - decimal_unpack() after mp_decode_extl() value
-    ok 77 - decimal_unpack() after mp_decode_extl() len
-    ok 78 - mp_sizeof_decimal(-2.718281828459045)
-    ok 79 - mp_sizeof_decimal(-2.718281828459045) == len(mp_encode_decimal(-2.718281828459045))
-    ok 80 - mp_next(mp_encode(-2.718281828459045))
-    ok 81 - mp_decode(mp_encode(-2.718281828459045) len
-    ok 82 - mp_decode(mp_encode(-2.718281828459045)) value
-    ok 83 - mp_decode(mp_encode(-2.718281828459045)) scale
-    ok 84 - str(mp_decode(mp_encode(-2.718281828459045))) == -2.718281828459045
-    ok 85 - mp_ext_type is MP_DECIMAL
-    ok 86 - decimal_unpack() after mp_decode_extl()
-    ok 87 - decimal_unpack() after mp_decode_extl() value
-    ok 88 - decimal_unpack() after mp_decode_extl() len
-    ok 89 - mp_sizeof_decimal(3.141592653589793)
-    ok 90 - mp_sizeof_decimal(3.141592653589793) == len(mp_encode_decimal(3.141592653589793))
-    ok 91 - mp_next(mp_encode(3.141592653589793))
-    ok 92 - mp_decode(mp_encode(3.141592653589793) len
-    ok 93 - mp_decode(mp_encode(3.141592653589793)) value
-    ok 94 - mp_decode(mp_encode(3.141592653589793)) scale
-    ok 95 - str(mp_decode(mp_encode(3.141592653589793))) == 3.141592653589793
-    ok 96 - mp_ext_type is MP_DECIMAL
-    ok 97 - decimal_unpack() after mp_decode_extl()
-    ok 98 - decimal_unpack() after mp_decode_extl() value
-    ok 99 - decimal_unpack() after mp_decode_extl() len
-    ok 100 - mp_sizeof_decimal(-3.141592653589793)
-    ok 101 - mp_sizeof_decimal(-3.141592653589793) == len(mp_encode_decimal(-3.141592653589793))
-    ok 102 - mp_next(mp_encode(-3.141592653589793))
-    ok 103 - mp_decode(mp_encode(-3.141592653589793) len
-    ok 104 - mp_decode(mp_encode(-3.141592653589793)) value
-    ok 105 - mp_decode(mp_encode(-3.141592653589793)) scale
-    ok 106 - str(mp_decode(mp_encode(-3.141592653589793))) == -3.141592653589793
-    ok 107 - mp_ext_type is MP_DECIMAL
-    ok 108 - decimal_unpack() after mp_decode_extl()
-    ok 109 - decimal_unpack() after mp_decode_extl() value
-    ok 110 - decimal_unpack() after mp_decode_extl() len
-    ok 111 - mp_sizeof_decimal(1234567891234567890.0987654321987654321)
-    ok 112 - mp_sizeof_decimal(1234567891234567890.0987654321987654321) == len(mp_encode_decimal(1234567891234567890.0987654321987654321))
-    ok 113 - mp_next(mp_encode(1234567891234567890.0987654321987654321))
-    ok 114 - mp_decode(mp_encode(1234567891234567890.0987654321987654321) len
-    ok 115 - mp_decode(mp_encode(1234567891234567890.0987654321987654321)) value
-    ok 116 - mp_decode(mp_encode(1234567891234567890.0987654321987654321)) scale
-    ok 117 - str(mp_decode(mp_encode(1234567891234567890.0987654321987654321))) == 1234567891234567890.0987654321987654321
-    ok 118 - mp_ext_type is MP_DECIMAL
-    ok 119 - decimal_unpack() after mp_decode_extl()
-    ok 120 - decimal_unpack() after mp_decode_extl() value
-    ok 121 - decimal_unpack() after mp_decode_extl() len
-    ok 122 - mp_sizeof_decimal(-1234567891234567890.0987654321987654321)
-    ok 123 - mp_sizeof_decimal(-1234567891234567890.0987654321987654321) == len(mp_encode_decimal(-1234567891234567890.0987654321987654321))
-    ok 124 - mp_next(mp_encode(-1234567891234567890.0987654321987654321))
-    ok 125 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321) len
-    ok 126 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321)) value
-    ok 127 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321)) scale
-    ok 128 - str(mp_decode(mp_encode(-1234567891234567890.0987654321987654321))) == -1234567891234567890.0987654321987654321
-    ok 129 - mp_ext_type is MP_DECIMAL
-    ok 130 - decimal_unpack() after mp_decode_extl()
-    ok 131 - decimal_unpack() after mp_decode_extl() value
-    ok 132 - decimal_unpack() after mp_decode_extl() len
-    ok 133 - mp_sizeof_decimal(0.0000000000000000000000000000000000001)
-    ok 134 - mp_sizeof_decimal(0.0000000000000000000000000000000000001) == len(mp_encode_decimal(0.0000000000000000000000000000000000001))
-    ok 135 - mp_next(mp_encode(0.0000000000000000000000000000000000001))
-    ok 136 - mp_decode(mp_encode(0.0000000000000000000000000000000000001) len
-    ok 137 - mp_decode(mp_encode(0.0000000000000000000000000000000000001)) value
-    ok 138 - mp_decode(mp_encode(0.0000000000000000000000000000000000001)) scale
-    ok 139 - str(mp_decode(mp_encode(0.0000000000000000000000000000000000001))) == 0.0000000000000000000000000000000000001
-    ok 140 - mp_ext_type is MP_DECIMAL
-    ok 141 - decimal_unpack() after mp_decode_extl()
-    ok 142 - decimal_unpack() after mp_decode_extl() value
-    ok 143 - decimal_unpack() after mp_decode_extl() len
-    ok 144 - mp_sizeof_decimal(-0.0000000000000000000000000000000000001)
-    ok 145 - mp_sizeof_decimal(-0.0000000000000000000000000000000000001) == len(mp_encode_decimal(-0.0000000000000000000000000000000000001))
-    ok 146 - mp_next(mp_encode(-0.0000000000000000000000000000000000001))
-    ok 147 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001) len
-    ok 148 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001)) value
-    ok 149 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001)) scale
-    ok 150 - str(mp_decode(mp_encode(-0.0000000000000000000000000000000000001))) == -0.0000000000000000000000000000000000001
-    ok 151 - mp_ext_type is MP_DECIMAL
-    ok 152 - decimal_unpack() after mp_decode_extl()
-    ok 153 - decimal_unpack() after mp_decode_extl() value
-    ok 154 - decimal_unpack() after mp_decode_extl() len
-    ok 155 - mp_sizeof_decimal(0.00000000000000000000000000000000000001)
-    ok 156 - mp_sizeof_decimal(0.00000000000000000000000000000000000001) == len(mp_encode_decimal(0.00000000000000000000000000000000000001))
-    ok 157 - mp_next(mp_encode(0.00000000000000000000000000000000000001))
-    ok 158 - mp_decode(mp_encode(0.00000000000000000000000000000000000001) len
-    ok 159 - mp_decode(mp_encode(0.00000000000000000000000000000000000001)) value
-    ok 160 - mp_decode(mp_encode(0.00000000000000000000000000000000000001)) scale
-    ok 161 - str(mp_decode(mp_encode(0.00000000000000000000000000000000000001))) == 0.00000000000000000000000000000000000001
-    ok 162 - mp_ext_type is MP_DECIMAL
-    ok 163 - decimal_unpack() after mp_decode_extl()
-    ok 164 - decimal_unpack() after mp_decode_extl() value
-    ok 165 - decimal_unpack() after mp_decode_extl() len
-    ok 166 - mp_sizeof_decimal(-0.00000000000000000000000000000000000001)
-    ok 167 - mp_sizeof_decimal(-0.00000000000000000000000000000000000001) == len(mp_encode_decimal(-0.00000000000000000000000000000000000001))
-    ok 168 - mp_next(mp_encode(-0.00000000000000000000000000000000000001))
-    ok 169 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001) len
-    ok 170 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001)) value
-    ok 171 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001)) scale
-    ok 172 - str(mp_decode(mp_encode(-0.00000000000000000000000000000000000001))) == -0.00000000000000000000000000000000000001
-    ok 173 - mp_ext_type is MP_DECIMAL
-    ok 174 - decimal_unpack() after mp_decode_extl()
-    ok 175 - decimal_unpack() after mp_decode_extl() value
-    ok 176 - decimal_unpack() after mp_decode_extl() len
-    ok 177 - mp_sizeof_decimal(99999999999999999999999999999999999999)
-    ok 178 - mp_sizeof_decimal(99999999999999999999999999999999999999) == len(mp_encode_decimal(99999999999999999999999999999999999999))
-    ok 179 - mp_next(mp_encode(99999999999999999999999999999999999999))
-    ok 180 - mp_decode(mp_encode(99999999999999999999999999999999999999) len
-    ok 181 - mp_decode(mp_encode(99999999999999999999999999999999999999)) value
-    ok 182 - mp_decode(mp_encode(99999999999999999999999999999999999999)) scale
-    ok 183 - str(mp_decode(mp_encode(99999999999999999999999999999999999999))) == 99999999999999999999999999999999999999
-    ok 184 - mp_ext_type is MP_DECIMAL
-    ok 185 - decimal_unpack() after mp_decode_extl()
-    ok 186 - decimal_unpack() after mp_decode_extl() value
-    ok 187 - decimal_unpack() after mp_decode_extl() len
-    ok 188 - mp_sizeof_decimal(-99999999999999999999999999999999999999)
-    ok 189 - mp_sizeof_decimal(-99999999999999999999999999999999999999) == len(mp_encode_decimal(-99999999999999999999999999999999999999))
-    ok 190 - mp_next(mp_encode(-99999999999999999999999999999999999999))
-    ok 191 - mp_decode(mp_encode(-99999999999999999999999999999999999999) len
-    ok 192 - mp_decode(mp_encode(-99999999999999999999999999999999999999)) value
-    ok 193 - mp_decode(mp_encode(-99999999999999999999999999999999999999)) scale
-    ok 194 - str(mp_decode(mp_encode(-99999999999999999999999999999999999999))) == -99999999999999999999999999999999999999
-    ok 195 - mp_ext_type is MP_DECIMAL
-    ok 196 - decimal_unpack() after mp_decode_extl()
-    ok 197 - decimal_unpack() after mp_decode_extl() value
-    ok 198 - decimal_unpack() after mp_decode_extl() len
-ok 281 - subtests
-    1..5
-	*** test_mp_print ***
-    ok 1 - correct mp_snprint size with empty buffer
-    ok 2 - correct mp_snprint size
-    ok 3 - correct mp_snprint result
-    ok 4 - correct mp_fprint size
-    ok 5 - correct mp_fprint result
-	*** test_mp_print: done ***
-ok 282 - subtests
diff --git a/test/unit/fiber.cc b/test/unit/fiber.cc
index b0dfc9b14..8568346e8 100644
--- a/test/unit/fiber.cc
+++ b/test/unit/fiber.cc
@@ -98,7 +98,7 @@ fiber_join_test()
 		note("exception propagated");
 	}
 
-	fputs("#gh-1238: log uncaught errors\n", stderr);
+	note("log uncaught errors (gh-1238)");
 	fiber = fiber_new_xc("exception", exception_f);
 	fiber_wakeup(fiber);
 
@@ -165,11 +165,12 @@ void
 fiber_name_test()
 {
 	header();
-	note("name of a new fiber: %s.\n", fiber_name(fiber()));
+
+	note("name of a new fiber: %s", fiber_name(fiber()));
 
 	fiber_set_name(fiber(), "Horace");
 
-	note("set new fiber name: %s.\n", fiber_name(fiber()));
+	note("set new fiber name: %s", fiber_name(fiber()));
 
 	char long_name[FIBER_NAME_MAX + 30];
 	memset(long_name, 'a', sizeof(long_name));
@@ -177,17 +178,20 @@ fiber_name_test()
 
 	fiber_set_name(fiber(), long_name);
 
-	note("fiber name is truncated: %s.\n", fiber_name(fiber()));
+	note("fiber name is truncated: %s", fiber_name(fiber()));
+
 	footer();
 }
 
 static int
 main_f(va_list ap)
 {
+	plan(0);
 	fiber_name_test();
 	fiber_join_test();
 	fiber_stack_test();
 	ev_break(loop(), EVBREAK_ALL);
+	check_plan();
 	return 0;
 }
 
diff --git a/test/unit/fiber.result b/test/unit/fiber.result
deleted file mode 100644
index a61e0a2b8..000000000
--- a/test/unit/fiber.result
+++ /dev/null
@@ -1,19 +0,0 @@
-#gh-1238: log uncaught errors
-SystemError Failed to allocate 42 bytes in allocator for exception: Cannot allocate memory
-	*** fiber_name_test ***
-# name of a new fiber: main.
-
-# set new fiber name: Horace.
-
-# fiber name is truncated: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.
-
-	*** fiber_name_test: done ***
-	*** fiber_join_test ***
-# exception propagated
-# cancel dead has started
-# by this time the fiber should be dead already
-	*** fiber_join_test: done ***
-	*** fiber_stack_test ***
-# normal-stack fiber not crashed
-# big-stack fiber not crashed
-	*** fiber_stack_test: done ***
diff --git a/test/unit/fiber_channel.cc b/test/unit/fiber_channel.cc
index 90c73a581..3b403768a 100644
--- a/test/unit/fiber_channel.cc
+++ b/test/unit/fiber_channel.cc
@@ -90,6 +90,7 @@ main_f(va_list ap)
 
 int main()
 {
+	plan(2);
 	memory_init();
 	fiber_init(fiber_c_invoke);
 	struct fiber *main= fiber_new_xc("main", main_f);
@@ -97,5 +98,6 @@ int main()
 	ev_run(loop(), 0);
 	fiber_free();
 	memory_free();
+	check_plan();
 	return status;
 }
diff --git a/test/unit/fiber_channel.result b/test/unit/fiber_channel.result
deleted file mode 100644
index b03949d8c..000000000
--- a/test/unit/fiber_channel.result
+++ /dev/null
@@ -1,23 +0,0 @@
-	*** fiber_channel_basic ***
-1..10
-ok 1 - fiber_channel_new()
-ok 2 - fiber_channel_size()
-ok 3 - fiber_channel_count()
-ok 4 - fiber_channel_is_full()
-ok 5 - fiber_channel_is_empty()
-ok 6 - fiber_channel_size(1)
-ok 7 - fiber_channel_count(1)
-ok 8 - fiber_channel_is_full(1)
-ok 9 - fiber_channel_is_empty(1)
-ok 10 - fiber_channel_get()
-	*** fiber_channel_basic: done ***
-	*** fiber_channel_get ***
-1..7
-ok 1 - fiber_channel_put(0)
-ok 2 - fiber_channel_put_timeout(0)
-ok 3 - fiber_channel_get(0)
-ok 4 - fiber_channel_put_timeout(1)
-ok 5 - fiber_channel_get(1)
-ok 6 - fiber_channel_put(closed)
-ok 7 - fiber_channel_get(closed)
-	*** fiber_channel_get: done ***
diff --git a/test/unit/fiber_channel_stress.cc b/test/unit/fiber_channel_stress.cc
index 98aec697b..e37f58751 100644
--- a/test/unit/fiber_channel_stress.cc
+++ b/test/unit/fiber_channel_stress.cc
@@ -50,6 +50,7 @@ main_f(va_list ap)
 
 int main()
 {
+	plan(0);
 	memory_init();
 	fiber_init(fiber_c_invoke);
 	struct fiber *main= fiber_new_xc("main", main_f);
@@ -57,5 +58,6 @@ int main()
 	ev_run(loop(), 0);
 	fiber_free();
 	memory_free();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/fiber_channel_stress.result b/test/unit/fiber_channel_stress.result
deleted file mode 100644
index 7abdb54e0..000000000
--- a/test/unit/fiber_channel_stress.result
+++ /dev/null
@@ -1,2 +0,0 @@
-	*** main_f ***
-	*** main_f: done ***
diff --git a/test/unit/fiber_cond.result b/test/unit/fiber_cond.result
deleted file mode 100644
index 20539e2be..000000000
--- a/test/unit/fiber_cond.result
+++ /dev/null
@@ -1,8 +0,0 @@
-1..7
-ok 1 - timeout
-ok 2 - timeout
-ok 3 - signal
-ok 4 - signal
-ok 5 - order
-ok 6 - broadcast
-ok 7 - broadcast
diff --git a/test/unit/fiber_stack.c b/test/unit/fiber_stack.c
index 41abe3764..202d963c2 100644
--- a/test/unit/fiber_stack.c
+++ b/test/unit/fiber_stack.c
@@ -97,6 +97,7 @@ main_f(va_list ap)
 
 int main()
 {
+	plan(0);
 	memory_init();
 	fiber_init(fiber_c_invoke);
 	fiber_attr_create(&default_attr);
@@ -105,5 +106,7 @@ int main()
 	ev_run(loop(), 0);
 	fiber_free();
 	memory_free();
+	check_plan();
+
 	return 0;
 }
diff --git a/test/unit/fiber_stack.result b/test/unit/fiber_stack.result
deleted file mode 100644
index 7cae4e96c..000000000
--- a/test/unit/fiber_stack.result
+++ /dev/null
@@ -1,11 +0,0 @@
-SystemError fiber mprotect failed: Cannot allocate memory
-fiber: Can't put guard page to slab. Leak 57344 bytes: Cannot allocate memory
-	*** main_f ***
-1..6
-ok 1 - mprotect: failed to setup fiber guard page
-ok 2 - mprotect: diag is armed after error
-ok 3 - madvise: non critical error on madvise hint
-ok 4 - madvise: diag is armed after error
-ok 5 - fiber with custom stack
-ok 6 - expected leak detected
-	*** main_f: done ***
diff --git a/test/unit/fiber_stress.cc b/test/unit/fiber_stress.cc
index 44ab12487..9f532c24b 100644
--- a/test/unit/fiber_stress.cc
+++ b/test/unit/fiber_stress.cc
@@ -1,5 +1,6 @@
 #include "memory.h"
 #include "fiber.h"
+#include "unit.h"
 
 enum {
 	ITERATIONS = 50000,
@@ -35,6 +36,7 @@ benchmark_f(va_list ap)
 
 int main()
 {
+	plan(0);
 	memory_init();
 	fiber_init(fiber_cxx_invoke);
 	struct fiber *benchmark = fiber_new_xc("benchmark", benchmark_f);
@@ -42,5 +44,6 @@ int main()
 	ev_run(loop(), 0);
 	fiber_free();
 	memory_free();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/fiber_stress.result b/test/unit/fiber_stress.result
deleted file mode 100644
index e69de29bb..000000000
diff --git a/test/unit/find_path.c b/test/unit/find_path.c
index 5c6c0a8b6..0857eb306 100644
--- a/test/unit/find_path.c
+++ b/test/unit/find_path.c
@@ -11,6 +11,8 @@ int
 main(int argc, char *argv[])
 {
 	header();
+	plan(0);
 	fail_unless(open(find_path(argv[0]), O_RDONLY) >= 0);
+	check_plan();
 	footer();
 }
diff --git a/test/unit/find_path.result b/test/unit/find_path.result
deleted file mode 100644
index 8300f0550..000000000
--- a/test/unit/find_path.result
+++ /dev/null
@@ -1,2 +0,0 @@
-	*** main ***
-	*** main: done ***
diff --git a/test/unit/guard.cc b/test/unit/guard.cc
index a2953b829..71b116f09 100644
--- a/test/unit/guard.cc
+++ b/test/unit/guard.cc
@@ -53,6 +53,7 @@ main_f(va_list ap)
 
 int main()
 {
+	plan(0);
 	memory_init();
 	fiber_init(fiber_cxx_invoke);
 	fiber_attr_create(&default_attr);
diff --git a/test/unit/guard.result b/test/unit/guard.result
deleted file mode 100644
index bc9889d42..000000000
--- a/test/unit/guard.result
+++ /dev/null
@@ -1 +0,0 @@
-# signal handler called
diff --git a/test/unit/guava.c b/test/unit/guava.c
index 4e3ced76a..cdc721a8d 100644
--- a/test/unit/guava.c
+++ b/test/unit/guava.c
@@ -61,7 +61,9 @@ lcg_compat_check()
 int
 main(void)
 {
+	plan(0);
 	correctness_check();
 	lcg_compat_check();
 	sameresult_check();
+	check_plan();
 }
diff --git a/test/unit/guava.result b/test/unit/guava.result
deleted file mode 100644
index afc3e890f..000000000
--- a/test/unit/guava.result
+++ /dev/null
@@ -1,6 +0,0 @@
-	*** correctness_check ***
-	*** correctness_check: done ***
-	*** lcg_compat_check ***
-	*** lcg_compat_check: done ***
-	*** sameresult_check ***
-	*** sameresult_check: done ***
diff --git a/test/unit/heap.c b/test/unit/heap.c
index 89806c633..b6fc668cd 100644
--- a/test/unit/heap.c
+++ b/test/unit/heap.c
@@ -533,6 +533,7 @@ test_heapify()
 int
 main(int argc, const char** argv)
 {
+	plan(0);
 	srand(179);
 	test_insert_1_to_3();
 	test_insert_3_to_1();
@@ -546,4 +547,5 @@ main(int argc, const char** argv)
 	test_random_delete_workload();
 	test_delete_last_node();
 	test_heapify();
+	check_plan();
 }
diff --git a/test/unit/heap.result b/test/unit/heap.result
deleted file mode 100644
index 7928983c1..000000000
--- a/test/unit/heap.result
+++ /dev/null
@@ -1,24 +0,0 @@
-	*** test_insert_1_to_3 ***
-	*** test_insert_1_to_3: done ***
-	*** test_insert_3_to_1 ***
-	*** test_insert_3_to_1: done ***
-	*** test_insert_50_to_150_mod_100 ***
-	*** test_insert_50_to_150_mod_100: done ***
-	*** test_insert_many_random ***
-	*** test_insert_many_random: done ***
-	*** test_insert_10_to_1_pop ***
-	*** test_insert_10_to_1_pop: done ***
-	*** test_insert_many_pop_many_random ***
-	*** test_insert_many_pop_many_random: done ***
-	*** test_insert_pop_workload ***
-	*** test_insert_pop_workload: done ***
-	*** test_pop_last ***
-	*** test_pop_last: done ***
-	*** test_insert_update_workload ***
-	*** test_insert_update_workload: done ***
-	*** test_random_delete_workload ***
-	*** test_random_delete_workload: done ***
-	*** test_delete_last_node ***
-	*** test_delete_last_node: done ***
-	*** test_heapify ***
-	*** test_heapify: done ***
diff --git a/test/unit/heap_iterator.c b/test/unit/heap_iterator.c
index 4fde39dfe..291b2066f 100644
--- a/test/unit/heap_iterator.c
+++ b/test/unit/heap_iterator.c
@@ -188,8 +188,10 @@ int
 main(int argc, const char** argv)
 {
 	srand(179);
+	plan(0);
 	test_iterator_create();
 	test_iterator_empty();
 	test_iterator_small();
 	test_iterator_large();
+	check_plan();
 }
diff --git a/test/unit/heap_iterator.result b/test/unit/heap_iterator.result
deleted file mode 100644
index 66b99dcc6..000000000
--- a/test/unit/heap_iterator.result
+++ /dev/null
@@ -1,8 +0,0 @@
-	*** test_iterator_create ***
-	*** test_iterator_create: done ***
-	*** test_iterator_empty ***
-	*** test_iterator_empty: done ***
-	*** test_iterator_small ***
-	*** test_iterator_small: done ***
-	*** test_iterator_large ***
-	*** test_iterator_large: done ***
diff --git a/test/unit/histogram.c b/test/unit/histogram.c
index 3056d20fe..084c7eff6 100644
--- a/test/unit/histogram.c
+++ b/test/unit/histogram.c
@@ -177,8 +177,10 @@ test_percentile(void)
 int
 main()
 {
+	plan(0);
 	srand(time(NULL));
 	test_counts();
 	test_discard();
 	test_percentile();
+	check_plan();
 }
diff --git a/test/unit/histogram.result b/test/unit/histogram.result
deleted file mode 100644
index e393c194d..000000000
--- a/test/unit/histogram.result
+++ /dev/null
@@ -1,6 +0,0 @@
-	*** test_counts ***
-	*** test_counts: done ***
-	*** test_discard ***
-	*** test_discard: done ***
-	*** test_percentile ***
-	*** test_percentile: done ***
diff --git a/test/unit/int96.cc b/test/unit/int96.cc
index 29dbbcbf5..09424d144 100644
--- a/test/unit/int96.cc
+++ b/test/unit/int96.cc
@@ -2,8 +2,6 @@
 
 #include "unit.h"
 
-#define check(expr) if (!(expr)) printf("failed at %s:%d\n", __FILE__, __LINE__)
-
 static void
 test()
 {
@@ -15,50 +13,50 @@ test()
 	int96_set_unsigned(&num1, a);
 	int96_set_unsigned(&num2, a);
 	int96_invert(&num2);
-	check(int96_is_neg_int64(&num2));
-	check(int96_extract_neg_int64(&num2) == int64_t(-a));
-	check(int96_is_uint64(&num));
-	check(int96_extract_uint64(&num) == 0);
+	is(int96_is_neg_int64(&num2), true, "int96_is_neg_int64()");
+	is(int96_extract_neg_int64(&num2), int64_t(-a), "int96_extract_neg_int64()");
+	is(int96_is_uint64(&num), true, "int96_is_uint64()");
+	is(int96_extract_uint64(&num), 0, "int96_extract_uint64()");
 	int96_add(&num, &num1);
-	check(int96_is_uint64(&num));
-	check(int96_extract_uint64(&num) == a);
+	is(int96_is_uint64(&num), true, "int96_is_uint64()");
+	is(int96_extract_uint64(&num), a, "int96_extract_uint64()");
 	int96_add(&num, &num1);
-	check(int96_is_uint64(&num));
-	check(int96_extract_uint64(&num) == a * 2);
+	is(int96_is_uint64(&num), true, "int96_is_uint64()");
+	is(int96_extract_uint64(&num), a * 2, "int96_extract_uint64()");
 	for (int i = 1; i < 1000; i++) {
 		for(int j = 0; j < i; j++) {
 			int96_add(&num, &num1);
-			check(!int96_is_uint64(&num) && !int96_is_neg_int64(&num));
+			fail_if(!(!int96_is_uint64(&num) && !int96_is_neg_int64(&num)));
 		}
 		for(int j = 0; j < i - 1; j++) {
 			int96_add(&num, &num2);
-			check(!int96_is_uint64(&num) && !int96_is_neg_int64(&num));
+			fail_if(!(!int96_is_uint64(&num) && !int96_is_neg_int64(&num)));
 		}
 		int96_add(&num, &num2);
-		check(int96_is_uint64(&num));
-		check(int96_extract_uint64(&num) == a * 2);
+		fail_if(!int96_is_uint64(&num));
+		fail_if(int96_extract_uint64(&num) != a * 2);
 	}
 	int96_add(&num, &num2);
-	check(int96_is_uint64(&num));
-	check(int96_extract_uint64(&num) == a);
+	is(int96_is_uint64(&num), true, "int96_is_uint64()");
+	is(int96_extract_uint64(&num), a, "int96_extract_uint64()");
 	int96_add(&num, &num2);
-	check(int96_is_uint64(&num));
-	check(int96_extract_uint64(&num) == 0);
+	is(int96_is_uint64(&num), true, "int96_is_uint64()");
+	is(int96_extract_uint64(&num), 0, "int96_extract_uint64()");
 	int96_add(&num, &num2);
-	check(int96_is_neg_int64(&num));
-	check(int96_extract_neg_int64(&num) == int64_t(-a));
+	is(int96_is_neg_int64(&num), true, "int96_is_neg_int64()");
+	is(int96_extract_neg_int64(&num), int64_t(-a), "int96_extract_neg_int64()");
 	for (int i = 1; i < 1000; i++) {
 		for(int j = 0; j < i; j++) {
 			int96_add(&num, &num2);
-			check(!int96_is_uint64(&num) && !int96_is_neg_int64(&num));
+			fail_if(!(!int96_is_uint64(&num) && !int96_is_neg_int64(&num)));
 		}
 		for(int j = 0; j < i - 1; j++) {
 			int96_add(&num, &num1);
-			check(!int96_is_uint64(&num) && !int96_is_neg_int64(&num));
+			fail_if(!(!int96_is_uint64(&num) && !int96_is_neg_int64(&num)));
 		}
 		int96_add(&num, &num1);
-		check(int96_is_neg_int64(&num));
-		check(int96_extract_neg_int64(&num) == int64_t(-a));
+		fail_if(!(int96_is_neg_int64(&num)));
+		fail_if(int96_extract_neg_int64(&num) != int64_t(-a));
 	}
 
 	footer();
@@ -67,5 +65,7 @@ test()
 int
 main(int, const char **)
 {
+	plan(14);
 	test();
+	check_plan();
 }
diff --git a/test/unit/int96.result b/test/unit/int96.result
deleted file mode 100644
index 4a0b26f56..000000000
--- a/test/unit/int96.result
+++ /dev/null
@@ -1,2 +0,0 @@
-	*** test ***
-	*** test: done ***
diff --git a/test/unit/json.result b/test/unit/json.result
deleted file mode 100644
index fb9d1490f..000000000
--- a/test/unit/json.result
+++ /dev/null
@@ -1,208 +0,0 @@
-	*** main ***
-1..6
-	*** test_basic ***
-    1..71
-    ok 1 - parse <[1]>
-    ok 2 - <[1]> is num
-    ok 3 - <[1]> is 0
-    ok 4 - parse <field1>
-    ok 5 - <field1> is str
-    ok 6 - len is 6
-    ok 7 - str is field1
-    ok 8 - parse <field2>
-    ok 9 - <field2> is str
-    ok 10 - len is 6
-    ok 11 - str is field2
-    ok 12 - parse <field3>
-    ok 13 - <field3> is str
-    ok 14 - len is 6
-    ok 15 - str is field3
-    ok 16 - parse <[5]>
-    ok 17 - <[5]> is num
-    ok 18 - <[5]> is 4
-    ok 19 - parse <[3]>
-    ok 20 - <[3]> is num
-    ok 21 - <[3]> is 2
-    ok 22 - parse <field>
-    ok 23 - <field> is str
-    ok 24 - len is 5
-    ok 25 - str is field
-    ok 26 - parse <[2]>
-    ok 27 - <[2]> is num
-    ok 28 - <[2]> is 1
-    ok 29 - parse <field>
-    ok 30 - <field> is str
-    ok 31 - len is 5
-    ok 32 - str is field
-    ok 33 - parse <f1>
-    ok 34 - <f1> is str
-    ok 35 - len is 2
-    ok 36 - str is f1
-    ok 37 - parse <f2'3'>
-    ok 38 - <f2'3'> is str
-    ok 39 - len is 5
-    ok 40 - str is f2'3'
-    ok 41 - parse <field1>
-    ok 42 - <field1> is str
-    ok 43 - len is 6
-    ok 44 - str is field1
-    ok 45 - parse <field1>
-    ok 46 - <field1> is str
-    ok 47 - len is 6
-    ok 48 - str is field1
-    ok 49 - parse <[1234]>
-    ok 50 - <[1234]> is num
-    ok 51 - <[1234]> is 1233
-    ok 52 - parse empty path
-    ok 53 - is str
-    ok 54 - parse <field1>
-    ok 55 - <field1> is str
-    ok 56 - len is 6
-    ok 57 - str is field1
-    ok 58 - parse <[2]>
-    ok 59 - <[2]> is num
-    ok 60 - <[2]> is 1
-    ok 61 - parse <[6]>
-    ok 62 - <[6]> is num
-    ok 63 - <[6]> is 5
-    ok 64 - parse <привет中国world>
-    ok 65 - <привет中国world> is str
-    ok 66 - len is 23
-    ok 67 - str is привет中国world
-    ok 68 - parse <中国a>
-    ok 69 - <中国a> is str
-    ok 70 - len is 7
-    ok 71 - str is 中国a
-ok 1 - subtests
-	*** test_basic: done ***
-	*** test_errors ***
-    1..22
-    ok 1 - error on position 2 for <[[>
-    ok 2 - error on position 2 for <[field]>
-    ok 3 - error on position 1 for <'field1'.field2>
-    ok 4 - error on position 2 for <[]>
-    ok 5 - error on position 1 for <''>
-    ok 6 - error on position 1 for < field1>
-    ok 7 - error on position 1 for <1field>
-    ok 8 - error on position 2 for <.1field>
-    ok 9 - error on position 8 for <['field>
-    ok 10 - error on position 9 for <['field'>
-    ok 11 - error on position 5 for <[123>
-    ok 12 - error on position 3 for <['']>
-    ok 13 - error on position 2 for <.[123]>
-    ok 14 - error on position 2 for <[.]>
-    ok 15 - error on position 6 for <['aaaÂÂ']>
-    ok 16 - error on position 2 for <.ÂÂ>
-    ok 17 - can not write <field.[index]>
-    ok 18 - can not omit '.' before not a first key out of []
-    ok 19 - error in leading <.>
-    ok 20 - space inside identifier
-    ok 21 - tab inside identifier
-    ok 22 - invalid token for index_base 1
-ok 2 - subtests
-	*** test_errors: done ***
-	*** test_tree ***
-    1..65
-    ok 1 - add path '[1][10]'
-    ok 2 - add path '[1][20].file'
-    ok 3 - add path '[1][20].file[2]'
-    ok 4 - add path '[1][20].file[8]'
-    ok 5 - add path '[1][20]["file"][8]'
-    ok 6 - lookup path '[1][10]'
-    ok 7 - lookup path '[1][20].file'
-    ok 8 - lookup unregistered path '[1][3]'
-    ok 9 - test foreach pre order 0: have 0 expected of 0
-    ok 10 - test foreach pre order 1: have 1 expected of 1
-    ok 11 - test foreach pre order 2: have 2 expected of 2
-    ok 12 - test foreach pre order 3: have 3 expected of 3
-    ok 13 - test foreach pre order 4: have 4 expected of 4
-    ok 14 - test foreach pre order 5: have 5 expected of 5
-    ok 15 - records iterated count 6 of 6
-    ok 16 - test foreach post order 0: have 1 expected of 1
-    ok 17 - test foreach post order 1: have 4 expected of 4
-    ok 18 - test foreach post order 2: have 5 expected of 5
-    ok 19 - test foreach post order 3: have 3 expected of 3
-    ok 20 - test foreach post order 4: have 2 expected of 2
-    ok 21 - test foreach post order 5: have 0 expected of 0
-    ok 22 - records iterated count 6 of 6
-    ok 23 - test foreach safe order 0: have 1 expected of 1
-    ok 24 - test foreach safe order 1: have 4 expected of 4
-    ok 25 - test foreach safe order 2: have 5 expected of 5
-    ok 26 - test foreach safe order 3: have 3 expected of 3
-    ok 27 - test foreach safe order 4: have 2 expected of 2
-    ok 28 - test foreach safe order 5: have 0 expected of 0
-    ok 29 - records iterated count 6 of 6
-    ok 30 - test foreach entry pre order 0: have 0 expected of 0
-    ok 31 - test foreach entry pre order 1: have 1 expected of 1
-    ok 32 - test foreach entry pre order 2: have 2 expected of 2
-    ok 33 - test foreach entry pre order 3: have 3 expected of 3
-    ok 34 - test foreach entry pre order 4: have 4 expected of 4
-    ok 35 - test foreach entry pre order 5: have 5 expected of 5
-    ok 36 - records iterated count 6 of 6
-    ok 37 - test foreach entry post order 0: have 1 expected of 1
-    ok 38 - test foreach entry post order 1: have 4 expected of 4
-    ok 39 - test foreach entry post order 2: have 5 expected of 5
-    ok 40 - test foreach entry post order 3: have 3 expected of 3
-    ok 41 - test foreach entry post order 4: have 2 expected of 2
-    ok 42 - test foreach entry post order 5: have 0 expected of 0
-    ok 43 - records iterated count 6 of 6
-    ok 44 - max_child_index 7 expected of 7
-    ok 45 - max_child_index 1 expected of 1
-    ok 46 - max_child_index -1 expected of -1
-    ok 47 - lookup removed path '[1][20].file[2]'
-    ok 48 - lookup removed path '[1][20].file[8]'
-    ok 49 - lookup path was not corrupted '[1][20].file'
-    ok 50 - test foreach entry safe order 0: have 1 expected of 1
-    ok 51 - test foreach entry safe order 1: have 3 expected of 3
-    ok 52 - test foreach entry safe order 2: have 2 expected of 2
-    ok 53 - test foreach entry safe order 3: have 0 expected of 0
-    ok 54 - records iterated count 4 of 4
-    ok 55 - interm node is not leaf
-    ok 56 - last node is leaf
-    ok 57 - last node became interm - it can't be leaf anymore
-    ok 58 - last node is leaf
-    ok 59 - add path '[1][10]'
-    ok 60 - lookup any token in non-multikey node
-    ok 61 - add path '[1][*]["data"]'
-    ok 62 - lookup path '[1][*]["data"]'
-    ok 63 - lookup numeric token in multikey node
-    ok 64 - lookup any token in multikey node
-    ok 65 - lookup string token in multikey node
-ok 3 - subtests
-	*** test_tree: done ***
-	*** test_path_cmp ***
-    1..8
-    ok 1 - path cmp result "Data[1]["FIO"].fname" with "Data[1]["FIO"].fname": have 0, expected 0
-    ok 2 - path cmp result "Data[1]["FIO"].fname" with "["Data"][1].FIO["fname"]": have 0, expected 0
-    ok 3 - path cmp result "Data[1]["FIO"].fname" with "Data[1]": have 1, expected 1
-    ok 4 - path cmp result "Data[1]["FIO"].fname" with "Data[1]["FIO"].fname[1]": have -1, expected -1
-    ok 5 - path cmp result "Data[1]["FIO"].fname" with "Data[1]["Info"].fname[1]": have -1, expected -1
-    ok 6 - path cmp result "Data[*]["FIO"].fname[*]" with "["Data"][*].FIO["fname"][*]": have 0, expected 0
-    ok 7 - path Data[1]["FIO"].fname is valid
-    ok 8 - path Data[[1]["FIO"].fname error pos 6 expected 6
-ok 4 - subtests
-	*** test_path_cmp: done ***
-	*** test_path_snprint ***
-    1..9
-    ok 1 - full path - retval
-    ok 2 - full path - terminating nul
-    ok 3 - full path - output
-    ok 4 - truncated path - retval
-    ok 5 - truncated path - terminating nul
-    ok 6 - truncated path - output
-    ok 7 - 1-byte buffer - retval
-    ok 8 - 1-byte buffer - terminating nul
-    ok 9 - 0-byte buffer - retval
-ok 5 - subtests
-	*** test_path_snprint: done ***
-	*** test_path_multikey ***
-    1..6
-    ok 1 - Test json_path_multikey_offset with : have 0 expected 0
-    ok 2 - Test json_path_multikey_offset with [1].Data[1].extra[1]: have 20 expected 20
-    ok 3 - Test json_path_multikey_offset with [*].Data[1].extra[1]: have 0 expected 0
-    ok 4 - Test json_path_multikey_offset with [*].Data[*].extra[1]: have 0 expected 0
-    ok 5 - Test json_path_multikey_offset with [1].Data[*].extra[1]: have 8 expected 8
-    ok 6 - Test json_path_multikey_offset with [1].Data[1].extra[*]: have 17 expected 17
-ok 6 - subtests
-	*** test_path_multikey: done ***
-	*** main: done ***
diff --git a/test/unit/light.cc b/test/unit/light.cc
index 6d89938b4..65e8adf47 100644
--- a/test/unit/light.cc
+++ b/test/unit/light.cc
@@ -80,11 +80,7 @@ simple_test()
 			hash_t fnd = light_find(&ht, h, val);
 			bool has1 = fnd != light_end;
 			bool has2 = vect[val];
-			assert(has1 == has2);
-			if (has1 != has2) {
-				fail("find key failed!", "true");
-				return;
-			}
+			fail_if(has1 != has2);
 
 			if (!has1) {
 				count++;
@@ -144,11 +140,7 @@ collision_test()
 			hash_t fnd = light_find(&ht, h * 1024, val);
 			bool has1 = fnd != light_end;
 			bool has2 = vect[val];
-			assert(has1 == has2);
-			if (has1 != has2) {
-				fail("find key failed!", "true");
-				return;
-			}
+			fail_if(has1 != has2);
 
 			if (!has1) {
 				count++;
@@ -320,6 +312,7 @@ iterator_freeze_check()
 int
 main(int, const char**)
 {
+	plan(0);
 	srand(time(0));
 	simple_test();
 	collision_test();
@@ -327,4 +320,5 @@ main(int, const char**)
 	iterator_freeze_check();
 	if (extents_count != 0)
 		fail("memory leak!", "true");
+	check_plan();
 }
diff --git a/test/unit/light.result b/test/unit/light.result
deleted file mode 100644
index 39c4d7c53..000000000
--- a/test/unit/light.result
+++ /dev/null
@@ -1,8 +0,0 @@
-	*** simple_test ***
-	*** simple_test: done ***
-	*** collision_test ***
-	*** collision_test: done ***
-	*** iterator_test ***
-	*** iterator_test: done ***
-	*** iterator_freeze_check ***
-	*** iterator_freeze_check: done ***
diff --git a/test/unit/luaL_iterator.result b/test/unit/luaL_iterator.result
deleted file mode 100644
index 2472eedcf..000000000
--- a/test/unit/luaL_iterator.result
+++ /dev/null
@@ -1,89 +0,0 @@
-1..86
-	*** main ***
-ok 1 - pairs, zero idx: stack size
-ok 2 - pairs, zero idx: iter 0: gen() retval count
-ok 3 - pairs, zero idx: iter 0: gen() 1st retval
-ok 4 - pairs, zero idx: iter 0: gen() 2nd retval
-ok 5 - pairs, zero idx: iter: 0: stack size
-ok 6 - pairs, zero idx: iterator ends
-ok 7 - pairs, zero idx: stack size
-ok 8 - pairs, zero idx: stack size
-ok 9 - ipairs, zero idx: stack size
-ok 10 - ipairs, zero idx: iter 0: gen() retval count
-ok 11 - ipairs, zero idx: iter 0: gen() 1st retval
-ok 12 - ipairs, zero idx: iter 0: gen() 2nd retval
-ok 13 - ipairs, zero idx: iter: 0: stack size
-ok 14 - ipairs, zero idx: iter 1: gen() retval count
-ok 15 - ipairs, zero idx: iter 1: gen() 1st retval
-ok 16 - ipairs, zero idx: iter 1: gen() 2nd retval
-ok 17 - ipairs, zero idx: iter: 1: stack size
-ok 18 - ipairs, zero idx: iter 2: gen() retval count
-ok 19 - ipairs, zero idx: iter 2: gen() 1st retval
-ok 20 - ipairs, zero idx: iter 2: gen() 2nd retval
-ok 21 - ipairs, zero idx: iter: 2: stack size
-ok 22 - ipairs, zero idx: iterator ends
-ok 23 - ipairs, zero idx: stack size
-ok 24 - ipairs, zero idx: stack size
-ok 25 - luafun iterator, zero idx: stack size
-ok 26 - luafun iterator, zero idx: iter 0: gen() retval count
-ok 27 - luafun iterator, zero idx: iter 0: gen() 1st retval
-ok 28 - luafun iterator, zero idx: iter 0: gen() 2nd retval
-ok 29 - luafun iterator, zero idx: iter: 0: stack size
-ok 30 - luafun iterator, zero idx: iter 1: gen() retval count
-ok 31 - luafun iterator, zero idx: iter 1: gen() 1st retval
-ok 32 - luafun iterator, zero idx: iter 1: gen() 2nd retval
-ok 33 - luafun iterator, zero idx: iter: 1: stack size
-ok 34 - luafun iterator, zero idx: iter 2: gen() retval count
-ok 35 - luafun iterator, zero idx: iter 2: gen() 1st retval
-ok 36 - luafun iterator, zero idx: iter 2: gen() 2nd retval
-ok 37 - luafun iterator, zero idx: iter: 2: stack size
-ok 38 - luafun iterator, zero idx: iterator ends
-ok 39 - luafun iterator, zero idx: stack size
-ok 40 - luafun iterator, zero idx: stack size
-ok 41 - pairs, from table: stack size
-ok 42 - pairs, from table: iter 0: gen() retval count
-ok 43 - pairs, from table: iter 0: gen() 1st retval
-ok 44 - pairs, from table: iter 0: gen() 2nd retval
-ok 45 - pairs, from table: iter: 0: stack size
-ok 46 - pairs, from table: iterator ends
-ok 47 - pairs, from table: stack size
-ok 48 - pairs, from table: stack size
-ok 49 - ipairs, from table: stack size
-ok 50 - ipairs, from table: iter 0: gen() retval count
-ok 51 - ipairs, from table: iter 0: gen() 1st retval
-ok 52 - ipairs, from table: iter 0: gen() 2nd retval
-ok 53 - ipairs, from table: iter: 0: stack size
-ok 54 - ipairs, from table: iter 1: gen() retval count
-ok 55 - ipairs, from table: iter 1: gen() 1st retval
-ok 56 - ipairs, from table: iter 1: gen() 2nd retval
-ok 57 - ipairs, from table: iter: 1: stack size
-ok 58 - ipairs, from table: iter 2: gen() retval count
-ok 59 - ipairs, from table: iter 2: gen() 1st retval
-ok 60 - ipairs, from table: iter 2: gen() 2nd retval
-ok 61 - ipairs, from table: iter: 2: stack size
-ok 62 - ipairs, from table: iterator ends
-ok 63 - ipairs, from table: stack size
-ok 64 - ipairs, from table: stack size
-ok 65 - luafun iterator, from table: stack size
-ok 66 - luafun iterator, from table: iter 0: gen() retval count
-ok 67 - luafun iterator, from table: iter 0: gen() 1st retval
-ok 68 - luafun iterator, from table: iter 0: gen() 2nd retval
-ok 69 - luafun iterator, from table: iter: 0: stack size
-ok 70 - luafun iterator, from table: iter 1: gen() retval count
-ok 71 - luafun iterator, from table: iter 1: gen() 1st retval
-ok 72 - luafun iterator, from table: iter 1: gen() 2nd retval
-ok 73 - luafun iterator, from table: iter: 1: stack size
-ok 74 - luafun iterator, from table: iter 2: gen() retval count
-ok 75 - luafun iterator, from table: iter 2: gen() 1st retval
-ok 76 - luafun iterator, from table: iter 2: gen() 2nd retval
-ok 77 - luafun iterator, from table: iter: 2: stack size
-ok 78 - luafun iterator, from table: iterator ends
-ok 79 - luafun iterator, from table: stack size
-ok 80 - luafun iterator, from table: stack size
-ok 81 - lua error: stack size
-ok 82 - lua error: iterator error
-ok 83 - lua error: check error type
-ok 84 - lua error: check error message
-ok 85 - lua error: stack size
-ok 86 - lua error: stack size
-	*** main: done ***
diff --git a/test/unit/luaT_tuple_new.result b/test/unit/luaT_tuple_new.result
deleted file mode 100644
index 110aa68c2..000000000
--- a/test/unit/luaT_tuple_new.result
+++ /dev/null
@@ -1,22 +0,0 @@
-1..19
-	*** test_basic ***
-ok 1 - table: tuple != NULL
-ok 2 - table: check tuple format id
-ok 3 - table: check tuple size
-ok 4 - table: check tuple data
-ok 5 - table: check retvals count
-ok 6 - tuple: tuple != NULL
-ok 7 - tuple: check tuple format id
-ok 8 - tuple: check tuple size
-ok 9 - tuple: check tuple data
-ok 10 - tuple: check retvals count
-ok 11 - objects: tuple != NULL
-ok 12 - objects: check tuple format id
-ok 13 - objects: check tuple size
-ok 14 - objects: check tuple data
-ok 15 - objects: check retvals count
-ok 16 - unexpected type: tuple == NULL
-ok 17 - unexpected type: check retvals count
-ok 18 - unexpected type: check error type
-ok 19 - unexpected type: check error message
-	*** test_basic: done ***
diff --git a/test/unit/merger.result b/test/unit/merger.result
deleted file mode 100644
index 766ebce63..000000000
--- a/test/unit/merger.result
+++ /dev/null
@@ -1,71 +0,0 @@
-1..4
-	*** test_basic ***
-    1..9
-	*** test_array_source ***
-    ok 1 - array source next() (any format): tuple != NULL
-    ok 2 - array source next() (any format): skip tuple validation
-    ok 3 - array source next() (any format): check tuple size
-    ok 4 - array source next() (any format): check tuple data
-    ok 5 - array source next() (any format): tuple != NULL
-    ok 6 - array source next() (any format): skip tuple validation
-    ok 7 - array source next() (any format): check tuple size
-    ok 8 - array source next() (any format): check tuple data
-    ok 9 - array source is empty (any format)
-	*** test_array_source: done ***
-ok 1 - subtests
-    1..9
-	*** test_array_source ***
-    ok 1 - array source next() (user's format): tuple != NULL
-    ok 2 - array source next() (user's format): validate tuple
-    ok 3 - array source next() (user's format): check tuple size
-    ok 4 - array source next() (user's format): check tuple data
-    ok 5 - array source next() (user's format): tuple != NULL
-    ok 6 - array source next() (user's format): validate tuple
-    ok 7 - array source next() (user's format): check tuple size
-    ok 8 - array source next() (user's format): check tuple data
-    ok 9 - array source is empty (user's format)
-	*** test_array_source: done ***
-ok 2 - subtests
-    1..17
-	*** test_merger ***
-    ok 1 - merger next() (any format): tuple != NULL
-    ok 2 - merger next() (any format): skip tuple validation
-    ok 3 - merger next() (any format): check tuple size
-    ok 4 - merger next() (any format): check tuple data
-    ok 5 - merger next() (any format): tuple != NULL
-    ok 6 - merger next() (any format): skip tuple validation
-    ok 7 - merger next() (any format): check tuple size
-    ok 8 - merger next() (any format): check tuple data
-    ok 9 - merger next() (any format): tuple != NULL
-    ok 10 - merger next() (any format): skip tuple validation
-    ok 11 - merger next() (any format): check tuple size
-    ok 12 - merger next() (any format): check tuple data
-    ok 13 - merger next() (any format): tuple != NULL
-    ok 14 - merger next() (any format): skip tuple validation
-    ok 15 - merger next() (any format): check tuple size
-    ok 16 - merger next() (any format): check tuple data
-    ok 17 - merger is empty (any format)
-	*** test_merger: done ***
-ok 3 - subtests
-    1..17
-	*** test_merger ***
-    ok 1 - merger next() (user's format): tuple != NULL
-    ok 2 - merger next() (user's format): validate tuple
-    ok 3 - merger next() (user's format): check tuple size
-    ok 4 - merger next() (user's format): check tuple data
-    ok 5 - merger next() (user's format): tuple != NULL
-    ok 6 - merger next() (user's format): validate tuple
-    ok 7 - merger next() (user's format): check tuple size
-    ok 8 - merger next() (user's format): check tuple data
-    ok 9 - merger next() (user's format): tuple != NULL
-    ok 10 - merger next() (user's format): validate tuple
-    ok 11 - merger next() (user's format): check tuple size
-    ok 12 - merger next() (user's format): check tuple data
-    ok 13 - merger next() (user's format): tuple != NULL
-    ok 14 - merger next() (user's format): validate tuple
-    ok 15 - merger next() (user's format): check tuple size
-    ok 16 - merger next() (user's format): check tuple data
-    ok 17 - merger is empty (user's format)
-	*** test_merger: done ***
-ok 4 - subtests
-	*** test_basic: done ***
diff --git a/test/unit/mhash.result b/test/unit/mhash.result
deleted file mode 100644
index fc757fa35..000000000
--- a/test/unit/mhash.result
+++ /dev/null
@@ -1,18 +0,0 @@
-	*** main ***
-1..3
-	*** mhash_int32_id_test ***
-    1..0
-	*** mhash_int32_id_test: done ***
-ok 1 - subtests
-	*** mhash_int32_collision_test ***
-    1..0
-	*** mhash_int32_collision_test: done ***
-ok 2 - subtests
-	*** mhash_random_test ***
-    1..3
-    ok 1 - empty random is always 'end'
-    ok 2 - one element is always found
-    ok 3 - incremental random from mutable hash
-ok 3 - subtests
-	*** mhash_random_test: done ***
-	*** main: done ***
diff --git a/test/unit/mhash_bytemap.result b/test/unit/mhash_bytemap.result
deleted file mode 100644
index fc757fa35..000000000
--- a/test/unit/mhash_bytemap.result
+++ /dev/null
@@ -1,18 +0,0 @@
-	*** main ***
-1..3
-	*** mhash_int32_id_test ***
-    1..0
-	*** mhash_int32_id_test: done ***
-ok 1 - subtests
-	*** mhash_int32_collision_test ***
-    1..0
-	*** mhash_int32_collision_test: done ***
-ok 2 - subtests
-	*** mhash_random_test ***
-    1..3
-    ok 1 - empty random is always 'end'
-    ok 2 - one element is always found
-    ok 3 - incremental random from mutable hash
-ok 3 - subtests
-	*** mhash_random_test: done ***
-	*** main: done ***
diff --git a/test/unit/mp_error.result b/test/unit/mp_error.result
deleted file mode 100644
index 0582458d3..000000000
--- a/test/unit/mp_error.result
+++ /dev/null
@@ -1,114 +0,0 @@
-	*** main ***
-1..6
-	*** test_stack_error_decode ***
-    1..17
-    ok 1 - check CustomError
-    ok 2 - check AccessDeniedError
-    ok 3 - check ClientError
-    ok 4 - check XlogError
-    ok 5 - check XlogGapError
-    ok 6 - check SystemError
-    ok 7 - check SocketError
-    ok 8 - check OutOfMemory
-    ok 9 - check TimedOut
-    ok 10 - check ChannelIsClosed
-    ok 11 - check FiberIsCancelled
-    ok 12 - check LuajitError
-    ok 13 - check IllegalParams
-    ok 14 - check CollationError
-    ok 15 - check SwimError
-    ok 16 - check CryptoError
-    ok 17 - stack size
-ok 1 - subtests
-	*** test_stack_error_decode: done ***
-	*** test_decode_unknown_type ***
-    1..1
-    ok 1 - check SomeNewError
-ok 2 - subtests
-	*** test_decode_unknown_type: done ***
-	*** test_fail_not_enough_fields ***
-    1..2
-    ok 1 - check not enough additional fields
-    ok 2 - error about parsing problem is set
-ok 3 - subtests
-	*** test_fail_not_enough_fields: done ***
-	*** test_unknown_fields ***
-    1..1
-    ok 1 - check unknown fields
-ok 4 - subtests
-	*** test_unknown_additional_fields ***
-    1..1
-    ok 1 - check unknown additional field
-ok 5 - subtests
-	*** test_unknown_additional_fields: done ***
-	*** test_mp_print ***
-    1..60
-    # zero depth, normal error
-    ok 1 - mp_snprint depth 0 correct returned value
-    ok 2 - mp_snprint depth 0 correct length
-    ok 3 - mp_snprint depth 0 correct prefix and suffix
-    ok 4 - mp_snprint depth 0 correct object in the middle
-    ok 5 - mp_snprint depth 0 correct with NULL buffer
-    ok 6 - mp_fprint depth 0 result and the actual file size are equal
-    ok 7 - mp_fprint depth 0 correct returned value
-    ok 8 - mp_fprint depth 0 correct length
-    ok 9 - mp_fprint depth 0 correct prefix and suffix
-    ok 10 - mp_fprint depth 0 correct object in the middle
-    # max depth, all is truncated
-    ok 11 - mp_snprint depth 32 correct returned value
-    ok 12 - mp_snprint depth 32 correct length
-    ok 13 - mp_snprint depth 32 correct prefix and suffix
-    ok 14 - mp_snprint depth 32 correct object in the middle
-    ok 15 - mp_snprint depth 32 correct with NULL buffer
-    ok 16 - mp_fprint depth 32 result and the actual file size are equal
-    ok 17 - mp_fprint depth 32 correct returned value
-    ok 18 - mp_fprint depth 32 correct length
-    ok 19 - mp_fprint depth 32 correct prefix and suffix
-    ok 20 - mp_fprint depth 32 correct object in the middle
-    # max depth - 1, top level of keys is visible
-    ok 21 - mp_snprint depth 31 correct returned value
-    ok 22 - mp_snprint depth 31 correct length
-    ok 23 - mp_snprint depth 31 correct prefix and suffix
-    ok 24 - mp_snprint depth 31 correct object in the middle
-    ok 25 - mp_snprint depth 31 correct with NULL buffer
-    ok 26 - mp_fprint depth 31 result and the actual file size are equal
-    ok 27 - mp_fprint depth 31 correct returned value
-    ok 28 - mp_fprint depth 31 correct length
-    ok 29 - mp_fprint depth 31 correct prefix and suffix
-    ok 30 - mp_fprint depth 31 correct object in the middle
-    # max depth - 2, top level of keys and error count are visible
-    ok 31 - mp_snprint depth 30 correct returned value
-    ok 32 - mp_snprint depth 30 correct length
-    ok 33 - mp_snprint depth 30 correct prefix and suffix
-    ok 34 - mp_snprint depth 30 correct object in the middle
-    ok 35 - mp_snprint depth 30 correct with NULL buffer
-    ok 36 - mp_fprint depth 30 result and the actual file size are equal
-    ok 37 - mp_fprint depth 30 correct returned value
-    ok 38 - mp_fprint depth 30 correct length
-    ok 39 - mp_fprint depth 30 correct prefix and suffix
-    ok 40 - mp_fprint depth 30 correct object in the middle
-    # max depth - 3, all except additional fields is visible
-    ok 41 - mp_snprint depth 29 correct returned value
-    ok 42 - mp_snprint depth 29 correct length
-    ok 43 - mp_snprint depth 29 correct prefix and suffix
-    ok 44 - mp_snprint depth 29 correct object in the middle
-    ok 45 - mp_snprint depth 29 correct with NULL buffer
-    ok 46 - mp_fprint depth 29 result and the actual file size are equal
-    ok 47 - mp_fprint depth 29 correct returned value
-    ok 48 - mp_fprint depth 29 correct length
-    ok 49 - mp_fprint depth 29 correct prefix and suffix
-    ok 50 - mp_fprint depth 29 correct object in the middle
-    # zero depth, error with unknown fields
-    ok 51 - mp_snprint depth 0 correct returned value
-    ok 52 - mp_snprint depth 0 correct length
-    ok 53 - mp_snprint depth 0 correct prefix and suffix
-    ok 54 - mp_snprint depth 0 correct object in the middle
-    ok 55 - mp_snprint depth 0 correct with NULL buffer
-    ok 56 - mp_fprint depth 0 result and the actual file size are equal
-    ok 57 - mp_fprint depth 0 correct returned value
-    ok 58 - mp_fprint depth 0 correct length
-    ok 59 - mp_fprint depth 0 correct prefix and suffix
-    ok 60 - mp_fprint depth 0 correct object in the middle
-ok 6 - subtests
-	*** test_mp_print: done ***
-	*** main: done ***
diff --git a/test/unit/msgpack.result b/test/unit/msgpack.result
deleted file mode 100644
index 0b0c10ed9..000000000
--- a/test/unit/msgpack.result
+++ /dev/null
@@ -1,2291 +0,0 @@
-1..23
-    1..135
-    # *** test_uints ***
-    # uint 0U
-    ok 1 - mp_check_uint(0U) == 0
-    ok 2 - mp_decode(mp_encode(0U)) == 0U
-    ok 3 - mp_check(0U)
-    ok 4 - len(mp_encode_uint(0U)
-    ok 5 - len(mp_decode_uint(0U))
-    ok 6 - len(mp_next_uint(0U))
-    ok 7 - len(mp_check_uint(0U))
-    ok 8 - mp_sizeof_uint(0U)
-    ok 9 - mp_encode(0U) == "\x00"
-    # uint 1U
-    ok 10 - mp_check_uint(1U) == 0
-    ok 11 - mp_decode(mp_encode(1U)) == 1U
-    ok 12 - mp_check(1U)
-    ok 13 - len(mp_encode_uint(1U)
-    ok 14 - len(mp_decode_uint(1U))
-    ok 15 - len(mp_next_uint(1U))
-    ok 16 - len(mp_check_uint(1U))
-    ok 17 - mp_sizeof_uint(1U)
-    ok 18 - mp_encode(1U) == "\x01"
-    # uint 0x7eU
-    ok 19 - mp_check_uint(0x7eU) == 0
-    ok 20 - mp_decode(mp_encode(0x7eU)) == 0x7eU
-    ok 21 - mp_check(0x7eU)
-    ok 22 - len(mp_encode_uint(0x7eU)
-    ok 23 - len(mp_decode_uint(0x7eU))
-    ok 24 - len(mp_next_uint(0x7eU))
-    ok 25 - len(mp_check_uint(0x7eU))
-    ok 26 - mp_sizeof_uint(0x7eU)
-    ok 27 - mp_encode(0x7eU) == "\x7e"
-    # uint 0x7fU
-    ok 28 - mp_check_uint(0x7fU) == 0
-    ok 29 - mp_decode(mp_encode(0x7fU)) == 0x7fU
-    ok 30 - mp_check(0x7fU)
-    ok 31 - len(mp_encode_uint(0x7fU)
-    ok 32 - len(mp_decode_uint(0x7fU))
-    ok 33 - len(mp_next_uint(0x7fU))
-    ok 34 - len(mp_check_uint(0x7fU))
-    ok 35 - mp_sizeof_uint(0x7fU)
-    ok 36 - mp_encode(0x7fU) == "\x7f"
-    # uint 0x80U
-    ok 37 - mp_check_uint(0x80U) == 0
-    ok 38 - mp_decode(mp_encode(0x80U)) == 0x80U
-    ok 39 - mp_check(0x80U)
-    ok 40 - len(mp_encode_uint(0x80U)
-    ok 41 - len(mp_decode_uint(0x80U))
-    ok 42 - len(mp_next_uint(0x80U))
-    ok 43 - len(mp_check_uint(0x80U))
-    ok 44 - mp_sizeof_uint(0x80U)
-    ok 45 - mp_encode(0x80U) == "\xcc\x80"
-    # uint 0xfeU
-    ok 46 - mp_check_uint(0xfeU) == 0
-    ok 47 - mp_decode(mp_encode(0xfeU)) == 0xfeU
-    ok 48 - mp_check(0xfeU)
-    ok 49 - len(mp_encode_uint(0xfeU)
-    ok 50 - len(mp_decode_uint(0xfeU))
-    ok 51 - len(mp_next_uint(0xfeU))
-    ok 52 - len(mp_check_uint(0xfeU))
-    ok 53 - mp_sizeof_uint(0xfeU)
-    ok 54 - mp_encode(0xfeU) == "\xcc\xfe"
-    # uint 0xffU
-    ok 55 - mp_check_uint(0xffU) == 0
-    ok 56 - mp_decode(mp_encode(0xffU)) == 0xffU
-    ok 57 - mp_check(0xffU)
-    ok 58 - len(mp_encode_uint(0xffU)
-    ok 59 - len(mp_decode_uint(0xffU))
-    ok 60 - len(mp_next_uint(0xffU))
-    ok 61 - len(mp_check_uint(0xffU))
-    ok 62 - mp_sizeof_uint(0xffU)
-    ok 63 - mp_encode(0xffU) == "\xcc\xff"
-    # uint 0xfffeU
-    ok 64 - mp_check_uint(0xfffeU) == 0
-    ok 65 - mp_decode(mp_encode(0xfffeU)) == 0xfffeU
-    ok 66 - mp_check(0xfffeU)
-    ok 67 - len(mp_encode_uint(0xfffeU)
-    ok 68 - len(mp_decode_uint(0xfffeU))
-    ok 69 - len(mp_next_uint(0xfffeU))
-    ok 70 - len(mp_check_uint(0xfffeU))
-    ok 71 - mp_sizeof_uint(0xfffeU)
-    ok 72 - mp_encode(0xfffeU) == "\xcd\xff\xfe"
-    # uint 0xffffU
-    ok 73 - mp_check_uint(0xffffU) == 0
-    ok 74 - mp_decode(mp_encode(0xffffU)) == 0xffffU
-    ok 75 - mp_check(0xffffU)
-    ok 76 - len(mp_encode_uint(0xffffU)
-    ok 77 - len(mp_decode_uint(0xffffU))
-    ok 78 - len(mp_next_uint(0xffffU))
-    ok 79 - len(mp_check_uint(0xffffU))
-    ok 80 - mp_sizeof_uint(0xffffU)
-    ok 81 - mp_encode(0xffffU) == "\xcd\xff\xff"
-    # uint 0x10000U
-    ok 82 - mp_check_uint(0x10000U) == 0
-    ok 83 - mp_decode(mp_encode(0x10000U)) == 0x10000U
-    ok 84 - mp_check(0x10000U)
-    ok 85 - len(mp_encode_uint(0x10000U)
-    ok 86 - len(mp_decode_uint(0x10000U))
-    ok 87 - len(mp_next_uint(0x10000U))
-    ok 88 - len(mp_check_uint(0x10000U))
-    ok 89 - mp_sizeof_uint(0x10000U)
-    ok 90 - mp_encode(0x10000U) == "\xce\x00\x01\x00\x00"
-    # uint 0xfffffffeU
-    ok 91 - mp_check_uint(0xfffffffeU) == 0
-    ok 92 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 93 - mp_check(0xfffffffeU)
-    ok 94 - len(mp_encode_uint(0xfffffffeU)
-    ok 95 - len(mp_decode_uint(0xfffffffeU))
-    ok 96 - len(mp_next_uint(0xfffffffeU))
-    ok 97 - len(mp_check_uint(0xfffffffeU))
-    ok 98 - mp_sizeof_uint(0xfffffffeU)
-    ok 99 - mp_encode(0xfffffffeU) == "\xce\xff\xff\xff\xfe"
-    # uint 0xffffffffU
-    ok 100 - mp_check_uint(0xffffffffU) == 0
-    ok 101 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 102 - mp_check(0xffffffffU)
-    ok 103 - len(mp_encode_uint(0xffffffffU)
-    ok 104 - len(mp_decode_uint(0xffffffffU))
-    ok 105 - len(mp_next_uint(0xffffffffU))
-    ok 106 - len(mp_check_uint(0xffffffffU))
-    ok 107 - mp_sizeof_uint(0xffffffffU)
-    ok 108 - mp_encode(0xffffffffU) == "\xce\xff\xff\xff\xff"
-    # uint 0x100000000ULL
-    ok 109 - mp_check_uint(0x100000000ULL) == 0
-    ok 110 - mp_decode(mp_encode(0x100000000ULL)) == 0x100000000ULL
-    ok 111 - mp_check(0x100000000ULL)
-    ok 112 - len(mp_encode_uint(0x100000000ULL)
-    ok 113 - len(mp_decode_uint(0x100000000ULL))
-    ok 114 - len(mp_next_uint(0x100000000ULL))
-    ok 115 - len(mp_check_uint(0x100000000ULL))
-    ok 116 - mp_sizeof_uint(0x100000000ULL)
-    ok 117 - mp_encode(0x100000000ULL) == "\xcf\x00\x00\x00\x01\x00\x00\x00\x00"
-    # uint 0xfffffffffffffffeULL
-    ok 118 - mp_check_uint(0xfffffffffffffffeULL) == 0
-    ok 119 - mp_decode(mp_encode(0xfffffffffffffffeULL)) == 0xfffffffffffffffeULL
-    ok 120 - mp_check(0xfffffffffffffffeULL)
-    ok 121 - len(mp_encode_uint(0xfffffffffffffffeULL)
-    ok 122 - len(mp_decode_uint(0xfffffffffffffffeULL))
-    ok 123 - len(mp_next_uint(0xfffffffffffffffeULL))
-    ok 124 - len(mp_check_uint(0xfffffffffffffffeULL))
-    ok 125 - mp_sizeof_uint(0xfffffffffffffffeULL)
-    ok 126 - mp_encode(0xfffffffffffffffeULL) == "\xcf\xff\xff\xff\xff\xff\xff\xff\xfe"
-    # uint 0xffffffffffffffffULL
-    ok 127 - mp_check_uint(0xffffffffffffffffULL) == 0
-    ok 128 - mp_decode(mp_encode(0xffffffffffffffffULL)) == 0xffffffffffffffffULL
-    ok 129 - mp_check(0xffffffffffffffffULL)
-    ok 130 - len(mp_encode_uint(0xffffffffffffffffULL)
-    ok 131 - len(mp_decode_uint(0xffffffffffffffffULL))
-    ok 132 - len(mp_next_uint(0xffffffffffffffffULL))
-    ok 133 - len(mp_check_uint(0xffffffffffffffffULL))
-    ok 134 - mp_sizeof_uint(0xffffffffffffffffULL)
-    ok 135 - mp_encode(0xffffffffffffffffULL) == "\xcf\xff\xff\xff\xff\xff\xff\xff\xff"
-    # *** test_uints: done ***
-ok 1 - subtests
-    1..153
-    # *** test_ints ***
-    # int -0x01
-    ok 1 - mp_check_int(-0x01) == 0
-    ok 2 - mp_decode(mp_encode(-0x01)) == -0x01
-    ok 3 - mp_check(-0x01)
-    ok 4 - len(mp_encode_int(-0x01)
-    ok 5 - len(mp_decode_int(-0x01))
-    ok 6 - len(mp_next_int(-0x01))
-    ok 7 - len(mp_check_int(-0x01))
-    ok 8 - mp_sizeof_int(-0x01)
-    ok 9 - mp_encode(-0x01) == "\xff"
-    # int -0x1e
-    ok 10 - mp_check_int(-0x1e) == 0
-    ok 11 - mp_decode(mp_encode(-0x1e)) == -0x1e
-    ok 12 - mp_check(-0x1e)
-    ok 13 - len(mp_encode_int(-0x1e)
-    ok 14 - len(mp_decode_int(-0x1e))
-    ok 15 - len(mp_next_int(-0x1e))
-    ok 16 - len(mp_check_int(-0x1e))
-    ok 17 - mp_sizeof_int(-0x1e)
-    ok 18 - mp_encode(-0x1e) == "\xe2"
-    # int -0x1f
-    ok 19 - mp_check_int(-0x1f) == 0
-    ok 20 - mp_decode(mp_encode(-0x1f)) == -0x1f
-    ok 21 - mp_check(-0x1f)
-    ok 22 - len(mp_encode_int(-0x1f)
-    ok 23 - len(mp_decode_int(-0x1f))
-    ok 24 - len(mp_next_int(-0x1f))
-    ok 25 - len(mp_check_int(-0x1f))
-    ok 26 - mp_sizeof_int(-0x1f)
-    ok 27 - mp_encode(-0x1f) == "\xe1"
-    # int -0x20
-    ok 28 - mp_check_int(-0x20) == 0
-    ok 29 - mp_decode(mp_encode(-0x20)) == -0x20
-    ok 30 - mp_check(-0x20)
-    ok 31 - len(mp_encode_int(-0x20)
-    ok 32 - len(mp_decode_int(-0x20))
-    ok 33 - len(mp_next_int(-0x20))
-    ok 34 - len(mp_check_int(-0x20))
-    ok 35 - mp_sizeof_int(-0x20)
-    ok 36 - mp_encode(-0x20) == "\xe0"
-    # int -0x21
-    ok 37 - mp_check_int(-0x21) == 0
-    ok 38 - mp_decode(mp_encode(-0x21)) == -0x21
-    ok 39 - mp_check(-0x21)
-    ok 40 - len(mp_encode_int(-0x21)
-    ok 41 - len(mp_decode_int(-0x21))
-    ok 42 - len(mp_next_int(-0x21))
-    ok 43 - len(mp_check_int(-0x21))
-    ok 44 - mp_sizeof_int(-0x21)
-    ok 45 - mp_encode(-0x21) == "\xd0\xdf"
-    # int -0x7f
-    ok 46 - mp_check_int(-0x7f) == 0
-    ok 47 - mp_decode(mp_encode(-0x7f)) == -0x7f
-    ok 48 - mp_check(-0x7f)
-    ok 49 - len(mp_encode_int(-0x7f)
-    ok 50 - len(mp_decode_int(-0x7f))
-    ok 51 - len(mp_next_int(-0x7f))
-    ok 52 - len(mp_check_int(-0x7f))
-    ok 53 - mp_sizeof_int(-0x7f)
-    ok 54 - mp_encode(-0x7f) == "\xd0\x81"
-    # int -0x80
-    ok 55 - mp_check_int(-0x80) == 0
-    ok 56 - mp_decode(mp_encode(-0x80)) == -0x80
-    ok 57 - mp_check(-0x80)
-    ok 58 - len(mp_encode_int(-0x80)
-    ok 59 - len(mp_decode_int(-0x80))
-    ok 60 - len(mp_next_int(-0x80))
-    ok 61 - len(mp_check_int(-0x80))
-    ok 62 - mp_sizeof_int(-0x80)
-    ok 63 - mp_encode(-0x80) == "\xd0\x80"
-    # int -0x81
-    ok 64 - mp_check_int(-0x81) == 0
-    ok 65 - mp_decode(mp_encode(-0x81)) == -0x81
-    ok 66 - mp_check(-0x81)
-    ok 67 - len(mp_encode_int(-0x81)
-    ok 68 - len(mp_decode_int(-0x81))
-    ok 69 - len(mp_next_int(-0x81))
-    ok 70 - len(mp_check_int(-0x81))
-    ok 71 - mp_sizeof_int(-0x81)
-    ok 72 - mp_encode(-0x81) == "\xd1\xff\x7f"
-    # int -0x7fff
-    ok 73 - mp_check_int(-0x7fff) == 0
-    ok 74 - mp_decode(mp_encode(-0x7fff)) == -0x7fff
-    ok 75 - mp_check(-0x7fff)
-    ok 76 - len(mp_encode_int(-0x7fff)
-    ok 77 - len(mp_decode_int(-0x7fff))
-    ok 78 - len(mp_next_int(-0x7fff))
-    ok 79 - len(mp_check_int(-0x7fff))
-    ok 80 - mp_sizeof_int(-0x7fff)
-    ok 81 - mp_encode(-0x7fff) == "\xd1\x80\x01"
-    # int -0x8000
-    ok 82 - mp_check_int(-0x8000) == 0
-    ok 83 - mp_decode(mp_encode(-0x8000)) == -0x8000
-    ok 84 - mp_check(-0x8000)
-    ok 85 - len(mp_encode_int(-0x8000)
-    ok 86 - len(mp_decode_int(-0x8000))
-    ok 87 - len(mp_next_int(-0x8000))
-    ok 88 - len(mp_check_int(-0x8000))
-    ok 89 - mp_sizeof_int(-0x8000)
-    ok 90 - mp_encode(-0x8000) == "\xd1\x80\x00"
-    # int -0x8001
-    ok 91 - mp_check_int(-0x8001) == 0
-    ok 92 - mp_decode(mp_encode(-0x8001)) == -0x8001
-    ok 93 - mp_check(-0x8001)
-    ok 94 - len(mp_encode_int(-0x8001)
-    ok 95 - len(mp_decode_int(-0x8001))
-    ok 96 - len(mp_next_int(-0x8001))
-    ok 97 - len(mp_check_int(-0x8001))
-    ok 98 - mp_sizeof_int(-0x8001)
-    ok 99 - mp_encode(-0x8001) == "\xd2\xff\xff\x7f\xff"
-    # int -0x7fffffff
-    ok 100 - mp_check_int(-0x7fffffff) == 0
-    ok 101 - mp_decode(mp_encode(-0x7fffffff)) == -0x7fffffff
-    ok 102 - mp_check(-0x7fffffff)
-    ok 103 - len(mp_encode_int(-0x7fffffff)
-    ok 104 - len(mp_decode_int(-0x7fffffff))
-    ok 105 - len(mp_next_int(-0x7fffffff))
-    ok 106 - len(mp_check_int(-0x7fffffff))
-    ok 107 - mp_sizeof_int(-0x7fffffff)
-    ok 108 - mp_encode(-0x7fffffff) == "\xd2\x80\x00\x00\x01"
-    # int -0x80000000LL
-    ok 109 - mp_check_int(-0x80000000LL) == 0
-    ok 110 - mp_decode(mp_encode(-0x80000000LL)) == -0x80000000LL
-    ok 111 - mp_check(-0x80000000LL)
-    ok 112 - len(mp_encode_int(-0x80000000LL)
-    ok 113 - len(mp_decode_int(-0x80000000LL))
-    ok 114 - len(mp_next_int(-0x80000000LL))
-    ok 115 - len(mp_check_int(-0x80000000LL))
-    ok 116 - mp_sizeof_int(-0x80000000LL)
-    ok 117 - mp_encode(-0x80000000LL) == "\xd2\x80\x00\x00\x00"
-    # int -0x80000001LL
-    ok 118 - mp_check_int(-0x80000001LL) == 0
-    ok 119 - mp_decode(mp_encode(-0x80000001LL)) == -0x80000001LL
-    ok 120 - mp_check(-0x80000001LL)
-    ok 121 - len(mp_encode_int(-0x80000001LL)
-    ok 122 - len(mp_decode_int(-0x80000001LL))
-    ok 123 - len(mp_next_int(-0x80000001LL))
-    ok 124 - len(mp_check_int(-0x80000001LL))
-    ok 125 - mp_sizeof_int(-0x80000001LL)
-    ok 126 - mp_encode(-0x80000001LL) == "\xd3\xff\xff\xff\xff\x7f\xff\xff\xff"
-    # int -0x80000001LL
-    ok 127 - mp_check_int(-0x80000001LL) == 0
-    ok 128 - mp_decode(mp_encode(-0x80000001LL)) == -0x80000001LL
-    ok 129 - mp_check(-0x80000001LL)
-    ok 130 - len(mp_encode_int(-0x80000001LL)
-    ok 131 - len(mp_decode_int(-0x80000001LL))
-    ok 132 - len(mp_next_int(-0x80000001LL))
-    ok 133 - len(mp_check_int(-0x80000001LL))
-    ok 134 - mp_sizeof_int(-0x80000001LL)
-    ok 135 - mp_encode(-0x80000001LL) == "\xd3\xff\xff\xff\xff\x7f\xff\xff\xff"
-    # int -0x7fffffffffffffffLL
-    ok 136 - mp_check_int(-0x7fffffffffffffffLL) == 0
-    ok 137 - mp_decode(mp_encode(-0x7fffffffffffffffLL)) == -0x7fffffffffffffffLL
-    ok 138 - mp_check(-0x7fffffffffffffffLL)
-    ok 139 - len(mp_encode_int(-0x7fffffffffffffffLL)
-    ok 140 - len(mp_decode_int(-0x7fffffffffffffffLL))
-    ok 141 - len(mp_next_int(-0x7fffffffffffffffLL))
-    ok 142 - len(mp_check_int(-0x7fffffffffffffffLL))
-    ok 143 - mp_sizeof_int(-0x7fffffffffffffffLL)
-    ok 144 - mp_encode(-0x7fffffffffffffffLL) == "\xd3\x80\x00\x00\x00\x00\x00\x00\x01"
-    # int (int64_t)-0x8000000000000000LL
-    ok 145 - mp_check_int((int64_t)-0x8000000000000000LL) == 0
-    ok 146 - mp_decode(mp_encode((int64_t)-0x8000000000000000LL)) == (int64_t)-0x8000000000000000LL
-    ok 147 - mp_check((int64_t)-0x8000000000000000LL)
-    ok 148 - len(mp_encode_int((int64_t)-0x8000000000000000LL)
-    ok 149 - len(mp_decode_int((int64_t)-0x8000000000000000LL))
-    ok 150 - len(mp_next_int((int64_t)-0x8000000000000000LL))
-    ok 151 - len(mp_check_int((int64_t)-0x8000000000000000LL))
-    ok 152 - mp_sizeof_int((int64_t)-0x8000000000000000LL)
-    ok 153 - mp_encode((int64_t)-0x8000000000000000LL) == "\xd3\x80\x00\x00\x00\x00\x00\x00\x00"
-    # *** test_ints: done ***
-ok 2 - subtests
-    1..18
-    # *** test_bools ***
-    # bool 1
-    ok 1 - mp_check_bool(1) == 0
-    ok 2 - mp_decode(mp_encode(1)) == 1
-    ok 3 - mp_check(1)
-    ok 4 - len(mp_encode_bool(1)
-    ok 5 - len(mp_decode_bool(1))
-    ok 6 - len(mp_next_bool(1))
-    ok 7 - len(mp_check_bool(1))
-    ok 8 - mp_sizeof_bool(1)
-    ok 9 - mp_encode(1) == "\xc3"
-    # bool 0
-    ok 10 - mp_check_bool(0) == 0
-    ok 11 - mp_decode(mp_encode(0)) == 0
-    ok 12 - mp_check(0)
-    ok 13 - len(mp_encode_bool(0)
-    ok 14 - len(mp_decode_bool(0))
-    ok 15 - len(mp_next_bool(0))
-    ok 16 - len(mp_check_bool(0))
-    ok 17 - mp_sizeof_bool(0)
-    ok 18 - mp_encode(0) == "\xc2"
-    # *** test_bools: done ***
-ok 3 - subtests
-    1..27
-    # *** test_floats ***
-    # float (float) 1.0
-    ok 1 - mp_check_float((float) 1.0) == 0
-    ok 2 - mp_decode(mp_encode((float) 1.0)) == (float) 1.0
-    ok 3 - mp_check((float) 1.0)
-    ok 4 - len(mp_encode_float((float) 1.0)
-    ok 5 - len(mp_decode_float((float) 1.0))
-    ok 6 - len(mp_next_float((float) 1.0))
-    ok 7 - len(mp_check_float((float) 1.0))
-    ok 8 - mp_sizeof_float((float) 1.0)
-    ok 9 - mp_encode((float) 1.0) == "\xca\x3f\x80\x00\x00"
-    # float (float) 3.141593
-    ok 10 - mp_check_float((float) 3.141593) == 0
-    ok 11 - mp_decode(mp_encode((float) 3.141593)) == (float) 3.141593
-    ok 12 - mp_check((float) 3.141593)
-    ok 13 - len(mp_encode_float((float) 3.141593)
-    ok 14 - len(mp_decode_float((float) 3.141593))
-    ok 15 - len(mp_next_float((float) 3.141593))
-    ok 16 - len(mp_check_float((float) 3.141593))
-    ok 17 - mp_sizeof_float((float) 3.141593)
-    ok 18 - mp_encode((float) 3.141593) == "\xca\x40\x49\x0f\xdc"
-    # float (float) -1e38f
-    ok 19 - mp_check_float((float) -1e38f) == 0
-    ok 20 - mp_decode(mp_encode((float) -1e38f)) == (float) -1e38f
-    ok 21 - mp_check((float) -1e38f)
-    ok 22 - len(mp_encode_float((float) -1e38f)
-    ok 23 - len(mp_decode_float((float) -1e38f))
-    ok 24 - len(mp_next_float((float) -1e38f))
-    ok 25 - len(mp_check_float((float) -1e38f))
-    ok 26 - mp_sizeof_float((float) -1e38f)
-    ok 27 - mp_encode((float) -1e38f) == "\xca\xfe\x96\x76\x99"
-    # *** test_floats: done ***
-ok 4 - subtests
-    1..27
-    # *** test_doubles ***
-    # double (double) 1.0
-    ok 1 - mp_check_double((double) 1.0) == 0
-    ok 2 - mp_decode(mp_encode((double) 1.0)) == (double) 1.0
-    ok 3 - mp_check((double) 1.0)
-    ok 4 - len(mp_encode_double((double) 1.0)
-    ok 5 - len(mp_decode_double((double) 1.0))
-    ok 6 - len(mp_next_double((double) 1.0))
-    ok 7 - len(mp_check_double((double) 1.0))
-    ok 8 - mp_sizeof_double((double) 1.0)
-    ok 9 - mp_encode((double) 1.0) == "\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"
-    # double (double) 3.141592653589793
-    ok 10 - mp_check_double((double) 3.141592653589793) == 0
-    ok 11 - mp_decode(mp_encode((double) 3.141592653589793)) == (double) 3.141592653589793
-    ok 12 - mp_check((double) 3.141592653589793)
-    ok 13 - len(mp_encode_double((double) 3.141592653589793)
-    ok 14 - len(mp_decode_double((double) 3.141592653589793))
-    ok 15 - len(mp_next_double((double) 3.141592653589793))
-    ok 16 - len(mp_check_double((double) 3.141592653589793))
-    ok 17 - mp_sizeof_double((double) 3.141592653589793)
-    ok 18 - mp_encode((double) 3.141592653589793) == "\xcb\x40\x09\x21\xfb\x54\x44\x2d\x18"
-    # double (double) -1e99
-    ok 19 - mp_check_double((double) -1e99) == 0
-    ok 20 - mp_decode(mp_encode((double) -1e99)) == (double) -1e99
-    ok 21 - mp_check((double) -1e99)
-    ok 22 - len(mp_encode_double((double) -1e99)
-    ok 23 - len(mp_decode_double((double) -1e99))
-    ok 24 - len(mp_next_double((double) -1e99))
-    ok 25 - len(mp_check_double((double) -1e99))
-    ok 26 - mp_sizeof_double((double) -1e99)
-    ok 27 - mp_encode((double) -1e99) == "\xcb\xd4\x7d\x42\xae\xa2\x87\x9f\x2e"
-    # *** test_doubles: done ***
-ok 5 - subtests
-    1..6
-    # *** test_nils ***
-    # nil
-    ok 1 - mp_check_nil()
-    ok 2 - len(mp_encode_nil() == 1
-    ok 3 - len(mp_decode_nil()) == 1
-    ok 4 - len(mp_next_nil()) == 1
-    ok 5 - len(mp_check_nil()) == 1
-    ok 6 - mp_sizeof_nil() == 1
-    # *** test_nils: done ***
-ok 6 - subtests
-    1..78
-    # *** test_strls ***
-    # strl 0x00U
-    ok 1 - mp_check_strl(0x00U) == 0
-    ok 2 - mp_decode(mp_encode(0x00U)) == 0x00U
-    ok 3 - len(mp_encode_strl(0x00U)
-    ok 4 - len(mp_decode_strl(0x00U))
-    ok 5 - mp_sizeof_strl(0x00U)
-    ok 6 - mp_encode(0x00U) == "\xa0"
-    # strl 0x01U
-    ok 7 - mp_check_strl(0x01U) == 0
-    ok 8 - mp_decode(mp_encode(0x01U)) == 0x01U
-    ok 9 - len(mp_encode_strl(0x01U)
-    ok 10 - len(mp_decode_strl(0x01U))
-    ok 11 - mp_sizeof_strl(0x01U)
-    ok 12 - mp_encode(0x01U) == "\xa1"
-    # strl 0x1eU
-    ok 13 - mp_check_strl(0x1eU) == 0
-    ok 14 - mp_decode(mp_encode(0x1eU)) == 0x1eU
-    ok 15 - len(mp_encode_strl(0x1eU)
-    ok 16 - len(mp_decode_strl(0x1eU))
-    ok 17 - mp_sizeof_strl(0x1eU)
-    ok 18 - mp_encode(0x1eU) == "\xbe"
-    # strl 0x1fU
-    ok 19 - mp_check_strl(0x1fU) == 0
-    ok 20 - mp_decode(mp_encode(0x1fU)) == 0x1fU
-    ok 21 - len(mp_encode_strl(0x1fU)
-    ok 22 - len(mp_decode_strl(0x1fU))
-    ok 23 - mp_sizeof_strl(0x1fU)
-    ok 24 - mp_encode(0x1fU) == "\xbf"
-    # strl 0x20U
-    ok 25 - mp_check_strl(0x20U) == 0
-    ok 26 - mp_decode(mp_encode(0x20U)) == 0x20U
-    ok 27 - len(mp_encode_strl(0x20U)
-    ok 28 - len(mp_decode_strl(0x20U))
-    ok 29 - mp_sizeof_strl(0x20U)
-    ok 30 - mp_encode(0x20U) == "\xd9\x20"
-    # strl 0xfeU
-    ok 31 - mp_check_strl(0xfeU) == 0
-    ok 32 - mp_decode(mp_encode(0xfeU)) == 0xfeU
-    ok 33 - len(mp_encode_strl(0xfeU)
-    ok 34 - len(mp_decode_strl(0xfeU))
-    ok 35 - mp_sizeof_strl(0xfeU)
-    ok 36 - mp_encode(0xfeU) == "\xd9\xfe"
-    # strl 0xffU
-    ok 37 - mp_check_strl(0xffU) == 0
-    ok 38 - mp_decode(mp_encode(0xffU)) == 0xffU
-    ok 39 - len(mp_encode_strl(0xffU)
-    ok 40 - len(mp_decode_strl(0xffU))
-    ok 41 - mp_sizeof_strl(0xffU)
-    ok 42 - mp_encode(0xffU) == "\xd9\xff"
-    # strl 0x0100U
-    ok 43 - mp_check_strl(0x0100U) == 0
-    ok 44 - mp_decode(mp_encode(0x0100U)) == 0x0100U
-    ok 45 - len(mp_encode_strl(0x0100U)
-    ok 46 - len(mp_decode_strl(0x0100U))
-    ok 47 - mp_sizeof_strl(0x0100U)
-    ok 48 - mp_encode(0x0100U) == "\xda\x01\x00"
-    # strl 0xfffeU
-    ok 49 - mp_check_strl(0xfffeU) == 0
-    ok 50 - mp_decode(mp_encode(0xfffeU)) == 0xfffeU
-    ok 51 - len(mp_encode_strl(0xfffeU)
-    ok 52 - len(mp_decode_strl(0xfffeU))
-    ok 53 - mp_sizeof_strl(0xfffeU)
-    ok 54 - mp_encode(0xfffeU) == "\xda\xff\xfe"
-    # strl 0xffffU
-    ok 55 - mp_check_strl(0xffffU) == 0
-    ok 56 - mp_decode(mp_encode(0xffffU)) == 0xffffU
-    ok 57 - len(mp_encode_strl(0xffffU)
-    ok 58 - len(mp_decode_strl(0xffffU))
-    ok 59 - mp_sizeof_strl(0xffffU)
-    ok 60 - mp_encode(0xffffU) == "\xda\xff\xff"
-    # strl 0x00010000U
-    ok 61 - mp_check_strl(0x00010000U) == 0
-    ok 62 - mp_decode(mp_encode(0x00010000U)) == 0x00010000U
-    ok 63 - len(mp_encode_strl(0x00010000U)
-    ok 64 - len(mp_decode_strl(0x00010000U))
-    ok 65 - mp_sizeof_strl(0x00010000U)
-    ok 66 - mp_encode(0x00010000U) == "\xdb\x00\x01\x00\x00"
-    # strl 0xfffffffeU
-    ok 67 - mp_check_strl(0xfffffffeU) == 0
-    ok 68 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 69 - len(mp_encode_strl(0xfffffffeU)
-    ok 70 - len(mp_decode_strl(0xfffffffeU))
-    ok 71 - mp_sizeof_strl(0xfffffffeU)
-    ok 72 - mp_encode(0xfffffffeU) == "\xdb\xff\xff\xff\xfe"
-    # strl 0xffffffffU
-    ok 73 - mp_check_strl(0xffffffffU) == 0
-    ok 74 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 75 - len(mp_encode_strl(0xffffffffU)
-    ok 76 - len(mp_decode_strl(0xffffffffU))
-    ok 77 - mp_sizeof_strl(0xffffffffU)
-    ok 78 - mp_encode(0xffffffffU) == "\xdb\xff\xff\xff\xff"
-    # *** test_strls: done ***
-ok 7 - subtests
-    1..78
-    # *** test_binls ***
-    # binl 0x00U
-    ok 1 - mp_check_binl(0x00U) == 0
-    ok 2 - mp_decode(mp_encode(0x00U)) == 0x00U
-    ok 3 - len(mp_encode_binl(0x00U)
-    ok 4 - len(mp_decode_binl(0x00U))
-    ok 5 - mp_sizeof_binl(0x00U)
-    ok 6 - mp_encode(0x00U) == "\xc4\x00"
-    # binl 0x01U
-    ok 7 - mp_check_binl(0x01U) == 0
-    ok 8 - mp_decode(mp_encode(0x01U)) == 0x01U
-    ok 9 - len(mp_encode_binl(0x01U)
-    ok 10 - len(mp_decode_binl(0x01U))
-    ok 11 - mp_sizeof_binl(0x01U)
-    ok 12 - mp_encode(0x01U) == "\xc4\x01"
-    # binl 0x1eU
-    ok 13 - mp_check_binl(0x1eU) == 0
-    ok 14 - mp_decode(mp_encode(0x1eU)) == 0x1eU
-    ok 15 - len(mp_encode_binl(0x1eU)
-    ok 16 - len(mp_decode_binl(0x1eU))
-    ok 17 - mp_sizeof_binl(0x1eU)
-    ok 18 - mp_encode(0x1eU) == "\xc4\x1e"
-    # binl 0x1fU
-    ok 19 - mp_check_binl(0x1fU) == 0
-    ok 20 - mp_decode(mp_encode(0x1fU)) == 0x1fU
-    ok 21 - len(mp_encode_binl(0x1fU)
-    ok 22 - len(mp_decode_binl(0x1fU))
-    ok 23 - mp_sizeof_binl(0x1fU)
-    ok 24 - mp_encode(0x1fU) == "\xc4\x1f"
-    # binl 0x20U
-    ok 25 - mp_check_binl(0x20U) == 0
-    ok 26 - mp_decode(mp_encode(0x20U)) == 0x20U
-    ok 27 - len(mp_encode_binl(0x20U)
-    ok 28 - len(mp_decode_binl(0x20U))
-    ok 29 - mp_sizeof_binl(0x20U)
-    ok 30 - mp_encode(0x20U) == "\xc4\x20"
-    # binl 0xfeU
-    ok 31 - mp_check_binl(0xfeU) == 0
-    ok 32 - mp_decode(mp_encode(0xfeU)) == 0xfeU
-    ok 33 - len(mp_encode_binl(0xfeU)
-    ok 34 - len(mp_decode_binl(0xfeU))
-    ok 35 - mp_sizeof_binl(0xfeU)
-    ok 36 - mp_encode(0xfeU) == "\xc4\xfe"
-    # binl 0xffU
-    ok 37 - mp_check_binl(0xffU) == 0
-    ok 38 - mp_decode(mp_encode(0xffU)) == 0xffU
-    ok 39 - len(mp_encode_binl(0xffU)
-    ok 40 - len(mp_decode_binl(0xffU))
-    ok 41 - mp_sizeof_binl(0xffU)
-    ok 42 - mp_encode(0xffU) == "\xc4\xff"
-    # binl 0x0100U
-    ok 43 - mp_check_binl(0x0100U) == 0
-    ok 44 - mp_decode(mp_encode(0x0100U)) == 0x0100U
-    ok 45 - len(mp_encode_binl(0x0100U)
-    ok 46 - len(mp_decode_binl(0x0100U))
-    ok 47 - mp_sizeof_binl(0x0100U)
-    ok 48 - mp_encode(0x0100U) == "\xc5\x01\x00"
-    # binl 0xfffeU
-    ok 49 - mp_check_binl(0xfffeU) == 0
-    ok 50 - mp_decode(mp_encode(0xfffeU)) == 0xfffeU
-    ok 51 - len(mp_encode_binl(0xfffeU)
-    ok 52 - len(mp_decode_binl(0xfffeU))
-    ok 53 - mp_sizeof_binl(0xfffeU)
-    ok 54 - mp_encode(0xfffeU) == "\xc5\xff\xfe"
-    # binl 0xffffU
-    ok 55 - mp_check_binl(0xffffU) == 0
-    ok 56 - mp_decode(mp_encode(0xffffU)) == 0xffffU
-    ok 57 - len(mp_encode_binl(0xffffU)
-    ok 58 - len(mp_decode_binl(0xffffU))
-    ok 59 - mp_sizeof_binl(0xffffU)
-    ok 60 - mp_encode(0xffffU) == "\xc5\xff\xff"
-    # binl 0x00010000U
-    ok 61 - mp_check_binl(0x00010000U) == 0
-    ok 62 - mp_decode(mp_encode(0x00010000U)) == 0x00010000U
-    ok 63 - len(mp_encode_binl(0x00010000U)
-    ok 64 - len(mp_decode_binl(0x00010000U))
-    ok 65 - mp_sizeof_binl(0x00010000U)
-    ok 66 - mp_encode(0x00010000U) == "\xc6\x00\x01\x00\x00"
-    # binl 0xfffffffeU
-    ok 67 - mp_check_binl(0xfffffffeU) == 0
-    ok 68 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 69 - len(mp_encode_binl(0xfffffffeU)
-    ok 70 - len(mp_decode_binl(0xfffffffeU))
-    ok 71 - mp_sizeof_binl(0xfffffffeU)
-    ok 72 - mp_encode(0xfffffffeU) == "\xc6\xff\xff\xff\xfe"
-    # binl 0xffffffffU
-    ok 73 - mp_check_binl(0xffffffffU) == 0
-    ok 74 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 75 - len(mp_encode_binl(0xffffffffU)
-    ok 76 - len(mp_decode_binl(0xffffffffU))
-    ok 77 - mp_sizeof_binl(0xffffffffU)
-    ok 78 - mp_encode(0xffffffffU) == "\xc6\xff\xff\xff\xff"
-    # *** test_binls: done ***
-ok 8 - subtests
-    1..168
-    # *** test_extls ***
-    # extl 0x01U
-    ok 1 - mp_check_extl(0x01U) == 0
-    ok 2 - mp_decode(mp_encode(0x01U)) == 0x01U
-    ok 3 - len(mp_encode_extl(0x01U)
-    ok 4 - len(mp_decode_extl(0x01U))
-    ok 5 - mp_sizeof_extl(0x01U)
-    ok 6 - mp_encode(0x01U) == "\xd4\x00"
-    # extl 0x02U
-    ok 7 - mp_check_extl(0x02U) == 0
-    ok 8 - mp_decode(mp_encode(0x02U)) == 0x02U
-    ok 9 - len(mp_encode_extl(0x02U)
-    ok 10 - len(mp_decode_extl(0x02U))
-    ok 11 - mp_sizeof_extl(0x02U)
-    ok 12 - mp_encode(0x02U) == "\xd5\x00"
-    # extl 0x04U
-    ok 13 - mp_check_extl(0x04U) == 0
-    ok 14 - mp_decode(mp_encode(0x04U)) == 0x04U
-    ok 15 - len(mp_encode_extl(0x04U)
-    ok 16 - len(mp_decode_extl(0x04U))
-    ok 17 - mp_sizeof_extl(0x04U)
-    ok 18 - mp_encode(0x04U) == "\xd6\x00"
-    # extl 0x08U
-    ok 19 - mp_check_extl(0x08U) == 0
-    ok 20 - mp_decode(mp_encode(0x08U)) == 0x08U
-    ok 21 - len(mp_encode_extl(0x08U)
-    ok 22 - len(mp_decode_extl(0x08U))
-    ok 23 - mp_sizeof_extl(0x08U)
-    ok 24 - mp_encode(0x08U) == "\xd7\x00"
-    # extl 0x10U
-    ok 25 - mp_check_extl(0x10U) == 0
-    ok 26 - mp_decode(mp_encode(0x10U)) == 0x10U
-    ok 27 - len(mp_encode_extl(0x10U)
-    ok 28 - len(mp_decode_extl(0x10U))
-    ok 29 - mp_sizeof_extl(0x10U)
-    ok 30 - mp_encode(0x10U) == "\xd8\x00"
-    # extl 0x11U
-    ok 31 - mp_check_extl(0x11U) == 0
-    ok 32 - mp_decode(mp_encode(0x11U)) == 0x11U
-    ok 33 - len(mp_encode_extl(0x11U)
-    ok 34 - len(mp_decode_extl(0x11U))
-    ok 35 - mp_sizeof_extl(0x11U)
-    ok 36 - mp_encode(0x11U) == "\xc7\x11\x00"
-    # extl 0xfeU
-    ok 37 - mp_check_extl(0xfeU) == 0
-    ok 38 - mp_decode(mp_encode(0xfeU)) == 0xfeU
-    ok 39 - len(mp_encode_extl(0xfeU)
-    ok 40 - len(mp_decode_extl(0xfeU))
-    ok 41 - mp_sizeof_extl(0xfeU)
-    ok 42 - mp_encode(0xfeU) == "\xc7\xfe\x00"
-    # extl 0xffU
-    ok 43 - mp_check_extl(0xffU) == 0
-    ok 44 - mp_decode(mp_encode(0xffU)) == 0xffU
-    ok 45 - len(mp_encode_extl(0xffU)
-    ok 46 - len(mp_decode_extl(0xffU))
-    ok 47 - mp_sizeof_extl(0xffU)
-    ok 48 - mp_encode(0xffU) == "\xc7\xff\x00"
-    # extl 0x00U
-    ok 49 - mp_check_extl(0x00U) == 0
-    ok 50 - mp_decode(mp_encode(0x00U)) == 0x00U
-    ok 51 - len(mp_encode_extl(0x00U)
-    ok 52 - len(mp_decode_extl(0x00U))
-    ok 53 - mp_sizeof_extl(0x00U)
-    ok 54 - mp_encode(0x00U) == "\xc7\x00\x00"
-    # extl 0x03U
-    ok 55 - mp_check_extl(0x03U) == 0
-    ok 56 - mp_decode(mp_encode(0x03U)) == 0x03U
-    ok 57 - len(mp_encode_extl(0x03U)
-    ok 58 - len(mp_decode_extl(0x03U))
-    ok 59 - mp_sizeof_extl(0x03U)
-    ok 60 - mp_encode(0x03U) == "\xc7\x03\x00"
-    # extl 0x05U
-    ok 61 - mp_check_extl(0x05U) == 0
-    ok 62 - mp_decode(mp_encode(0x05U)) == 0x05U
-    ok 63 - len(mp_encode_extl(0x05U)
-    ok 64 - len(mp_decode_extl(0x05U))
-    ok 65 - mp_sizeof_extl(0x05U)
-    ok 66 - mp_encode(0x05U) == "\xc7\x05\x00"
-    # extl 0x06U
-    ok 67 - mp_check_extl(0x06U) == 0
-    ok 68 - mp_decode(mp_encode(0x06U)) == 0x06U
-    ok 69 - len(mp_encode_extl(0x06U)
-    ok 70 - len(mp_decode_extl(0x06U))
-    ok 71 - mp_sizeof_extl(0x06U)
-    ok 72 - mp_encode(0x06U) == "\xc7\x06\x00"
-    # extl 0x07U
-    ok 73 - mp_check_extl(0x07U) == 0
-    ok 74 - mp_decode(mp_encode(0x07U)) == 0x07U
-    ok 75 - len(mp_encode_extl(0x07U)
-    ok 76 - len(mp_decode_extl(0x07U))
-    ok 77 - mp_sizeof_extl(0x07U)
-    ok 78 - mp_encode(0x07U) == "\xc7\x07\x00"
-    # extl 0x09U
-    ok 79 - mp_check_extl(0x09U) == 0
-    ok 80 - mp_decode(mp_encode(0x09U)) == 0x09U
-    ok 81 - len(mp_encode_extl(0x09U)
-    ok 82 - len(mp_decode_extl(0x09U))
-    ok 83 - mp_sizeof_extl(0x09U)
-    ok 84 - mp_encode(0x09U) == "\xc7\x09\x00"
-    # extl 0x0aU
-    ok 85 - mp_check_extl(0x0aU) == 0
-    ok 86 - mp_decode(mp_encode(0x0aU)) == 0x0aU
-    ok 87 - len(mp_encode_extl(0x0aU)
-    ok 88 - len(mp_decode_extl(0x0aU))
-    ok 89 - mp_sizeof_extl(0x0aU)
-    ok 90 - mp_encode(0x0aU) == "\xc7\x0a\x00"
-    # extl 0x0bU
-    ok 91 - mp_check_extl(0x0bU) == 0
-    ok 92 - mp_decode(mp_encode(0x0bU)) == 0x0bU
-    ok 93 - len(mp_encode_extl(0x0bU)
-    ok 94 - len(mp_decode_extl(0x0bU))
-    ok 95 - mp_sizeof_extl(0x0bU)
-    ok 96 - mp_encode(0x0bU) == "\xc7\x0b\x00"
-    # extl 0x0cU
-    ok 97 - mp_check_extl(0x0cU) == 0
-    ok 98 - mp_decode(mp_encode(0x0cU)) == 0x0cU
-    ok 99 - len(mp_encode_extl(0x0cU)
-    ok 100 - len(mp_decode_extl(0x0cU))
-    ok 101 - mp_sizeof_extl(0x0cU)
-    ok 102 - mp_encode(0x0cU) == "\xc7\x0c\x00"
-    # extl 0x0dU
-    ok 103 - mp_check_extl(0x0dU) == 0
-    ok 104 - mp_decode(mp_encode(0x0dU)) == 0x0dU
-    ok 105 - len(mp_encode_extl(0x0dU)
-    ok 106 - len(mp_decode_extl(0x0dU))
-    ok 107 - mp_sizeof_extl(0x0dU)
-    ok 108 - mp_encode(0x0dU) == "\xc7\x0d\x00"
-    # extl 0x0eU
-    ok 109 - mp_check_extl(0x0eU) == 0
-    ok 110 - mp_decode(mp_encode(0x0eU)) == 0x0eU
-    ok 111 - len(mp_encode_extl(0x0eU)
-    ok 112 - len(mp_decode_extl(0x0eU))
-    ok 113 - mp_sizeof_extl(0x0eU)
-    ok 114 - mp_encode(0x0eU) == "\xc7\x0e\x00"
-    # extl 0x0fU
-    ok 115 - mp_check_extl(0x0fU) == 0
-    ok 116 - mp_decode(mp_encode(0x0fU)) == 0x0fU
-    ok 117 - len(mp_encode_extl(0x0fU)
-    ok 118 - len(mp_decode_extl(0x0fU))
-    ok 119 - mp_sizeof_extl(0x0fU)
-    ok 120 - mp_encode(0x0fU) == "\xc7\x0f\x00"
-    # extl 0x0100U
-    ok 121 - mp_check_extl(0x0100U) == 0
-    ok 122 - mp_decode(mp_encode(0x0100U)) == 0x0100U
-    ok 123 - len(mp_encode_extl(0x0100U)
-    ok 124 - len(mp_decode_extl(0x0100U))
-    ok 125 - mp_sizeof_extl(0x0100U)
-    ok 126 - mp_encode(0x0100U) == "\xc8\x01\x00\x00"
-    # extl 0x0101U
-    ok 127 - mp_check_extl(0x0101U) == 0
-    ok 128 - mp_decode(mp_encode(0x0101U)) == 0x0101U
-    ok 129 - len(mp_encode_extl(0x0101U)
-    ok 130 - len(mp_decode_extl(0x0101U))
-    ok 131 - mp_sizeof_extl(0x0101U)
-    ok 132 - mp_encode(0x0101U) == "\xc8\x01\x01\x00"
-    # extl 0xfffeU
-    ok 133 - mp_check_extl(0xfffeU) == 0
-    ok 134 - mp_decode(mp_encode(0xfffeU)) == 0xfffeU
-    ok 135 - len(mp_encode_extl(0xfffeU)
-    ok 136 - len(mp_decode_extl(0xfffeU))
-    ok 137 - mp_sizeof_extl(0xfffeU)
-    ok 138 - mp_encode(0xfffeU) == "\xc8\xff\xfe\x00"
-    # extl 0xffffU
-    ok 139 - mp_check_extl(0xffffU) == 0
-    ok 140 - mp_decode(mp_encode(0xffffU)) == 0xffffU
-    ok 141 - len(mp_encode_extl(0xffffU)
-    ok 142 - len(mp_decode_extl(0xffffU))
-    ok 143 - mp_sizeof_extl(0xffffU)
-    ok 144 - mp_encode(0xffffU) == "\xc8\xff\xff\x00"
-    # extl 0x00010000U
-    ok 145 - mp_check_extl(0x00010000U) == 0
-    ok 146 - mp_decode(mp_encode(0x00010000U)) == 0x00010000U
-    ok 147 - len(mp_encode_extl(0x00010000U)
-    ok 148 - len(mp_decode_extl(0x00010000U))
-    ok 149 - mp_sizeof_extl(0x00010000U)
-    ok 150 - mp_encode(0x00010000U) == "\xc9\x00\x01\x00\x00\x00"
-    # extl 0x00010001U
-    ok 151 - mp_check_extl(0x00010001U) == 0
-    ok 152 - mp_decode(mp_encode(0x00010001U)) == 0x00010001U
-    ok 153 - len(mp_encode_extl(0x00010001U)
-    ok 154 - len(mp_decode_extl(0x00010001U))
-    ok 155 - mp_sizeof_extl(0x00010001U)
-    ok 156 - mp_encode(0x00010001U) == "\xc9\x00\x01\x00\x01\x00"
-    # extl 0xfffffffeU
-    ok 157 - mp_check_extl(0xfffffffeU) == 0
-    ok 158 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 159 - len(mp_encode_extl(0xfffffffeU)
-    ok 160 - len(mp_decode_extl(0xfffffffeU))
-    ok 161 - mp_sizeof_extl(0xfffffffeU)
-    ok 162 - mp_encode(0xfffffffeU) == "\xc9\xff\xff\xff\xfe\x00"
-    # extl 0xffffffffU
-    ok 163 - mp_check_extl(0xffffffffU) == 0
-    ok 164 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 165 - len(mp_encode_extl(0xffffffffU)
-    ok 166 - len(mp_decode_extl(0xffffffffU))
-    ok 167 - mp_sizeof_extl(0xffffffffU)
-    ok 168 - mp_encode(0xffffffffU) == "\xc9\xff\xff\xff\xff\x00"
-    # *** test_extls: done ***
-ok 9 - subtests
-    1..96
-    # *** test_strs ***
-    # str len=0x01
-    ok 1 - len(mp_decode_str(x, 1))
-    ok 2 - len(mp_decode_strbin(x, 1))
-    ok 3 - mp_check_str(mp_encode_str(x, 0x01))
-    ok 4 - len(mp_decode_str(x, 0x01)
-    ok 5 - len(mp_next_str(x, 0x01)
-    ok 6 - len(mp_check_str(x, 0x01)
-    ok 7 - mp_sizeof_str(0x01)
-    ok 8 - mp_encode_str(x, 0x01) == x
-    # str len=0x1e
-    ok 9 - len(mp_decode_str(x, 30))
-    ok 10 - len(mp_decode_strbin(x, 30))
-    ok 11 - mp_check_str(mp_encode_str(x, 0x1e))
-    ok 12 - len(mp_decode_str(x, 0x1e)
-    ok 13 - len(mp_next_str(x, 0x1e)
-    ok 14 - len(mp_check_str(x, 0x1e)
-    ok 15 - mp_sizeof_str(0x1e)
-    ok 16 - mp_encode_str(x, 0x1e) == x
-    # str len=0x1f
-    ok 17 - len(mp_decode_str(x, 31))
-    ok 18 - len(mp_decode_strbin(x, 31))
-    ok 19 - mp_check_str(mp_encode_str(x, 0x1f))
-    ok 20 - len(mp_decode_str(x, 0x1f)
-    ok 21 - len(mp_next_str(x, 0x1f)
-    ok 22 - len(mp_check_str(x, 0x1f)
-    ok 23 - mp_sizeof_str(0x1f)
-    ok 24 - mp_encode_str(x, 0x1f) == x
-    # str len=0x20
-    ok 25 - len(mp_decode_str(x, 32))
-    ok 26 - len(mp_decode_strbin(x, 32))
-    ok 27 - mp_check_str(mp_encode_str(x, 0x20))
-    ok 28 - len(mp_decode_str(x, 0x20)
-    ok 29 - len(mp_next_str(x, 0x20)
-    ok 30 - len(mp_check_str(x, 0x20)
-    ok 31 - mp_sizeof_str(0x20)
-    ok 32 - mp_encode_str(x, 0x20) == x
-    # str len=0xfe
-    ok 33 - len(mp_decode_str(x, 254))
-    ok 34 - len(mp_decode_strbin(x, 254))
-    ok 35 - mp_check_str(mp_encode_str(x, 0xfe))
-    ok 36 - len(mp_decode_str(x, 0xfe)
-    ok 37 - len(mp_next_str(x, 0xfe)
-    ok 38 - len(mp_check_str(x, 0xfe)
-    ok 39 - mp_sizeof_str(0xfe)
-    ok 40 - mp_encode_str(x, 0xfe) == x
-    # str len=0xff
-    ok 41 - len(mp_decode_str(x, 255))
-    ok 42 - len(mp_decode_strbin(x, 255))
-    ok 43 - mp_check_str(mp_encode_str(x, 0xff))
-    ok 44 - len(mp_decode_str(x, 0xff)
-    ok 45 - len(mp_next_str(x, 0xff)
-    ok 46 - len(mp_check_str(x, 0xff)
-    ok 47 - mp_sizeof_str(0xff)
-    ok 48 - mp_encode_str(x, 0xff) == x
-    # str len=0x100
-    ok 49 - len(mp_decode_str(x, 256))
-    ok 50 - len(mp_decode_strbin(x, 256))
-    ok 51 - mp_check_str(mp_encode_str(x, 0x100))
-    ok 52 - len(mp_decode_str(x, 0x100)
-    ok 53 - len(mp_next_str(x, 0x100)
-    ok 54 - len(mp_check_str(x, 0x100)
-    ok 55 - mp_sizeof_str(0x100)
-    ok 56 - mp_encode_str(x, 0x100) == x
-    # str len=0x101
-    ok 57 - len(mp_decode_str(x, 257))
-    ok 58 - len(mp_decode_strbin(x, 257))
-    ok 59 - mp_check_str(mp_encode_str(x, 0x101))
-    ok 60 - len(mp_decode_str(x, 0x101)
-    ok 61 - len(mp_next_str(x, 0x101)
-    ok 62 - len(mp_check_str(x, 0x101)
-    ok 63 - mp_sizeof_str(0x101)
-    ok 64 - mp_encode_str(x, 0x101) == x
-    # str len=0xfffe
-    ok 65 - len(mp_decode_str(x, 65534))
-    ok 66 - len(mp_decode_strbin(x, 65534))
-    ok 67 - mp_check_str(mp_encode_str(x, 0xfffe))
-    ok 68 - len(mp_decode_str(x, 0xfffe)
-    ok 69 - len(mp_next_str(x, 0xfffe)
-    ok 70 - len(mp_check_str(x, 0xfffe)
-    ok 71 - mp_sizeof_str(0xfffe)
-    ok 72 - mp_encode_str(x, 0xfffe) == x
-    # str len=0xffff
-    ok 73 - len(mp_decode_str(x, 65535))
-    ok 74 - len(mp_decode_strbin(x, 65535))
-    ok 75 - mp_check_str(mp_encode_str(x, 0xffff))
-    ok 76 - len(mp_decode_str(x, 0xffff)
-    ok 77 - len(mp_next_str(x, 0xffff)
-    ok 78 - len(mp_check_str(x, 0xffff)
-    ok 79 - mp_sizeof_str(0xffff)
-    ok 80 - mp_encode_str(x, 0xffff) == x
-    # str len=0x10000
-    ok 81 - len(mp_decode_str(x, 65536))
-    ok 82 - len(mp_decode_strbin(x, 65536))
-    ok 83 - mp_check_str(mp_encode_str(x, 0x10000))
-    ok 84 - len(mp_decode_str(x, 0x10000)
-    ok 85 - len(mp_next_str(x, 0x10000)
-    ok 86 - len(mp_check_str(x, 0x10000)
-    ok 87 - mp_sizeof_str(0x10000)
-    ok 88 - mp_encode_str(x, 0x10000) == x
-    # str len=0x10001
-    ok 89 - len(mp_decode_str(x, 65537))
-    ok 90 - len(mp_decode_strbin(x, 65537))
-    ok 91 - mp_check_str(mp_encode_str(x, 0x10001))
-    ok 92 - len(mp_decode_str(x, 0x10001)
-    ok 93 - len(mp_next_str(x, 0x10001)
-    ok 94 - len(mp_check_str(x, 0x10001)
-    ok 95 - mp_sizeof_str(0x10001)
-    ok 96 - mp_encode_str(x, 0x10001) == x
-    # *** test_strs: done ***
-ok 10 - subtests
-    1..96
-    # *** test_bins ***
-    # bin len=0x01
-    ok 1 - len(mp_decode_bin(x, 1))
-    ok 2 - len(mp_decode_strbin(x, 1))
-    ok 3 - mp_check_bin(mp_encode_bin(x, 0x01))
-    ok 4 - len(mp_decode_bin(x, 0x01)
-    ok 5 - len(mp_next_bin(x, 0x01)
-    ok 6 - len(mp_check_bin(x, 0x01)
-    ok 7 - mp_sizeof_bin(0x01)
-    ok 8 - mp_encode_bin(x, 0x01) == x
-    # bin len=0x1e
-    ok 9 - len(mp_decode_bin(x, 30))
-    ok 10 - len(mp_decode_strbin(x, 30))
-    ok 11 - mp_check_bin(mp_encode_bin(x, 0x1e))
-    ok 12 - len(mp_decode_bin(x, 0x1e)
-    ok 13 - len(mp_next_bin(x, 0x1e)
-    ok 14 - len(mp_check_bin(x, 0x1e)
-    ok 15 - mp_sizeof_bin(0x1e)
-    ok 16 - mp_encode_bin(x, 0x1e) == x
-    # bin len=0x1f
-    ok 17 - len(mp_decode_bin(x, 31))
-    ok 18 - len(mp_decode_strbin(x, 31))
-    ok 19 - mp_check_bin(mp_encode_bin(x, 0x1f))
-    ok 20 - len(mp_decode_bin(x, 0x1f)
-    ok 21 - len(mp_next_bin(x, 0x1f)
-    ok 22 - len(mp_check_bin(x, 0x1f)
-    ok 23 - mp_sizeof_bin(0x1f)
-    ok 24 - mp_encode_bin(x, 0x1f) == x
-    # bin len=0x20
-    ok 25 - len(mp_decode_bin(x, 32))
-    ok 26 - len(mp_decode_strbin(x, 32))
-    ok 27 - mp_check_bin(mp_encode_bin(x, 0x20))
-    ok 28 - len(mp_decode_bin(x, 0x20)
-    ok 29 - len(mp_next_bin(x, 0x20)
-    ok 30 - len(mp_check_bin(x, 0x20)
-    ok 31 - mp_sizeof_bin(0x20)
-    ok 32 - mp_encode_bin(x, 0x20) == x
-    # bin len=0xfe
-    ok 33 - len(mp_decode_bin(x, 254))
-    ok 34 - len(mp_decode_strbin(x, 254))
-    ok 35 - mp_check_bin(mp_encode_bin(x, 0xfe))
-    ok 36 - len(mp_decode_bin(x, 0xfe)
-    ok 37 - len(mp_next_bin(x, 0xfe)
-    ok 38 - len(mp_check_bin(x, 0xfe)
-    ok 39 - mp_sizeof_bin(0xfe)
-    ok 40 - mp_encode_bin(x, 0xfe) == x
-    # bin len=0xff
-    ok 41 - len(mp_decode_bin(x, 255))
-    ok 42 - len(mp_decode_strbin(x, 255))
-    ok 43 - mp_check_bin(mp_encode_bin(x, 0xff))
-    ok 44 - len(mp_decode_bin(x, 0xff)
-    ok 45 - len(mp_next_bin(x, 0xff)
-    ok 46 - len(mp_check_bin(x, 0xff)
-    ok 47 - mp_sizeof_bin(0xff)
-    ok 48 - mp_encode_bin(x, 0xff) == x
-    # bin len=0x100
-    ok 49 - len(mp_decode_bin(x, 256))
-    ok 50 - len(mp_decode_strbin(x, 256))
-    ok 51 - mp_check_bin(mp_encode_bin(x, 0x100))
-    ok 52 - len(mp_decode_bin(x, 0x100)
-    ok 53 - len(mp_next_bin(x, 0x100)
-    ok 54 - len(mp_check_bin(x, 0x100)
-    ok 55 - mp_sizeof_bin(0x100)
-    ok 56 - mp_encode_bin(x, 0x100) == x
-    # bin len=0x101
-    ok 57 - len(mp_decode_bin(x, 257))
-    ok 58 - len(mp_decode_strbin(x, 257))
-    ok 59 - mp_check_bin(mp_encode_bin(x, 0x101))
-    ok 60 - len(mp_decode_bin(x, 0x101)
-    ok 61 - len(mp_next_bin(x, 0x101)
-    ok 62 - len(mp_check_bin(x, 0x101)
-    ok 63 - mp_sizeof_bin(0x101)
-    ok 64 - mp_encode_bin(x, 0x101) == x
-    # bin len=0xfffe
-    ok 65 - len(mp_decode_bin(x, 65534))
-    ok 66 - len(mp_decode_strbin(x, 65534))
-    ok 67 - mp_check_bin(mp_encode_bin(x, 0xfffe))
-    ok 68 - len(mp_decode_bin(x, 0xfffe)
-    ok 69 - len(mp_next_bin(x, 0xfffe)
-    ok 70 - len(mp_check_bin(x, 0xfffe)
-    ok 71 - mp_sizeof_bin(0xfffe)
-    ok 72 - mp_encode_bin(x, 0xfffe) == x
-    # bin len=0xffff
-    ok 73 - len(mp_decode_bin(x, 65535))
-    ok 74 - len(mp_decode_strbin(x, 65535))
-    ok 75 - mp_check_bin(mp_encode_bin(x, 0xffff))
-    ok 76 - len(mp_decode_bin(x, 0xffff)
-    ok 77 - len(mp_next_bin(x, 0xffff)
-    ok 78 - len(mp_check_bin(x, 0xffff)
-    ok 79 - mp_sizeof_bin(0xffff)
-    ok 80 - mp_encode_bin(x, 0xffff) == x
-    # bin len=0x10000
-    ok 81 - len(mp_decode_bin(x, 65536))
-    ok 82 - len(mp_decode_strbin(x, 65536))
-    ok 83 - mp_check_bin(mp_encode_bin(x, 0x10000))
-    ok 84 - len(mp_decode_bin(x, 0x10000)
-    ok 85 - len(mp_next_bin(x, 0x10000)
-    ok 86 - len(mp_check_bin(x, 0x10000)
-    ok 87 - mp_sizeof_bin(0x10000)
-    ok 88 - mp_encode_bin(x, 0x10000) == x
-    # bin len=0x10001
-    ok 89 - len(mp_decode_bin(x, 65537))
-    ok 90 - len(mp_decode_strbin(x, 65537))
-    ok 91 - mp_check_bin(mp_encode_bin(x, 0x10001))
-    ok 92 - len(mp_decode_bin(x, 0x10001)
-    ok 93 - len(mp_next_bin(x, 0x10001)
-    ok 94 - len(mp_check_bin(x, 0x10001)
-    ok 95 - mp_sizeof_bin(0x10001)
-    ok 96 - mp_encode_bin(x, 0x10001) == x
-    # *** test_bins: done ***
-ok 11 - subtests
-    1..225
-    # *** test_exts ***
-    # ext len=0x01
-    ok 1 - len(mp_decode_ext(x, 1))
-    ok 2 - type(mp_decode_ext(x))
-    ok 3 - len(mp_decode_strbin(x, 1))
-    ok 4 - mp_check_ext(mp_encode_ext(x, 0x01))
-    ok 5 - len(mp_decode_ext(x, 0x01)
-    ok 6 - len(mp_next_ext(x, 0x01)
-    ok 7 - len(mp_check_ext(x, 0x01)
-    ok 8 - mp_sizeof_ext(0x01)
-    ok 9 - mp_encode_ext(x, 0x01) == x
-    # ext len=0x02
-    ok 10 - len(mp_decode_ext(x, 2))
-    ok 11 - type(mp_decode_ext(x))
-    ok 12 - len(mp_decode_strbin(x, 2))
-    ok 13 - mp_check_ext(mp_encode_ext(x, 0x02))
-    ok 14 - len(mp_decode_ext(x, 0x02)
-    ok 15 - len(mp_next_ext(x, 0x02)
-    ok 16 - len(mp_check_ext(x, 0x02)
-    ok 17 - mp_sizeof_ext(0x02)
-    ok 18 - mp_encode_ext(x, 0x02) == x
-    # ext len=0x03
-    ok 19 - len(mp_decode_ext(x, 3))
-    ok 20 - type(mp_decode_ext(x))
-    ok 21 - len(mp_decode_strbin(x, 3))
-    ok 22 - mp_check_ext(mp_encode_ext(x, 0x03))
-    ok 23 - len(mp_decode_ext(x, 0x03)
-    ok 24 - len(mp_next_ext(x, 0x03)
-    ok 25 - len(mp_check_ext(x, 0x03)
-    ok 26 - mp_sizeof_ext(0x03)
-    ok 27 - mp_encode_ext(x, 0x03) == x
-    # ext len=0x04
-    ok 28 - len(mp_decode_ext(x, 4))
-    ok 29 - type(mp_decode_ext(x))
-    ok 30 - len(mp_decode_strbin(x, 4))
-    ok 31 - mp_check_ext(mp_encode_ext(x, 0x04))
-    ok 32 - len(mp_decode_ext(x, 0x04)
-    ok 33 - len(mp_next_ext(x, 0x04)
-    ok 34 - len(mp_check_ext(x, 0x04)
-    ok 35 - mp_sizeof_ext(0x04)
-    ok 36 - mp_encode_ext(x, 0x04) == x
-    # ext len=0x05
-    ok 37 - len(mp_decode_ext(x, 5))
-    ok 38 - type(mp_decode_ext(x))
-    ok 39 - len(mp_decode_strbin(x, 5))
-    ok 40 - mp_check_ext(mp_encode_ext(x, 0x05))
-    ok 41 - len(mp_decode_ext(x, 0x05)
-    ok 42 - len(mp_next_ext(x, 0x05)
-    ok 43 - len(mp_check_ext(x, 0x05)
-    ok 44 - mp_sizeof_ext(0x05)
-    ok 45 - mp_encode_ext(x, 0x05) == x
-    # ext len=0x06
-    ok 46 - len(mp_decode_ext(x, 6))
-    ok 47 - type(mp_decode_ext(x))
-    ok 48 - len(mp_decode_strbin(x, 6))
-    ok 49 - mp_check_ext(mp_encode_ext(x, 0x06))
-    ok 50 - len(mp_decode_ext(x, 0x06)
-    ok 51 - len(mp_next_ext(x, 0x06)
-    ok 52 - len(mp_check_ext(x, 0x06)
-    ok 53 - mp_sizeof_ext(0x06)
-    ok 54 - mp_encode_ext(x, 0x06) == x
-    # ext len=0x07
-    ok 55 - len(mp_decode_ext(x, 7))
-    ok 56 - type(mp_decode_ext(x))
-    ok 57 - len(mp_decode_strbin(x, 7))
-    ok 58 - mp_check_ext(mp_encode_ext(x, 0x07))
-    ok 59 - len(mp_decode_ext(x, 0x07)
-    ok 60 - len(mp_next_ext(x, 0x07)
-    ok 61 - len(mp_check_ext(x, 0x07)
-    ok 62 - mp_sizeof_ext(0x07)
-    ok 63 - mp_encode_ext(x, 0x07) == x
-    # ext len=0x08
-    ok 64 - len(mp_decode_ext(x, 8))
-    ok 65 - type(mp_decode_ext(x))
-    ok 66 - len(mp_decode_strbin(x, 8))
-    ok 67 - mp_check_ext(mp_encode_ext(x, 0x08))
-    ok 68 - len(mp_decode_ext(x, 0x08)
-    ok 69 - len(mp_next_ext(x, 0x08)
-    ok 70 - len(mp_check_ext(x, 0x08)
-    ok 71 - mp_sizeof_ext(0x08)
-    ok 72 - mp_encode_ext(x, 0x08) == x
-    # ext len=0x09
-    ok 73 - len(mp_decode_ext(x, 9))
-    ok 74 - type(mp_decode_ext(x))
-    ok 75 - len(mp_decode_strbin(x, 9))
-    ok 76 - mp_check_ext(mp_encode_ext(x, 0x09))
-    ok 77 - len(mp_decode_ext(x, 0x09)
-    ok 78 - len(mp_next_ext(x, 0x09)
-    ok 79 - len(mp_check_ext(x, 0x09)
-    ok 80 - mp_sizeof_ext(0x09)
-    ok 81 - mp_encode_ext(x, 0x09) == x
-    # ext len=0x0a
-    ok 82 - len(mp_decode_ext(x, 10))
-    ok 83 - type(mp_decode_ext(x))
-    ok 84 - len(mp_decode_strbin(x, 10))
-    ok 85 - mp_check_ext(mp_encode_ext(x, 0x0a))
-    ok 86 - len(mp_decode_ext(x, 0x0a)
-    ok 87 - len(mp_next_ext(x, 0x0a)
-    ok 88 - len(mp_check_ext(x, 0x0a)
-    ok 89 - mp_sizeof_ext(0x0a)
-    ok 90 - mp_encode_ext(x, 0x0a) == x
-    # ext len=0x0b
-    ok 91 - len(mp_decode_ext(x, 11))
-    ok 92 - type(mp_decode_ext(x))
-    ok 93 - len(mp_decode_strbin(x, 11))
-    ok 94 - mp_check_ext(mp_encode_ext(x, 0x0b))
-    ok 95 - len(mp_decode_ext(x, 0x0b)
-    ok 96 - len(mp_next_ext(x, 0x0b)
-    ok 97 - len(mp_check_ext(x, 0x0b)
-    ok 98 - mp_sizeof_ext(0x0b)
-    ok 99 - mp_encode_ext(x, 0x0b) == x
-    # ext len=0x0c
-    ok 100 - len(mp_decode_ext(x, 12))
-    ok 101 - type(mp_decode_ext(x))
-    ok 102 - len(mp_decode_strbin(x, 12))
-    ok 103 - mp_check_ext(mp_encode_ext(x, 0x0c))
-    ok 104 - len(mp_decode_ext(x, 0x0c)
-    ok 105 - len(mp_next_ext(x, 0x0c)
-    ok 106 - len(mp_check_ext(x, 0x0c)
-    ok 107 - mp_sizeof_ext(0x0c)
-    ok 108 - mp_encode_ext(x, 0x0c) == x
-    # ext len=0x0d
-    ok 109 - len(mp_decode_ext(x, 13))
-    ok 110 - type(mp_decode_ext(x))
-    ok 111 - len(mp_decode_strbin(x, 13))
-    ok 112 - mp_check_ext(mp_encode_ext(x, 0x0d))
-    ok 113 - len(mp_decode_ext(x, 0x0d)
-    ok 114 - len(mp_next_ext(x, 0x0d)
-    ok 115 - len(mp_check_ext(x, 0x0d)
-    ok 116 - mp_sizeof_ext(0x0d)
-    ok 117 - mp_encode_ext(x, 0x0d) == x
-    # ext len=0x0e
-    ok 118 - len(mp_decode_ext(x, 14))
-    ok 119 - type(mp_decode_ext(x))
-    ok 120 - len(mp_decode_strbin(x, 14))
-    ok 121 - mp_check_ext(mp_encode_ext(x, 0x0e))
-    ok 122 - len(mp_decode_ext(x, 0x0e)
-    ok 123 - len(mp_next_ext(x, 0x0e)
-    ok 124 - len(mp_check_ext(x, 0x0e)
-    ok 125 - mp_sizeof_ext(0x0e)
-    ok 126 - mp_encode_ext(x, 0x0e) == x
-    # ext len=0x0f
-    ok 127 - len(mp_decode_ext(x, 15))
-    ok 128 - type(mp_decode_ext(x))
-    ok 129 - len(mp_decode_strbin(x, 15))
-    ok 130 - mp_check_ext(mp_encode_ext(x, 0x0f))
-    ok 131 - len(mp_decode_ext(x, 0x0f)
-    ok 132 - len(mp_next_ext(x, 0x0f)
-    ok 133 - len(mp_check_ext(x, 0x0f)
-    ok 134 - mp_sizeof_ext(0x0f)
-    ok 135 - mp_encode_ext(x, 0x0f) == x
-    # ext len=0x10
-    ok 136 - len(mp_decode_ext(x, 16))
-    ok 137 - type(mp_decode_ext(x))
-    ok 138 - len(mp_decode_strbin(x, 16))
-    ok 139 - mp_check_ext(mp_encode_ext(x, 0x10))
-    ok 140 - len(mp_decode_ext(x, 0x10)
-    ok 141 - len(mp_next_ext(x, 0x10)
-    ok 142 - len(mp_check_ext(x, 0x10)
-    ok 143 - mp_sizeof_ext(0x10)
-    ok 144 - mp_encode_ext(x, 0x10) == x
-    # ext len=0x11
-    ok 145 - len(mp_decode_ext(x, 17))
-    ok 146 - type(mp_decode_ext(x))
-    ok 147 - len(mp_decode_strbin(x, 17))
-    ok 148 - mp_check_ext(mp_encode_ext(x, 0x11))
-    ok 149 - len(mp_decode_ext(x, 0x11)
-    ok 150 - len(mp_next_ext(x, 0x11)
-    ok 151 - len(mp_check_ext(x, 0x11)
-    ok 152 - mp_sizeof_ext(0x11)
-    ok 153 - mp_encode_ext(x, 0x11) == x
-    # ext len=0xfe
-    ok 154 - len(mp_decode_ext(x, 254))
-    ok 155 - type(mp_decode_ext(x))
-    ok 156 - len(mp_decode_strbin(x, 254))
-    ok 157 - mp_check_ext(mp_encode_ext(x, 0xfe))
-    ok 158 - len(mp_decode_ext(x, 0xfe)
-    ok 159 - len(mp_next_ext(x, 0xfe)
-    ok 160 - len(mp_check_ext(x, 0xfe)
-    ok 161 - mp_sizeof_ext(0xfe)
-    ok 162 - mp_encode_ext(x, 0xfe) == x
-    # ext len=0xff
-    ok 163 - len(mp_decode_ext(x, 255))
-    ok 164 - type(mp_decode_ext(x))
-    ok 165 - len(mp_decode_strbin(x, 255))
-    ok 166 - mp_check_ext(mp_encode_ext(x, 0xff))
-    ok 167 - len(mp_decode_ext(x, 0xff)
-    ok 168 - len(mp_next_ext(x, 0xff)
-    ok 169 - len(mp_check_ext(x, 0xff)
-    ok 170 - mp_sizeof_ext(0xff)
-    ok 171 - mp_encode_ext(x, 0xff) == x
-    # ext len=0x0100
-    ok 172 - len(mp_decode_ext(x, 256))
-    ok 173 - type(mp_decode_ext(x))
-    ok 174 - len(mp_decode_strbin(x, 256))
-    ok 175 - mp_check_ext(mp_encode_ext(x, 0x0100))
-    ok 176 - len(mp_decode_ext(x, 0x0100)
-    ok 177 - len(mp_next_ext(x, 0x0100)
-    ok 178 - len(mp_check_ext(x, 0x0100)
-    ok 179 - mp_sizeof_ext(0x0100)
-    ok 180 - mp_encode_ext(x, 0x0100) == x
-    # ext len=0x0101
-    ok 181 - len(mp_decode_ext(x, 257))
-    ok 182 - type(mp_decode_ext(x))
-    ok 183 - len(mp_decode_strbin(x, 257))
-    ok 184 - mp_check_ext(mp_encode_ext(x, 0x0101))
-    ok 185 - len(mp_decode_ext(x, 0x0101)
-    ok 186 - len(mp_next_ext(x, 0x0101)
-    ok 187 - len(mp_check_ext(x, 0x0101)
-    ok 188 - mp_sizeof_ext(0x0101)
-    ok 189 - mp_encode_ext(x, 0x0101) == x
-    # ext len=0xfffe
-    ok 190 - len(mp_decode_ext(x, 65534))
-    ok 191 - type(mp_decode_ext(x))
-    ok 192 - len(mp_decode_strbin(x, 65534))
-    ok 193 - mp_check_ext(mp_encode_ext(x, 0xfffe))
-    ok 194 - len(mp_decode_ext(x, 0xfffe)
-    ok 195 - len(mp_next_ext(x, 0xfffe)
-    ok 196 - len(mp_check_ext(x, 0xfffe)
-    ok 197 - mp_sizeof_ext(0xfffe)
-    ok 198 - mp_encode_ext(x, 0xfffe) == x
-    # ext len=0xffff
-    ok 199 - len(mp_decode_ext(x, 65535))
-    ok 200 - type(mp_decode_ext(x))
-    ok 201 - len(mp_decode_strbin(x, 65535))
-    ok 202 - mp_check_ext(mp_encode_ext(x, 0xffff))
-    ok 203 - len(mp_decode_ext(x, 0xffff)
-    ok 204 - len(mp_next_ext(x, 0xffff)
-    ok 205 - len(mp_check_ext(x, 0xffff)
-    ok 206 - mp_sizeof_ext(0xffff)
-    ok 207 - mp_encode_ext(x, 0xffff) == x
-    # ext len=0x00010000
-    ok 208 - len(mp_decode_ext(x, 65536))
-    ok 209 - type(mp_decode_ext(x))
-    ok 210 - len(mp_decode_strbin(x, 65536))
-    ok 211 - mp_check_ext(mp_encode_ext(x, 0x00010000))
-    ok 212 - len(mp_decode_ext(x, 0x00010000)
-    ok 213 - len(mp_next_ext(x, 0x00010000)
-    ok 214 - len(mp_check_ext(x, 0x00010000)
-    ok 215 - mp_sizeof_ext(0x00010000)
-    ok 216 - mp_encode_ext(x, 0x00010000) == x
-    # ext len=0x00010001
-    ok 217 - len(mp_decode_ext(x, 65537))
-    ok 218 - type(mp_decode_ext(x))
-    ok 219 - len(mp_decode_strbin(x, 65537))
-    ok 220 - mp_check_ext(mp_encode_ext(x, 0x00010001))
-    ok 221 - len(mp_decode_ext(x, 0x00010001)
-    ok 222 - len(mp_next_ext(x, 0x00010001)
-    ok 223 - len(mp_check_ext(x, 0x00010001)
-    ok 224 - mp_sizeof_ext(0x00010001)
-    ok 225 - mp_encode_ext(x, 0x00010001) == x
-    # *** test_exts: done ***
-ok 12 - subtests
-    1..54
-    # *** test_arrays ***
-    # array 0
-    ok 1 - mp_check_array(0) == 0
-    ok 2 - mp_decode(mp_encode(0)) == 0
-    ok 3 - len(mp_encode_array(0)
-    ok 4 - len(mp_decode_array(0))
-    ok 5 - mp_sizeof_array(0)
-    ok 6 - mp_encode(0) == "\x90"
-    # array 1
-    ok 7 - mp_check_array(1) == 0
-    ok 8 - mp_decode(mp_encode(1)) == 1
-    ok 9 - len(mp_encode_array(1)
-    ok 10 - len(mp_decode_array(1))
-    ok 11 - mp_sizeof_array(1)
-    ok 12 - mp_encode(1) == "\x91"
-    # array 15
-    ok 13 - mp_check_array(15) == 0
-    ok 14 - mp_decode(mp_encode(15)) == 15
-    ok 15 - len(mp_encode_array(15)
-    ok 16 - len(mp_decode_array(15))
-    ok 17 - mp_sizeof_array(15)
-    ok 18 - mp_encode(15) == "\x9f"
-    # array 16
-    ok 19 - mp_check_array(16) == 0
-    ok 20 - mp_decode(mp_encode(16)) == 16
-    ok 21 - len(mp_encode_array(16)
-    ok 22 - len(mp_decode_array(16))
-    ok 23 - mp_sizeof_array(16)
-    ok 24 - mp_encode(16) == "\xdc\x00\x10"
-    # array 0xfffe
-    ok 25 - mp_check_array(0xfffe) == 0
-    ok 26 - mp_decode(mp_encode(0xfffe)) == 0xfffe
-    ok 27 - len(mp_encode_array(0xfffe)
-    ok 28 - len(mp_decode_array(0xfffe))
-    ok 29 - mp_sizeof_array(0xfffe)
-    ok 30 - mp_encode(0xfffe) == "\xdc\xff\xfe"
-    # array 0xffff
-    ok 31 - mp_check_array(0xffff) == 0
-    ok 32 - mp_decode(mp_encode(0xffff)) == 0xffff
-    ok 33 - len(mp_encode_array(0xffff)
-    ok 34 - len(mp_decode_array(0xffff))
-    ok 35 - mp_sizeof_array(0xffff)
-    ok 36 - mp_encode(0xffff) == "\xdc\xff\xff"
-    # array 0x10000
-    ok 37 - mp_check_array(0x10000) == 0
-    ok 38 - mp_decode(mp_encode(0x10000)) == 0x10000
-    ok 39 - len(mp_encode_array(0x10000)
-    ok 40 - len(mp_decode_array(0x10000))
-    ok 41 - mp_sizeof_array(0x10000)
-    ok 42 - mp_encode(0x10000) == "\xdd\x00\x01\x00\x00"
-    # array 0xfffffffeU
-    ok 43 - mp_check_array(0xfffffffeU) == 0
-    ok 44 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 45 - len(mp_encode_array(0xfffffffeU)
-    ok 46 - len(mp_decode_array(0xfffffffeU))
-    ok 47 - mp_sizeof_array(0xfffffffeU)
-    ok 48 - mp_encode(0xfffffffeU) == "\xdd\xff\xff\xff\xfe"
-    # array 0xffffffffU
-    ok 49 - mp_check_array(0xffffffffU) == 0
-    ok 50 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 51 - len(mp_encode_array(0xffffffffU)
-    ok 52 - len(mp_decode_array(0xffffffffU))
-    ok 53 - mp_sizeof_array(0xffffffffU)
-    ok 54 - mp_encode(0xffffffffU) == "\xdd\xff\xff\xff\xff"
-    # *** test_arrays: done ***
-ok 13 - subtests
-    1..54
-    # *** test_maps ***
-    # map 0
-    ok 1 - mp_check_map(0) == 0
-    ok 2 - mp_decode(mp_encode(0)) == 0
-    ok 3 - len(mp_encode_map(0)
-    ok 4 - len(mp_decode_map(0))
-    ok 5 - mp_sizeof_map(0)
-    ok 6 - mp_encode(0) == "\x80"
-    # map 1
-    ok 7 - mp_check_map(1) == 0
-    ok 8 - mp_decode(mp_encode(1)) == 1
-    ok 9 - len(mp_encode_map(1)
-    ok 10 - len(mp_decode_map(1))
-    ok 11 - mp_sizeof_map(1)
-    ok 12 - mp_encode(1) == "\x81"
-    # map 15
-    ok 13 - mp_check_map(15) == 0
-    ok 14 - mp_decode(mp_encode(15)) == 15
-    ok 15 - len(mp_encode_map(15)
-    ok 16 - len(mp_decode_map(15))
-    ok 17 - mp_sizeof_map(15)
-    ok 18 - mp_encode(15) == "\x8f"
-    # map 16
-    ok 19 - mp_check_map(16) == 0
-    ok 20 - mp_decode(mp_encode(16)) == 16
-    ok 21 - len(mp_encode_map(16)
-    ok 22 - len(mp_decode_map(16))
-    ok 23 - mp_sizeof_map(16)
-    ok 24 - mp_encode(16) == "\xde\x00\x10"
-    # map 0xfffe
-    ok 25 - mp_check_map(0xfffe) == 0
-    ok 26 - mp_decode(mp_encode(0xfffe)) == 0xfffe
-    ok 27 - len(mp_encode_map(0xfffe)
-    ok 28 - len(mp_decode_map(0xfffe))
-    ok 29 - mp_sizeof_map(0xfffe)
-    ok 30 - mp_encode(0xfffe) == "\xde\xff\xfe"
-    # map 0xffff
-    ok 31 - mp_check_map(0xffff) == 0
-    ok 32 - mp_decode(mp_encode(0xffff)) == 0xffff
-    ok 33 - len(mp_encode_map(0xffff)
-    ok 34 - len(mp_decode_map(0xffff))
-    ok 35 - mp_sizeof_map(0xffff)
-    ok 36 - mp_encode(0xffff) == "\xde\xff\xff"
-    # map 0x10000
-    ok 37 - mp_check_map(0x10000) == 0
-    ok 38 - mp_decode(mp_encode(0x10000)) == 0x10000
-    ok 39 - len(mp_encode_map(0x10000)
-    ok 40 - len(mp_decode_map(0x10000))
-    ok 41 - mp_sizeof_map(0x10000)
-    ok 42 - mp_encode(0x10000) == "\xdf\x00\x01\x00\x00"
-    # map 0xfffffffeU
-    ok 43 - mp_check_map(0xfffffffeU) == 0
-    ok 44 - mp_decode(mp_encode(0xfffffffeU)) == 0xfffffffeU
-    ok 45 - len(mp_encode_map(0xfffffffeU)
-    ok 46 - len(mp_decode_map(0xfffffffeU))
-    ok 47 - mp_sizeof_map(0xfffffffeU)
-    ok 48 - mp_encode(0xfffffffeU) == "\xdf\xff\xff\xff\xfe"
-    # map 0xffffffffU
-    ok 49 - mp_check_map(0xffffffffU) == 0
-    ok 50 - mp_decode(mp_encode(0xffffffffU)) == 0xffffffffU
-    ok 51 - len(mp_encode_map(0xffffffffU)
-    ok 52 - len(mp_decode_map(0xffffffffU))
-    ok 53 - mp_sizeof_map(0xffffffffU)
-    ok 54 - mp_encode(0xffffffffU) == "\xdf\xff\xff\xff\xff"
-    # *** test_maps: done ***
-ok 14 - subtests
-    1..52
-    # *** test_next_on_arrays ***
-    # next/check on array(0)
-    ok 1 - mp_check(array 0))
-    ok 2 - len(array 0) == 1
-    ok 3 - len(mp_check(array 0)) == 1
-    ok 4 - len(mp_next(array 0)) == 1
-    # next/check on array(1)
-    ok 5 - mp_check(array 1))
-    ok 6 - len(array 1) == 2
-    ok 7 - len(mp_check(array 1)) == 2
-    ok 8 - len(mp_next(array 1)) == 2
-    # next/check on array(15)
-    ok 9 - mp_check(array 15))
-    ok 10 - len(array 15) == 16
-    ok 11 - len(mp_check(array 15)) == 16
-    ok 12 - len(mp_next(array 15)) == 16
-    # next/check on array(16)
-    ok 13 - mp_check(array 16))
-    ok 14 - len(array 16) == 19
-    ok 15 - len(mp_check(array 16)) == 19
-    ok 16 - len(mp_next(array 16)) == 19
-    # next/check on array(17)
-    ok 17 - mp_check(array 17))
-    ok 18 - len(array 17) == 20
-    ok 19 - len(mp_check(array 17)) == 20
-    ok 20 - len(mp_next(array 17)) == 20
-    # next/check on array(254)
-    ok 21 - mp_check(array 254))
-    ok 22 - len(array 254) == 257
-    ok 23 - len(mp_check(array 254)) == 257
-    ok 24 - len(mp_next(array 254)) == 257
-    # next/check on array(255)
-    ok 25 - mp_check(array 255))
-    ok 26 - len(array 255) == 258
-    ok 27 - len(mp_check(array 255)) == 258
-    ok 28 - len(mp_next(array 255)) == 258
-    # next/check on array(256)
-    ok 29 - mp_check(array 256))
-    ok 30 - len(array 256) == 259
-    ok 31 - len(mp_check(array 256)) == 259
-    ok 32 - len(mp_next(array 256)) == 259
-    # next/check on array(257)
-    ok 33 - mp_check(array 257))
-    ok 34 - len(array 257) == 260
-    ok 35 - len(mp_check(array 257)) == 260
-    ok 36 - len(mp_next(array 257)) == 260
-    # next/check on array(65534)
-    ok 37 - mp_check(array 65534))
-    ok 38 - len(array 65534) == 65537
-    ok 39 - len(mp_check(array 65534)) == 65537
-    ok 40 - len(mp_next(array 65534)) == 65537
-    # next/check on array(65535)
-    ok 41 - mp_check(array 65535))
-    ok 42 - len(array 65535) == 65538
-    ok 43 - len(mp_check(array 65535)) == 65538
-    ok 44 - len(mp_next(array 65535)) == 65538
-    # next/check on array(65536)
-    ok 45 - mp_check(array 65536))
-    ok 46 - len(array 65536) == 65541
-    ok 47 - len(mp_check(array 65536)) == 65541
-    ok 48 - len(mp_next(array 65536)) == 65541
-    # next/check on array(65537)
-    ok 49 - mp_check(array 65537))
-    ok 50 - len(array 65537) == 65542
-    ok 51 - len(mp_check(array 65537)) == 65542
-    ok 52 - len(mp_next(array 65537)) == 65542
-    # *** test_next_on_arrays: done ***
-ok 15 - subtests
-    1..52
-    # *** test_next_on_maps ***
-    # next/check on map(0)
-    ok 1 - mp_check(map 0))
-    ok 2 - len(map 0) == 1
-    ok 3 - len(mp_check(map 0)) == 1
-    ok 4 - len(mp_next(map 0)) == 1
-    # next/check on map(1)
-    ok 5 - mp_check(map 1))
-    ok 6 - len(map 1) == 3
-    ok 7 - len(mp_check(map 1)) == 3
-    ok 8 - len(mp_next(map 1)) == 3
-    # next/check on map(15)
-    ok 9 - mp_check(map 15))
-    ok 10 - len(map 15) == 31
-    ok 11 - len(mp_check(map 15)) == 31
-    ok 12 - len(mp_next(map 15)) == 31
-    # next/check on map(16)
-    ok 13 - mp_check(map 16))
-    ok 14 - len(map 16) == 35
-    ok 15 - len(mp_check(map 16)) == 35
-    ok 16 - len(mp_next(map 16)) == 35
-    # next/check on map(17)
-    ok 17 - mp_check(map 17))
-    ok 18 - len(map 17) == 37
-    ok 19 - len(mp_check(map 17)) == 37
-    ok 20 - len(mp_next(map 17)) == 37
-    # next/check on map(254)
-    ok 21 - mp_check(map 254))
-    ok 22 - len(map 254) == 511
-    ok 23 - len(mp_check(map 254)) == 511
-    ok 24 - len(mp_next(map 254)) == 511
-    # next/check on map(255)
-    ok 25 - mp_check(map 255))
-    ok 26 - len(map 255) == 513
-    ok 27 - len(mp_check(map 255)) == 513
-    ok 28 - len(mp_next(map 255)) == 513
-    # next/check on map(256)
-    ok 29 - mp_check(map 256))
-    ok 30 - len(map 256) == 515
-    ok 31 - len(mp_check(map 256)) == 515
-    ok 32 - len(mp_next(map 256)) == 515
-    # next/check on map(257)
-    ok 33 - mp_check(map 257))
-    ok 34 - len(map 257) == 517
-    ok 35 - len(mp_check(map 257)) == 517
-    ok 36 - len(mp_next(map 257)) == 517
-    # next/check on map(65534)
-    ok 37 - mp_check(map 65534))
-    ok 38 - len(map 65534) == 131071
-    ok 39 - len(mp_check(map 65534)) == 131071
-    ok 40 - len(mp_next(map 65534)) == 131071
-    # next/check on map(65535)
-    ok 41 - mp_check(map 65535))
-    ok 42 - len(map 65535) == 131073
-    ok 43 - len(mp_check(map 65535)) == 131073
-    ok 44 - len(mp_next(map 65535)) == 131073
-    # next/check on map(65536)
-    ok 45 - mp_check(map 65536))
-    ok 46 - len(map 65536) == 131077
-    ok 47 - len(mp_check(map 65536)) == 131077
-    ok 48 - len(mp_next(map 65536)) == 131077
-    # next/check on map(65537)
-    ok 49 - mp_check(map 65537))
-    ok 50 - len(map 65537) == 131079
-    ok 51 - len(mp_check(map 65537)) == 131079
-    ok 52 - len(mp_next(map 65537)) == 131079
-    # *** test_next_on_maps: done ***
-ok 16 - subtests
-    1..227
-    # *** test_compare_uints ***
-    ok 1 - mp_compare_uint(0, 0) == 0
-    ok 2 - mp_compare_uint(0, 0) == 0
-    ok 3 - mp_compare_uint(0, 0) == 0
-    ok 4 - mp_compare_uint(0, 1) < 0
-    ok 5 - mp_compare_uint(0, 126) < 0
-    ok 6 - mp_compare_uint(0, 127) < 0
-    ok 7 - mp_compare_uint(0, 128) < 0
-    ok 8 - mp_compare_uint(0, 254) < 0
-    ok 9 - mp_compare_uint(0, 255) < 0
-    ok 10 - mp_compare_uint(0, 65534) < 0
-    ok 11 - mp_compare_uint(0, 65535) < 0
-    ok 12 - mp_compare_uint(0, 65536) < 0
-    ok 13 - mp_compare_uint(0, 4294967294) < 0
-    ok 14 - mp_compare_uint(0, 4294967295) < 0
-    ok 15 - mp_compare_uint(0, 4294967296) < 0
-    ok 16 - mp_compare_uint(0, 18446744073709551614) < 0
-    ok 17 - mp_compare_uint(0, 18446744073709551615) < 0
-    ok 18 - mp_compare_uint(1, 0) > 0
-    ok 19 - mp_compare_uint(1, 1) == 0
-    ok 20 - mp_compare_uint(1, 126) < 0
-    ok 21 - mp_compare_uint(1, 127) < 0
-    ok 22 - mp_compare_uint(1, 128) < 0
-    ok 23 - mp_compare_uint(1, 254) < 0
-    ok 24 - mp_compare_uint(1, 255) < 0
-    ok 25 - mp_compare_uint(1, 65534) < 0
-    ok 26 - mp_compare_uint(1, 65535) < 0
-    ok 27 - mp_compare_uint(1, 65536) < 0
-    ok 28 - mp_compare_uint(1, 4294967294) < 0
-    ok 29 - mp_compare_uint(1, 4294967295) < 0
-    ok 30 - mp_compare_uint(1, 4294967296) < 0
-    ok 31 - mp_compare_uint(1, 18446744073709551614) < 0
-    ok 32 - mp_compare_uint(1, 18446744073709551615) < 0
-    ok 33 - mp_compare_uint(126, 0) > 0
-    ok 34 - mp_compare_uint(126, 1) > 0
-    ok 35 - mp_compare_uint(126, 126) == 0
-    ok 36 - mp_compare_uint(126, 127) < 0
-    ok 37 - mp_compare_uint(126, 128) < 0
-    ok 38 - mp_compare_uint(126, 254) < 0
-    ok 39 - mp_compare_uint(126, 255) < 0
-    ok 40 - mp_compare_uint(126, 65534) < 0
-    ok 41 - mp_compare_uint(126, 65535) < 0
-    ok 42 - mp_compare_uint(126, 65536) < 0
-    ok 43 - mp_compare_uint(126, 4294967294) < 0
-    ok 44 - mp_compare_uint(126, 4294967295) < 0
-    ok 45 - mp_compare_uint(126, 4294967296) < 0
-    ok 46 - mp_compare_uint(126, 18446744073709551614) < 0
-    ok 47 - mp_compare_uint(126, 18446744073709551615) < 0
-    ok 48 - mp_compare_uint(127, 0) > 0
-    ok 49 - mp_compare_uint(127, 1) > 0
-    ok 50 - mp_compare_uint(127, 126) > 0
-    ok 51 - mp_compare_uint(127, 127) == 0
-    ok 52 - mp_compare_uint(127, 128) < 0
-    ok 53 - mp_compare_uint(127, 254) < 0
-    ok 54 - mp_compare_uint(127, 255) < 0
-    ok 55 - mp_compare_uint(127, 65534) < 0
-    ok 56 - mp_compare_uint(127, 65535) < 0
-    ok 57 - mp_compare_uint(127, 65536) < 0
-    ok 58 - mp_compare_uint(127, 4294967294) < 0
-    ok 59 - mp_compare_uint(127, 4294967295) < 0
-    ok 60 - mp_compare_uint(127, 4294967296) < 0
-    ok 61 - mp_compare_uint(127, 18446744073709551614) < 0
-    ok 62 - mp_compare_uint(127, 18446744073709551615) < 0
-    ok 63 - mp_compare_uint(128, 0) > 0
-    ok 64 - mp_compare_uint(128, 1) > 0
-    ok 65 - mp_compare_uint(128, 126) > 0
-    ok 66 - mp_compare_uint(128, 127) > 0
-    ok 67 - mp_compare_uint(128, 128) == 0
-    ok 68 - mp_compare_uint(128, 254) < 0
-    ok 69 - mp_compare_uint(128, 255) < 0
-    ok 70 - mp_compare_uint(128, 65534) < 0
-    ok 71 - mp_compare_uint(128, 65535) < 0
-    ok 72 - mp_compare_uint(128, 65536) < 0
-    ok 73 - mp_compare_uint(128, 4294967294) < 0
-    ok 74 - mp_compare_uint(128, 4294967295) < 0
-    ok 75 - mp_compare_uint(128, 4294967296) < 0
-    ok 76 - mp_compare_uint(128, 18446744073709551614) < 0
-    ok 77 - mp_compare_uint(128, 18446744073709551615) < 0
-    ok 78 - mp_compare_uint(254, 0) > 0
-    ok 79 - mp_compare_uint(254, 1) > 0
-    ok 80 - mp_compare_uint(254, 126) > 0
-    ok 81 - mp_compare_uint(254, 127) > 0
-    ok 82 - mp_compare_uint(254, 128) > 0
-    ok 83 - mp_compare_uint(254, 254) == 0
-    ok 84 - mp_compare_uint(254, 255) < 0
-    ok 85 - mp_compare_uint(254, 65534) < 0
-    ok 86 - mp_compare_uint(254, 65535) < 0
-    ok 87 - mp_compare_uint(254, 65536) < 0
-    ok 88 - mp_compare_uint(254, 4294967294) < 0
-    ok 89 - mp_compare_uint(254, 4294967295) < 0
-    ok 90 - mp_compare_uint(254, 4294967296) < 0
-    ok 91 - mp_compare_uint(254, 18446744073709551614) < 0
-    ok 92 - mp_compare_uint(254, 18446744073709551615) < 0
-    ok 93 - mp_compare_uint(255, 0) > 0
-    ok 94 - mp_compare_uint(255, 1) > 0
-    ok 95 - mp_compare_uint(255, 126) > 0
-    ok 96 - mp_compare_uint(255, 127) > 0
-    ok 97 - mp_compare_uint(255, 128) > 0
-    ok 98 - mp_compare_uint(255, 254) > 0
-    ok 99 - mp_compare_uint(255, 255) == 0
-    ok 100 - mp_compare_uint(255, 65534) < 0
-    ok 101 - mp_compare_uint(255, 65535) < 0
-    ok 102 - mp_compare_uint(255, 65536) < 0
-    ok 103 - mp_compare_uint(255, 4294967294) < 0
-    ok 104 - mp_compare_uint(255, 4294967295) < 0
-    ok 105 - mp_compare_uint(255, 4294967296) < 0
-    ok 106 - mp_compare_uint(255, 18446744073709551614) < 0
-    ok 107 - mp_compare_uint(255, 18446744073709551615) < 0
-    ok 108 - mp_compare_uint(65534, 0) > 0
-    ok 109 - mp_compare_uint(65534, 1) > 0
-    ok 110 - mp_compare_uint(65534, 126) > 0
-    ok 111 - mp_compare_uint(65534, 127) > 0
-    ok 112 - mp_compare_uint(65534, 128) > 0
-    ok 113 - mp_compare_uint(65534, 254) > 0
-    ok 114 - mp_compare_uint(65534, 255) > 0
-    ok 115 - mp_compare_uint(65534, 65534) == 0
-    ok 116 - mp_compare_uint(65534, 65535) < 0
-    ok 117 - mp_compare_uint(65534, 65536) < 0
-    ok 118 - mp_compare_uint(65534, 4294967294) < 0
-    ok 119 - mp_compare_uint(65534, 4294967295) < 0
-    ok 120 - mp_compare_uint(65534, 4294967296) < 0
-    ok 121 - mp_compare_uint(65534, 18446744073709551614) < 0
-    ok 122 - mp_compare_uint(65534, 18446744073709551615) < 0
-    ok 123 - mp_compare_uint(65535, 0) > 0
-    ok 124 - mp_compare_uint(65535, 1) > 0
-    ok 125 - mp_compare_uint(65535, 126) > 0
-    ok 126 - mp_compare_uint(65535, 127) > 0
-    ok 127 - mp_compare_uint(65535, 128) > 0
-    ok 128 - mp_compare_uint(65535, 254) > 0
-    ok 129 - mp_compare_uint(65535, 255) > 0
-    ok 130 - mp_compare_uint(65535, 65534) > 0
-    ok 131 - mp_compare_uint(65535, 65535) == 0
-    ok 132 - mp_compare_uint(65535, 65536) < 0
-    ok 133 - mp_compare_uint(65535, 4294967294) < 0
-    ok 134 - mp_compare_uint(65535, 4294967295) < 0
-    ok 135 - mp_compare_uint(65535, 4294967296) < 0
-    ok 136 - mp_compare_uint(65535, 18446744073709551614) < 0
-    ok 137 - mp_compare_uint(65535, 18446744073709551615) < 0
-    ok 138 - mp_compare_uint(65536, 0) > 0
-    ok 139 - mp_compare_uint(65536, 1) > 0
-    ok 140 - mp_compare_uint(65536, 126) > 0
-    ok 141 - mp_compare_uint(65536, 127) > 0
-    ok 142 - mp_compare_uint(65536, 128) > 0
-    ok 143 - mp_compare_uint(65536, 254) > 0
-    ok 144 - mp_compare_uint(65536, 255) > 0
-    ok 145 - mp_compare_uint(65536, 65534) > 0
-    ok 146 - mp_compare_uint(65536, 65535) > 0
-    ok 147 - mp_compare_uint(65536, 65536) == 0
-    ok 148 - mp_compare_uint(65536, 4294967294) < 0
-    ok 149 - mp_compare_uint(65536, 4294967295) < 0
-    ok 150 - mp_compare_uint(65536, 4294967296) < 0
-    ok 151 - mp_compare_uint(65536, 18446744073709551614) < 0
-    ok 152 - mp_compare_uint(65536, 18446744073709551615) < 0
-    ok 153 - mp_compare_uint(4294967294, 0) > 0
-    ok 154 - mp_compare_uint(4294967294, 1) > 0
-    ok 155 - mp_compare_uint(4294967294, 126) > 0
-    ok 156 - mp_compare_uint(4294967294, 127) > 0
-    ok 157 - mp_compare_uint(4294967294, 128) > 0
-    ok 158 - mp_compare_uint(4294967294, 254) > 0
-    ok 159 - mp_compare_uint(4294967294, 255) > 0
-    ok 160 - mp_compare_uint(4294967294, 65534) > 0
-    ok 161 - mp_compare_uint(4294967294, 65535) > 0
-    ok 162 - mp_compare_uint(4294967294, 65536) > 0
-    ok 163 - mp_compare_uint(4294967294, 4294967294) == 0
-    ok 164 - mp_compare_uint(4294967294, 4294967295) < 0
-    ok 165 - mp_compare_uint(4294967294, 4294967296) < 0
-    ok 166 - mp_compare_uint(4294967294, 18446744073709551614) < 0
-    ok 167 - mp_compare_uint(4294967294, 18446744073709551615) < 0
-    ok 168 - mp_compare_uint(4294967295, 0) > 0
-    ok 169 - mp_compare_uint(4294967295, 1) > 0
-    ok 170 - mp_compare_uint(4294967295, 126) > 0
-    ok 171 - mp_compare_uint(4294967295, 127) > 0
-    ok 172 - mp_compare_uint(4294967295, 128) > 0
-    ok 173 - mp_compare_uint(4294967295, 254) > 0
-    ok 174 - mp_compare_uint(4294967295, 255) > 0
-    ok 175 - mp_compare_uint(4294967295, 65534) > 0
-    ok 176 - mp_compare_uint(4294967295, 65535) > 0
-    ok 177 - mp_compare_uint(4294967295, 65536) > 0
-    ok 178 - mp_compare_uint(4294967295, 4294967294) > 0
-    ok 179 - mp_compare_uint(4294967295, 4294967295) == 0
-    ok 180 - mp_compare_uint(4294967295, 4294967296) < 0
-    ok 181 - mp_compare_uint(4294967295, 18446744073709551614) < 0
-    ok 182 - mp_compare_uint(4294967295, 18446744073709551615) < 0
-    ok 183 - mp_compare_uint(4294967296, 0) > 0
-    ok 184 - mp_compare_uint(4294967296, 1) > 0
-    ok 185 - mp_compare_uint(4294967296, 126) > 0
-    ok 186 - mp_compare_uint(4294967296, 127) > 0
-    ok 187 - mp_compare_uint(4294967296, 128) > 0
-    ok 188 - mp_compare_uint(4294967296, 254) > 0
-    ok 189 - mp_compare_uint(4294967296, 255) > 0
-    ok 190 - mp_compare_uint(4294967296, 65534) > 0
-    ok 191 - mp_compare_uint(4294967296, 65535) > 0
-    ok 192 - mp_compare_uint(4294967296, 65536) > 0
-    ok 193 - mp_compare_uint(4294967296, 4294967294) > 0
-    ok 194 - mp_compare_uint(4294967296, 4294967295) > 0
-    ok 195 - mp_compare_uint(4294967296, 4294967296) == 0
-    ok 196 - mp_compare_uint(4294967296, 18446744073709551614) < 0
-    ok 197 - mp_compare_uint(4294967296, 18446744073709551615) < 0
-    ok 198 - mp_compare_uint(18446744073709551614, 0) > 0
-    ok 199 - mp_compare_uint(18446744073709551614, 1) > 0
-    ok 200 - mp_compare_uint(18446744073709551614, 126) > 0
-    ok 201 - mp_compare_uint(18446744073709551614, 127) > 0
-    ok 202 - mp_compare_uint(18446744073709551614, 128) > 0
-    ok 203 - mp_compare_uint(18446744073709551614, 254) > 0
-    ok 204 - mp_compare_uint(18446744073709551614, 255) > 0
-    ok 205 - mp_compare_uint(18446744073709551614, 65534) > 0
-    ok 206 - mp_compare_uint(18446744073709551614, 65535) > 0
-    ok 207 - mp_compare_uint(18446744073709551614, 65536) > 0
-    ok 208 - mp_compare_uint(18446744073709551614, 4294967294) > 0
-    ok 209 - mp_compare_uint(18446744073709551614, 4294967295) > 0
-    ok 210 - mp_compare_uint(18446744073709551614, 4294967296) > 0
-    ok 211 - mp_compare_uint(18446744073709551614, 18446744073709551614) == 0
-    ok 212 - mp_compare_uint(18446744073709551614, 18446744073709551615) < 0
-    ok 213 - mp_compare_uint(18446744073709551615, 0) > 0
-    ok 214 - mp_compare_uint(18446744073709551615, 1) > 0
-    ok 215 - mp_compare_uint(18446744073709551615, 126) > 0
-    ok 216 - mp_compare_uint(18446744073709551615, 127) > 0
-    ok 217 - mp_compare_uint(18446744073709551615, 128) > 0
-    ok 218 - mp_compare_uint(18446744073709551615, 254) > 0
-    ok 219 - mp_compare_uint(18446744073709551615, 255) > 0
-    ok 220 - mp_compare_uint(18446744073709551615, 65534) > 0
-    ok 221 - mp_compare_uint(18446744073709551615, 65535) > 0
-    ok 222 - mp_compare_uint(18446744073709551615, 65536) > 0
-    ok 223 - mp_compare_uint(18446744073709551615, 4294967294) > 0
-    ok 224 - mp_compare_uint(18446744073709551615, 4294967295) > 0
-    ok 225 - mp_compare_uint(18446744073709551615, 4294967296) > 0
-    ok 226 - mp_compare_uint(18446744073709551615, 18446744073709551614) > 0
-    ok 227 - mp_compare_uint(18446744073709551615, 18446744073709551615) == 0
-    # *** test_compare_uints: done ***
-ok 17 - subtests
-    1..282
-    # *** test_format ***
-    ok 1 - Test type on step 0
-    ok 2 - Test value on step 0
-    ok 3 - Test type on step 1
-    ok 4 - Test value on step 1
-    ok 5 - Test type on step 2
-    ok 6 - Test value on step 2
-    ok 7 - Test type on step 3
-    ok 8 - Test value on step 3
-    ok 9 - Test type on step 4
-    ok 10 - Test value on step 4
-    ok 11 - Test type on step 5
-    ok 12 - Test value on step 5
-    ok 13 - Test type on step 6
-    ok 14 - Test value on step 6
-    ok 15 - Test type on step 7
-    ok 16 - Test value on step 7
-    ok 17 - Test type on step 8
-    ok 18 - Test value on step 8
-    ok 19 - Test type on step 9
-    ok 20 - Test value on step 9
-    ok 21 - Test type on step 10
-    ok 22 - Test value on step 10
-    ok 23 - Test type on step 11
-    ok 24 - Test value on step 11
-    ok 25 - Test type on step 12
-    ok 26 - Test value on step 12
-    ok 27 - Test type on step 13
-    ok 28 - Test value on step 13
-    ok 29 - Test type on step 14
-    ok 30 - Test value on step 14
-    ok 31 - Test type on step 0
-    ok 32 - Test value on step 0
-    ok 33 - Test type on step 1
-    ok 34 - Test value on step 1
-    ok 35 - Test type on step 2
-    ok 36 - Test value on step 2
-    ok 37 - Test type on step 3
-    ok 38 - Test value on step 3
-    ok 39 - Test type on step 4
-    ok 40 - Test value on step 4
-    ok 41 - Test type on step 5
-    ok 42 - Test value on step 5
-    ok 43 - Test type on step 6
-    ok 44 - Test value on step 6
-    ok 45 - Test type on step 7
-    ok 46 - Test value on step 7
-    ok 47 - Test type on step 8
-    ok 48 - Test value on step 8
-    ok 49 - Test type on step 9
-    ok 50 - Test value on step 9
-    ok 51 - Test type on step 10
-    ok 52 - Test value on step 10
-    ok 53 - Test type on step 11
-    ok 54 - Test value on step 11
-    ok 55 - Test type on step 12
-    ok 56 - Test value on step 12
-    ok 57 - Test type on step 13
-    ok 58 - Test value on step 13
-    ok 59 - Test type on step 14
-    ok 60 - Test value on step 14
-    ok 61 - check
-    ok 62 - type
-    ok 63 - decode
-    ok 64 - check
-    ok 65 - type
-    ok 66 - check
-    ok 67 - type
-    ok 68 - decode
-    ok 69 - check
-    ok 70 - type
-    ok 71 - decode
-    ok 72 - check
-    ok 73 - type
-    ok 74 - decode
-    ok 75 - check
-    ok 76 - type
-    ok 77 - decode
-    ok 78 - check
-    ok 79 - type
-    ok 80 - decode
-    ok 81 - check
-    ok 82 - type
-    ok 83 - decode
-    ok 84 - check
-    ok 85 - type
-    ok 86 - decode
-    ok 87 - check
-    ok 88 - type
-    ok 89 - decode
-    ok 90 - check
-    ok 91 - type
-    ok 92 - decode
-    ok 93 - check
-    ok 94 - type
-    ok 95 - decode
-    ok 96 - check
-    ok 97 - type
-    ok 98 - decode
-    ok 99 - compare
-    ok 100 - check
-    ok 101 - type
-    ok 102 - decode
-    ok 103 - check
-    ok 104 - type
-    ok 105 - decode
-    ok 106 - compare
-    ok 107 - check
-    ok 108 - type
-    ok 109 - decode
-    ok 110 - check
-    ok 111 - type
-    ok 112 - decode
-    ok 113 - check
-    ok 114 - type
-    ok 115 - check
-    ok 116 - compare
-    ok 117 - check
-    ok 118 - type
-    ok 119 - decode
-    ok 120 - check
-    ok 121 - type
-    ok 122 - decode
-    ok 123 - check
-    ok 124 - type
-    ok 125 - decode
-    ok 126 - compare
-    ok 127 - check
-    ok 128 - type
-    ok 129 - decode
-    ok 130 - check
-    ok 131 - type
-    ok 132 - decode
-    ok 133 - check
-    ok 134 - type
-    ok 135 - decode
-    ok 136 - check
-    ok 137 - type
-    ok 138 - decode
-    ok 139 - nothing more
-    ok 140 - no magic detected
-    ok 141 - return value on step 0
-    ok 142 - buffer overflow on step 0
-    ok 143 - return value on step 1
-    ok 144 - buffer overflow on step 1
-    ok 145 - return value on step 2
-    ok 146 - buffer overflow on step 2
-    ok 147 - return value on step 3
-    ok 148 - buffer overflow on step 3
-    ok 149 - return value on step 4
-    ok 150 - buffer overflow on step 4
-    ok 151 - return value on step 5
-    ok 152 - buffer overflow on step 5
-    ok 153 - return value on step 6
-    ok 154 - buffer overflow on step 6
-    ok 155 - return value on step 7
-    ok 156 - buffer overflow on step 7
-    ok 157 - return value on step 8
-    ok 158 - buffer overflow on step 8
-    ok 159 - return value on step 9
-    ok 160 - buffer overflow on step 9
-    ok 161 - return value on step 10
-    ok 162 - buffer overflow on step 10
-    ok 163 - return value on step 11
-    ok 164 - buffer overflow on step 11
-    ok 165 - return value on step 12
-    ok 166 - buffer overflow on step 12
-    ok 167 - return value on step 13
-    ok 168 - buffer overflow on step 13
-    ok 169 - return value on step 14
-    ok 170 - buffer overflow on step 14
-    ok 171 - return value on step 15
-    ok 172 - buffer overflow on step 15
-    ok 173 - return value on step 16
-    ok 174 - buffer overflow on step 16
-    ok 175 - return value on step 17
-    ok 176 - buffer overflow on step 17
-    ok 177 - return value on step 18
-    ok 178 - buffer overflow on step 18
-    ok 179 - return value on step 19
-    ok 180 - buffer overflow on step 19
-    ok 181 - return value on step 20
-    ok 182 - buffer overflow on step 20
-    ok 183 - return value on step 21
-    ok 184 - buffer overflow on step 21
-    ok 185 - return value on step 22
-    ok 186 - buffer overflow on step 22
-    ok 187 - return value on step 23
-    ok 188 - buffer overflow on step 23
-    ok 189 - return value on step 24
-    ok 190 - buffer overflow on step 24
-    ok 191 - return value on step 25
-    ok 192 - buffer overflow on step 25
-    ok 193 - return value on step 26
-    ok 194 - buffer overflow on step 26
-    ok 195 - return value on step 27
-    ok 196 - buffer overflow on step 27
-    ok 197 - return value on step 28
-    ok 198 - buffer overflow on step 28
-    ok 199 - return value on step 29
-    ok 200 - buffer overflow on step 29
-    ok 201 - return value on step 30
-    ok 202 - buffer overflow on step 30
-    ok 203 - return value on step 31
-    ok 204 - buffer overflow on step 31
-    ok 205 - return value on step 32
-    ok 206 - buffer overflow on step 32
-    ok 207 - return value on step 33
-    ok 208 - buffer overflow on step 33
-    ok 209 - return value on step 34
-    ok 210 - buffer overflow on step 34
-    ok 211 - return value on step 35
-    ok 212 - buffer overflow on step 35
-    ok 213 - return value on step 36
-    ok 214 - buffer overflow on step 36
-    ok 215 - return value on step 37
-    ok 216 - buffer overflow on step 37
-    ok 217 - return value on step 38
-    ok 218 - buffer overflow on step 38
-    ok 219 - return value on step 39
-    ok 220 - buffer overflow on step 39
-    ok 221 - return value on step 40
-    ok 222 - buffer overflow on step 40
-    ok 223 - return value on step 41
-    ok 224 - buffer overflow on step 41
-    ok 225 - return value on step 42
-    ok 226 - buffer overflow on step 42
-    ok 227 - return value on step 43
-    ok 228 - buffer overflow on step 43
-    ok 229 - return value on step 44
-    ok 230 - buffer overflow on step 44
-    ok 231 - return value on step 45
-    ok 232 - buffer overflow on step 45
-    ok 233 - return value on step 46
-    ok 234 - buffer overflow on step 46
-    ok 235 - return value on step 47
-    ok 236 - buffer overflow on step 47
-    ok 237 - return value on step 48
-    ok 238 - buffer overflow on step 48
-    ok 239 - return value on step 49
-    ok 240 - buffer overflow on step 49
-    ok 241 - return value on step 50
-    ok 242 - buffer overflow on step 50
-    ok 243 - return value on step 51
-    ok 244 - buffer overflow on step 51
-    ok 245 - return value on step 52
-    ok 246 - buffer overflow on step 52
-    ok 247 - return value on step 53
-    ok 248 - buffer overflow on step 53
-    ok 249 - return value on step 54
-    ok 250 - buffer overflow on step 54
-    ok 251 - return value on step 55
-    ok 252 - buffer overflow on step 55
-    ok 253 - return value on step 56
-    ok 254 - buffer overflow on step 56
-    ok 255 - return value on step 57
-    ok 256 - buffer overflow on step 57
-    ok 257 - return value on step 58
-    ok 258 - buffer overflow on step 58
-    ok 259 - return value on step 59
-    ok 260 - buffer overflow on step 59
-    ok 261 - return value on step 60
-    ok 262 - buffer overflow on step 60
-    ok 263 - return value on step 61
-    ok 264 - buffer overflow on step 61
-    ok 265 - return value on step 62
-    ok 266 - buffer overflow on step 62
-    ok 267 - return value on step 63
-    ok 268 - buffer overflow on step 63
-    ok 269 - return value on step 64
-    ok 270 - buffer overflow on step 64
-    ok 271 - return value on step 65
-    ok 272 - buffer overflow on step 65
-    ok 273 - return value on step 66
-    ok 274 - buffer overflow on step 66
-    ok 275 - return value on step 67
-    ok 276 - buffer overflow on step 67
-    ok 277 - return value on step 68
-    ok 278 - buffer overflow on step 68
-    ok 279 - return value on step 69
-    ok 280 - buffer overflow on step 69
-    ok 281 - return value on step 70
-    ok 282 - buffer overflow on step 70
-    # *** test_format: done ***
-ok 18 - subtests
-    1..12
-    # *** test_mp_print ***
-    ok 1 - mp_snprint return value
-    ok 2 - mp_snprint result
-    ok 3 - mp_snprint limit = 0
-    ok 4 - mp_snprint limit = 1
-    ok 5 - mp_snprint limit = 2
-    ok 6 - mp_snprint limit = expected
-    ok 7 - mp_snprint limit = expected + 1
-    ok 8 - mp_fprint return value
-    ok 9 - mp_fprint result
-    ok 10 - mp_fprint I/O error
-    ok 11 - mp_snprint max nesting depth return value
-    ok 12 - mp_snprint max nesting depth result
-    # *** test_mp_print: done ***
-ok 19 - subtests
-    1..5
-    # *** test_mp_print_ext ***
-    ok 1 - mp_snrpint size match
-    ok 2 - str is correct
-    ok 3 - mp_fprint size match
-    ok 4 - mp_fprint written correct number of bytes
-    ok 5 - str is correct
-    # *** test_mp_print_ext: done ***
-ok 20 - subtests
-    1..65
-    # *** test_mp_check ***
-    ok 1 - invalid fixmap 1
-    ok 2 - invalid fixmap 2
-    ok 3 - invalid fixmap 3
-    ok 4 - invalid fixarray 1
-    ok 5 - invalid fixarray 2
-    ok 6 - invalid fixarray 3
-    ok 7 - invalid fixstr 1
-    ok 8 - invalid fixstr 2
-    ok 9 - invalid fixstr 3
-    ok 10 - invalid bin8 1
-    ok 11 - invalid bin8 2
-    ok 12 - invalid bin16 1
-    ok 13 - invalid bin16 2
-    ok 14 - invalid bin32 1
-    ok 15 - invalid bin32 2
-    ok 16 - invalid ext8 1
-    ok 17 - invalid ext8 2
-    ok 18 - invalid ext8 3
-    ok 19 - invalid ext8 4
-    ok 20 - invalid ext16 1
-    ok 21 - invalid ext16 2
-    ok 22 - invalid ext16 3
-    ok 23 - invalid ext16 4
-    ok 24 - invalid ext32 1
-    ok 25 - invalid ext32 2
-    ok 26 - invalid ext32 3
-    ok 27 - invalid ext32 4
-    ok 28 - invalid float32 1
-    ok 29 - invalid float32 2
-    ok 30 - invalid float64 1
-    ok 31 - invalid float64 2
-    ok 32 - invalid uint8 1
-    ok 33 - invalid uint16 1
-    ok 34 - invalid uint32 1
-    ok 35 - invalid uint64 1
-    ok 36 - invalid int8 1
-    ok 37 - invalid int16 1
-    ok 38 - invalid int32 1
-    ok 39 - invalid int64 1
-    ok 40 - invalid fixext8 1
-    ok 41 - invalid fixext8 2
-    ok 42 - invalid fixext16 1
-    ok 43 - invalid fixext16 2
-    ok 44 - invalid fixext32 1
-    ok 45 - invalid fixext32 2
-    ok 46 - invalid fixext64 1
-    ok 47 - invalid fixext64 2
-    ok 48 - invalid fixext128 1
-    ok 49 - invalid fixext128 2
-    ok 50 - invalid str8 1
-    ok 51 - invalid str8 2
-    ok 52 - invalid str16 1
-    ok 53 - invalid str16 2
-    ok 54 - invalid str32 1
-    ok 55 - invalid str32 2
-    ok 56 - invalid array16 1
-    ok 57 - invalid array16 2
-    ok 58 - invalid array32 1
-    ok 59 - invalid array32 2
-    ok 60 - invalid map16 1
-    ok 61 - invalid map16 2
-    ok 62 - invalid map16 2
-    ok 63 - invalid map32 1
-    ok 64 - invalid map32 2
-    ok 65 - invalid map32 3
-    # *** test_mp_check: done ***
-ok 21 - subtests
-    1..96
-    # *** test_numbers ***
-    ok 1 - mp_read_int32(mp_encode_uint(123)) check success
-    ok 2 - mp_read_int32(mp_encode_uint(123)) check pos advanced
-    ok 3 - mp_read_int32(mp_encode_uint(123)) check result
-    ok 4 - mp_read_int32(mp_encode_uint(12345)) check success
-    ok 5 - mp_read_int32(mp_encode_uint(12345)) check pos advanced
-    ok 6 - mp_read_int32(mp_encode_uint(12345)) check result
-    ok 7 - mp_read_int32(mp_encode_uint(2147483647)) check success
-    ok 8 - mp_read_int32(mp_encode_uint(2147483647)) check pos advanced
-    ok 9 - mp_read_int32(mp_encode_uint(2147483647)) check result
-    ok 10 - mp_read_int32(mp_encode_uint(2147483648)) check fail
-    ok 11 - mp_read_int32(mp_encode_uint(2147483648)) check pos unchanged
-    ok 12 - mp_read_int32(mp_encode_int(-123)) check success
-    ok 13 - mp_read_int32(mp_encode_int(-123)) check pos advanced
-    ok 14 - mp_read_int32(mp_encode_int(-123)) check result
-    ok 15 - mp_read_int32(mp_encode_int(-12345)) check success
-    ok 16 - mp_read_int32(mp_encode_int(-12345)) check pos advanced
-    ok 17 - mp_read_int32(mp_encode_int(-12345)) check result
-    ok 18 - mp_read_int32(mp_encode_int(-2147483648)) check success
-    ok 19 - mp_read_int32(mp_encode_int(-2147483648)) check pos advanced
-    ok 20 - mp_read_int32(mp_encode_int(-2147483648)) check result
-    ok 21 - mp_read_int32(mp_encode_int(-2147483649LL)) check fail
-    ok 22 - mp_read_int32(mp_encode_int(-2147483649LL)) check pos unchanged
-    ok 23 - mp_read_int32(mp_encode_float(-1e2)) check fail
-    ok 24 - mp_read_int32(mp_encode_float(-1e2)) check pos unchanged
-    ok 25 - mp_read_int32(mp_encode_double(1.2345)) check fail
-    ok 26 - mp_read_int32(mp_encode_double(1.2345)) check pos unchanged
-    ok 27 - mp_read_int32(mp_encode_map(5)) check fail
-    ok 28 - mp_read_int32(mp_encode_map(5)) check pos unchanged
-    ok 29 - mp_read_int64(mp_encode_uint(123)) check success
-    ok 30 - mp_read_int64(mp_encode_uint(123)) check pos advanced
-    ok 31 - mp_read_int64(mp_encode_uint(123)) check result
-    ok 32 - mp_read_int64(mp_encode_uint(12345)) check success
-    ok 33 - mp_read_int64(mp_encode_uint(12345)) check pos advanced
-    ok 34 - mp_read_int64(mp_encode_uint(12345)) check result
-    ok 35 - mp_read_int64(mp_encode_uint(123456789)) check success
-    ok 36 - mp_read_int64(mp_encode_uint(123456789)) check pos advanced
-    ok 37 - mp_read_int64(mp_encode_uint(123456789)) check result
-    ok 38 - mp_read_int64(mp_encode_uint(9223372036854775807ULL)) check success
-    ok 39 - mp_read_int64(mp_encode_uint(9223372036854775807ULL)) check pos advanced
-    ok 40 - mp_read_int64(mp_encode_uint(9223372036854775807ULL)) check result
-    ok 41 - mp_read_int64(mp_encode_uint(9223372036854775808ULL)) check fail
-    ok 42 - mp_read_int64(mp_encode_uint(9223372036854775808ULL)) check pos unchanged
-    ok 43 - mp_read_int64(mp_encode_int(-123)) check success
-    ok 44 - mp_read_int64(mp_encode_int(-123)) check pos advanced
-    ok 45 - mp_read_int64(mp_encode_int(-123)) check result
-    ok 46 - mp_read_int64(mp_encode_int(-12345)) check success
-    ok 47 - mp_read_int64(mp_encode_int(-12345)) check pos advanced
-    ok 48 - mp_read_int64(mp_encode_int(-12345)) check result
-    ok 49 - mp_read_int64(mp_encode_int(-123456789)) check success
-    ok 50 - mp_read_int64(mp_encode_int(-123456789)) check pos advanced
-    ok 51 - mp_read_int64(mp_encode_int(-123456789)) check result
-    ok 52 - mp_read_int64(mp_encode_int(-9223372036854775807LL)) check success
-    ok 53 - mp_read_int64(mp_encode_int(-9223372036854775807LL)) check pos advanced
-    ok 54 - mp_read_int64(mp_encode_int(-9223372036854775807LL)) check result
-    ok 55 - mp_read_int64(mp_encode_float(100)) check fail
-    ok 56 - mp_read_int64(mp_encode_float(100)) check pos unchanged
-    ok 57 - mp_read_int64(mp_encode_double(-5.4321)) check fail
-    ok 58 - mp_read_int64(mp_encode_double(-5.4321)) check pos unchanged
-    ok 59 - mp_read_int64(mp_encode_array(10)) check fail
-    ok 60 - mp_read_int64(mp_encode_array(10)) check pos unchanged
-    ok 61 - mp_read_double(mp_encode_uint(123)) check success
-    ok 62 - mp_read_double(mp_encode_uint(123)) check pos advanced
-    ok 63 - mp_read_double(mp_encode_uint(123)) check result
-    ok 64 - mp_read_double(mp_encode_uint(12345)) check success
-    ok 65 - mp_read_double(mp_encode_uint(12345)) check pos advanced
-    ok 66 - mp_read_double(mp_encode_uint(12345)) check result
-    ok 67 - mp_read_double(mp_encode_uint(123456789)) check success
-    ok 68 - mp_read_double(mp_encode_uint(123456789)) check pos advanced
-    ok 69 - mp_read_double(mp_encode_uint(123456789)) check result
-    ok 70 - mp_read_double(mp_encode_uint(1234567890000ULL)) check success
-    ok 71 - mp_read_double(mp_encode_uint(1234567890000ULL)) check pos advanced
-    ok 72 - mp_read_double(mp_encode_uint(1234567890000ULL)) check result
-    ok 73 - mp_read_double(mp_encode_uint(123456789123456789ULL)) check fail
-    ok 74 - mp_read_double(mp_encode_uint(123456789123456789ULL)) check pos unchanged
-    ok 75 - mp_read_double(mp_encode_int(-123)) check success
-    ok 76 - mp_read_double(mp_encode_int(-123)) check pos advanced
-    ok 77 - mp_read_double(mp_encode_int(-123)) check result
-    ok 78 - mp_read_double(mp_encode_int(-12345)) check success
-    ok 79 - mp_read_double(mp_encode_int(-12345)) check pos advanced
-    ok 80 - mp_read_double(mp_encode_int(-12345)) check result
-    ok 81 - mp_read_double(mp_encode_int(-123456789)) check success
-    ok 82 - mp_read_double(mp_encode_int(-123456789)) check pos advanced
-    ok 83 - mp_read_double(mp_encode_int(-123456789)) check result
-    ok 84 - mp_read_double(mp_encode_int(-1234567890000LL)) check success
-    ok 85 - mp_read_double(mp_encode_int(-1234567890000LL)) check pos advanced
-    ok 86 - mp_read_double(mp_encode_int(-1234567890000LL)) check result
-    ok 87 - mp_read_double(mp_encode_int(-123456789123456789LL)) check fail
-    ok 88 - mp_read_double(mp_encode_int(-123456789123456789LL)) check pos unchanged
-    ok 89 - mp_read_double(mp_encode_float(6.565e6)) check success
-    ok 90 - mp_read_double(mp_encode_float(6.565e6)) check pos advanced
-    ok 91 - mp_read_double(mp_encode_float(6.565e6)) check result
-    ok 92 - mp_read_double(mp_encode_double(-5.555)) check success
-    ok 93 - mp_read_double(mp_encode_double(-5.555)) check pos advanced
-    ok 94 - mp_read_double(mp_encode_double(-5.555)) check result
-    ok 95 - mp_read_double(mp_encode_strl(100)) check fail
-    ok 96 - mp_read_double(mp_encode_strl(100)) check pos unchanged
-    # *** test_numbers: done ***
-ok 22 - subtests
-    1..4
-    # *** test_overflow ***
-    ok 1 - mp_check array overflow
-    ok 2 - mp_check map overflow
-    ok 3 - mp_check str overflow
-    ok 4 - mp_check bin overflow
-    # *** test_overflow: done ***
-ok 23 - subtests
diff --git a/test/unit/popen.result b/test/unit/popen.result
deleted file mode 100644
index f5e6bc2ca..000000000
--- a/test/unit/popen.result
+++ /dev/null
@@ -1,30 +0,0 @@
-1..3
-	*** main_f ***
-    1..6
-	*** popen_write_exit ***
-    ok 1 - popen_new
-    ok 2 - state alive
-    ok 3 - write flag check
-    ok 4 - write to pipe
-    ok 5 - child exited
-    ok 6 - popen_delete
-	*** popen_write_exit: done ***
-ok 1 - subtests
-    1..5
-	*** popen_read_exit ***
-    ok 1 - popen_new
-    ok 2 - child exited
-    ok 3 - read flag check
-    ok 4 - read from pipe
-    ok 5 - popen_delete
-	*** popen_read_exit: done ***
-ok 2 - subtests
-    1..4
-	*** popen_kill ***
-    ok 1 - popen_new
-    ok 2 - popen_send_signal
-    ok 3 - child terminated
-    ok 4 - popen_delete
-	*** popen_kill: done ***
-ok 3 - subtests
-	*** main_f: done ***
diff --git a/test/unit/queue.c b/test/unit/queue.c
index 3caec1a41..e53856b28 100644
--- a/test/unit/queue.c
+++ b/test/unit/queue.c
@@ -31,7 +31,6 @@
 #include "third_party/queue.h"
 #include "unit.h"
 #include <stdio.h>
-#include <assert.h>
 
 struct elem
 {
@@ -59,11 +58,11 @@ void test0()
 {
 	header();
 	struct elem_queue queue = STAILQ_HEAD_INITIALIZER(queue);
-	printf("Initialized: %s\n", queue2str(&queue));
+	note("Initialized: %s", queue2str(&queue));
 	STAILQ_INIT(&queue);
-	printf("STAILQ_INIT: %s\n", queue2str(&queue));
+	note("STAILQ_INIT: %s", queue2str(&queue));
 	STAILQ_REVERSE(&queue, elem, entry);
-	printf("STAILQ_REVERSE: %s\n", queue2str(&queue));
+	note("STAILQ_REVERSE: %s", queue2str(&queue));
 	footer();
 }
 
@@ -75,9 +74,9 @@ void test1()
 	struct elem_queue queue = STAILQ_HEAD_INITIALIZER(queue);
 	el1.val = 1;
 	STAILQ_INSERT_TAIL(&queue, &el1, entry);
-	printf("STAILQ_INIT: %s\n", queue2str(&queue));
+	note("STAILQ_INIT: %s", queue2str(&queue));
 	STAILQ_REVERSE(&queue, elem, entry);
-	printf("STAILQ_REVERSE: %s\n", queue2str(&queue));
+	note("STAILQ_REVERSE: %s", queue2str(&queue));
 	footer();
 }
 
@@ -91,9 +90,9 @@ void test2()
 	el2.val = 2;
 	STAILQ_INSERT_TAIL(&queue, &el1, entry);
 	STAILQ_INSERT_TAIL(&queue, &el2, entry);
-	printf("STAILQ_INIT: %s\n", queue2str(&queue));
+	note("STAILQ_INIT: %s", queue2str(&queue));
 	STAILQ_REVERSE(&queue, elem, entry);
-	printf("STAILQ_REVERSE: %s\n", queue2str(&queue));
+	note("STAILQ_REVERSE: %s", queue2str(&queue));
 	footer();
 }
 
@@ -108,9 +107,9 @@ void test3()
 	STAILQ_INSERT_TAIL(&queue, &el1, entry);
 	STAILQ_INSERT_TAIL(&queue, &el2, entry);
 	STAILQ_INSERT_TAIL(&queue, &el3, entry);
-	printf("STAILQ_INIT: %s\n", queue2str(&queue));
+	note("STAILQ_INIT: %s", queue2str(&queue));
 	STAILQ_REVERSE(&queue, elem, entry);
-	printf("STAILQ_REVERSE: %s\n", queue2str(&queue));
+	note("STAILQ_REVERSE: %s", queue2str(&queue));
 	footer();
 }
 
@@ -122,44 +121,46 @@ void test_splice()
 	struct elem_queue queue1 = STAILQ_HEAD_INITIALIZER(queue1);
 	struct elem_queue queue2 = STAILQ_HEAD_INITIALIZER(queue2);
 	STAILQ_SPLICE(&queue1, STAILQ_FIRST(&queue1), entry, &queue2);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	STAILQ_SPLICE(&queue2, STAILQ_FIRST(&queue2), entry, &queue1);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	el1.val = 1;
 	el2.val = 2;
 	el3.val = 3;
 	STAILQ_INSERT_TAIL(&queue1, &el1, entry);
 	STAILQ_INSERT_TAIL(&queue1, &el2, entry);
 	STAILQ_INSERT_TAIL(&queue1, &el3, entry);
-	printf("STAILQ_INIT: %s\n", queue2str(&queue1));
+	note("STAILQ_INIT: %s", queue2str(&queue1));
 	STAILQ_SPLICE(&queue1, STAILQ_FIRST(&queue1), entry, &queue2);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	STAILQ_SPLICE(&queue2, STAILQ_FIRST(&queue2), entry, &queue1);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	STAILQ_SPLICE(&queue1, STAILQ_NEXT(STAILQ_FIRST(&queue1), entry),
 					   entry, &queue2);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	STAILQ_SPLICE(&queue2, STAILQ_NEXT(STAILQ_FIRST(&queue2), entry),
 		      entry, &queue1);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	STAILQ_SPLICE(&queue2, STAILQ_FIRST(&queue2), entry, &queue1);
-	printf("q1: %s\n", queue2str(&queue1));
-	printf("q2: %s\n", queue2str(&queue2));
+	note("q1: %s", queue2str(&queue1));
+	note("q2: %s", queue2str(&queue2));
 	footer();
 }
 
 int main()
 {
+	plan(0);
 	test0();
 	test1();
 	test2();
 	test3();
 	test_splice();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/queue.result b/test/unit/queue.result
deleted file mode 100644
index 18b0c0758..000000000
--- a/test/unit/queue.result
+++ /dev/null
@@ -1,34 +0,0 @@
-	*** test0 ***
-Initialized: 
-STAILQ_INIT: 
-STAILQ_REVERSE: 
-	*** test0: done ***
-	*** test1 ***
-STAILQ_INIT: 1 
-STAILQ_REVERSE: 1 
-	*** test1: done ***
-	*** test2 ***
-STAILQ_INIT: 1 2 
-STAILQ_REVERSE: 2 1 
-	*** test2: done ***
-	*** test3 ***
-STAILQ_INIT: 1 2 3 
-STAILQ_REVERSE: 3 2 1 
-	*** test3: done ***
-	*** test_splice ***
-q1: 
-q2: 
-q1: 
-q2: 
-STAILQ_INIT: 1 2 3 
-q1: 
-q2: 1 2 3 
-q1: 1 2 3 
-q2: 
-q1: 1 
-q2: 2 3 
-q1: 1 3 
-q2: 2 
-q1: 1 3 2 
-q2: 
-	*** test_splice: done ***
diff --git a/test/unit/ratelimit.result b/test/unit/ratelimit.result
deleted file mode 100644
index 8a755c64d..000000000
--- a/test/unit/ratelimit.result
+++ /dev/null
@@ -1,13 +0,0 @@
-	*** main ***
-1..10
-ok 1 - emitted 10 expected 10
-ok 2 - suppressed 0 expected 0
-ok 3 - emitted 0 expected 0
-ok 4 - suppressed 0 expected 0
-ok 5 - emitted 1 expected 1
-ok 6 - suppressed 10 expected 10
-ok 7 - emitted 1 expected 1
-ok 8 - suppressed 0 expected 0
-ok 9 - emitted 1000 expected 1000
-ok 10 - suppressed 3000 expected 3000
-	*** main: done ***
diff --git a/test/unit/reflection_c.result b/test/unit/reflection_c.result
deleted file mode 100644
index 294fa9799..000000000
--- a/test/unit/reflection_c.result
+++ /dev/null
@@ -1,5 +0,0 @@
-1..4
-ok 1 - assignable
-ok 2 - assignable
-ok 3 - assignable
-ok 4 - assignable
diff --git a/test/unit/reflection_cxx.result b/test/unit/reflection_cxx.result
deleted file mode 100644
index 0f4f51eb4..000000000
--- a/test/unit/reflection_cxx.result
+++ /dev/null
@@ -1,31 +0,0 @@
-1..30
-ok 1 - type.name
-ok 2 - type.parent
-ok 3 - type.parent
-ok 4 - is_instance
-ok 5 - is_instance
-ok 6 - is_instance
-ok 7 - is_instance
-ok 8 - methods order
-ok 9 - methods order
-ok 10 - methods order
-ok 11 - methods order
-ok 12 - methods order
-ok 13 - method.owner
-ok 14 - method.name
-ok 15 - method.rtype (non void)
-ok 16 - method.rtype (void)
-ok 17 - method.nargs (zero)
-ok 18 - method.nargs (non-zero)
-ok 19 - method.atype
-ok 20 - method.isconst
-ok 21 - !method.isconst
-ok 22 - !invokable<invalid args>
-ok 23 - !invokable<extra args>
-ok 24 - !invokable<>(invalid object)
-ok 25 - invokable<const char *>
-ok 26 - invokable<void, const char *>
-ok 27 - invoke (int)
-ok 28 - invoke (const char *)
-ok 29 - invoke (void)
-ok 30 - !invokable<>() on const method with non-const object
diff --git a/test/unit/rmean.cc b/test/unit/rmean.cc
index 50db96f6d..7dea28e46 100644
--- a/test/unit/rmean.cc
+++ b/test/unit/rmean.cc
@@ -5,7 +5,7 @@
 
 int print_stat(const char *name, int rps, int64_t total, void* ctx)
 {
-	printf("%s: rps %d, total %d%c", name, rps, (int)total,
+	note("%s: rps %d, total %d%c", name, rps, (int)total,
 	       name[2] == '2' ? '\n' : '\t');
 	return 0;
 }
@@ -13,8 +13,8 @@ int print_stat(const char *name, int rps, int64_t total, void* ctx)
 void test_100rps(rmean *st)
 {
 	header();
-	printf("Send 100 requests every second for 10 seconds\n");
-	printf("Calc rps at third and last second\n");
+	note("Send 100 requests every second for 10 seconds");
+	note("Calc rps at third and last second");
 	for(int i = 0; i < 10; i++) { /* 10 seconds */
 		rmean_collect(st, 0, 100); /* send 100 requests */
 		rmean_roll(st->stats[0].value, 1);
@@ -35,7 +35,7 @@ void test_100rps(rmean *st)
 void test_mean15rps(rmean *st)
 {
 	header();
-	printf("Send 15 rps on the average, and 3 rps to EV2\n");
+	note("Send 15 rps on the average, and 3 rps to EV2");
 	for(int i = 0; i < 10; i++) { /* 10 seconds */
 		for(int j = 0; j < 15; j++) {
 			rmean_collect(st, 0, 1); /* send 15 requests */
@@ -58,7 +58,8 @@ void test_mean15rps(rmean *st)
 
 int main()
 {
-	printf("Stat. 2 names, timer simulation\n");
+	plan(0);
+	note("Stat. 2 names, timer simulation");
 
 	memory_init();
 	fiber_init(fiber_cxx_invoke);
@@ -74,5 +75,7 @@ int main()
 
 	fiber_free();
 	memory_free();
+	check_plan();
+
 	return 0;
 }
diff --git a/test/unit/rmean.result b/test/unit/rmean.result
deleted file mode 100644
index ce050f050..000000000
--- a/test/unit/rmean.result
+++ /dev/null
@@ -1,11 +0,0 @@
-Stat. 2 names, timer simulation
-	*** test_100rps ***
-Send 100 requests every second for 10 seconds
-Calc rps at third and last second
-EV1: rps 60, total 300	EV2: rps 0, total 0
-EV1: rps 100, total 1000	EV2: rps 0, total 0
-	*** test_100rps: done ***
-	*** test_mean15rps ***
-Send 15 rps on the average, and 3 rps to EV2
-EV1: rps 15, total 1150	EV2: rps 3, total 30
-	*** test_mean15rps: done ***
diff --git a/test/unit/rope.c b/test/unit/rope.c
index 5ab4c51f7..990e7cc9b 100644
--- a/test/unit/rope.c
+++ b/test/unit/rope.c
@@ -4,7 +4,7 @@
 static void
 test_rope_extract(struct rope *rope, rope_size_t pos)
 {
-	printf("extract pos = %zu: ", (size_t) pos);
+	printf("# extract pos = %zu: ", (size_t) pos);
 	struct rope_node *node = rope_extract_node(rope, pos);
 	rope_check(rope);
 	str_print(node->data, node->leaf_size);
@@ -14,7 +14,7 @@ test_rope_extract(struct rope *rope, rope_size_t pos)
 static inline void
 test_rope_cut(struct rope *rope, rope_size_t offset, rope_size_t size)
 {
-	printf("erase offset = %zu, size = %zu \n", (size_t) offset, (size_t) size);
+	note("erase offset = %zu, size = %zu", (size_t) offset, (size_t) size);
 	while (size-- > 0)
 		rope_erase(rope, offset);
 	rope_pretty_print(rope, str_print);
@@ -63,6 +63,8 @@ test_rope()
 int
 main()
 {
+	plan(0);
 	test_rope();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/rope.result b/test/unit/rope.result
deleted file mode 100644
index 996063800..000000000
--- a/test/unit/rope.result
+++ /dev/null
@@ -1,299 +0,0 @@
-insert offset = 0, str = 'who's gonna be'
-size = 14
-string = 'who's gonna be'
-└──{ len = 14, height = 1, data = 'who's gonna be'}
-
-insert offset = 14, str = '<Mr.X>'
-size = 20
-string = 'who's gonna be<Mr.X>'
-│  ┌──nil
-└──{ len = 14, height = 2, data = 'who's gonna be'}
-   └──{ len = 6, height = 1, data = '<Mr.X>'}
-
-insert offset = 20, str = ', Mr. <black!?!>Black'
-size = 41
-string = 'who's gonna be<Mr.X>, Mr. <black!?!>Black'
-│  ┌──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 2, data = '<Mr.X>'}
-   └──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-
-insert offset = 41, str = ', but they <know-something-'
-size = 68
-string = 'who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-'
-│  ┌──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 3, data = '<Mr.X>'}
-   │  ┌──nil
-   └──{ len = 21, height = 2, data = ', Mr. <black!?!>Black'}
-      └──{ len = 27, height = 1, data = ', but they <know-something-'}
-
-insert offset = 0, str = 'guys all '
-size = 77
-string = 'guys all who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-'
-│     ┌──{ len = 9, height = 1, data = 'guys all '}
-│  ┌──{ len = 14, height = 2, data = 'who's gonna be'}
-│  │  └──nil
-└──{ len = 6, height = 3, data = '<Mr.X>'}
-   │  ┌──nil
-   └──{ len = 21, height = 2, data = ', Mr. <black!?!>Black'}
-      └──{ len = 27, height = 1, data = ', but they <know-something-'}
-
-insert offset = 9, str = 'five fighting over '
-size = 96
-string = 'guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-'
-│     ┌──{ len = 9, height = 1, data = 'guys all '}
-│  ┌──{ len = 19, height = 2, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 3, data = '<Mr.X>'}
-   │  ┌──nil
-   └──{ len = 21, height = 2, data = ', Mr. <black!?!>Black'}
-      └──{ len = 27, height = 1, data = ', but they <know-something-'}
-
-insert offset = 0, str = '<yes, got got>You got four of '
-size = 126
-string = '<yes, got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-'
-│        ┌──{ len = 30, height = 1, data = '<yes, got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 4, data = '<Mr.X>'}
-   │  ┌──nil
-   └──{ len = 21, height = 2, data = ', Mr. <black!?!>Black'}
-      └──{ len = 27, height = 1, data = ', but they <know-something-'}
-
-insert offset = 126, str = 'special> don't know each other'
-size = 156
-string = '<yes, got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other'
-│        ┌──{ len = 30, height = 1, data = '<yes, got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 4, data = '<Mr.X>'}
-   │  ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   └──{ len = 27, height = 2, data = ', but they <know-something-'}
-      └──{ len = 30, height = 1, data = 'special> don't know each other'}
-
-insert offset = 4294967295, str = ', so nobody wants to back.'
-size = 182
-string = '<yes, got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back.'
-│        ┌──{ len = 30, height = 1, data = '<yes, got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 4, data = '<Mr.X>'}
-   │  ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   └──{ len = 27, height = 3, data = ', but they <know-something-'}
-      │  ┌──nil
-      └──{ len = 30, height = 2, data = 'special> don't know each other'}
-         └──{ len = 26, height = 1, data = ', so nobody wants to back.'}
-
-insert offset = 181, str = ' down'
-size = 187
-string = '<yes, got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.'
-│        ┌──{ len = 30, height = 1, data = '<yes, got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 4, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 3, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 2, data = ' down'}
-         └──{ len = 1, height = 1, data = '.'}
-
-insert offset = 4294967295, str = '<point-point>'
-size = 200
-string = '<yes, got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.<point-point>'
-│        ┌──{ len = 30, height = 1, data = '<yes, got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 5, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 4, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 3, data = ' down'}
-         │  ┌──nil
-         └──{ len = 1, height = 2, data = '.'}
-            └──{ len = 13, height = 1, data = '<point-point>'}
-
-erase offset = 0, size = 5 
-size = 195
-string = ' got got>You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.<point-point>'
-│        ┌──{ len = 25, height = 1, data = ' got got>You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 5, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 4, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 3, data = ' down'}
-         │  ┌──nil
-         └──{ len = 1, height = 2, data = '.'}
-            └──{ len = 13, height = 1, data = '<point-point>'}
-
-erase offset = 0, size = 9 
-size = 186
-string = 'You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.<point-point>'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 5, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 4, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 3, data = ' down'}
-         │  ┌──nil
-         └──{ len = 1, height = 2, data = '.'}
-            └──{ len = 13, height = 1, data = '<point-point>'}
-
-erase offset = 179, size = 7 
-size = 179
-string = 'You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.<point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 5, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 4, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 3, data = ' down'}
-         │  ┌──{ len = 1, height = 1, data = '.'}
-         └──{ len = 6, height = 2, data = '<point'}
-            └──nil
-
-erase offset = 173, size = 1 
-size = 178
-string = 'You got four of guys all five fighting over who's gonna be<Mr.X>, Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 6, height = 5, data = '<Mr.X>'}
-   │     ┌──{ len = 21, height = 1, data = ', Mr. <black!?!>Black'}
-   │  ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │  │  └──nil
-   └──{ len = 30, height = 4, data = 'special> don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 3, data = ' down'}
-         │  ┌──{ len = 1, height = 1, data = '.'}
-         └──{ len = 5, height = 2, data = 'point'}
-            └──nil
-
-erase offset = 58, size = 7 
-size = 171
-string = 'You got four of guys all five fighting over who's gonna be Mr. <black!?!>Black, but they <know-something-special> don't know each other, so nobody wants to back down.point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 20, height = 4, data = ' Mr. <black!?!>Black'}
-   │     ┌──{ len = 27, height = 1, data = ', but they <know-something-'}
-   │  ┌──{ len = 30, height = 2, data = 'special> don't know each other'}
-   │  │  └──{ len = 25, height = 1, data = ', so nobody wants to back'}
-   └──{ len = 5, height = 3, data = ' down'}
-      │  ┌──{ len = 1, height = 1, data = '.'}
-      └──{ len = 5, height = 2, data = 'point'}
-         └──nil
-
-erase offset = 63, size = 10 
-size = 161
-string = 'You got four of guys all five fighting over who's gonna be Mr. Black, but they <know-something-special> don't know each other, so nobody wants to back down.point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 5, height = 5, data = ' Mr. '}
-   │        ┌──{ len = 5, height = 1, data = 'Black'}
-   │     ┌──{ len = 27, height = 2, data = ', but they <know-something-'}
-   │     │  └──nil
-   │  ┌──{ len = 30, height = 3, data = 'special> don't know each other'}
-   │  │  └──{ len = 25, height = 1, data = ', so nobody wants to back'}
-   └──{ len = 5, height = 4, data = ' down'}
-      │  ┌──{ len = 1, height = 1, data = '.'}
-      └──{ len = 5, height = 2, data = 'point'}
-         └──nil
-
-erase offset = 79, size = 25 
-size = 136
-string = 'You got four of guys all five fighting over who's gonna be Mr. Black, but they don't know each other, so nobody wants to back down.point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 19, height = 3, data = 'five fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 5, height = 5, data = ' Mr. '}
-   │        ┌──{ len = 5, height = 1, data = 'Black'}
-   │     ┌──{ len = 11, height = 2, data = ', but they '}
-   │     │  └──nil
-   │  ┌──{ len = 21, height = 3, data = 'don't know each other'}
-   │  │  └──{ len = 25, height = 1, data = ', so nobody wants to back'}
-   └──{ len = 5, height = 4, data = ' down'}
-      │  ┌──{ len = 1, height = 1, data = '.'}
-      └──{ len = 5, height = 2, data = 'point'}
-         └──nil
-
-erase offset = 25, size = 5 
-size = 131
-string = 'You got four of guys all fighting over who's gonna be Mr. Black, but they don't know each other, so nobody wants to back down.point'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 14, height = 3, data = 'fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 5, height = 5, data = ' Mr. '}
-   │        ┌──{ len = 5, height = 1, data = 'Black'}
-   │     ┌──{ len = 11, height = 2, data = ', but they '}
-   │     │  └──nil
-   │  ┌──{ len = 21, height = 3, data = 'don't know each other'}
-   │  │  └──{ len = 25, height = 1, data = ', so nobody wants to back'}
-   └──{ len = 5, height = 4, data = ' down'}
-      │  ┌──{ len = 1, height = 1, data = '.'}
-      └──{ len = 5, height = 2, data = 'point'}
-         └──nil
-
-erase offset = 126, size = 5 
-size = 126
-string = 'You got four of guys all fighting over who's gonna be Mr. Black, but they don't know each other, so nobody wants to back down.'
-│        ┌──{ len = 16, height = 1, data = 'You got four of '}
-│     ┌──{ len = 9, height = 2, data = 'guys all '}
-│     │  └──nil
-│  ┌──{ len = 14, height = 3, data = 'fighting over '}
-│  │  └──{ len = 14, height = 1, data = 'who's gonna be'}
-└──{ len = 5, height = 4, data = ' Mr. '}
-   │     ┌──{ len = 5, height = 1, data = 'Black'}
-   │  ┌──{ len = 11, height = 2, data = ', but they '}
-   │  │  └──nil
-   └──{ len = 21, height = 3, data = 'don't know each other'}
-      │  ┌──{ len = 25, height = 1, data = ', so nobody wants to back'}
-      └──{ len = 5, height = 2, data = ' down'}
-         └──{ len = 1, height = 1, data = '.'}
-
-extract pos = 0: You got four of 
-extract pos = 5: ot four of 
-extract pos = 19: s all 
-extract pos = 59: lack
-extract pos = 124: n
diff --git a/test/unit/rope_avl.c b/test/unit/rope_avl.c
index b095fb1a6..45950947b 100644
--- a/test/unit/rope_avl.c
+++ b/test/unit/rope_avl.c
@@ -36,6 +36,8 @@ test_avl_rotations()
 int
 main()
 {
+	plan(0);
 	test_avl_rotations();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/rope_avl.result b/test/unit/rope_avl.result
deleted file mode 100644
index 141ffe967..000000000
--- a/test/unit/rope_avl.result
+++ /dev/null
@@ -1,123 +0,0 @@
-	*** test_avl_rotations ***
-insert offset = 0, str = '1'
-size = 1
-string = '1'
-└──{ len = 1, height = 1, data = '1'}
-
-insert offset = 1, str = '2'
-size = 2
-string = '12'
-│  ┌──nil
-└──{ len = 1, height = 2, data = '1'}
-   └──{ len = 1, height = 1, data = '2'}
-
-insert offset = 2, str = '<'
-size = 3
-string = '12<'
-│  ┌──{ len = 1, height = 1, data = '1'}
-└──{ len = 1, height = 2, data = '2'}
-   └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 0, str = '0'
-size = 4
-string = '012<'
-│     ┌──{ len = 1, height = 1, data = '0'}
-│  ┌──{ len = 1, height = 2, data = '1'}
-│  │  └──nil
-└──{ len = 1, height = 3, data = '2'}
-   └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 0, str = '>'
-size = 5
-string = '>012<'
-│     ┌──{ len = 1, height = 1, data = '>'}
-│  ┌──{ len = 1, height = 2, data = '0'}
-│  │  └──{ len = 1, height = 1, data = '1'}
-└──{ len = 1, height = 3, data = '2'}
-   └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 1, str = '*'
-size = 6
-string = '>*012<'
-│     ┌──nil
-│  ┌──{ len = 1, height = 2, data = '>'}
-│  │  └──{ len = 1, height = 1, data = '*'}
-└──{ len = 1, height = 3, data = '0'}
-   │  ┌──{ len = 1, height = 1, data = '1'}
-   └──{ len = 1, height = 2, data = '2'}
-      └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 3, str = 'p'
-size = 7
-string = '>*0p12<'
-│     ┌──nil
-│  ┌──{ len = 1, height = 2, data = '>'}
-│  │  └──{ len = 1, height = 1, data = '*'}
-└──{ len = 1, height = 4, data = '0'}
-   │     ┌──{ len = 1, height = 1, data = 'p'}
-   │  ┌──{ len = 1, height = 2, data = '1'}
-   │  │  └──nil
-   └──{ len = 1, height = 3, data = '2'}
-      └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 3, str = 'p'
-size = 8
-string = '>*0pp12<'
-│     ┌──nil
-│  ┌──{ len = 1, height = 2, data = '>'}
-│  │  └──{ len = 1, height = 1, data = '*'}
-└──{ len = 1, height = 4, data = '0'}
-   │     ┌──{ len = 1, height = 1, data = 'p'}
-   │  ┌──{ len = 1, height = 2, data = 'p'}
-   │  │  └──{ len = 1, height = 1, data = '1'}
-   └──{ len = 1, height = 3, data = '2'}
-      └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 3, str = 'p'
-size = 9
-string = '>*0ppp12<'
-│     ┌──nil
-│  ┌──{ len = 1, height = 2, data = '>'}
-│  │  └──{ len = 1, height = 1, data = '*'}
-└──{ len = 1, height = 4, data = '0'}
-   │     ┌──{ len = 1, height = 1, data = 'p'}
-   │  ┌──{ len = 1, height = 2, data = 'p'}
-   │  │  └──nil
-   └──{ len = 1, height = 3, data = 'p'}
-      │  ┌──{ len = 1, height = 1, data = '1'}
-      └──{ len = 1, height = 2, data = '2'}
-         └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 3, str = 'p'
-size = 10
-string = '>*0pppp12<'
-│     ┌──nil
-│  ┌──{ len = 1, height = 2, data = '>'}
-│  │  └──{ len = 1, height = 1, data = '*'}
-└──{ len = 1, height = 4, data = '0'}
-   │     ┌──{ len = 1, height = 1, data = 'p'}
-   │  ┌──{ len = 1, height = 2, data = 'p'}
-   │  │  └──{ len = 1, height = 1, data = 'p'}
-   └──{ len = 1, height = 3, data = 'p'}
-      │  ┌──{ len = 1, height = 1, data = '1'}
-      └──{ len = 1, height = 2, data = '2'}
-         └──{ len = 1, height = 1, data = '<'}
-
-insert offset = 3, str = '*'
-size = 11
-string = '>*0*pppp12<'
-│        ┌──nil
-│     ┌──{ len = 1, height = 2, data = '>'}
-│     │  └──{ len = 1, height = 1, data = '*'}
-│  ┌──{ len = 1, height = 3, data = '0'}
-│  │  │  ┌──{ len = 1, height = 1, data = '*'}
-│  │  └──{ len = 1, height = 2, data = 'p'}
-│  │     └──nil
-└──{ len = 1, height = 4, data = 'p'}
-   │  ┌──{ len = 1, height = 1, data = 'p'}
-   └──{ len = 1, height = 3, data = 'p'}
-      │  ┌──{ len = 1, height = 1, data = '1'}
-      └──{ len = 1, height = 2, data = '2'}
-         └──{ len = 1, height = 1, data = '<'}
-
-	*** test_avl_rotations: done ***
diff --git a/test/unit/rope_basic.c b/test/unit/rope_basic.c
index d9e116292..718195fa8 100644
--- a/test/unit/rope_basic.c
+++ b/test/unit/rope_basic.c
@@ -97,10 +97,12 @@ test_erase()
 int
 main()
 {
+	plan(0);
 	test_empty_rope();
 	test_append();
 	test_prepend();
 	test_insert();
 	test_erase();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/rope_basic.result b/test/unit/rope_basic.result
deleted file mode 100644
index fd8ef015e..000000000
--- a/test/unit/rope_basic.result
+++ /dev/null
@@ -1,139 +0,0 @@
-	*** test_empty_rope ***
-size = 0
-string = ''
-└──nil
-
-	*** test_empty_rope: done ***
-	*** test_append ***
-insert offset = 0, str = ' a '
-size = 3
-string = ' a '
-└──{ len = 3, height = 1, data = ' a '}
-
-insert offset = 3, str = ' b '
-size = 6
-string = ' a  b '
-│  ┌──nil
-└──{ len = 3, height = 2, data = ' a '}
-   └──{ len = 3, height = 1, data = ' b '}
-
-insert offset = 6, str = ' c '
-size = 9
-string = ' a  b  c '
-│  ┌──{ len = 3, height = 1, data = ' a '}
-└──{ len = 3, height = 2, data = ' b '}
-   └──{ len = 3, height = 1, data = ' c '}
-
-	*** test_append: done ***
-	*** test_prepend ***
-insert offset = 0, str = ' c '
-size = 3
-string = ' c '
-└──{ len = 3, height = 1, data = ' c '}
-
-insert offset = 0, str = ' b '
-size = 6
-string = ' b  c '
-│  ┌──{ len = 3, height = 1, data = ' b '}
-└──{ len = 3, height = 2, data = ' c '}
-   └──nil
-
-insert offset = 0, str = ' a '
-size = 9
-string = ' a  b  c '
-│  ┌──{ len = 3, height = 1, data = ' a '}
-└──{ len = 3, height = 2, data = ' b '}
-   └──{ len = 3, height = 1, data = ' c '}
-
-	*** test_prepend: done ***
-	*** test_insert ***
-insert offset = 0, str = '   a '
-size = 5
-string = '   a '
-└──{ len = 5, height = 1, data = '   a '}
-
-insert offset = 4, str = 'b '
-size = 7
-string = '   ab  '
-│  ┌──{ len = 4, height = 1, data = '   a'}
-└──{ len = 2, height = 2, data = 'b '}
-   └──{ len = 1, height = 1, data = ' '}
-
-insert offset = 5, str = 'c '
-size = 9
-string = '   abc   '
-│  ┌──{ len = 4, height = 1, data = '   a'}
-└──{ len = 1, height = 3, data = 'b'}
-   │  ┌──{ len = 2, height = 1, data = 'c '}
-   └──{ len = 1, height = 2, data = ' '}
-      └──{ len = 1, height = 1, data = ' '}
-
-insert offset = 1, str = ' '
-size = 10
-string = '    abc   '
-│     ┌──{ len = 1, height = 1, data = ' '}
-│  ┌──{ len = 1, height = 2, data = ' '}
-│  │  └──{ len = 3, height = 1, data = '  a'}
-└──{ len = 1, height = 3, data = 'b'}
-   │  ┌──{ len = 2, height = 1, data = 'c '}
-   └──{ len = 1, height = 2, data = ' '}
-      └──{ len = 1, height = 1, data = ' '}
-
-insert offset = 9, str = ' '
-size = 11
-string = '    abc    '
-│     ┌──{ len = 1, height = 1, data = ' '}
-│  ┌──{ len = 1, height = 2, data = ' '}
-│  │  └──{ len = 3, height = 1, data = '  a'}
-└──{ len = 1, height = 4, data = 'b'}
-   │  ┌──{ len = 2, height = 1, data = 'c '}
-   └──{ len = 1, height = 3, data = ' '}
-      │  ┌──{ len = 1, height = 1, data = ' '}
-      └──{ len = 1, height = 2, data = ' '}
-         └──nil
-
-insert offset = 4, str = '*'
-size = 12
-string = '    *abc    '
-│     ┌──{ len = 1, height = 1, data = ' '}
-│  ┌──{ len = 1, height = 3, data = ' '}
-│  │  │  ┌──{ len = 2, height = 1, data = '  '}
-│  │  └──{ len = 1, height = 2, data = '*'}
-│  │     └──{ len = 1, height = 1, data = 'a'}
-└──{ len = 1, height = 4, data = 'b'}
-   │  ┌──{ len = 2, height = 1, data = 'c '}
-   └──{ len = 1, height = 3, data = ' '}
-      │  ┌──{ len = 1, height = 1, data = ' '}
-      └──{ len = 1, height = 2, data = ' '}
-         └──nil
-
-insert offset = 8, str = '*'
-size = 13
-string = '    *abc*    '
-│     ┌──{ len = 1, height = 1, data = ' '}
-│  ┌──{ len = 1, height = 3, data = ' '}
-│  │  │  ┌──{ len = 2, height = 1, data = '  '}
-│  │  └──{ len = 1, height = 2, data = '*'}
-│  │     └──{ len = 1, height = 1, data = 'a'}
-└──{ len = 1, height = 4, data = 'b'}
-   │     ┌──{ len = 1, height = 1, data = 'c'}
-   │  ┌──{ len = 1, height = 2, data = '*'}
-   │  │  └──{ len = 1, height = 1, data = ' '}
-   └──{ len = 1, height = 3, data = ' '}
-      │  ┌──{ len = 1, height = 1, data = ' '}
-      └──{ len = 1, height = 2, data = ' '}
-         └──nil
-
-	*** test_insert: done ***
-	*** test_erase ***
-erase offset = 0
-size = 0
-string = ''
-└──nil
-
-erase offset = 0
-size = 1
-string = 'b'
-└──{ len = 1, height = 1, data = 'b'}
-
-	*** test_erase: done ***
diff --git a/test/unit/rope_common.h b/test/unit/rope_common.h
index 3392e87e3..b094b48fb 100644
--- a/test/unit/rope_common.h
+++ b/test/unit/rope_common.h
@@ -3,6 +3,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "unit.h"
+
 static inline char *
 str_getn(void *ctx, char *data, size_t size, size_t offset)
 {
@@ -68,7 +71,7 @@ test_rope_new()
 static inline void
 test_rope_insert(struct rope *rope, rope_size_t offset, char *str)
 {
-	printf("insert offset = %zu, str = '%s'\n", (size_t) offset, str);
+	note("insert offset = %zu, str = '%s'", (size_t) offset, str);
 	rope_insert(rope, offset, str, strlen(str));
 	rope_pretty_print(rope, str_print);
 	rope_check(rope);
@@ -77,7 +80,7 @@ test_rope_insert(struct rope *rope, rope_size_t offset, char *str)
 static inline void
 test_rope_erase(struct rope *rope, rope_size_t offset)
 {
-	printf("erase offset = %zu\n", (size_t) offset);
+	note("erase offset = %zu", (size_t) offset);
 	rope_erase(rope, offset);
 	rope_pretty_print(rope, str_print);
 	rope_check(rope);
diff --git a/test/unit/rope_stress.c b/test/unit/rope_stress.c
index bc312d7c0..1f86d95e3 100644
--- a/test/unit/rope_stress.c
+++ b/test/unit/rope_stress.c
@@ -64,8 +64,10 @@ test_rope_stress_large()
 int
 main()
 {
+	plan(0);
 	srand(time(NULL));
 	test_rope_stress_small();
 	test_rope_stress_large();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/rope_stress.result b/test/unit/rope_stress.result
deleted file mode 100644
index bd2e45b75..000000000
--- a/test/unit/rope_stress.result
+++ /dev/null
@@ -1,4 +0,0 @@
-	*** test_rope_stress_small ***
-	*** test_rope_stress_small: done ***
-	*** test_rope_stress_large ***
-	*** test_rope_stress_large: done ***
diff --git a/test/unit/rtree.cc b/test/unit/rtree.cc
index 02ca9cdd6..7ef9f776d 100644
--- a/test/unit/rtree.cc
+++ b/test/unit/rtree.cc
@@ -43,7 +43,7 @@ simple_check()
 		   extent_alloc, extent_free, &page_count,
 		   RTREE_EUCLID);
 
-	printf("Insert 1..X, remove 1..X\n");
+	note("Insert 1..X, remove 1..X");
 	for (size_t i = 1; i <= rounds; i++) {
 		record_t rec = (record_t)i;
 
@@ -82,7 +82,7 @@ simple_check()
 		fail("Tree count mismatch (1)", "true");
 	}
 
-	printf("Insert 1..X, remove X..1\n");
+	note("Insert 1..X, remove X..1");
 	for (size_t i = 1; i <= rounds; i++) {
 		record_t rec = (record_t)i;
 
@@ -122,7 +122,7 @@ simple_check()
 	}
 
 
-	printf("Insert X..1, remove 1..X\n");
+	note("Insert X..1, remove 1..X");
 	for (size_t i = rounds; i != 0; i--) {
 		record_t rec = (record_t)i;
 
@@ -162,7 +162,7 @@ simple_check()
 	}
 
 
-	printf("Insert X..1, remove X..1\n");
+	note("Insert X..1, remove X..1");
 	for (size_t i = rounds; i != 0; i--) {
 		record_t rec = (record_t)i;
 
@@ -279,9 +279,11 @@ neighbor_test()
 int
 main(void)
 {
+	plan(0);
 	simple_check();
 	neighbor_test();
 	if (page_count != 0) {
 		fail("memory leak!", "true");
 	}
+	check_plan();
 }
diff --git a/test/unit/rtree.result b/test/unit/rtree.result
deleted file mode 100644
index 6efa93438..000000000
--- a/test/unit/rtree.result
+++ /dev/null
@@ -1,8 +0,0 @@
-	*** simple_check ***
-Insert 1..X, remove 1..X
-Insert 1..X, remove X..1
-Insert X..1, remove 1..X
-Insert X..1, remove X..1
-	*** simple_check: done ***
-	*** neighbor_test ***
-	*** neighbor_test: done ***
diff --git a/test/unit/rtree_iterator.cc b/test/unit/rtree_iterator.cc
index b3c8695e9..49a7b85e7 100644
--- a/test/unit/rtree_iterator.cc
+++ b/test/unit/rtree_iterator.cc
@@ -53,7 +53,7 @@ iterator_check()
 			rtree_insert(&tree, &rect, record_t(++count));
 		}
 	}
-	printf("Test tree size: %d\n", (int)rtree_number_of_records(&tree));
+	note("Test tree size: %d", (int)rtree_number_of_records(&tree));
 
 	/* Test that tree filled ok */
 	for (size_t i = 0; i < count1; i++) {
@@ -305,9 +305,11 @@ iterator_invalidate_check()
 int
 main(void)
 {
+	plan(0);
 	iterator_check();
 	iterator_invalidate_check();
 	if (extent_count != 0) {
 		fail("memory leak!", "false");
 	}
+	check_plan();
 }
diff --git a/test/unit/rtree_iterator.result b/test/unit/rtree_iterator.result
deleted file mode 100644
index 5eac9f090..000000000
--- a/test/unit/rtree_iterator.result
+++ /dev/null
@@ -1,7 +0,0 @@
-	*** iterator_check ***
-Test tree size: 50000
---> 0x1 0x2 0x3 0x4 0x5 0x6 0x7 
-<-- 0xc34c 0xc34d 0xc34e 0xc34f 0xc350 0xc34b 0xc34a 
-	*** iterator_check: done ***
-	*** iterator_invalidate_check ***
-	*** iterator_invalidate_check: done ***
diff --git a/test/unit/rtree_multidim.cc b/test/unit/rtree_multidim.cc
index e09f6190b..779cf3873 100644
--- a/test/unit/rtree_multidim.cc
+++ b/test/unit/rtree_multidim.cc
@@ -348,14 +348,14 @@ test_select_neigh(const CBoxSet<DIMENSION> &set, const struct rtree *tree)
 		}
 	}
 	if (res1.size() != res2.size()) {
-		printf("%s result size differ %d %d\n", __func__,
-		       (int)res1.size(), (int)res2.size());
+		diag("%s result size differ %d %d\n", __func__,
+		     (int)res1.size(), (int)res2.size());
 	} else {
 		for (size_t i = 0; i < res1.size(); i++)
 			if (res1[i].id != res2[i].id &&
 			    res1[i].box.Distance2(box) !=
 			    res2[i].box.Distance2(box))
-				printf("%s result differ!\n", __func__);
+				diag("%s result differ!\n", __func__);
 	}
 	rtree_iterator_destroy(&iterator);
 
@@ -388,14 +388,14 @@ test_select_neigh_man(const CBoxSet<DIMENSION> &set, struct rtree *tree)
 		}
 	}
 	if (res1.size() != res2.size()) {
-		printf("%s result size differ %d %d\n", __func__,
-		       (int)res1.size(), (int)res2.size());
+		diag("%s result size differ %d %d\n", __func__,
+		     (int)res1.size(), (int)res2.size());
 	} else {
 		for (size_t i = 0; i < res1.size(); i++)
 			if (res1[i].id != res2[i].id &&
 			    res1[i].box.DistanceMan(box) !=
 			    res2[i].box.DistanceMan(box))
-				printf("%s result differ!\n", __func__);
+				diag("%s result differ!\n", __func__);
 	}
 	tree->distance_type = RTREE_EUCLID; /* dirty hack */
 	rtree_iterator_destroy(&iterator);
@@ -428,12 +428,12 @@ test_select_in(const CBoxSet<DIMENSION> &set, const struct rtree *tree)
 	sort(res1.begin(), res1.end());
 	sort(res2.begin(), res2.end());
 	if (res1.size() != res2.size()) {
-		printf("%s result size differ %d %d\n", __func__,
-		       (int)res1.size(), (int)res2.size());
+		diag("%s result size differ %d %d\n", __func__,
+		     (int)res1.size(), (int)res2.size());
 	} else {
 		for (size_t i = 0; i < res1.size(); i++)
 			if (res1[i].id != res2[i].id)
-				printf("%s result differ!\n", __func__);
+				diag("%s result differ!\n", __func__);
 	}
 	rtree_iterator_destroy(&iterator);
 
@@ -465,12 +465,12 @@ test_select_strict_in(const CBoxSet<DIMENSION> &set, const struct rtree *tree)
 	sort(res1.begin(), res1.end());
 	sort(res2.begin(), res2.end());
 	if (res1.size() != res2.size()) {
-		printf("%s result size differ %d %d\n", __func__,
-		       (int)res1.size(), (int)res2.size());
+		diag("%s result size differ %d %d\n", __func__,
+		     (int)res1.size(), (int)res2.size());
 	} else {
 		for (size_t i = 0; i < res1.size(); i++)
 			if (res1[i].id != res2[i].id)
-				printf("%s result differ!\n", __func__);
+				diag("%s result differ!\n", __func__);
 	}
 	rtree_iterator_destroy(&iterator);
 
@@ -489,8 +489,8 @@ rand_test()
 		   extent_alloc, extent_free, &page_count,
 		   RTREE_EUCLID);
 
-	printf("\tDIMENSION: %u, page size: %u, max fill good: %d\n",
-	       DIMENSION, tree.page_size, tree.page_max_fill >= 10);
+	note("\tDIMENSION: %u, page size: %u, max fill good: %d\n",
+              DIMENSION, tree.page_size, tree.page_max_fill >= 10);
 
 	for (unsigned i = 0; i < TEST_ROUNDS; i++) {
 		bool insert;
@@ -513,7 +513,7 @@ rand_test()
 			struct rtree_rect rt;
 			set.entries[id].box.FillRTreeRect(&rt);
 			if (!rtree_remove(&tree, &rt, (void *)(id + 1))) {
-				printf("Error in remove\n");
+				diag("Error in remove\n");
 			}
 			set.DeleteBox(id);
 		}
@@ -526,12 +526,16 @@ rand_test()
 
 	rtree_destroy(&tree);
 
+	note("\tDIMENSION: %u, page size: %u, max fill good: %d\n",
+              DIMENSION, tree.page_size, tree.page_max_fill >= 10);
+
 	footer();
 }
 
 int
 main(void)
 {
+	plan(0);
 	srand(time(0));
 	rand_test<1>();
 	rand_test<2>();
@@ -541,4 +545,5 @@ main(void)
 	if (page_count != 0) {
 		fail("memory leak!", "true");
 	}
+	check_plan();
 }
diff --git a/test/unit/rtree_multidim.result b/test/unit/rtree_multidim.result
deleted file mode 100644
index 9370ecc3a..000000000
--- a/test/unit/rtree_multidim.result
+++ /dev/null
@@ -1,15 +0,0 @@
-	*** rand_test ***
-	DIMENSION: 1, page size: 512, max fill good: 1
-	*** rand_test: done ***
-	*** rand_test ***
-	DIMENSION: 2, page size: 1024, max fill good: 1
-	*** rand_test: done ***
-	*** rand_test ***
-	DIMENSION: 3, page size: 1024, max fill good: 1
-	*** rand_test: done ***
-	*** rand_test ***
-	DIMENSION: 8, page size: 4096, max fill good: 1
-	*** rand_test: done ***
-	*** rand_test ***
-	DIMENSION: 16, page size: 8192, max fill good: 1
-	*** rand_test: done ***
diff --git a/test/unit/say.result b/test/unit/say.result
deleted file mode 100644
index 8dfed7b61..000000000
--- a/test/unit/say.result
+++ /dev/null
@@ -1,67 +0,0 @@
-1..33
-# type: file
-# next: 
-ok 1 - 
-# type: file
-# next: /dev/null
-ok 2 - /dev/null
-# type: pipe
-# next: 
-ok 3 - |
-# type: pipe
-# next: /usr/bin/cronolog
-ok 4 - |/usr/bin/cronolog
-# type: file
-# next: 
-ok 5 - file:
-# type: file
-# next: instance.log
-ok 6 - file:instance.log
-# type: pipe
-# next: 
-ok 7 - pipe:
-# type: pipe
-# next: gzip > instance.log.gz
-ok 8 - pipe:gzip > instance.log.gz
-# type: syslog
-# next: 
-ok 9 - syslog:
-# type: syslog
-# next: identity=
-ok 10 - syslog:identity=
-# next: unknown:
-ok 11 - unknown:
-# next: unknown:example.org
-ok 12 - unknown:example.org
-# facility: 24
-ok 13 - 
-# identity: tarantool
-# facility: 24
-ok 14 - identity=tarantool
-# facility: 1
-ok 15 - facility=user
-# identity: xtarantoolx
-# facility: 17
-ok 16 - identity=xtarantoolx,facility=local1
-# identity: xtarantoolx
-ok 17 - identity=xtarantoolx,facility=kern
-# identity: xtarantoolx
-# facility: 8
-ok 18 - identity=xtarantoolx,facility=uucp
-ok 19 - identity=xtarantoolx,facility=foo
-# identity: bar
-# facility: 10
-ok 20 - facility=authpriv,identity=bar
-ok 21 - invalid=
-ok 22 - facility=local1,facility=local2
-ok 23 - identity=foo,identity=bar
-ok 24 - plain
-ok 25 - json
-ok 26 - custom
-ok 27 - freopen
-ok 28 - parsed identity
-ok 29 - parsed facility
-ok 30 - ftell
-ok 31 - log_say
-ok 32 - fseek
-ok 33 - syslog line
diff --git a/test/unit/scramble.c b/test/unit/scramble.c
index 8f1ee55af..65270bb4c 100644
--- a/test/unit/scramble.c
+++ b/test/unit/scramble.c
@@ -30,7 +30,7 @@ test_scramble()
 
 	scramble_prepare(scramble, salt, password, strlen(password));
 
-	printf("%d\n", scramble_check(scramble, salt, hash2));
+	note("%d", scramble_check(scramble, salt, hash2));
 
 	int remote_salt[SCRAMBLE_SIZE/sizeof(int)];
 	for(size_t i = 0; i < sizeof(salt)/sizeof(int); ++i)
@@ -40,16 +40,16 @@ test_scramble()
 
 	scramble_reencode(new_scramble, scramble, salt, remote_salt, hash2);
 
-	printf("%d\n", scramble_check(new_scramble, remote_salt, hash2));
+	note("%d", scramble_check(new_scramble, remote_salt, hash2));
 
 	password = "wrongpass";
 	scramble_prepare(scramble, salt, password, strlen(password));
 
-	printf("%d\n", scramble_check(scramble, salt, hash2) != 0);
+	note("%d", scramble_check(scramble, salt, hash2) != 0);
 
 	scramble_prepare(scramble, salt, password, 0);
 
-	printf("%d\n", scramble_check(scramble, salt, hash2) != 0);
+	note("%d", scramble_check(scramble, salt, hash2) != 0);
 }
 
 void
@@ -68,8 +68,10 @@ int main()
 {
 	random_init();
 
+	plan(0);
 	test_scramble();
 	test_password_prepare();
+	check_plan();
 
 	return 0;
 }
diff --git a/test/unit/scramble.result b/test/unit/scramble.result
deleted file mode 100644
index 0463db267..000000000
--- a/test/unit/scramble.result
+++ /dev/null
@@ -1,4 +0,0 @@
-0
-0
-1
-1
diff --git a/test/unit/sio.result b/test/unit/sio.result
deleted file mode 100644
index 896736bf9..000000000
--- a/test/unit/sio.result
+++ /dev/null
@@ -1,36 +0,0 @@
-	*** main ***
-1..2
-	*** check_uri_to_addr ***
-    1..22
-    ok 1 - invalid uri is detected
-    ok 2 - too long UNIX path
-    ok 3 - UNIX
-    ok 4 - UNIX path
-    ok 5 - UNIX family
-    ok 6 - unix host is not empty
-    ok 7 - localhost
-    ok 8 - localhost family
-    ok 9 - localhost address
-    ok 10 - localhost port
-    ok 11 - 'localhost' host is not empty
-    ok 12 - 'any'
-    ok 13 - 'any' family
-    ok 14 - 'any' address
-    ok 15 - 'any' port
-    ok 16 - only port specified - host is empty
-    ok 17 - IP
-    ok 18 - IP family
-    ok 19 - IP address
-    ok 20 - IP port
-    ok 21 - IPv4 host is not empty
-    ok 22 - invalid IP
-ok 1 - subtests
-	*** check_uri_to_addr: done ***
-	*** check_auto_bind ***
-    1..3
-    ok 1 - bind to 0 works
-    ok 2 - getsockname works on 0 bind
-    ok 3 - a real port is returned
-ok 2 - subtests
-	*** check_auto_bind: done ***
-	*** main: done ***
diff --git a/test/unit/sql-bitvec.result b/test/unit/sql-bitvec.result
deleted file mode 100644
index 13c23510f..000000000
--- a/test/unit/sql-bitvec.result
+++ /dev/null
@@ -1,39 +0,0 @@
-1..5
-	*** main ***
-    1..2
-    ok 1 - error test
-    ok 2 - error test
-ok 1 - subtests
-    1..4
-    ok 1 - various sizes
-    ok 2 - various sizes
-    ok 3 - various sizes
-    ok 4 - various sizes
-ok 2 - subtests
-    1..4
-    ok 1 - larger increments
-    ok 2 - larger increments
-    ok 3 - larger increments
-    ok 4 - larger increments
-ok 3 - subtests
-    1..9
-    ok 1 - clearing mechanism
-    ok 2 - clearing mechanism
-    ok 3 - clearing mechanism
-    ok 4 - clearing mechanism
-    ok 5 - clearing mechanism
-    ok 6 - clearing mechanism
-    ok 7 - clearing mechanism
-    ok 8 - clearing mechanism
-    ok 9 - clearing mechanism
-ok 4 - subtests
-    1..7
-    ok 1 - random subsets
-    ok 2 - random subsets
-    ok 3 - random subsets
-    ok 4 - random subsets
-    ok 5 - random subsets
-    ok 6 - random subsets
-    ok 7 - random subsets
-ok 5 - subtests
-	*** main: done ***
diff --git a/test/unit/stailq.result b/test/unit/stailq.result
deleted file mode 100644
index 041545008..000000000
--- a/test/unit/stailq.result
+++ /dev/null
@@ -1,76 +0,0 @@
-1..75
-ok 1 - list is empty
-ok 2 - list is empty after reverse
-ok 3 - first item
-ok 4 - last item
-ok 5 - element (foreach) 0
-ok 6 - element (foreach) 1
-ok 7 - element (foreach) 2
-ok 8 - element (foreach) 3
-ok 9 - element (foreach) 4
-ok 10 - element (foreach) 5
-ok 11 - element (foreach) 6
-ok 12 - first item
-ok 13 - head is not empty
-ok 14 - first entry
-ok 15 - shift item 0
-ok 16 - shift item 1
-ok 17 - shift item 2
-ok 18 - shift item 3
-ok 19 - shift item 4
-ok 20 - shift item 5
-ok 21 - shift item 6
-ok 22 - list is empty after shift
-ok 23 - next is empty
-ok 24 - element (foreach_entry) 6
-ok 25 - element (foreach_entry) 5
-ok 26 - element (foreach_entry) 4
-ok 27 - element (foreach_entry) 3
-ok 28 - element (foreach_entry) 2
-ok 29 - element (foreach_entry) 1
-ok 30 - element (foreach_entry) 0
-ok 31 - element (foreach_entry) 0
-ok 32 - element (foreach_entry) 1
-ok 33 - element (foreach_entry) 2
-ok 34 - element (foreach_entry) 3
-ok 35 - element (foreach_entry) 4
-ok 36 - element (foreach_entry) 5
-ok 37 - element (foreach_entry) 6
-ok 38 - head is empty after cut at first
-ok 39 - tail element after cut at first 0
-ok 40 - tail element after cut at first 1
-ok 41 - tail element after cut at first 2
-ok 42 - tail element after cut at first 3
-ok 43 - tail element after cut at first 4
-ok 44 - tail element after cut at first 5
-ok 45 - tail element after cut at first 6
-ok 46 - tail is empty after cut at last
-ok 47 - head element after cut at last 0
-ok 48 - head element after cut at last 1
-ok 49 - head element after cut at last 2
-ok 50 - head element after cut at last 3
-ok 51 - head element after cut at last 4
-ok 52 - head element after cut at last 5
-ok 53 - head element after cut at last 6
-ok 54 - head element after cut at middle 0
-ok 55 - head element after cut at middle 1
-ok 56 - head element after cut at middle 2
-ok 57 - head element after cut at middle 3
-ok 58 - tail element after cut at middle 4
-ok 59 - tail element after cut at middle 5
-ok 60 - tail element after cut at middle 6
-ok 61 - tail is empty after concat
-ok 62 - head element after concat 0
-ok 63 - head element after concat 1
-ok 64 - head element after concat 2
-ok 65 - head element after concat 3
-ok 66 - head element after concat 4
-ok 67 - head element after concat 5
-ok 68 - head element after concat 6
-ok 69 - element 0 (insert)
-ok 70 - element 1 (insert)
-ok 71 - element 2 (insert)
-ok 72 - element 3 (insert)
-ok 73 - element 4 (insert)
-ok 74 - first item (insert)
-ok 75 - last item (insert)
diff --git a/test/unit/swim.result b/test/unit/swim.result
deleted file mode 100644
index 07ea6a1a0..000000000
--- a/test/unit/swim.result
+++ /dev/null
@@ -1,234 +0,0 @@
-	*** main_f ***
-1..23
-	*** swim_test_one_link ***
-    1..6
-    ok 1 - no rounds - no fullmesh
-    ok 2 - one link
-    ok 3 - self 0 is alive
-    ok 4 - self 1 is alive
-    ok 5 - 0 sees 1 as alive
-    ok 6 - 1 sees 0 as alive
-ok 1 - subtests
-	*** swim_test_one_link: done ***
-	*** swim_test_sequence ***
-    1..1
-    ok 1 - sequence
-ok 2 - subtests
-	*** swim_test_sequence: done ***
-	*** swim_test_uuid_update ***
-    1..7
-    ok 1 - UUID update
-    ok 2 - old UUID is marked as 'left'
-    ok 3 - old UUID is dropped after a while
-    ok 4 - dropped everywhere
-    ok 5 - two members in each
-    ok 6 - can not update to an existing UUID - swim_cfg fails
-    ok 7 - diag says 'exists'
-ok 3 - subtests
-	*** swim_test_uuid_update: done ***
-	*** swim_test_cfg ***
-    1..16
-    ok 1 - first cfg failed - no URI
-    ok 2 - diag says 'mandatory'
-    ok 3 - first cfg failed - no UUID
-    ok 4 - diag says 'mandatory'
-    ok 5 - configured first time
-    ok 6 - second time can omit URI, UUID
-    ok 7 - hearbeat is dynamic
-    ok 8 - URI is unchanged after recfg with NULL URI
-    ok 9 - can not use invalid URI
-    ok 10 - diag says 'invalid uri'
-    ok 11 - can not use domain names
-    ok 12 - diag says 'invalid uri'
-    ok 13 - UNIX sockets are not supported
-    ok 14 - diag says 'only IP'
-    ok 15 - can not bind to an occupied port
-    ok 16 - diag says 'bind'
-ok 4 - subtests
-	*** swim_test_cfg: done ***
-	*** swim_test_add_remove ***
-    1..14
-    ok 1 - can not add an existing member
-    ok 2 - diag says 'already exists'
-    ok 3 - can not add a invalid uri
-    ok 4 - diag says 'invalid uri'
-    ok 5 - can not remove self
-    ok 6 - diag says the same
-    ok 7 - find by UUID works
-    ok 8 - now remove one element
-    ok 9 - and it can not be found anymore
-    ok 10 - remove of a not existing member
-    ok 11 - after removal the cluster is not in fullmesh
-    ok 12 - but it is back in 1 step
-    ok 13 - back in fullmesh after a member removal in the middle of a step
-    ok 14 - if a referenced member is dropped, it can be detected from the public API
-ok 5 - subtests
-	*** swim_test_add_remove: done ***
-	*** swim_test_basic_failure_detection ***
-    1..9
-    ok 1 - node is added as alive
-    ok 2 - member still is not suspected after 1 noack
-    ok 3 - but it is suspected after one more
-    ok 4 - it is not dead after 2 more noacks
-    ok 5 - but it is dead after one more
-    ok 6 - after 2 more unacks the member still is not deleted - dissemination TTD keeps it
-    ok 7 - but it is dropped after 2 rounds when TTD gets 0
-    ok 8 - fullmesh is restored
-    ok 9 - a member is added back on an ACK
-ok 6 - subtests
-	*** swim_test_basic_failure_detection: done ***
-	*** swim_test_probe ***
-    1..3
-    ok 1 - probe validates URI
-    ok 2 - send probe
-    ok 3 - receive ACK on probe and get fullmesh
-ok 7 - subtests
-	*** swim_test_probe: done ***
-	*** swim_test_refute ***
-    1..6
-    ok 1 - S2 increments its own incarnation to refute its suspicion
-    ok 2 - new incarnation has reached S1 with a next round message
-    ok 3 - after restart S2's version is 0 again
-    ok 4 - but generation is new
-    ok 5 - S2 disseminates new incarnation, S1 learns it
-    ok 6 - and considers S2 alive
-ok 8 - subtests
-	*** swim_test_refute: done ***
-	*** swim_test_basic_gossip ***
-    1..4
-    ok 1 - S1 still thinks that S2 is alive
-    ok 2 - but one more second, and a second ack timed out - S1 sees S2 as suspected
-    ok 3 - S3 still thinks that S2 is alive
-    ok 4 - S3 learns about suspected S2 from S1
-ok 9 - subtests
-	*** swim_test_basic_gossip: done ***
-	*** swim_test_too_big_packet ***
-    1..3
-    ok 1 - despite S1 can not send all the 50 members in a one packet, fullmesh is eventually reached
-    ok 2 - a dead member is detected in time not depending on cluster size
-    ok 3 - S26 death is eventually learned by everyone
-ok 10 - subtests
-	*** swim_test_too_big_packet: done ***
-	*** swim_test_undead ***
-    1..2
-    ok 1 - member S2 is dead
-    ok 2 - but it is never deleted due to the cfg option
-ok 11 - subtests
-	*** swim_test_undead: done ***
-	*** swim_test_packet_loss ***
-    1..5
-    ok 1 - drop rate = 5.00, but the failure is disseminated
-    ok 2 - drop rate = 10.00, but the failure is disseminated
-    ok 3 - drop rate = 20.00, but the failure is disseminated
-    ok 4 - drop rate = 50.00, but the failure is disseminated
-    ok 5 - drop rate = 90.00, but the failure is disseminated
-ok 12 - subtests
-	*** swim_test_packet_loss: done ***
-	*** swim_test_quit ***
-    1..10
-    ok 1 - 'self' is 'left' immediately after quit
-    ok 2 - 'quit' is sent to all the members without delays between dispatches
-    ok 3 - quited member S1 has returned and refuted the old status
-    ok 4 - another member S2 has taken the quited UUID
-    ok 5 - S3 did not add S1 back when received its 'quit'
-    ok 6 - S2 finally got 'quit' message from S1, but with its 'own' UUID - refute it
-    ok 7 - S3 sees S1 as left
-    ok 8 - S2 does not see S1 at all
-    ok 9 - after more time S1 is dropped from S3
-    ok 10 - and still is not added to S2 - left members can not be added
-ok 13 - subtests
-	*** swim_test_quit: done ***
-	*** swim_test_uri_update ***
-    1..2
-    ok 1 - S1 updated its URI and S2 sees that
-    ok 2 - S2 still keeps new S1's URI, even received the old one from S3
-ok 14 - subtests
-	*** swim_test_uri_update: done ***
-	*** swim_test_broadcast ***
-    1..6
-    ok 1 - S1 chooses to broadcast with port 2
-    ok 2 - S2 receives the broadcast from S1
-    ok 3 - others don't
-    ok 4 - S1 broadcasts ping without port
-    ok 5 - now everyone sees S1
-    ok 6 - fullmesh is reached, and no one link was added explicitly
-ok 15 - subtests
-	*** swim_test_broadcast: done ***
-	*** swim_test_payload_basic ***
-    1..11
-    ok 1 - no payload by default
-    ok 2 - can not set too big payload
-    ok 3 - diag says too big
-    ok 4 - payload is set
-    ok 5 - version is incremented on each payload update
-    ok 6 - payload is successfully obtained back
-    ok 7 - payload is disseminated
-    ok 8 - payload is changed
-    ok 9 - version is incremented on each payload update
-    ok 10 - second payload is disseminated
-    ok 11 - third payload is disseminated via anti-entropy
-ok 16 - subtests
-	*** swim_test_payload_basic: done ***
-	*** swim_test_indirect_ping ***
-    1..2
-    ok 1 - S1 is still alive everywhere
-    ok 2 - as well as S2 - they communicated via S3
-ok 17 - subtests
-	*** swim_test_indirect_ping: done ***
-	*** swim_test_encryption ***
-    1..3
-    ok 1 - cluster works with encryption
-    ok 2 - different encryption keys - can't interact
-    ok 3 - cluster works after encryption has been disabled
-ok 18 - subtests
-	*** swim_test_encryption: done ***
-	*** swim_test_slow_net ***
-    1..0
-    # slow network leads to idle round steps, they should not produce a new message
-ok 19 - subtests
-	*** swim_test_slow_net: done ***
-	*** swim_test_triggers ***
-    1..20
-    ok 1 - trigger is fired
-    ok 2 - is not deleted
-    ok 3 - ctx.member is set
-    ok 4 - ctx.events is set
-    ok 5 - self payload is updated
-    ok 6 - self is set as a member
-    ok 7 - both version and payload events are presented
-    ok 8 - suspicion fired a trigger
-    ok 9 - status suspected
-    ok 10 - death fired a trigger
-    ok 11 - status dead
-    ok 12 - drop fired a trigger
-    ok 13 - status dropped
-    ok 14 - dropped member is not presented in the member table
-    ok 15 - but is in the event context
-    ok 16 - yielding trigger is fired
-    ok 17 - non-yielding still is not
-    ok 18 - trigger is not deleted until all currently sleeping triggers are finished
-    # now all the triggers are done and deleted
-    ok 19 - local URI update warns about version update
-    ok 20 - version is a part of incarnation, so the latter is updated too
-ok 20 - subtests
-	*** swim_test_triggers: done ***
-	*** swim_test_generation ***
-    1..3
-    ok 1 - S1 disseminated its payload to S2
-    ok 2 - S1 restarted and set another payload. Without generation it could lead to never disseminated new payload.
-    ok 3 - S2 sees new generation of S1
-ok 21 - subtests
-	*** swim_test_generation: done ***
-	*** swim_test_dissemination_speed ***
-    1..2
-    ok 1 - dissemination work in log time even at the very start of a cluster
-    ok 2 - dissemination can withstand an event storm
-ok 22 - subtests
-	*** swim_test_dissemination_speed: done ***
-	*** swim_test_suspect_new_members ***
-    1..2
-    ok 1 - S2 dropped S1 as dead
-    ok 2 - S3 didn't add S1 from S2's messages, because S1 didn't answer on a ping
-ok 23 - subtests
-	*** swim_test_suspect_new_members: done ***
-	*** main_f: done ***
diff --git a/test/unit/swim_errinj.result b/test/unit/swim_errinj.result
deleted file mode 100644
index c60389d7f..000000000
--- a/test/unit/swim_errinj.result
+++ /dev/null
@@ -1,18 +0,0 @@
-	*** main_f ***
-1..1
-	*** swim_test_payload_refutation ***
-    1..11
-    ok 1 - S2 sees new version of S1
-    ok 2 - S3 does the same
-    ok 3 - but S2 does not known the new payload
-    ok 4 - as well as S3
-    ok 5 - S2 learned S1's payload via anti-entropy
-    ok 6 - version still is the same
-    ok 7 - S3 was blocked and does not know anything
-    ok 8 - version still is the same
-    ok 9 - S2 keeps the same new S1's payload, S3 did not rewrite it
-    ok 10 - S3 still does not know anything
-    ok 11 - S3 learns S1's payload from S2
-ok 1 - subtests
-	*** swim_test_payload_refutation: done ***
-	*** main_f: done ***
diff --git a/test/unit/swim_proto.c b/test/unit/swim_proto.c
index d7fafc7f0..e1407ebb7 100644
--- a/test/unit/swim_proto.c
+++ b/test/unit/swim_proto.c
@@ -264,4 +264,4 @@ main()
 	int rc = check_plan();
 	footer();
 	return rc;
-}
\ No newline at end of file
+}
diff --git a/test/unit/swim_proto.result b/test/unit/swim_proto.result
deleted file mode 100644
index 8a41a5d40..000000000
--- a/test/unit/swim_proto.result
+++ /dev/null
@@ -1,40 +0,0 @@
-	*** main ***
-1..3
-	*** swim_test_member_def ***
-    1..12
-    ok 1 - not map header
-    ok 2 - not uint member key
-    ok 3 - too big member key
-    ok 4 - STATUS is not uint
-    ok 5 - invalid STATUS
-    ok 6 - invalid address
-    ok 7 - bad port
-    ok 8 - unexpected buffer end
-    ok 9 - unexpected buffer end
-    ok 10 - uuid is nil/undefined
-    ok 11 - port is 0/undefined
-    ok 12 - normal member def
-ok 1 - subtests
-	*** swim_test_member_def: done ***
-	*** swim_test_meta ***
-    1..8
-    ok 1 - not map header
-    ok 2 - not uint meta key
-    ok 3 - unknown meta key
-    ok 4 - unexpected end
-    ok 5 - invalid version
-    ok 6 - port is 0/undefined
-    ok 7 - version is 0/undefined
-    ok 8 - normal meta
-ok 2 - subtests
-	*** swim_test_meta: done ***
-	*** swim_test_route ***
-    1..5
-    ok 1 - route was expected, but map is too short
-    ok 2 - no route map
-    ok 3 - empty route map
-    ok 4 - zero addresses
-    ok 5 - normal route
-ok 3 - subtests
-	*** swim_test_route: done ***
-	*** main: done ***
diff --git a/test/unit/tuple_bigref.result b/test/unit/tuple_bigref.result
deleted file mode 100644
index 6e3f0cfa4..000000000
--- a/test/unit/tuple_bigref.result
+++ /dev/null
@@ -1,17 +0,0 @@
-	*** main ***
-1..2
-	*** test_bigrefs_overall ***
-    1..3
-    ok 1 - All tuples have refs == 1.
-    ok 2 - All tuples have bigrefs.
-    ok 3 - All tuples were deleted.
-	*** test_bigrefs_overall: done ***
-ok 1 - subtests
-	*** test_bigrefs_non_consistent ***
-    1..3
-    ok 1 - All tuples have bigrefs.
-    ok 2 - 11 tuples don't have bigrefs and all other tuples have
-    ok 3 - All tuples have bigrefs and their indexes are in right order.
-	*** test_bigrefs_non_consistent: done ***
-ok 2 - subtests
-	*** main: done ***
diff --git a/test/unit/uri.result b/test/unit/uri.result
deleted file mode 100644
index 804560b69..000000000
--- a/test/unit/uri.result
+++ /dev/null
@@ -1,1307 +0,0 @@
-1..63
-    1..19
-    ok 1 - host: parse
-    ok 2 - host: scheme
-    ok 3 - host: login
-    ok 4 - host: password
-    ok 5 - host: host
-    ok 6 - host: service
-    ok 7 - host: path
-    ok 8 - host: query
-    ok 9 - host: fragment
-    ok 10 - host: host_hint
-    ok 11 - host: parse
-    ok 12 - host: scheme
-    ok 13 - host: login
-    ok 14 - host: password
-    ok 15 - host: host
-    ok 16 - host: service
-    ok 17 - host: path
-    ok 18 - host: query
-    ok 19 - host: fragment
-ok 1 - subtests
-    1..19
-    ok 1 - host/: parse
-    ok 2 - host/: scheme
-    ok 3 - host/: login
-    ok 4 - host/: password
-    ok 5 - host/: host
-    ok 6 - host/: service
-    ok 7 - host/: path
-    ok 8 - host/: query
-    ok 9 - host/: fragment
-    ok 10 - host/: host_hint
-    ok 11 - host/: parse
-    ok 12 - host/: scheme
-    ok 13 - host/: login
-    ok 14 - host/: password
-    ok 15 - host/: host
-    ok 16 - host/: service
-    ok 17 - host/: path
-    ok 18 - host/: query
-    ok 19 - host/: fragment
-ok 2 - subtests
-    1..19
-    ok 1 - host/path1/path2/path3: parse
-    ok 2 - host/path1/path2/path3: scheme
-    ok 3 - host/path1/path2/path3: login
-    ok 4 - host/path1/path2/path3: password
-    ok 5 - host/path1/path2/path3: host
-    ok 6 - host/path1/path2/path3: service
-    ok 7 - host/path1/path2/path3: path
-    ok 8 - host/path1/path2/path3: query
-    ok 9 - host/path1/path2/path3: fragment
-    ok 10 - host/path1/path2/path3: host_hint
-    ok 11 - host/path1/path2/path3: parse
-    ok 12 - host/path1/path2/path3: scheme
-    ok 13 - host/path1/path2/path3: login
-    ok 14 - host/path1/path2/path3: password
-    ok 15 - host/path1/path2/path3: host
-    ok 16 - host/path1/path2/path3: service
-    ok 17 - host/path1/path2/path3: path
-    ok 18 - host/path1/path2/path3: query
-    ok 19 - host/path1/path2/path3: fragment
-ok 3 - subtests
-    1..19
-    ok 1 - host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - host/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 4 - subtests
-    1..19
-    ok 1 - host:service: parse
-    ok 2 - host:service: scheme
-    ok 3 - host:service: login
-    ok 4 - host:service: password
-    ok 5 - host:service: host
-    ok 6 - host:service: service
-    ok 7 - host:service: path
-    ok 8 - host:service: query
-    ok 9 - host:service: fragment
-    ok 10 - host:service: host_hint
-    ok 11 - host:service: parse
-    ok 12 - host:service: scheme
-    ok 13 - host:service: login
-    ok 14 - host:service: password
-    ok 15 - host:service: host
-    ok 16 - host:service: service
-    ok 17 - host:service: path
-    ok 18 - host:service: query
-    ok 19 - host:service: fragment
-ok 5 - subtests
-    1..19
-    ok 1 - host:service/: parse
-    ok 2 - host:service/: scheme
-    ok 3 - host:service/: login
-    ok 4 - host:service/: password
-    ok 5 - host:service/: host
-    ok 6 - host:service/: service
-    ok 7 - host:service/: path
-    ok 8 - host:service/: query
-    ok 9 - host:service/: fragment
-    ok 10 - host:service/: host_hint
-    ok 11 - host:service/: parse
-    ok 12 - host:service/: scheme
-    ok 13 - host:service/: login
-    ok 14 - host:service/: password
-    ok 15 - host:service/: host
-    ok 16 - host:service/: service
-    ok 17 - host:service/: path
-    ok 18 - host:service/: query
-    ok 19 - host:service/: fragment
-ok 6 - subtests
-    1..19
-    ok 1 - host:service/path1/path2/path3: parse
-    ok 2 - host:service/path1/path2/path3: scheme
-    ok 3 - host:service/path1/path2/path3: login
-    ok 4 - host:service/path1/path2/path3: password
-    ok 5 - host:service/path1/path2/path3: host
-    ok 6 - host:service/path1/path2/path3: service
-    ok 7 - host:service/path1/path2/path3: path
-    ok 8 - host:service/path1/path2/path3: query
-    ok 9 - host:service/path1/path2/path3: fragment
-    ok 10 - host:service/path1/path2/path3: host_hint
-    ok 11 - host:service/path1/path2/path3: parse
-    ok 12 - host:service/path1/path2/path3: scheme
-    ok 13 - host:service/path1/path2/path3: login
-    ok 14 - host:service/path1/path2/path3: password
-    ok 15 - host:service/path1/path2/path3: host
-    ok 16 - host:service/path1/path2/path3: service
-    ok 17 - host:service/path1/path2/path3: path
-    ok 18 - host:service/path1/path2/path3: query
-    ok 19 - host:service/path1/path2/path3: fragment
-ok 7 - subtests
-    1..19
-    ok 1 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 8 - subtests
-    1..19
-    ok 1 - login at host: parse
-    ok 2 - login at host: scheme
-    ok 3 - login at host: login
-    ok 4 - login at host: password
-    ok 5 - login at host: host
-    ok 6 - login at host: service
-    ok 7 - login at host: path
-    ok 8 - login at host: query
-    ok 9 - login at host: fragment
-    ok 10 - login at host: host_hint
-    ok 11 - login at host: parse
-    ok 12 - login at host: scheme
-    ok 13 - login at host: login
-    ok 14 - login at host: password
-    ok 15 - login at host: host
-    ok 16 - login at host: service
-    ok 17 - login at host: path
-    ok 18 - login at host: query
-    ok 19 - login at host: fragment
-ok 9 - subtests
-    1..19
-    ok 1 - login at host/: parse
-    ok 2 - login at host/: scheme
-    ok 3 - login at host/: login
-    ok 4 - login at host/: password
-    ok 5 - login at host/: host
-    ok 6 - login at host/: service
-    ok 7 - login at host/: path
-    ok 8 - login at host/: query
-    ok 9 - login at host/: fragment
-    ok 10 - login at host/: host_hint
-    ok 11 - login at host/: parse
-    ok 12 - login at host/: scheme
-    ok 13 - login at host/: login
-    ok 14 - login at host/: password
-    ok 15 - login at host/: host
-    ok 16 - login at host/: service
-    ok 17 - login at host/: path
-    ok 18 - login at host/: query
-    ok 19 - login at host/: fragment
-ok 10 - subtests
-    1..19
-    ok 1 - login at host/path1/path2/path3: parse
-    ok 2 - login at host/path1/path2/path3: scheme
-    ok 3 - login at host/path1/path2/path3: login
-    ok 4 - login at host/path1/path2/path3: password
-    ok 5 - login at host/path1/path2/path3: host
-    ok 6 - login at host/path1/path2/path3: service
-    ok 7 - login at host/path1/path2/path3: path
-    ok 8 - login at host/path1/path2/path3: query
-    ok 9 - login at host/path1/path2/path3: fragment
-    ok 10 - login at host/path1/path2/path3: host_hint
-    ok 11 - login at host/path1/path2/path3: parse
-    ok 12 - login at host/path1/path2/path3: scheme
-    ok 13 - login at host/path1/path2/path3: login
-    ok 14 - login at host/path1/path2/path3: password
-    ok 15 - login at host/path1/path2/path3: host
-    ok 16 - login at host/path1/path2/path3: service
-    ok 17 - login at host/path1/path2/path3: path
-    ok 18 - login at host/path1/path2/path3: query
-    ok 19 - login at host/path1/path2/path3: fragment
-ok 11 - subtests
-    1..19
-    ok 1 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - login at host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 12 - subtests
-    1..19
-    ok 1 - login:password at host: parse
-    ok 2 - login:password at host: scheme
-    ok 3 - login:password at host: login
-    ok 4 - login:password at host: password
-    ok 5 - login:password at host: host
-    ok 6 - login:password at host: service
-    ok 7 - login:password at host: path
-    ok 8 - login:password at host: query
-    ok 9 - login:password at host: fragment
-    ok 10 - login:password at host: host_hint
-    ok 11 - login:password at host: parse
-    ok 12 - login:password at host: scheme
-    ok 13 - login:password at host: login
-    ok 14 - login:password at host: password
-    ok 15 - login:password at host: host
-    ok 16 - login:password at host: service
-    ok 17 - login:password at host: path
-    ok 18 - login:password at host: query
-    ok 19 - login:password at host: fragment
-ok 13 - subtests
-    1..19
-    ok 1 - login:@host: parse
-    ok 2 - login:@host: scheme
-    ok 3 - login:@host: login
-    ok 4 - login:@host: password
-    ok 5 - login:@host: host
-    ok 6 - login:@host: service
-    ok 7 - login:@host: path
-    ok 8 - login:@host: query
-    ok 9 - login:@host: fragment
-    ok 10 - login:@host: host_hint
-    ok 11 - login:@host: parse
-    ok 12 - login:@host: scheme
-    ok 13 - login:@host: login
-    ok 14 - login:@host: password
-    ok 15 - login:@host: host
-    ok 16 - login:@host: service
-    ok 17 - login:@host: path
-    ok 18 - login:@host: query
-    ok 19 - login:@host: fragment
-ok 14 - subtests
-    1..19
-    ok 1 - login:password at host/: parse
-    ok 2 - login:password at host/: scheme
-    ok 3 - login:password at host/: login
-    ok 4 - login:password at host/: password
-    ok 5 - login:password at host/: host
-    ok 6 - login:password at host/: service
-    ok 7 - login:password at host/: path
-    ok 8 - login:password at host/: query
-    ok 9 - login:password at host/: fragment
-    ok 10 - login:password at host/: host_hint
-    ok 11 - login:password at host/: parse
-    ok 12 - login:password at host/: scheme
-    ok 13 - login:password at host/: login
-    ok 14 - login:password at host/: password
-    ok 15 - login:password at host/: host
-    ok 16 - login:password at host/: service
-    ok 17 - login:password at host/: path
-    ok 18 - login:password at host/: query
-    ok 19 - login:password at host/: fragment
-ok 15 - subtests
-    1..19
-    ok 1 - login:password at host/path1/path2/path3: parse
-    ok 2 - login:password at host/path1/path2/path3: scheme
-    ok 3 - login:password at host/path1/path2/path3: login
-    ok 4 - login:password at host/path1/path2/path3: password
-    ok 5 - login:password at host/path1/path2/path3: host
-    ok 6 - login:password at host/path1/path2/path3: service
-    ok 7 - login:password at host/path1/path2/path3: path
-    ok 8 - login:password at host/path1/path2/path3: query
-    ok 9 - login:password at host/path1/path2/path3: fragment
-    ok 10 - login:password at host/path1/path2/path3: host_hint
-    ok 11 - login:password at host/path1/path2/path3: parse
-    ok 12 - login:password at host/path1/path2/path3: scheme
-    ok 13 - login:password at host/path1/path2/path3: login
-    ok 14 - login:password at host/path1/path2/path3: password
-    ok 15 - login:password at host/path1/path2/path3: host
-    ok 16 - login:password at host/path1/path2/path3: service
-    ok 17 - login:password at host/path1/path2/path3: path
-    ok 18 - login:password at host/path1/path2/path3: query
-    ok 19 - login:password at host/path1/path2/path3: fragment
-ok 16 - subtests
-    1..19
-    ok 1 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - login:password at host/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 17 - subtests
-    1..19
-    ok 1 - login:password at host:service: parse
-    ok 2 - login:password at host:service: scheme
-    ok 3 - login:password at host:service: login
-    ok 4 - login:password at host:service: password
-    ok 5 - login:password at host:service: host
-    ok 6 - login:password at host:service: service
-    ok 7 - login:password at host:service: path
-    ok 8 - login:password at host:service: query
-    ok 9 - login:password at host:service: fragment
-    ok 10 - login:password at host:service: host_hint
-    ok 11 - login:password at host:service: parse
-    ok 12 - login:password at host:service: scheme
-    ok 13 - login:password at host:service: login
-    ok 14 - login:password at host:service: password
-    ok 15 - login:password at host:service: host
-    ok 16 - login:password at host:service: service
-    ok 17 - login:password at host:service: path
-    ok 18 - login:password at host:service: query
-    ok 19 - login:password at host:service: fragment
-ok 18 - subtests
-    1..19
-    ok 1 - login:password at host:service/: parse
-    ok 2 - login:password at host:service/: scheme
-    ok 3 - login:password at host:service/: login
-    ok 4 - login:password at host:service/: password
-    ok 5 - login:password at host:service/: host
-    ok 6 - login:password at host:service/: service
-    ok 7 - login:password at host:service/: path
-    ok 8 - login:password at host:service/: query
-    ok 9 - login:password at host:service/: fragment
-    ok 10 - login:password at host:service/: host_hint
-    ok 11 - login:password at host:service/: parse
-    ok 12 - login:password at host:service/: scheme
-    ok 13 - login:password at host:service/: login
-    ok 14 - login:password at host:service/: password
-    ok 15 - login:password at host:service/: host
-    ok 16 - login:password at host:service/: service
-    ok 17 - login:password at host:service/: path
-    ok 18 - login:password at host:service/: query
-    ok 19 - login:password at host:service/: fragment
-ok 19 - subtests
-    1..19
-    ok 1 - login:password at host:service/path1/path2/path3: parse
-    ok 2 - login:password at host:service/path1/path2/path3: scheme
-    ok 3 - login:password at host:service/path1/path2/path3: login
-    ok 4 - login:password at host:service/path1/path2/path3: password
-    ok 5 - login:password at host:service/path1/path2/path3: host
-    ok 6 - login:password at host:service/path1/path2/path3: service
-    ok 7 - login:password at host:service/path1/path2/path3: path
-    ok 8 - login:password at host:service/path1/path2/path3: query
-    ok 9 - login:password at host:service/path1/path2/path3: fragment
-    ok 10 - login:password at host:service/path1/path2/path3: host_hint
-    ok 11 - login:password at host:service/path1/path2/path3: parse
-    ok 12 - login:password at host:service/path1/path2/path3: scheme
-    ok 13 - login:password at host:service/path1/path2/path3: login
-    ok 14 - login:password at host:service/path1/path2/path3: password
-    ok 15 - login:password at host:service/path1/path2/path3: host
-    ok 16 - login:password at host:service/path1/path2/path3: service
-    ok 17 - login:password at host:service/path1/path2/path3: path
-    ok 18 - login:password at host:service/path1/path2/path3: query
-    ok 19 - login:password at host:service/path1/path2/path3: fragment
-ok 20 - subtests
-    1..19
-    ok 1 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - login:password at host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 21 - subtests
-    1..19
-    ok 1 - scheme://login:password@host:service: parse
-    ok 2 - scheme://login:password@host:service: scheme
-    ok 3 - scheme://login:password@host:service: login
-    ok 4 - scheme://login:password@host:service: password
-    ok 5 - scheme://login:password@host:service: host
-    ok 6 - scheme://login:password@host:service: service
-    ok 7 - scheme://login:password@host:service: path
-    ok 8 - scheme://login:password@host:service: query
-    ok 9 - scheme://login:password@host:service: fragment
-    ok 10 - scheme://login:password@host:service: host_hint
-    ok 11 - scheme://login:password@host:service: parse
-    ok 12 - scheme://login:password@host:service: scheme
-    ok 13 - scheme://login:password@host:service: login
-    ok 14 - scheme://login:password@host:service: password
-    ok 15 - scheme://login:password@host:service: host
-    ok 16 - scheme://login:password@host:service: service
-    ok 17 - scheme://login:password@host:service: path
-    ok 18 - scheme://login:password@host:service: query
-    ok 19 - scheme://login:password@host:service: fragment
-ok 22 - subtests
-    1..19
-    ok 1 - scheme://login:password@host:service/: parse
-    ok 2 - scheme://login:password@host:service/: scheme
-    ok 3 - scheme://login:password@host:service/: login
-    ok 4 - scheme://login:password@host:service/: password
-    ok 5 - scheme://login:password@host:service/: host
-    ok 6 - scheme://login:password@host:service/: service
-    ok 7 - scheme://login:password@host:service/: path
-    ok 8 - scheme://login:password@host:service/: query
-    ok 9 - scheme://login:password@host:service/: fragment
-    ok 10 - scheme://login:password@host:service/: host_hint
-    ok 11 - scheme://login:password@host:service/: parse
-    ok 12 - scheme://login:password@host:service/: scheme
-    ok 13 - scheme://login:password@host:service/: login
-    ok 14 - scheme://login:password@host:service/: password
-    ok 15 - scheme://login:password@host:service/: host
-    ok 16 - scheme://login:password@host:service/: service
-    ok 17 - scheme://login:password@host:service/: path
-    ok 18 - scheme://login:password@host:service/: query
-    ok 19 - scheme://login:password@host:service/: fragment
-ok 23 - subtests
-    1..19
-    ok 1 - scheme://login:password@host:service/path1/path2/path3: parse
-    ok 2 - scheme://login:password@host:service/path1/path2/path3: scheme
-    ok 3 - scheme://login:password@host:service/path1/path2/path3: login
-    ok 4 - scheme://login:password@host:service/path1/path2/path3: password
-    ok 5 - scheme://login:password@host:service/path1/path2/path3: host
-    ok 6 - scheme://login:password@host:service/path1/path2/path3: service
-    ok 7 - scheme://login:password@host:service/path1/path2/path3: path
-    ok 8 - scheme://login:password@host:service/path1/path2/path3: query
-    ok 9 - scheme://login:password@host:service/path1/path2/path3: fragment
-    ok 10 - scheme://login:password@host:service/path1/path2/path3: host_hint
-    ok 11 - scheme://login:password@host:service/path1/path2/path3: parse
-    ok 12 - scheme://login:password@host:service/path1/path2/path3: scheme
-    ok 13 - scheme://login:password@host:service/path1/path2/path3: login
-    ok 14 - scheme://login:password@host:service/path1/path2/path3: password
-    ok 15 - scheme://login:password@host:service/path1/path2/path3: host
-    ok 16 - scheme://login:password@host:service/path1/path2/path3: service
-    ok 17 - scheme://login:password@host:service/path1/path2/path3: path
-    ok 18 - scheme://login:password@host:service/path1/path2/path3: query
-    ok 19 - scheme://login:password@host:service/path1/path2/path3: fragment
-ok 24 - subtests
-    1..19
-    ok 1 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - scheme://login:password@host:service/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 25 - subtests
-    1..19
-    ok 1 - host/path: parse
-    ok 2 - host/path: scheme
-    ok 3 - host/path: login
-    ok 4 - host/path: password
-    ok 5 - host/path: host
-    ok 6 - host/path: service
-    ok 7 - host/path: path
-    ok 8 - host/path: query
-    ok 9 - host/path: fragment
-    ok 10 - host/path: host_hint
-    ok 11 - host/path: parse
-    ok 12 - host/path: scheme
-    ok 13 - host/path: login
-    ok 14 - host/path: password
-    ok 15 - host/path: host
-    ok 16 - host/path: service
-    ok 17 - host/path: path
-    ok 18 - host/path: query
-    ok 19 - host/path: fragment
-ok 26 - subtests
-    1..19
-    ok 1 - host//: parse
-    ok 2 - host//: scheme
-    ok 3 - host//: login
-    ok 4 - host//: password
-    ok 5 - host//: host
-    ok 6 - host//: service
-    ok 7 - host//: path
-    ok 8 - host//: query
-    ok 9 - host//: fragment
-    ok 10 - host//: host_hint
-    ok 11 - host//: parse
-    ok 12 - host//: scheme
-    ok 13 - host//: login
-    ok 14 - host//: password
-    ok 15 - host//: host
-    ok 16 - host//: service
-    ok 17 - host//: path
-    ok 18 - host//: query
-    ok 19 - host//: fragment
-ok 27 - subtests
-    1..19
-    ok 1 - host//path: parse
-    ok 2 - host//path: scheme
-    ok 3 - host//path: login
-    ok 4 - host//path: password
-    ok 5 - host//path: host
-    ok 6 - host//path: service
-    ok 7 - host//path: path
-    ok 8 - host//path: query
-    ok 9 - host//path: fragment
-    ok 10 - host//path: host_hint
-    ok 11 - host//path: parse
-    ok 12 - host//path: scheme
-    ok 13 - host//path: login
-    ok 14 - host//path: password
-    ok 15 - host//path: host
-    ok 16 - host//path: service
-    ok 17 - host//path: path
-    ok 18 - host//path: query
-    ok 19 - host//path: fragment
-ok 28 - subtests
-    1..19
-    ok 1 - host/;abc?q: parse
-    ok 2 - host/;abc?q: scheme
-    ok 3 - host/;abc?q: login
-    ok 4 - host/;abc?q: password
-    ok 5 - host/;abc?q: host
-    ok 6 - host/;abc?q: service
-    ok 7 - host/;abc?q: path
-    ok 8 - host/;abc?q: query
-    ok 9 - host/;abc?q: fragment
-    ok 10 - host/;abc?q: host_hint
-    ok 11 - host/;abc?q: parse
-    ok 12 - host/;abc?q: scheme
-    ok 13 - host/;abc?q: login
-    ok 14 - host/;abc?q: password
-    ok 15 - host/;abc?q: host
-    ok 16 - host/;abc?q: service
-    ok 17 - host/;abc?q: path
-    ok 18 - host/;abc?q: query
-    ok 19 - host/;abc?q: fragment
-ok 29 - subtests
-    1..19
-    ok 1 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: parse
-    ok 2 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: scheme
-    ok 3 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: login
-    ok 4 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: password
-    ok 5 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: host
-    ok 6 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: service
-    ok 7 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: path
-    ok 8 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: query
-    ok 9 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: fragment
-    ok 10 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: parse
-    ok 12 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: scheme
-    ok 13 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: login
-    ok 14 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: password
-    ok 15 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: host
-    ok 16 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: service
-    ok 17 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: path
-    ok 18 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: query
-    ok 19 - scheme://login:password@host:service/@path1/:path2?q1=v1&q2=v2#fragment: fragment
-ok 30 - subtests
-    1..19
-    ok 1 - host/~user: parse
-    ok 2 - host/~user: scheme
-    ok 3 - host/~user: login
-    ok 4 - host/~user: password
-    ok 5 - host/~user: host
-    ok 6 - host/~user: service
-    ok 7 - host/~user: path
-    ok 8 - host/~user: query
-    ok 9 - host/~user: fragment
-    ok 10 - host/~user: host_hint
-    ok 11 - host/~user: parse
-    ok 12 - host/~user: scheme
-    ok 13 - host/~user: login
-    ok 14 - host/~user: password
-    ok 15 - host/~user: host
-    ok 16 - host/~user: service
-    ok 17 - host/~user: path
-    ok 18 - host/~user: query
-    ok 19 - host/~user: fragment
-ok 31 - subtests
-    1..19
-    ok 1 - try.tarantool.org: parse
-    ok 2 - try.tarantool.org: scheme
-    ok 3 - try.tarantool.org: login
-    ok 4 - try.tarantool.org: password
-    ok 5 - try.tarantool.org: host
-    ok 6 - try.tarantool.org: service
-    ok 7 - try.tarantool.org: path
-    ok 8 - try.tarantool.org: query
-    ok 9 - try.tarantool.org: fragment
-    ok 10 - try.tarantool.org: host_hint
-    ok 11 - try.tarantool.org: parse
-    ok 12 - try.tarantool.org: scheme
-    ok 13 - try.tarantool.org: login
-    ok 14 - try.tarantool.org: password
-    ok 15 - try.tarantool.org: host
-    ok 16 - try.tarantool.org: service
-    ok 17 - try.tarantool.org: path
-    ok 18 - try.tarantool.org: query
-    ok 19 - try.tarantool.org: fragment
-ok 32 - subtests
-    1..19
-    ok 1 - try.tarantool.org: parse
-    ok 2 - try.tarantool.org: scheme
-    ok 3 - try.tarantool.org: login
-    ok 4 - try.tarantool.org: password
-    ok 5 - try.tarantool.org: host
-    ok 6 - try.tarantool.org: service
-    ok 7 - try.tarantool.org: path
-    ok 8 - try.tarantool.org: query
-    ok 9 - try.tarantool.org: fragment
-    ok 10 - try.tarantool.org: host_hint
-    ok 11 - try.tarantool.org: parse
-    ok 12 - try.tarantool.org: scheme
-    ok 13 - try.tarantool.org: login
-    ok 14 - try.tarantool.org: password
-    ok 15 - try.tarantool.org: host
-    ok 16 - try.tarantool.org: service
-    ok 17 - try.tarantool.org: path
-    ok 18 - try.tarantool.org: query
-    ok 19 - try.tarantool.org: fragment
-ok 33 - subtests
-    1..19
-    ok 1 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: parse
-    ok 2 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: scheme
-    ok 3 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: login
-    ok 4 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: password
-    ok 5 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: host
-    ok 6 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: service
-    ok 7 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: path
-    ok 8 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: query
-    ok 9 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: fragment
-    ok 10 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: host_hint
-    ok 11 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: parse
-    ok 12 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: scheme
-    ok 13 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: login
-    ok 14 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: password
-    ok 15 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: host
-    ok 16 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: service
-    ok 17 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: path
-    ok 18 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: query
-    ok 19 - www.llanfairpwllgwyngyllgogerychwyrndrobwyll-llantysiliogogogoch.com: fragment
-ok 34 - subtests
-    1..19
-    ok 1 - 0.0.0.0: parse
-    ok 2 - 0.0.0.0: scheme
-    ok 3 - 0.0.0.0: login
-    ok 4 - 0.0.0.0: password
-    ok 5 - 0.0.0.0: host
-    ok 6 - 0.0.0.0: service
-    ok 7 - 0.0.0.0: path
-    ok 8 - 0.0.0.0: query
-    ok 9 - 0.0.0.0: fragment
-    ok 10 - 0.0.0.0: host_hint
-    ok 11 - 0.0.0.0: parse
-    ok 12 - 0.0.0.0: scheme
-    ok 13 - 0.0.0.0: login
-    ok 14 - 0.0.0.0: password
-    ok 15 - 0.0.0.0: host
-    ok 16 - 0.0.0.0: service
-    ok 17 - 0.0.0.0: path
-    ok 18 - 0.0.0.0: query
-    ok 19 - 0.0.0.0: fragment
-ok 35 - subtests
-    1..19
-    ok 1 - 127.0.0.1: parse
-    ok 2 - 127.0.0.1: scheme
-    ok 3 - 127.0.0.1: login
-    ok 4 - 127.0.0.1: password
-    ok 5 - 127.0.0.1: host
-    ok 6 - 127.0.0.1: service
-    ok 7 - 127.0.0.1: path
-    ok 8 - 127.0.0.1: query
-    ok 9 - 127.0.0.1: fragment
-    ok 10 - 127.0.0.1: host_hint
-    ok 11 - 127.0.0.1: parse
-    ok 12 - 127.0.0.1: scheme
-    ok 13 - 127.0.0.1: login
-    ok 14 - 127.0.0.1: password
-    ok 15 - 127.0.0.1: host
-    ok 16 - 127.0.0.1: service
-    ok 17 - 127.0.0.1: path
-    ok 18 - 127.0.0.1: query
-    ok 19 - 127.0.0.1: fragment
-ok 36 - subtests
-    1..19
-    ok 1 - 127.0.0.1:3313: parse
-    ok 2 - 127.0.0.1:3313: scheme
-    ok 3 - 127.0.0.1:3313: login
-    ok 4 - 127.0.0.1:3313: password
-    ok 5 - 127.0.0.1:3313: host
-    ok 6 - 127.0.0.1:3313: service
-    ok 7 - 127.0.0.1:3313: path
-    ok 8 - 127.0.0.1:3313: query
-    ok 9 - 127.0.0.1:3313: fragment
-    ok 10 - 127.0.0.1:3313: host_hint
-    ok 11 - 127.0.0.1:3313: parse
-    ok 12 - 127.0.0.1:3313: scheme
-    ok 13 - 127.0.0.1:3313: login
-    ok 14 - 127.0.0.1:3313: password
-    ok 15 - 127.0.0.1:3313: host
-    ok 16 - 127.0.0.1:3313: service
-    ok 17 - 127.0.0.1:3313: path
-    ok 18 - 127.0.0.1:3313: query
-    ok 19 - 127.0.0.1:3313: fragment
-ok 37 - subtests
-    1..19
-    ok 1 - scheme://login:password@127.0.0.1:3313: parse
-    ok 2 - scheme://login:password@127.0.0.1:3313: scheme
-    ok 3 - scheme://login:password@127.0.0.1:3313: login
-    ok 4 - scheme://login:password@127.0.0.1:3313: password
-    ok 5 - scheme://login:password@127.0.0.1:3313: host
-    ok 6 - scheme://login:password@127.0.0.1:3313: service
-    ok 7 - scheme://login:password@127.0.0.1:3313: path
-    ok 8 - scheme://login:password@127.0.0.1:3313: query
-    ok 9 - scheme://login:password@127.0.0.1:3313: fragment
-    ok 10 - scheme://login:password@127.0.0.1:3313: host_hint
-    ok 11 - scheme://login:password@127.0.0.1:3313: parse
-    ok 12 - scheme://login:password@127.0.0.1:3313: scheme
-    ok 13 - scheme://login:password@127.0.0.1:3313: login
-    ok 14 - scheme://login:password@127.0.0.1:3313: password
-    ok 15 - scheme://login:password@127.0.0.1:3313: host
-    ok 16 - scheme://login:password@127.0.0.1:3313: service
-    ok 17 - scheme://login:password@127.0.0.1:3313: path
-    ok 18 - scheme://login:password@127.0.0.1:3313: query
-    ok 19 - scheme://login:password@127.0.0.1:3313: fragment
-ok 38 - subtests
-    1..19
-    ok 1 - [2001::11a3:09d7::1]: parse
-    ok 2 - [2001::11a3:09d7::1]: scheme
-    ok 3 - [2001::11a3:09d7::1]: login
-    ok 4 - [2001::11a3:09d7::1]: password
-    ok 5 - [2001::11a3:09d7::1]: host
-    ok 6 - [2001::11a3:09d7::1]: service
-    ok 7 - [2001::11a3:09d7::1]: path
-    ok 8 - [2001::11a3:09d7::1]: query
-    ok 9 - [2001::11a3:09d7::1]: fragment
-    ok 10 - [2001::11a3:09d7::1]: host_hint
-    ok 11 - [2001::11a3:09d7::1]: parse
-    ok 12 - [2001::11a3:09d7::1]: scheme
-    ok 13 - [2001::11a3:09d7::1]: login
-    ok 14 - [2001::11a3:09d7::1]: password
-    ok 15 - [2001::11a3:09d7::1]: host
-    ok 16 - [2001::11a3:09d7::1]: service
-    ok 17 - [2001::11a3:09d7::1]: path
-    ok 18 - [2001::11a3:09d7::1]: query
-    ok 19 - [2001::11a3:09d7::1]: fragment
-ok 39 - subtests
-    1..19
-    ok 1 - scheme://login:password@[2001::11a3:09d7::1]:3313: parse
-    ok 2 - scheme://login:password@[2001::11a3:09d7::1]:3313: scheme
-    ok 3 - scheme://login:password@[2001::11a3:09d7::1]:3313: login
-    ok 4 - scheme://login:password@[2001::11a3:09d7::1]:3313: password
-    ok 5 - scheme://login:password@[2001::11a3:09d7::1]:3313: host
-    ok 6 - scheme://login:password@[2001::11a3:09d7::1]:3313: service
-    ok 7 - scheme://login:password@[2001::11a3:09d7::1]:3313: path
-    ok 8 - scheme://login:password@[2001::11a3:09d7::1]:3313: query
-    ok 9 - scheme://login:password@[2001::11a3:09d7::1]:3313: fragment
-    ok 10 - scheme://login:password@[2001::11a3:09d7::1]:3313: host_hint
-    ok 11 - scheme://login:password@[2001::11a3:09d7::1]:3313: parse
-    ok 12 - scheme://login:password@[2001::11a3:09d7::1]:3313: scheme
-    ok 13 - scheme://login:password@[2001::11a3:09d7::1]:3313: login
-    ok 14 - scheme://login:password@[2001::11a3:09d7::1]:3313: password
-    ok 15 - scheme://login:password@[2001::11a3:09d7::1]:3313: host
-    ok 16 - scheme://login:password@[2001::11a3:09d7::1]:3313: service
-    ok 17 - scheme://login:password@[2001::11a3:09d7::1]:3313: path
-    ok 18 - scheme://login:password@[2001::11a3:09d7::1]:3313: query
-    ok 19 - scheme://login:password@[2001::11a3:09d7::1]:3313: fragment
-ok 40 - subtests
-    1..19
-    ok 1 - scheme://[2001:0db8:11a3:09d7::1]: parse
-    ok 2 - scheme://[2001:0db8:11a3:09d7::1]: scheme
-    ok 3 - scheme://[2001:0db8:11a3:09d7::1]: login
-    ok 4 - scheme://[2001:0db8:11a3:09d7::1]: password
-    ok 5 - scheme://[2001:0db8:11a3:09d7::1]: host
-    ok 6 - scheme://[2001:0db8:11a3:09d7::1]: service
-    ok 7 - scheme://[2001:0db8:11a3:09d7::1]: path
-    ok 8 - scheme://[2001:0db8:11a3:09d7::1]: query
-    ok 9 - scheme://[2001:0db8:11a3:09d7::1]: fragment
-    ok 10 - scheme://[2001:0db8:11a3:09d7::1]: host_hint
-    ok 11 - scheme://[2001:0db8:11a3:09d7::1]: parse
-    ok 12 - scheme://[2001:0db8:11a3:09d7::1]: scheme
-    ok 13 - scheme://[2001:0db8:11a3:09d7::1]: login
-    ok 14 - scheme://[2001:0db8:11a3:09d7::1]: password
-    ok 15 - scheme://[2001:0db8:11a3:09d7::1]: host
-    ok 16 - scheme://[2001:0db8:11a3:09d7::1]: service
-    ok 17 - scheme://[2001:0db8:11a3:09d7::1]: path
-    ok 18 - scheme://[2001:0db8:11a3:09d7::1]: query
-    ok 19 - scheme://[2001:0db8:11a3:09d7::1]: fragment
-ok 41 - subtests
-    1..19
-    ok 1 - [::ffff:11.2.3.4]: parse
-    ok 2 - [::ffff:11.2.3.4]: scheme
-    ok 3 - [::ffff:11.2.3.4]: login
-    ok 4 - [::ffff:11.2.3.4]: password
-    ok 5 - [::ffff:11.2.3.4]: host
-    ok 6 - [::ffff:11.2.3.4]: service
-    ok 7 - [::ffff:11.2.3.4]: path
-    ok 8 - [::ffff:11.2.3.4]: query
-    ok 9 - [::ffff:11.2.3.4]: fragment
-    ok 10 - [::ffff:11.2.3.4]: host_hint
-    ok 11 - [::ffff:11.2.3.4]: parse
-    ok 12 - [::ffff:11.2.3.4]: scheme
-    ok 13 - [::ffff:11.2.3.4]: login
-    ok 14 - [::ffff:11.2.3.4]: password
-    ok 15 - [::ffff:11.2.3.4]: host
-    ok 16 - [::ffff:11.2.3.4]: service
-    ok 17 - [::ffff:11.2.3.4]: path
-    ok 18 - [::ffff:11.2.3.4]: query
-    ok 19 - [::ffff:11.2.3.4]: fragment
-ok 42 - subtests
-    1..19
-    ok 1 - scheme://login:password@[::ffff:11.2.3.4]:3313: parse
-    ok 2 - scheme://login:password@[::ffff:11.2.3.4]:3313: scheme
-    ok 3 - scheme://login:password@[::ffff:11.2.3.4]:3313: login
-    ok 4 - scheme://login:password@[::ffff:11.2.3.4]:3313: password
-    ok 5 - scheme://login:password@[::ffff:11.2.3.4]:3313: host
-    ok 6 - scheme://login:password@[::ffff:11.2.3.4]:3313: service
-    ok 7 - scheme://login:password@[::ffff:11.2.3.4]:3313: path
-    ok 8 - scheme://login:password@[::ffff:11.2.3.4]:3313: query
-    ok 9 - scheme://login:password@[::ffff:11.2.3.4]:3313: fragment
-    ok 10 - scheme://login:password@[::ffff:11.2.3.4]:3313: host_hint
-    ok 11 - scheme://login:password@[::ffff:11.2.3.4]:3313: parse
-    ok 12 - scheme://login:password@[::ffff:11.2.3.4]:3313: scheme
-    ok 13 - scheme://login:password@[::ffff:11.2.3.4]:3313: login
-    ok 14 - scheme://login:password@[::ffff:11.2.3.4]:3313: password
-    ok 15 - scheme://login:password@[::ffff:11.2.3.4]:3313: host
-    ok 16 - scheme://login:password@[::ffff:11.2.3.4]:3313: service
-    ok 17 - scheme://login:password@[::ffff:11.2.3.4]:3313: path
-    ok 18 - scheme://login:password@[::ffff:11.2.3.4]:3313: query
-    ok 19 - scheme://login:password@[::ffff:11.2.3.4]:3313: fragment
-ok 43 - subtests
-    1..19
-    ok 1 - 1: parse
-    ok 2 - 1: scheme
-    ok 3 - 1: login
-    ok 4 - 1: password
-    ok 5 - 1: host
-    ok 6 - 1: service
-    ok 7 - 1: path
-    ok 8 - 1: query
-    ok 9 - 1: fragment
-    ok 10 - 1: host_hint
-    ok 11 - 1: parse
-    ok 12 - 1: scheme
-    ok 13 - 1: login
-    ok 14 - 1: password
-    ok 15 - 1: host
-    ok 16 - 1: service
-    ok 17 - 1: path
-    ok 18 - 1: query
-    ok 19 - 1: fragment
-ok 44 - subtests
-    1..19
-    ok 1 - 10: parse
-    ok 2 - 10: scheme
-    ok 3 - 10: login
-    ok 4 - 10: password
-    ok 5 - 10: host
-    ok 6 - 10: service
-    ok 7 - 10: path
-    ok 8 - 10: query
-    ok 9 - 10: fragment
-    ok 10 - 10: host_hint
-    ok 11 - 10: parse
-    ok 12 - 10: scheme
-    ok 13 - 10: login
-    ok 14 - 10: password
-    ok 15 - 10: host
-    ok 16 - 10: service
-    ok 17 - 10: path
-    ok 18 - 10: query
-    ok 19 - 10: fragment
-ok 45 - subtests
-    1..19
-    ok 1 - 331: parse
-    ok 2 - 331: scheme
-    ok 3 - 331: login
-    ok 4 - 331: password
-    ok 5 - 331: host
-    ok 6 - 331: service
-    ok 7 - 331: path
-    ok 8 - 331: query
-    ok 9 - 331: fragment
-    ok 10 - 331: host_hint
-    ok 11 - 331: parse
-    ok 12 - 331: scheme
-    ok 13 - 331: login
-    ok 14 - 331: password
-    ok 15 - 331: host
-    ok 16 - 331: service
-    ok 17 - 331: path
-    ok 18 - 331: query
-    ok 19 - 331: fragment
-ok 46 - subtests
-    1..19
-    ok 1 - 3313: parse
-    ok 2 - 3313: scheme
-    ok 3 - 3313: login
-    ok 4 - 3313: password
-    ok 5 - 3313: host
-    ok 6 - 3313: service
-    ok 7 - 3313: path
-    ok 8 - 3313: query
-    ok 9 - 3313: fragment
-    ok 10 - 3313: host_hint
-    ok 11 - 3313: parse
-    ok 12 - 3313: scheme
-    ok 13 - 3313: login
-    ok 14 - 3313: password
-    ok 15 - 3313: host
-    ok 16 - 3313: service
-    ok 17 - 3313: path
-    ok 18 - 3313: query
-    ok 19 - 3313: fragment
-ok 47 - subtests
-    1..19
-    ok 1 - /: parse
-    ok 2 - /: scheme
-    ok 3 - /: login
-    ok 4 - /: password
-    ok 5 - /: host
-    ok 6 - /: service
-    ok 7 - /: path
-    ok 8 - /: query
-    ok 9 - /: fragment
-    ok 10 - /: host_hint
-    ok 11 - /: parse
-    ok 12 - /: scheme
-    ok 13 - /: login
-    ok 14 - /: password
-    ok 15 - /: host
-    ok 16 - /: service
-    ok 17 - /: path
-    ok 18 - /: query
-    ok 19 - /: fragment
-ok 48 - subtests
-    1..19
-    ok 1 - /path1/path2/path3: parse
-    ok 2 - /path1/path2/path3: scheme
-    ok 3 - /path1/path2/path3: login
-    ok 4 - /path1/path2/path3: password
-    ok 5 - /path1/path2/path3: host
-    ok 6 - /path1/path2/path3: service
-    ok 7 - /path1/path2/path3: path
-    ok 8 - /path1/path2/path3: query
-    ok 9 - /path1/path2/path3: fragment
-    ok 10 - /path1/path2/path3: host_hint
-    ok 11 - /path1/path2/path3: parse
-    ok 12 - /path1/path2/path3: scheme
-    ok 13 - /path1/path2/path3: login
-    ok 14 - /path1/path2/path3: password
-    ok 15 - /path1/path2/path3: host
-    ok 16 - /path1/path2/path3: service
-    ok 17 - /path1/path2/path3: path
-    ok 18 - /path1/path2/path3: query
-    ok 19 - /path1/path2/path3: fragment
-ok 49 - subtests
-    1..19
-    ok 1 - login:password@/path1/path2/path3: parse
-    ok 2 - login:password@/path1/path2/path3: scheme
-    ok 3 - login:password@/path1/path2/path3: login
-    ok 4 - login:password@/path1/path2/path3: password
-    ok 5 - login:password@/path1/path2/path3: host
-    ok 6 - login:password@/path1/path2/path3: service
-    ok 7 - login:password@/path1/path2/path3: path
-    ok 8 - login:password@/path1/path2/path3: query
-    ok 9 - login:password@/path1/path2/path3: fragment
-    ok 10 - login:password@/path1/path2/path3: host_hint
-    ok 11 - login:password@/path1/path2/path3: parse
-    ok 12 - login:password@/path1/path2/path3: scheme
-    ok 13 - login:password@/path1/path2/path3: login
-    ok 14 - login:password@/path1/path2/path3: password
-    ok 15 - login:password@/path1/path2/path3: host
-    ok 16 - login:password@/path1/path2/path3: service
-    ok 17 - login:password@/path1/path2/path3: path
-    ok 18 - login:password@/path1/path2/path3: query
-    ok 19 - login:password@/path1/path2/path3: fragment
-ok 50 - subtests
-    1..19
-    ok 1 - unix/:/path1/path2/path3: parse
-    ok 2 - unix/:/path1/path2/path3: scheme
-    ok 3 - unix/:/path1/path2/path3: login
-    ok 4 - unix/:/path1/path2/path3: password
-    ok 5 - unix/:/path1/path2/path3: host
-    ok 6 - unix/:/path1/path2/path3: service
-    ok 7 - unix/:/path1/path2/path3: path
-    ok 8 - unix/:/path1/path2/path3: query
-    ok 9 - unix/:/path1/path2/path3: fragment
-    ok 10 - unix/:/path1/path2/path3: host_hint
-    ok 11 - unix/:/path1/path2/path3: parse
-    ok 12 - unix/:/path1/path2/path3: scheme
-    ok 13 - unix/:/path1/path2/path3: login
-    ok 14 - unix/:/path1/path2/path3: password
-    ok 15 - unix/:/path1/path2/path3: host
-    ok 16 - unix/:/path1/path2/path3: service
-    ok 17 - unix/:/path1/path2/path3: path
-    ok 18 - unix/:/path1/path2/path3: query
-    ok 19 - unix/:/path1/path2/path3: fragment
-ok 51 - subtests
-    1..19
-    ok 1 - unix/:/path1/path2/path3:: parse
-    ok 2 - unix/:/path1/path2/path3:: scheme
-    ok 3 - unix/:/path1/path2/path3:: login
-    ok 4 - unix/:/path1/path2/path3:: password
-    ok 5 - unix/:/path1/path2/path3:: host
-    ok 6 - unix/:/path1/path2/path3:: service
-    ok 7 - unix/:/path1/path2/path3:: path
-    ok 8 - unix/:/path1/path2/path3:: query
-    ok 9 - unix/:/path1/path2/path3:: fragment
-    ok 10 - unix/:/path1/path2/path3:: host_hint
-    ok 11 - unix/:/path1/path2/path3:: parse
-    ok 12 - unix/:/path1/path2/path3:: scheme
-    ok 13 - unix/:/path1/path2/path3:: login
-    ok 14 - unix/:/path1/path2/path3:: password
-    ok 15 - unix/:/path1/path2/path3:: host
-    ok 16 - unix/:/path1/path2/path3:: service
-    ok 17 - unix/:/path1/path2/path3:: path
-    ok 18 - unix/:/path1/path2/path3:: query
-    ok 19 - unix/:/path1/path2/path3:: fragment
-ok 52 - subtests
-    1..19
-    ok 1 - unix/:/path1/path2/path3:/: parse
-    ok 2 - unix/:/path1/path2/path3:/: scheme
-    ok 3 - unix/:/path1/path2/path3:/: login
-    ok 4 - unix/:/path1/path2/path3:/: password
-    ok 5 - unix/:/path1/path2/path3:/: host
-    ok 6 - unix/:/path1/path2/path3:/: service
-    ok 7 - unix/:/path1/path2/path3:/: path
-    ok 8 - unix/:/path1/path2/path3:/: query
-    ok 9 - unix/:/path1/path2/path3:/: fragment
-    ok 10 - unix/:/path1/path2/path3:/: host_hint
-    ok 11 - unix/:/path1/path2/path3:/: parse
-    ok 12 - unix/:/path1/path2/path3:/: scheme
-    ok 13 - unix/:/path1/path2/path3:/: login
-    ok 14 - unix/:/path1/path2/path3:/: password
-    ok 15 - unix/:/path1/path2/path3:/: host
-    ok 16 - unix/:/path1/path2/path3:/: service
-    ok 17 - unix/:/path1/path2/path3:/: path
-    ok 18 - unix/:/path1/path2/path3:/: query
-    ok 19 - unix/:/path1/path2/path3:/: fragment
-ok 53 - subtests
-    1..19
-    ok 1 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 2 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 3 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 4 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 5 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 6 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 7 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 8 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 9 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-    ok 10 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: parse
-    ok 12 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: scheme
-    ok 13 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: login
-    ok 14 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: password
-    ok 15 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: host
-    ok 16 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: service
-    ok 17 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: path
-    ok 18 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: query
-    ok 19 - unix/:/path1/path2/path3?q1=v1&q2=v2#fragment: fragment
-ok 54 - subtests
-    1..19
-    ok 1 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: parse
-    ok 2 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: scheme
-    ok 3 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: login
-    ok 4 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: password
-    ok 5 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: host
-    ok 6 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: service
-    ok 7 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: path
-    ok 8 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: query
-    ok 9 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: fragment
-    ok 10 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: host_hint
-    ok 11 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: parse
-    ok 12 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: scheme
-    ok 13 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: login
-    ok 14 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: password
-    ok 15 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: host
-    ok 16 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: service
-    ok 17 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: path
-    ok 18 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: query
-    ok 19 - unix/:/path1/path2/path3:/p1/p2?q1=v1&q2=v2#fragment: fragment
-ok 55 - subtests
-    1..19
-    ok 1 - login:password at unix/:/path1/path2/path3: parse
-    ok 2 - login:password at unix/:/path1/path2/path3: scheme
-    ok 3 - login:password at unix/:/path1/path2/path3: login
-    ok 4 - login:password at unix/:/path1/path2/path3: password
-    ok 5 - login:password at unix/:/path1/path2/path3: host
-    ok 6 - login:password at unix/:/path1/path2/path3: service
-    ok 7 - login:password at unix/:/path1/path2/path3: path
-    ok 8 - login:password at unix/:/path1/path2/path3: query
-    ok 9 - login:password at unix/:/path1/path2/path3: fragment
-    ok 10 - login:password at unix/:/path1/path2/path3: host_hint
-    ok 11 - login:password at unix/:/path1/path2/path3: parse
-    ok 12 - login:password at unix/:/path1/path2/path3: scheme
-    ok 13 - login:password at unix/:/path1/path2/path3: login
-    ok 14 - login:password at unix/:/path1/path2/path3: password
-    ok 15 - login:password at unix/:/path1/path2/path3: host
-    ok 16 - login:password at unix/:/path1/path2/path3: service
-    ok 17 - login:password at unix/:/path1/path2/path3: path
-    ok 18 - login:password at unix/:/path1/path2/path3: query
-    ok 19 - login:password at unix/:/path1/path2/path3: fragment
-ok 56 - subtests
-    1..19
-    ok 1 - login:password at unix/:/path1/path2/path3:: parse
-    ok 2 - login:password at unix/:/path1/path2/path3:: scheme
-    ok 3 - login:password at unix/:/path1/path2/path3:: login
-    ok 4 - login:password at unix/:/path1/path2/path3:: password
-    ok 5 - login:password at unix/:/path1/path2/path3:: host
-    ok 6 - login:password at unix/:/path1/path2/path3:: service
-    ok 7 - login:password at unix/:/path1/path2/path3:: path
-    ok 8 - login:password at unix/:/path1/path2/path3:: query
-    ok 9 - login:password at unix/:/path1/path2/path3:: fragment
-    ok 10 - login:password at unix/:/path1/path2/path3:: host_hint
-    ok 11 - login:password at unix/:/path1/path2/path3:: parse
-    ok 12 - login:password at unix/:/path1/path2/path3:: scheme
-    ok 13 - login:password at unix/:/path1/path2/path3:: login
-    ok 14 - login:password at unix/:/path1/path2/path3:: password
-    ok 15 - login:password at unix/:/path1/path2/path3:: host
-    ok 16 - login:password at unix/:/path1/path2/path3:: service
-    ok 17 - login:password at unix/:/path1/path2/path3:: path
-    ok 18 - login:password at unix/:/path1/path2/path3:: query
-    ok 19 - login:password at unix/:/path1/path2/path3:: fragment
-ok 57 - subtests
-    1..19
-    ok 1 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: parse
-    ok 2 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: scheme
-    ok 3 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: login
-    ok 4 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: password
-    ok 5 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: host
-    ok 6 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: service
-    ok 7 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: path
-    ok 8 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: query
-    ok 9 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: fragment
-    ok 10 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: host_hint
-    ok 11 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: parse
-    ok 12 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: scheme
-    ok 13 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: login
-    ok 14 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: password
-    ok 15 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: host
-    ok 16 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: service
-    ok 17 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: path
-    ok 18 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: query
-    ok 19 - scheme://login:password@unix/:/tmp/unix.sock:/path1/path2/path3: fragment
-ok 58 - subtests
-    1..19
-    ok 1 - unix/:./relative/path.sock:/test: parse
-    ok 2 - unix/:./relative/path.sock:/test: scheme
-    ok 3 - unix/:./relative/path.sock:/test: login
-    ok 4 - unix/:./relative/path.sock:/test: password
-    ok 5 - unix/:./relative/path.sock:/test: host
-    ok 6 - unix/:./relative/path.sock:/test: service
-    ok 7 - unix/:./relative/path.sock:/test: path
-    ok 8 - unix/:./relative/path.sock:/test: query
-    ok 9 - unix/:./relative/path.sock:/test: fragment
-    ok 10 - unix/:./relative/path.sock:/test: host_hint
-    ok 11 - unix/:./relative/path.sock:/test: parse
-    ok 12 - unix/:./relative/path.sock:/test: scheme
-    ok 13 - unix/:./relative/path.sock:/test: login
-    ok 14 - unix/:./relative/path.sock:/test: password
-    ok 15 - unix/:./relative/path.sock:/test: host
-    ok 16 - unix/:./relative/path.sock:/test: service
-    ok 17 - unix/:./relative/path.sock:/test: path
-    ok 18 - unix/:./relative/path.sock:/test: query
-    ok 19 - unix/:./relative/path.sock:/test: fragment
-ok 59 - subtests
-    1..19
-    ok 1 - scheme://unix/:./relative/path.sock:/test: parse
-    ok 2 - scheme://unix/:./relative/path.sock:/test: scheme
-    ok 3 - scheme://unix/:./relative/path.sock:/test: login
-    ok 4 - scheme://unix/:./relative/path.sock:/test: password
-    ok 5 - scheme://unix/:./relative/path.sock:/test: host
-    ok 6 - scheme://unix/:./relative/path.sock:/test: service
-    ok 7 - scheme://unix/:./relative/path.sock:/test: path
-    ok 8 - scheme://unix/:./relative/path.sock:/test: query
-    ok 9 - scheme://unix/:./relative/path.sock:/test: fragment
-    ok 10 - scheme://unix/:./relative/path.sock:/test: host_hint
-    ok 11 - scheme://unix/:./relative/path.sock:/test: parse
-    ok 12 - scheme://unix/:./relative/path.sock:/test: scheme
-    ok 13 - scheme://unix/:./relative/path.sock:/test: login
-    ok 14 - scheme://unix/:./relative/path.sock:/test: password
-    ok 15 - scheme://unix/:./relative/path.sock:/test: host
-    ok 16 - scheme://unix/:./relative/path.sock:/test: service
-    ok 17 - scheme://unix/:./relative/path.sock:/test: path
-    ok 18 - scheme://unix/:./relative/path.sock:/test: query
-    ok 19 - scheme://unix/:./relative/path.sock:/test: fragment
-ok 60 - subtests
-    1..19
-    ok 1 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: parse
-    ok 2 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: scheme
-    ok 3 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: login
-    ok 4 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: password
-    ok 5 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: host
-    ok 6 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: service
-    ok 7 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: path
-    ok 8 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: query
-    ok 9 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: fragment
-    ok 10 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: host_hint
-    ok 11 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: parse
-    ok 12 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: scheme
-    ok 13 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: login
-    ok 14 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: password
-    ok 15 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: host
-    ok 16 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: service
-    ok 17 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: path
-    ok 18 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: query
-    ok 19 - http://tarantool.org/dist/master/debian/pool/main/t/tarantool/tarantool_1.6.3+314+g91066ee+20140910+1434.orig.tar.gz: fragment
-ok 61 - subtests
-    1..19
-    ok 1 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: parse
-    ok 2 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: scheme
-    ok 3 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: login
-    ok 4 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: password
-    ok 5 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: host
-    ok 6 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: service
-    ok 7 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: path
-    ok 8 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: query
-    ok 9 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: fragment
-    ok 10 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: host_hint
-    ok 11 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: parse
-    ok 12 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: scheme
-    ok 13 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: login
-    ok 14 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: password
-    ok 15 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: host
-    ok 16 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: service
-    ok 17 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: path
-    ok 18 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: query
-    ok 19 - https://www.google.com/search?safe=off&site=&tbm=isch&source=hp&biw=1918&bih=1109&q=Tarantool&oq=Tarantool&gs_l=img.3..0i24l3j0i10i24j0i24&gws_rd=ssl: fragment
-ok 62 - subtests
-    1..2
-    ok 1 - empty is invalid
-    ok 2 - :// is invalid
-ok 63 - subtests
diff --git a/test/unit/uuid.result b/test/unit/uuid.result
deleted file mode 100644
index 4899ae4a2..000000000
--- a/test/unit/uuid.result
+++ /dev/null
@@ -1,18 +0,0 @@
-1..4
-ok 1 - 6611265b-8852-4832-af8b-4164d52c62eb > 186ebbf7-cf97-4e2e-8b1b-76154f6f3949
-ok 2 - 075b4148-8fb0-2e7f-af50-4164d52c62eb < 1fbc929f-5da8-28c5-8b36-76154f6f3949
-    1..4
-    ok 1 - mp_sizeof_uuid() == encoded length
-    ok 2 - mp_decode_uuid() return code
-    ok 3 - mp_sizeof_uuid() == decoded length
-    ok 4 - mp_decode_uuid(mp_encode_uuid(uu)) == uu
-ok 3 - subtests
-    1..5
-	*** mp_print_test ***
-    ok 1 - correct mp_snprint size with empty buffer
-    ok 2 - correct mp_snprint size
-    ok 3 - correct mp_snprint result
-    ok 4 - correct mp_fprint size
-    ok 5 - correct mp_fprint result
-	*** mp_print_test: done ***
-ok 4 - subtests
diff --git a/test/unit/vclock.cc b/test/unit/vclock.cc
index 15e9f9379..2af367da0 100644
--- a/test/unit/vclock.cc
+++ b/test/unit/vclock.cc
@@ -412,6 +412,5 @@ main(void)
 	test_tostring();
 	test_fromstring();
 	test_fromstring_invalid();
-
-	return check_plan();
+	check_plan();
 }
diff --git a/test/unit/vclock.result b/test/unit/vclock.result
deleted file mode 100644
index 2ca741bbd..000000000
--- a/test/unit/vclock.result
+++ /dev/null
@@ -1,149 +0,0 @@
-1..5
-    1..40
-	*** test_compare ***
-    ok 1 - compare (), () => 0
-    ok 2 - compare (), () => 0
-    ok 3 - compare (), (10) => -1
-    ok 4 - compare (10), () => 1
-    ok 5 - compare (0), (0) => 0
-    ok 6 - compare (0), (0) => 0
-    ok 7 - compare (1), (1) => 0
-    ok 8 - compare (1), (1) => 0
-    ok 9 - compare (1), (2) => -1
-    ok 10 - compare (2), (1) => 1
-    ok 11 - compare (), (10, 1, 0) => -1
-    ok 12 - compare (10, 1, 0), () => 1
-    ok 13 - compare (5), (10, 1, 0) => -1
-    ok 14 - compare (10, 1, 0), (5) => 1
-    ok 15 - compare (10), (10, 1, 0) => -1
-    ok 16 - compare (10, 1, 0), (10) => 1
-    ok 17 - compare (15), (10, 1, 0) => 2147483647
-    ok 18 - compare (10, 1, 0), (15) => 2147483647
-    ok 19 - compare (10, 1, 0), (10, 1, 1) => -1
-    ok 20 - compare (10, 1, 1), (10, 1, 0) => 1
-    ok 21 - compare (10, 1, 0), (10, 2, 0) => -1
-    ok 22 - compare (10, 2, 0), (10, 1, 0) => 1
-    ok 23 - compare (10, 1, 0), (10, 1, 0) => 0
-    ok 24 - compare (10, 1, 0), (10, 1, 0) => 0
-    ok 25 - compare (10, 0, 1), (10, 1, 0) => 2147483647
-    ok 26 - compare (10, 1, 0), (10, 0, 1) => 2147483647
-    ok 27 - compare (10, 2, 1), (10, 1, 2) => 2147483647
-    ok 28 - compare (10, 1, 2), (10, 2, 1) => 2147483647
-    ok 29 - compare (10, 0, 1), (11, 0, 0) => 2147483647
-    ok 30 - compare (11, 0, 0), (10, 0, 1) => 2147483647
-    ok 31 - compare (10, 0, 5), (5, 0, 10) => 2147483647
-    ok 32 - compare (5, 0, 10), (10, 0, 5) => 2147483647
-    ok 33 - compare (10, 10, 10), (10, 10, 10) => 0
-    ok 34 - compare (10, 10, 10), (10, 10, 10) => 0
-    ok 35 - compare (10, 10, 10), (10, 10, 10, 1) => -1
-    ok 36 - compare (10, 10, 10, 1), (10, 10, 10) => 1
-    ok 37 - compare (10, 10, 10), (10, 10, 10, 1, 2, 3) => -1
-    ok 38 - compare (10, 10, 10, 1, 2, 3), (10, 10, 10) => 1
-    ok 39 - compare (0, 0, 0), (10, 0, 0, 0, 0) => -1
-    ok 40 - compare (10, 0, 0, 0, 0), (0, 0, 0) => 1
-	*** test_compare: done ***
-ok 1 - subtests
-    1..36
-	*** test_isearch ***
-    ok 1 - query #1
-    ok 2 - query #2
-    ok 3 - query #3
-    ok 4 - query #4
-    ok 5 - query #5
-    ok 6 - query #6
-    ok 7 - query #7
-    ok 8 - query #8
-    ok 9 - query #9
-    ok 10 - query #10
-    ok 11 - query #11
-    ok 12 - query #12
-    ok 13 - query #13
-    ok 14 - query #14
-    ok 15 - query #15
-    ok 16 - query #16
-    ok 17 - query #17
-    ok 18 - query #18
-    ok 19 - query #19
-    ok 20 - query #20
-    ok 21 - query #21
-    ok 22 - query #22
-    ok 23 - query #23
-    ok 24 - query #24
-    ok 25 - query #25
-    ok 26 - query #26
-    ok 27 - query #27
-    ok 28 - query #28
-    ok 29 - query #29
-    ok 30 - query #30
-    ok 31 - query #31
-    ok 32 - query #32
-    ok 33 - query #33
-    ok 34 - query #34
-    ok 35 - query #35
-    ok 36 - query #36
-	*** test_isearch: done ***
-ok 2 - subtests
-    1..8
-	*** test_tostring ***
-    ok 1 - tostring () => {}
-    ok 2 - tostring (-1, -1, -1) => {}
-    ok 3 - tostring (1) => {0: 1}
-    ok 4 - tostring (1, 2) => {0: 1, 1: 2}
-    ok 5 - tostring (10, 15, 20) => {0: 10, 1: 15, 2: 20}
-    ok 6 - tostring (10, -1, 15, -1, 20) => {0: 10, 2: 15, 4: 20}
-    ok 7 - tostring (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) => {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15}
-    ok 8 - tostring (9223372036854775000, 9223372036854775001, 9223372036854775002, 9223372036854775003, 9223372036854775004, 9223372036854775005, 9223372036854775006, 9223372036854775007, 9223372036854775008, 9223372036854775009, 9223372036854775010, 9223372036854775011, 9223372036854775012, 9223372036854775013, 9223372036854775014, 9223372036854775015) => {0: 9223372036854775000, 1: 9223372036854775001, 2: 9223372036854775002, 3: 9223372036854775003, 4: 9223372036854775004, 5: 9223372036854775005, 6: 9223372036854775006, 7: 9223372036854775007, 8: 9223372036854775008, 9: 9223372036854775009, 10: 9223372036854775010, 11: 9223372036854775011, 12: 9223372036854775012, 13: 9223372036854775013, 14: 9223372036854775014, 15: 9223372036854775015}
-	*** test_tostring: done ***
-ok 3 - subtests
-    1..12
-	*** test_fromstring ***
-    ok 1 - fromstring {} => ()
-    ok 2 - fromstring  	 	 { 	 	 } 	 	  => ()
-    ok 3 - fromstring {0: 10} => (10)
-    ok 4 - fromstring {0: 10,} => (10)
-    ok 5 - fromstring {	 0	 :	  10	 ,	 } => (10)
-    ok 6 - fromstring {0: 10, 1: 15, 3: 20} => (10, 15, -1, 20)
-    ok 7 - fromstring {2: 20, 0: 10, 4: 30} => (10, -1, 20, -1, 30)
-    ok 8 - fromstring {4: 30, 2: 20} => (-1, -1, 20, -1, 30)
-    ok 9 - fromstring {4: 30, 2: 20,} => (-1, -1, 20, -1, 30)
-    ok 10 - fromstring {0: 4294967295} => (4294967295)
-    ok 11 - fromstring {0: 4294967296} => (4294967296)
-    ok 12 - fromstring {0: 9223372036854775807} => (9223372036854775807)
-	*** test_fromstring: done ***
-ok 4 - subtests
-    1..32
-	*** test_fromstring_invalid ***
-    ok 1 - fromstring "" => 1
-    ok 2 - fromstring " " => 2
-    ok 3 - fromstring "	 	 	 " => 7
-    ok 4 - fromstring "}" => 1
-    ok 5 - fromstring "1: 10" => 1
-    ok 6 - fromstring "abcde" => 1
-    ok 7 - fromstring "12345" => 1
-    ok 8 - fromstring "" => 1
-    ok 9 - fromstring "{" => 2
-    ok 10 - fromstring "{1	 " => 5
-    ok 11 - fromstring "{1:	 " => 6
-    ok 12 - fromstring "{1:10" => 6
-    ok 13 - fromstring "{1:10	 " => 8
-    ok 14 - fromstring "{1:10," => 7
-    ok 15 - fromstring "{1:10,	 	 " => 11
-    ok 16 - fromstring "{1:10 2:20" => 7
-    ok 17 - fromstring "{1:10,," => 7
-    ok 18 - fromstring "{1:10, 10,}" => 10
-    ok 19 - fromstring "{1:-1}" => 4
-    ok 20 - fromstring "{-1:1}" => 2
-    ok 21 - fromstring "{128:1}" => 5
-    ok 22 - fromstring "{1:abcde}" => 4
-    ok 23 - fromstring "{abcde:1}" => 2
-    ok 24 - fromstring "{1:1.1}" => 5
-    ok 25 - fromstring "{1.1:1}" => 3
-    ok 26 - fromstring "{4294967296:1}" => 12
-    ok 27 - fromstring "{1:9223372036854775808}" => 23
-    ok 28 - fromstring "{1:18446744073709551616}" => 24
-    ok 29 - fromstring "{1:18446744073709551616}" => 24
-    ok 30 - fromstring "{1:340282366920938463463374607431768211456}" => 43
-    ok 31 - fromstring "{1:10, 1:20}" => 12
-    ok 32 - fromstring "{1:20, 1:10}" => 12
-	*** test_fromstring_invalid: done ***
-ok 5 - subtests
diff --git a/test/unit/vy_cache.result b/test/unit/vy_cache.result
deleted file mode 100644
index a67e8edb0..000000000
--- a/test/unit/vy_cache.result
+++ /dev/null
@@ -1,9 +0,0 @@
-	*** test_basic ***
-1..6
-ok 1 - cache is filled with 6 statements
-ok 2 - cache is filled with 12 statements
-ok 3 - cache is filled with 18 statements
-ok 4 - next_key * 4
-ok 5 - restore
-ok 6 - restore on position after last
-	*** test_basic: done ***
diff --git a/test/unit/vy_mem.c b/test/unit/vy_mem.c
index 2e461f312..4e136b72b 100644
--- a/test/unit/vy_mem.c
+++ b/test/unit/vy_mem.c
@@ -9,7 +9,7 @@ test_basic(void)
 {
 	header();
 
-	plan(12);
+	plan(9);
 
 	/* Create key_def */
 	uint32_t fields[] = { 0 };
@@ -334,11 +334,13 @@ test_iterator_restore_after_insertion()
 int
 main(int argc, char *argv[])
 {
+	plan(2);
 	vy_iterator_C_test_init(0);
 
 	test_basic();
 	test_iterator_restore_after_insertion();
 
 	vy_iterator_C_test_finish();
+	check_plan();
 	return 0;
 }
diff --git a/test/unit/vy_mem.result b/test/unit/vy_mem.result
deleted file mode 100644
index 5c9c7af58..000000000
--- a/test/unit/vy_mem.result
+++ /dev/null
@@ -1,17 +0,0 @@
-# Looks like you planned 12 tests but ran 9.
-	*** test_basic ***
-1..12
-ok 1 - mem->dump_lsn on empty mem
-ok 2 - mem->dump_lsn after prepare
-ok 3 - mem->dump_lsn after commit
-ok 4 - vy_mem_older_lsn 1
-ok 5 - vy_mem_older_lsn 2
-ok 6 - vy_mem_rollback 1
-ok 7 - vy_mem_rollback 2
-ok 8 - vy_mem->version
-ok 9 - vy_mem->version
-	*** test_basic: done ***
-	*** test_iterator_restore_after_insertion ***
-1..1
-ok 1 - check wrong_output 0
-	*** test_iterator_restore_after_insertion: done ***
diff --git a/test/unit/vy_point_lookup.result b/test/unit/vy_point_lookup.result
deleted file mode 100644
index 4e68dda6d..000000000
--- a/test/unit/vy_point_lookup.result
+++ /dev/null
@@ -1,20 +0,0 @@
-1..1
-	*** test_basic ***
-    1..15
-    ok 1 - vy_lsm_env_create
-    ok 2 - key_def is not NULL
-    ok 3 - tuple_format_new is not NULL
-    ok 4 - lsm is not NULL
-    ok 5 - range is not NULL
-    ok 6 - temp dir name is not NULL
-    ok 7 - temp dir create (2)
-    ok 8 - temp dir create (3)
-    ok 9 - vy_lsm_rotate_mem
-    ok 10 - vy_run_new
-    ok 11 - vy_run_write
-    ok 12 - vy_run_new
-    ok 13 - vy_run_write
-    ok 14 - select results
-    ok 15 - no errors happened
-ok 1 - subtests
-	*** test_basic: done ***
diff --git a/test/unit/vy_write_iterator.result b/test/unit/vy_write_iterator.result
deleted file mode 100644
index a80116852..000000000
--- a/test/unit/vy_write_iterator.result
+++ /dev/null
@@ -1,61 +0,0 @@
-	*** test_basic ***
-1..58
-ok 1 - stmt 0 is correct
-ok 2 - stmt 1 is correct
-ok 3 - stmt 2 is correct
-ok 4 - stmt 3 is correct
-ok 5 - correct results count
-ok 6 - stmt 0 is correct
-ok 7 - stmt 1 is correct
-ok 8 - stmt 2 is correct
-ok 9 - stmt 3 is correct
-ok 10 - correct results count
-ok 11 - stmt 0 is correct
-ok 12 - stmt 1 is correct
-ok 13 - correct results count
-ok 14 - stmt 0 is correct
-ok 15 - stmt 1 is correct
-ok 16 - correct results count
-ok 17 - stmt 0 is correct
-ok 18 - correct results count
-ok 19 - stmt 0 is correct
-ok 20 - stmt 1 is correct
-ok 21 - correct results count
-ok 22 - stmt 0 is correct
-ok 23 - stmt 1 is correct
-ok 24 - correct results count
-ok 25 - stmt 0 is correct
-ok 26 - stmt 1 is correct
-ok 27 - stmt 2 is correct
-ok 28 - correct results count
-ok 29 - stmt 0 is correct
-ok 30 - correct results count
-ok 31 - stmt 0 is correct
-ok 32 - stmt 1 is correct
-ok 33 - stmt 2 is correct
-ok 34 - correct results count
-ok 35 - stmt 0 is correct
-ok 36 - stmt 1 is correct
-ok 37 - stmt 2 is correct
-ok 38 - correct results count
-ok 39 - stmt 0 is correct
-ok 40 - stmt 1 is correct
-ok 41 - stmt 2 is correct
-ok 42 - correct results count
-ok 43 - deferred stmt 0 is correct
-ok 44 - deferred stmt 1 is correct
-ok 45 - deferred stmt 2 is correct
-ok 46 - deferred stmt 3 is correct
-ok 47 - correct deferred stmt count
-ok 48 - stmt 0 is correct
-ok 49 - stmt 1 is correct
-ok 50 - correct results count
-ok 51 - correct deferred stmt count
-ok 52 - stmt 0 is correct
-ok 53 - stmt 1 is correct
-ok 54 - correct results count
-ok 55 - correct deferred stmt count
-ok 56 - stmt 0 is correct
-ok 57 - correct results count
-ok 58 - correct deferred stmt count
-	*** test_basic: done ***
diff --git a/test/unit/xrow.result b/test/unit/xrow.result
deleted file mode 100644
index 5ee92ad7b..000000000
--- a/test/unit/xrow.result
+++ /dev/null
@@ -1,58 +0,0 @@
-1..3
-    1..40
-    ok 1 - round trip
-    ok 2 - roundtrip.version_id
-    ok 3 - roundtrip.protocol
-    ok 4 - roundtrip.uuid
-    ok 5 - roundtrip.salt_len
-    ok 6 - roundtrip.salt
-    ok 7 - decode iproto
-    ok 8 - iproto.version_id
-    ok 9 - iproto.protocol
-    ok 10 - iproto.uuid
-    ok 11 - iproto.salt_len
-    ok 12 - iproto.salt
-    ok 13 - decode lua
-    ok 14 - lua.version_id
-    ok 15 - lua.protocol
-    ok 16 - lua.uuid
-    ok 17 - lua.salt_len
-    ok 18 - decode iproto166
-    ok 19 - iproto166.version_id
-    ok 20 - iproto166.protocol
-    ok 21 - iproto166.uuid
-    ok 22 - iproto166.salt_len
-    ok 23 - iproto166.salt
-    ok 24 - decode lua166
-    ok 25 - lua166.version_id
-    ok 26 - lua166.protocol
-    ok 27 - lua166.uuid
-    ok 28 - lua166.salt_len
-    ok 29 - invalid 0
-    ok 30 - invalid 1
-    ok 31 - invalid 2
-    ok 32 - invalid 3
-    ok 33 - invalid 4
-    ok 34 - invalid 5
-    ok 35 - invalid 6
-    ok 36 - invalid 7
-    ok 37 - invalid 8
-    ok 38 - invalid 9
-    ok 39 - invalid 10
-    ok 40 - invalid 11
-ok 1 - subtests
-    1..10
-    ok 1 - bad msgpack end
-    ok 2 - encode
-    ok 3 - header map size
-    ok 4 - header decode
-    ok 5 - decoded type
-    ok 6 - decoded replica_id
-    ok 7 - decoded lsn
-    ok 8 - decoded tm
-    ok 9 - decoded sync
-    ok 10 - decoded bodycnt
-ok 2 - subtests
-    1..1
-    ok 1 - request_str
-ok 3 - subtests
-- 
2.23.0



More information about the Tarantool-patches mailing list