evv/uc2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix assert side effects with NDEBUG (Release mode CI fix)

Browse Source
This commit is contained in:
Eremey Valetov
2026-03-30 17:26:18 -04:00
parent 157a517006
commit 97e05ad81a
8 changed files with 46 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/src/test_blockstore.c
View File

@@ -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);

18
tests/src/test_delta.c
View File

@@ -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);

10
tests/src/test_dict.c
View File

@@ -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)

10
tests/src/test_lz4.c
View File

@@ -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);
}

6
tests/src/test_merkle.c
View File

@@ -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);

26
tests/src/test_preprocess.c
View File

@@ -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)

8
tests/src/test_rans.c
View File

@@ -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);

10
tests/src/test_simhash.c
View File

@@ -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)