diff --git a/tests/src/test_blockstore.c b/tests/src/test_blockstore.c
index 72eafbb..ac875ea 100644
--- a/tests/src/test_blockstore.c
+++ b/tests/src/test_blockstore.c
@@ -32,7 +32,7 @@ static void rmrf(const char *path)
 static void test_open_close(void)
 {
 	struct uc2_blockstore bs;
-	assert(uc2_blockstore_open(&bs, store_path) == 0);
+	{ int _r = uc2_blockstore_open(&bs, store_path); (void)_r; assert(_r == 0); }
 	assert(bs.nblocks == 0);
 	assert(bs.total_bytes == 0);
 	assert(bs.saved_bytes == 0);
@@ -99,7 +99,7 @@ static void test_read_back(void)
 		uint8_t buf[65536];
 		int n = uc2_blockstore_read(&bs, tree.chunks[i].hash, buf, sizeof buf);
 		assert(n == (int)tree.chunks[i].length);
-		assert(memcmp(buf, data + tree.chunks[i].offset, n) == 0);
+		{ int _r = memcmp(buf, data + tree.chunks[i].offset, n); (void)_r; assert(_r == 0); }
 	}
 
 	uc2_blockstore_close(&bs);
diff --git a/tests/src/test_delta.c b/tests/src/test_delta.c
index 3860d53..17945a9 100644
--- a/tests/src/test_delta.c
+++ b/tests/src/test_delta.c
@@ -25,7 +25,7 @@ static void test_identical(void)
 	assert(uc2_delta_apply(data, sizeof data, delta, delta_len,
 	                       &recon, &recon_len) == 0);
 	assert(recon_len == sizeof data);
-	assert(memcmp(recon, data, sizeof data) == 0);
+	{ int _r = memcmp(recon, data, sizeof data); (void)_r; assert(_r == 0); }
 
 	free(delta);
 	free(recon);
@@ -39,7 +39,7 @@ static void test_small_change(void)
 	size_t slen = sizeof src, tlen = sizeof tgt;
 
 	uint8_t *delta; size_t delta_len;
-	assert(uc2_delta_encode(src, slen, tgt, tlen, &delta, &delta_len) == 0);
+	{ int _r = uc2_delta_encode(src, slen, tgt, tlen, &delta, &delta_len); (void)_r; assert(_r == 0); }
 
 	printf("(delta=%zu vs tgt=%zu) ", delta_len, tlen);
 	assert(delta_len < tlen);  /* delta should be smaller than full target */
@@ -48,7 +48,7 @@ static void test_small_change(void)
 	assert(uc2_delta_apply(src, slen, delta, delta_len,
 	                       &recon, &recon_len) == 0);
 	assert(recon_len == tlen);
-	assert(memcmp(recon, tgt, tlen) == 0);
+	{ int _r = memcmp(recon, tgt, tlen); (void)_r; assert(_r == 0); }
 
 	free(delta);
 	free(recon);
@@ -67,7 +67,7 @@ static void test_completely_different(void)
 	assert(uc2_delta_apply(src, sizeof src, delta, delta_len,
 	                       &recon, &recon_len) == 0);
 	assert(recon_len == sizeof tgt);
-	assert(memcmp(recon, tgt, sizeof tgt) == 0);
+	{ int _r = memcmp(recon, tgt, sizeof tgt); (void)_r; assert(_r == 0); }
 
 	free(delta);
 	free(recon);
@@ -93,7 +93,7 @@ static void test_binary_patch(void)
 	}
 
 	uint8_t *delta; size_t delta_len;
-	assert(uc2_delta_encode(src, len, tgt, len, &delta, &delta_len) == 0);
+	{ int _r = uc2_delta_encode(src, len, tgt, len, &delta, &delta_len); (void)_r; assert(_r == 0); }
 
 	printf("(delta=%zu vs orig=%zu = %.0f%% savings) ",
 	       delta_len, len, (1.0 - (double)delta_len / len) * 100);
@@ -103,7 +103,7 @@ static void test_binary_patch(void)
 	assert(uc2_delta_apply(src, len, delta, delta_len,
 	                       &recon, &recon_len) == 0);
 	assert(recon_len == len);
-	assert(memcmp(recon, tgt, len) == 0);
+	{ int _r = memcmp(recon, tgt, len); (void)_r; assert(_r == 0); }
 
 	free(src);
 	free(tgt);
@@ -115,7 +115,7 @@ static void test_empty_target(void)
 {
 	uint8_t src[] = "source data";
 	uint8_t *delta; size_t delta_len;
-	assert(uc2_delta_encode(src, sizeof src, NULL, 0, &delta, &delta_len) == 0);
+	{ int _r = uc2_delta_encode(src, sizeof src, NULL, 0, &delta, &delta_len); (void)_r; assert(_r == 0); }
 
 	uint8_t *recon; size_t recon_len;
 	assert(uc2_delta_apply(src, sizeof src, delta, delta_len,
@@ -134,13 +134,13 @@ static void test_append(void)
 	size_t slen = sizeof src, tlen = sizeof tgt;
 
 	uint8_t *delta; size_t delta_len;
-	assert(uc2_delta_encode(src, slen, tgt, tlen, &delta, &delta_len) == 0);
+	{ int _r = uc2_delta_encode(src, slen, tgt, tlen, &delta, &delta_len); (void)_r; assert(_r == 0); }
 
 	uint8_t *recon; size_t recon_len;
 	assert(uc2_delta_apply(src, slen, delta, delta_len,
 	                       &recon, &recon_len) == 0);
 	assert(recon_len == tlen);
-	assert(memcmp(recon, tgt, tlen) == 0);
+	{ int _r = memcmp(recon, tgt, tlen); (void)_r; assert(_r == 0); }
 
 	free(delta);
 	free(recon);
diff --git a/tests/src/test_dict.c b/tests/src/test_dict.c
index e1f04f8..c52f7fb 100644
--- a/tests/src/test_dict.c
+++ b/tests/src/test_dict.c
@@ -13,7 +13,7 @@ static void test_create_verify(void)
 {
 	uint8_t data[] = "Dictionary content for testing purposes.";
 	struct uc2_dict dict;
-	assert(uc2_dict_create(&dict, data, sizeof data) == 0);
+	{ int _r = uc2_dict_create(&dict, data, sizeof data); (void)_r; assert(_r == 0); }
 	assert(dict.size == sizeof data);
 	assert(dict.id != 0);
 	assert(dict.checksum != 0);
@@ -27,7 +27,7 @@ static void test_id_deterministic(void)
 	struct uc2_dict d1, d2;
 	uc2_dict_create(&d1, data, sizeof data);
 	uc2_dict_create(&d2, data, sizeof data);
-	assert(uc2_dict_id(&d1) == uc2_dict_id(&d2));
+	{ int _r = uc2_dict_id(&d1); (void)_r; assert(_r == uc2_dict_id(&d2)); }
 	assert(uc2_dict_match(&d1, &d2));
 	uc2_dict_free(&d1);
 	uc2_dict_free(&d2);
@@ -60,11 +60,11 @@ static void test_serialize_roundtrip(void)
 	assert(buf != NULL);
 
 	struct uc2_dict restored;
-	assert(uc2_dict_deserialize(&restored, buf, len) == 0);
+	{ int _r = uc2_dict_deserialize(&restored, buf, len); (void)_r; assert(_r == 0); }
 	assert(restored.id == orig.id);
 	assert(restored.checksum == orig.checksum);
 	assert(restored.size == orig.size);
-	assert(memcmp(restored.data, orig.data, orig.size) == 0);
+	{ int _r = memcmp(restored.data, orig.data, orig.size); (void)_r; assert(_r == 0); }
 	assert(uc2_dict_verify(&restored));
 
 	free(buf);
@@ -90,7 +90,7 @@ static void test_deserialize_bad_magic(void)
 {
 	uint8_t bad[] = "NOT_UC2D_HEADER_WITH_ENOUGH_BYTES";
 	struct uc2_dict dict;
-	assert(uc2_dict_deserialize(&dict, bad, sizeof bad) == -1);
+	{ int _r = uc2_dict_deserialize(&dict, bad, sizeof bad); (void)_r; assert(_r == -1); }
 }
 
 int main(void)
diff --git a/tests/src/test_lz4.c b/tests/src/test_lz4.c
index aa47a1f..9e3b70f 100644
--- a/tests/src/test_lz4.c
+++ b/tests/src/test_lz4.c
@@ -23,7 +23,7 @@ static void test_roundtrip_text(void)
 	uint8_t *dec = malloc(len);
 	size_t dlen = uc2_lz4_decompress(comp, clen, dec, len);
 	assert(dlen == len);
-	assert(memcmp(dec, text, len) == 0);
+	{ int _r = memcmp(dec, text, len); (void)_r; assert(_r == 0); }
 	free(comp); free(dec);
 }
 
@@ -47,7 +47,7 @@ static void test_roundtrip_binary(void)
 	uint8_t *dec = malloc(len);
 	size_t dlen = uc2_lz4_decompress(comp, clen, dec, len);
 	assert(dlen == len);
-	assert(memcmp(dec, data, len) == 0);
+	{ int _r = memcmp(dec, data, len); (void)_r; assert(_r == 0); }
 	free(data); free(comp); free(dec);
 }
 
@@ -67,7 +67,7 @@ static void test_all_same(void)
 	uint8_t *dec = malloc(len);
 	size_t dlen = uc2_lz4_decompress(comp, clen, dec, len);
 	assert(dlen == len);
-	assert(memcmp(dec, data, len) == 0);
+	{ int _r = memcmp(dec, data, len); (void)_r; assert(_r == 0); }
 	free(data); free(comp); free(dec);
 }
 
@@ -90,7 +90,7 @@ static void test_incompressible(void)
 	uint8_t *dec = malloc(len);
 	size_t dlen = uc2_lz4_decompress(comp, clen, dec, len);
 	assert(dlen == len);
-	assert(memcmp(dec, data, len) == 0);
+	{ int _r = memcmp(dec, data, len); (void)_r; assert(_r == 0); }
 	free(data); free(comp); free(dec);
 }
 
@@ -105,7 +105,7 @@ static void test_small(void)
 	uint8_t dec[3];
 	size_t dlen = uc2_lz4_decompress(comp, clen, dec, 3);
 	assert(dlen == 3);
-	assert(memcmp(dec, data, 3) == 0);
+	{ int _r = memcmp(dec, data, 3); (void)_r; assert(_r == 0); }
 	free(comp);
 }
 
diff --git a/tests/src/test_merkle.c b/tests/src/test_merkle.c
index 982078c..9cee458 100644
--- a/tests/src/test_merkle.c
+++ b/tests/src/test_merkle.c
@@ -32,7 +32,7 @@ static void test_build_empty(void)
 	struct uc2_merkle tree;
 	uc2_merkle_build(&tree, NULL, 0, 13);
 	assert(tree.nchunks == 0);
-	assert(uc2_merkle_root(&tree) == 0);
+	{ int _r = uc2_merkle_root(&tree); (void)_r; assert(_r == 0); }
 	uc2_merkle_free(&tree);
 }
 
@@ -58,9 +58,9 @@ static void test_identical_files(void)
 	uc2_merkle_build(&t1, data, len, 13);
 	uc2_merkle_build(&t2, data, len, 13);
 
-	assert(uc2_merkle_root(&t1) == uc2_merkle_root(&t2));
+	{ int _r = uc2_merkle_root(&t1); (void)_r; assert(_r == uc2_merkle_root(&t2)); }
 	assert(t1.nchunks == t2.nchunks);
-	assert(uc2_merkle_common(&t1, &t2) == t1.nchunks);
+	{ int _r = uc2_merkle_common(&t1, &t2); (void)_r; assert(_r == t1.nchunks); }
 	assert(fabs(uc2_merkle_similarity(&t1, &t2) - 1.0) < 0.001);
 
 	uc2_merkle_free(&t1);
diff --git a/tests/src/test_preprocess.c b/tests/src/test_preprocess.c
index 4af8619..8d592ec 100644
--- a/tests/src/test_preprocess.c
+++ b/tests/src/test_preprocess.c
@@ -29,7 +29,7 @@ static void test_bcj_roundtrip(void)
 	assert(memcmp(code, orig, sizeof code) != 0);
 
 	uc2_bcj_revert(code, sizeof code);
-	assert(memcmp(code, orig, sizeof code) == 0);
+	{ int _r = memcmp(code, orig, sizeof code); (void)_r; assert(_r == 0); }
 }
 
 static void test_bcj_normalizes(void)
@@ -72,14 +72,14 @@ static void test_bwt_roundtrip(void)
 	size_t len = 6;
 	uint8_t *bwt;
 	uint32_t pidx;
-	assert(uc2_bwt_apply(data, len, &bwt, &pidx) == 0);
+	{ int _r = uc2_bwt_apply(data, len, &bwt, &pidx); (void)_r; assert(_r == 0); }
 
 	/* BWT of "banana" is well-known: "nnbaaa" with primary index at 3 */
 	printf("(bwt='%.*s' idx=%u) ", (int)len, bwt, pidx);
 
 	uint8_t *orig;
-	assert(uc2_bwt_revert(bwt, len, pidx, &orig) == 0);
-	assert(memcmp(orig, data, len) == 0);
+	{ int _r = uc2_bwt_revert(bwt, len, pidx, &orig); (void)_r; assert(_r == 0); }
+	{ int _r = memcmp(orig, data, len); (void)_r; assert(_r == 0); }
 
 	free(bwt);
 	free(orig);
@@ -93,11 +93,11 @@ static void test_bwt_roundtrip_binary(void)
 
 	uint8_t *bwt;
 	uint32_t pidx;
-	assert(uc2_bwt_apply(data, len, &bwt, &pidx) == 0);
+	{ int _r = uc2_bwt_apply(data, len, &bwt, &pidx); (void)_r; assert(_r == 0); }
 
 	uint8_t *orig;
-	assert(uc2_bwt_revert(bwt, len, pidx, &orig) == 0);
-	assert(memcmp(orig, data, len) == 0);
+	{ int _r = uc2_bwt_revert(bwt, len, pidx, &orig); (void)_r; assert(_r == 0); }
+	{ int _r = memcmp(orig, data, len); (void)_r; assert(_r == 0); }
 
 	free(data);
 	free(bwt);
@@ -118,7 +118,7 @@ static void test_delta_roundtrip(void)
 		assert(data[i] == 2);
 
 	uc2_delta_filter_revert(data, sizeof data, 1);
-	assert(memcmp(data, orig, sizeof data) == 0);
+	{ int _r = memcmp(data, orig, sizeof data); (void)_r; assert(_r == 0); }
 }
 
 static void test_delta_stride2(void)
@@ -134,7 +134,7 @@ static void test_delta_stride2(void)
 	assert(data[4] == 2 && data[5] == 2);
 
 	uc2_delta_filter_revert(data, sizeof data, 2);
-	assert(memcmp(data, orig, sizeof data) == 0);
+	{ int _r = memcmp(data, orig, sizeof data); (void)_r; assert(_r == 0); }
 }
 
 /* --- Content detection tests --- */
@@ -143,26 +143,26 @@ static void test_detect_text(void)
 {
 	uint8_t data[] = "This is plain text content with newlines\n"
 	                 "and more text on the second line.\n";
-	assert(uc2_detect_content(data, sizeof data - 1) == UC2_CONTENT_TEXT);
+	{ int _r = uc2_detect_content(data, sizeof data - 1); (void)_r; assert(_r == UC2_CONTENT_TEXT); }
 }
 
 static void test_detect_x86_mz(void)
 {
 	uint8_t data[] = {'M', 'Z', 0x90, 0x00};
-	assert(uc2_detect_content(data, sizeof data) == UC2_CONTENT_X86);
+	{ int _r = uc2_detect_content(data, sizeof data); (void)_r; assert(_r == UC2_CONTENT_X86); }
 }
 
 static void test_detect_x86_elf(void)
 {
 	uint8_t data[] = {0x7F, 'E', 'L', 'F', 0x02};
-	assert(uc2_detect_content(data, sizeof data) == UC2_CONTENT_X86);
+	{ int _r = uc2_detect_content(data, sizeof data); (void)_r; assert(_r == UC2_CONTENT_X86); }
 }
 
 static void test_detect_binary(void)
 {
 	uint8_t data[64];
 	for (int i = 0; i < 64; i++) data[i] = (uint8_t)(i * 7);
-	assert(uc2_detect_content(data, sizeof data) == UC2_CONTENT_BINARY);
+	{ int _r = uc2_detect_content(data, sizeof data); (void)_r; assert(_r == UC2_CONTENT_BINARY); }
 }
 
 int main(void)
diff --git a/tests/src/test_rans.c b/tests/src/test_rans.c
index e4a4543..9660f1e 100644
--- a/tests/src/test_rans.c
+++ b/tests/src/test_rans.c
@@ -96,7 +96,7 @@ static void test_roundtrip_skewed(void)
 	struct uc2_rans_dec dec;
 	uc2_rans_dec_init(&dec, &tab, data, len);
 	for (int i = 0; i < 200; i++)
-		assert(uc2_rans_decode(&dec) == syms[i]);
+		{ int _r = uc2_rans_decode(&dec); (void)_r; assert(_r == syms[i]); }
 
 	free(data);
 }
@@ -134,7 +134,7 @@ static void test_roundtrip_large_alphabet(void)
 	struct uc2_rans_dec dec;
 	uc2_rans_dec_init(&dec, &tab, data, len);
 	for (int i = 0; i < nsyms; i++)
-		assert(uc2_rans_decode(&dec) == syms[i]);
+		{ int _r = uc2_rans_decode(&dec); (void)_r; assert(_r == syms[i]); }
 
 	free(syms);
 	free(data);
@@ -161,7 +161,7 @@ static void test_single_symbol(void)
 	struct uc2_rans_dec dec;
 	uc2_rans_dec_init(&dec, &tab, data, len);
 	for (int i = 0; i < 100; i++)
-		assert(uc2_rans_decode(&dec) == 0);
+		{ int _r = uc2_rans_decode(&dec); (void)_r; assert(_r == 0); }
 
 	free(data);
 }
@@ -206,7 +206,7 @@ static void test_vs_huffman_size(void)
 	struct uc2_rans_dec dec;
 	uc2_rans_dec_init(&dec, &tab, data, len);
 	for (int i = 0; i < nsyms; i++)
-		assert(uc2_rans_decode(&dec) == syms[i]);
+		{ int _r = uc2_rans_decode(&dec); (void)_r; assert(_r == syms[i]); }
 
 	free(syms);
 	free(data);
diff --git a/tests/src/test_simhash.c b/tests/src/test_simhash.c
index 11cc012..25b8261 100644
--- a/tests/src/test_simhash.c
+++ b/tests/src/test_simhash.c
@@ -15,7 +15,7 @@ static void test_identical(void)
 	uint64_t h1 = uc2_simhash(data, sizeof data - 1);
 	uint64_t h2 = uc2_simhash(data, sizeof data - 1);
 	assert(h1 == h2);
-	assert(uc2_hamming(h1, h2) == 0);
+	{ int _r = uc2_hamming(h1, h2); (void)_r; assert(_r == 0); }
 }
 
 static void test_similar(void)
@@ -70,10 +70,10 @@ static void test_patched_binary(void)
 
 static void test_hamming(void)
 {
-	assert(uc2_hamming(0, 0) == 0);
-	assert(uc2_hamming(0, 1) == 1);
-	assert(uc2_hamming(0xFF, 0x00) == 8);
-	assert(uc2_hamming(0xFFFFFFFFFFFFFFFFULL, 0) == 64);
+	{ int _r = uc2_hamming(0, 0); (void)_r; assert(_r == 0); }
+	{ int _r = uc2_hamming(0, 1); (void)_r; assert(_r == 1); }
+	{ int _r = uc2_hamming(0xFF, 0x00); (void)_r; assert(_r == 8); }
+	{ int _r = uc2_hamming(0xFFFFFFFFFFFFFFFFULL, 0); (void)_r; assert(_r == 64); }
 }
 
 static void test_short_input(void)