ztest: remove the obsolete NULL appended to zassert macros
This commit removes the usage of NULL parameter as message in zassert_* macros after making it optional Signed-off-by: Michał Barnaś <mb@semihalf.com>
This commit is contained in:
Michał Barnaś
Anas Nashif
parent
36f74e9837
commit
dae8efa692
201 changed files with 2846 additions and 2846 deletions
|
|
@ -225,7 +225,7 @@ static int rawprf(const char *format, ...)
|
|||
|
||||
if (IS_ENABLED(CONFIG_CBPRINTF_NANO)
|
||||
&& !IS_ENABLED(CONFIG_CBPRINTF_LIBC_SUBSTS)) {
|
||||
zassert_equal(rv, 0, NULL);
|
||||
zassert_equal(rv, 0);
|
||||
rv = outbuf.idx;
|
||||
}
|
||||
return rv;
|
||||
|
|
@ -248,11 +248,11 @@ static int rawprf(const char *format, ...)
|
|||
CBPRINTF_STATIC_PACKAGE(&package[PKG_ALIGN_OFFSET], _len - 1, \
|
||||
st_pkg_rv, PKG_ALIGN_OFFSET, \
|
||||
PACKAGE_FLAGS, _fmt, __VA_ARGS__); \
|
||||
zassert_equal(st_pkg_rv, -ENOSPC, NULL); \
|
||||
zassert_equal(st_pkg_rv, -ENOSPC); \
|
||||
CBPRINTF_STATIC_PACKAGE(&package[PKG_ALIGN_OFFSET], _len, \
|
||||
st_pkg_rv, PKG_ALIGN_OFFSET, \
|
||||
PACKAGE_FLAGS, _fmt, __VA_ARGS__); \
|
||||
zassert_equal(st_pkg_rv, _len, NULL); \
|
||||
zassert_equal(st_pkg_rv, _len); \
|
||||
rv = cbpprintf(out, &package_buf, &package[PKG_ALIGN_OFFSET]); \
|
||||
if (rv >= 0) { \
|
||||
sp_buf = _buf; \
|
||||
|
|
@ -379,15 +379,15 @@ ZTEST(prf, test_c)
|
|||
size_t spaces = 255;
|
||||
|
||||
zassert_equal(rc, 258, "len %d", rc);
|
||||
zassert_equal(*bp, '/', NULL);
|
||||
zassert_equal(*bp, '/');
|
||||
++bp;
|
||||
while (spaces-- > 0) {
|
||||
zassert_equal(*bp, ' ', NULL);
|
||||
zassert_equal(*bp, ' ');
|
||||
++bp;
|
||||
}
|
||||
zassert_equal(*bp, 'a', NULL);
|
||||
zassert_equal(*bp, 'a');
|
||||
++bp;
|
||||
zassert_equal(*bp, '/', NULL);
|
||||
zassert_equal(*bp, '/');
|
||||
|
||||
if (IS_ENABLED(CONFIG_CBPRINTF_NANO)) {
|
||||
TC_PRINT("short test for nano\n");
|
||||
|
|
@ -437,8 +437,8 @@ ZTEST(prf, test_v_c)
|
|||
reset_out();
|
||||
buf[1] = 'b';
|
||||
rc = rawprf("%c", 'a');
|
||||
zassert_equal(rc, 1, NULL);
|
||||
zassert_equal(buf[0], 'a', NULL);
|
||||
zassert_equal(rc, 1);
|
||||
zassert_equal(buf[0], 'a');
|
||||
if (!ENABLED_USE_LIBC) {
|
||||
zassert_equal(buf[1], 'b', "wth %x", buf[1]);
|
||||
}
|
||||
|
|
@ -524,7 +524,7 @@ ZTEST(prf, test_d_length)
|
|||
reset_out();
|
||||
rc = rawprf("/%Ld/", max);
|
||||
zassert_equal(rc, 5, "len %d", rc);
|
||||
zassert_equal(strncmp("/%Ld/", buf, rc), 0, NULL);
|
||||
zassert_equal(strncmp("/%Ld/", buf, rc), 0);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_d_flags)
|
||||
|
|
@ -663,7 +663,7 @@ ZTEST(prf, test_x_flags)
|
|||
reset_out();
|
||||
rc = rawprf("/%+x/% x/", sv, sv);
|
||||
zassert_equal(rc, 9, "rc %d", rc);
|
||||
zassert_equal(strncmp("/123/123/", buf, rc), 0, NULL);
|
||||
zassert_equal(strncmp("/123/123/", buf, rc), 0);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_o)
|
||||
|
|
@ -913,7 +913,7 @@ ZTEST(prf, test_fp_length)
|
|||
reset_out();
|
||||
rc = rawprf("/%hf/", dv);
|
||||
zassert_equal(rc, 5, "len %d", rc);
|
||||
zassert_equal(strncmp("/%hf/", buf, rc), 0, NULL);
|
||||
zassert_equal(strncmp("/%hf/", buf, rc), 0);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_fp_flags)
|
||||
|
|
@ -944,9 +944,9 @@ ZTEST(prf, test_fp_flags)
|
|||
PRF_CHECK("/23/23.0000/23/23./", rc);
|
||||
|
||||
rc = prf(NULL, "% .380f", 0x1p-400);
|
||||
zassert_equal(rc, 383, NULL);
|
||||
zassert_equal(strncmp(buf, " 0.000", 6), 0, NULL);
|
||||
zassert_equal(strncmp(&buf[119], "00003872", 8), 0, NULL);
|
||||
zassert_equal(rc, 383);
|
||||
zassert_equal(strncmp(buf, " 0.000", 6), 0);
|
||||
zassert_equal(strncmp(&buf[119], "00003872", 8), 0);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_star_width)
|
||||
|
|
@ -1012,29 +1012,29 @@ ZTEST(prf, test_n)
|
|||
|
||||
rc = prf(NULL, "12345%n", &l);
|
||||
zassert_equal(l, rc, "%d != %d", l, rc);
|
||||
zassert_equal(rc, 5, NULL);
|
||||
zassert_equal(rc, 5);
|
||||
|
||||
|
||||
rc = prf(NULL, "12345%hn", &l_h);
|
||||
zassert_equal(l_h, rc, NULL);
|
||||
zassert_equal(l_h, rc);
|
||||
|
||||
rc = prf(NULL, "12345%hhn", &l_hh);
|
||||
zassert_equal(l_hh, rc, NULL);
|
||||
zassert_equal(l_hh, rc);
|
||||
|
||||
rc = prf(NULL, "12345%ln", &l_l);
|
||||
zassert_equal(l_l, rc, NULL);
|
||||
zassert_equal(l_l, rc);
|
||||
|
||||
rc = prf(NULL, "12345%lln", &l_ll);
|
||||
zassert_equal(l_ll, rc, NULL);
|
||||
zassert_equal(l_ll, rc);
|
||||
|
||||
rc = prf(NULL, "12345%jn", &l_j);
|
||||
zassert_equal(l_j, rc, NULL);
|
||||
zassert_equal(l_j, rc);
|
||||
|
||||
rc = prf(NULL, "12345%zn", &l_z);
|
||||
zassert_equal(l_z, rc, NULL);
|
||||
zassert_equal(l_z, rc);
|
||||
|
||||
rc = prf(NULL, "12345%tn", &l_t);
|
||||
zassert_equal(l_t, rc, NULL);
|
||||
zassert_equal(l_t, rc);
|
||||
}
|
||||
|
||||
#define EXPECTED_1ARG(_t) (IS_ENABLED(CONFIG_CBPRINTF_NANO) \
|
||||
|
|
@ -1058,28 +1058,28 @@ ZTEST(prf, test_p)
|
|||
|
||||
reset_out();
|
||||
rc = rawprf("/%12p/", ptr);
|
||||
zassert_equal(rc, 14, NULL);
|
||||
zassert_equal(strncmp("/ 0xcafe21/", buf, rc), 0, NULL);
|
||||
zassert_equal(rc, 14);
|
||||
zassert_equal(strncmp("/ 0xcafe21/", buf, rc), 0);
|
||||
|
||||
reset_out();
|
||||
rc = rawprf("/%12p/", NULL);
|
||||
zassert_equal(rc, 14, NULL);
|
||||
zassert_equal(strncmp("/ (nil)/", buf, rc), 0, NULL);
|
||||
zassert_equal(rc, 14);
|
||||
zassert_equal(strncmp("/ (nil)/", buf, rc), 0);
|
||||
|
||||
reset_out();
|
||||
rc = rawprf("/%-12p/", ptr);
|
||||
zassert_equal(rc, 14, NULL);
|
||||
zassert_equal(strncmp("/0xcafe21 /", buf, rc), 0, NULL);
|
||||
zassert_equal(rc, 14);
|
||||
zassert_equal(strncmp("/0xcafe21 /", buf, rc), 0);
|
||||
|
||||
reset_out();
|
||||
rc = rawprf("/%-12p/", NULL);
|
||||
zassert_equal(rc, 14, NULL);
|
||||
zassert_equal(strncmp("/(nil) /", buf, rc), 0, NULL);
|
||||
zassert_equal(rc, 14);
|
||||
zassert_equal(strncmp("/(nil) /", buf, rc), 0);
|
||||
|
||||
reset_out();
|
||||
rc = rawprf("/%.8p/", ptr);
|
||||
zassert_equal(rc, 12, NULL);
|
||||
zassert_equal(strncmp("/0x00cafe21/", buf, rc), 0, NULL);
|
||||
zassert_equal(rc, 12);
|
||||
zassert_equal(strncmp("/0x00cafe21/", buf, rc), 0);
|
||||
}
|
||||
|
||||
static int out_counter(int c,
|
||||
|
|
@ -1113,23 +1113,23 @@ ZTEST(prf, test_libc_substs)
|
|||
lbuf[len] = full_flag;
|
||||
|
||||
rc = snprintfcb(lbuf, len, "%06d", 1);
|
||||
zassert_equal(rc, 6, NULL);
|
||||
zassert_equal(strncmp("000001", lbuf, rc), 0, NULL);
|
||||
zassert_equal(lbuf[7], full_flag, NULL);
|
||||
zassert_equal(rc, 6);
|
||||
zassert_equal(strncmp("000001", lbuf, rc), 0);
|
||||
zassert_equal(lbuf[7], full_flag);
|
||||
|
||||
rc = snprintfcb(lbuf, len, "%07d", 1);
|
||||
zassert_equal(rc, 7, NULL);
|
||||
zassert_equal(strncmp("000000", lbuf, rc), 0, NULL);
|
||||
zassert_equal(lbuf[7], full_flag, NULL);
|
||||
zassert_equal(rc, 7);
|
||||
zassert_equal(strncmp("000000", lbuf, rc), 0);
|
||||
zassert_equal(lbuf[7], full_flag);
|
||||
|
||||
rc = snprintfcb(lbuf, len, "%020d", 1);
|
||||
zassert_equal(rc, 20, "rc %d", rc);
|
||||
zassert_equal(lbuf[7], full_flag, NULL);
|
||||
zassert_equal(strncmp("000000", lbuf, rc), 0, NULL);
|
||||
zassert_equal(lbuf[7], full_flag);
|
||||
zassert_equal(strncmp("000000", lbuf, rc), 0);
|
||||
|
||||
rc = cbprintf(out_counter, &count, "%020d", 1);
|
||||
zassert_equal(rc, 20, "rc %d", rc);
|
||||
zassert_equal(count, 20, NULL);
|
||||
zassert_equal(count, 20);
|
||||
|
||||
if (!IS_ENABLED(CONFIG_CBPRINTF_NANO)) {
|
||||
rc = cbprintf(out_e42, NULL, "%020d", 1);
|
||||
|
|
@ -1149,7 +1149,7 @@ ZTEST(prf, test_cbprintf_package)
|
|||
|
||||
/* Verify we can calculate length without storing */
|
||||
rc = cbprintf_package(NULL, PKG_ALIGN_OFFSET, PACKAGE_FLAGS, fmt, 3);
|
||||
zassert_true(rc > sizeof(int), NULL);
|
||||
zassert_true(rc > sizeof(int));
|
||||
|
||||
/* Capture the base package information for future tests. */
|
||||
size_t len = rc;
|
||||
|
|
@ -1160,12 +1160,12 @@ ZTEST(prf, test_cbprintf_package)
|
|||
* unaligned. Same alignment offset was used for space calculation.
|
||||
*/
|
||||
rc = cbprintf_package(&buf[PKG_ALIGN_OFFSET], len, PACKAGE_FLAGS, fmt, 3);
|
||||
zassert_equal(rc, len, NULL);
|
||||
zassert_equal(rc, len);
|
||||
|
||||
/* Verify we get an error if can't store */
|
||||
len -= 1;
|
||||
rc = cbprintf_package(&buf[PKG_ALIGN_OFFSET], len, PACKAGE_FLAGS, fmt, 3);
|
||||
zassert_equal(rc, -ENOSPC, NULL);
|
||||
zassert_equal(rc, -ENOSPC);
|
||||
}
|
||||
|
||||
/* Test using @ref CBPRINTF_PACKAGE_ADD_STRING_IDXS flag.
|
||||
|
|
@ -1198,7 +1198,7 @@ ZTEST(prf, test_cbprintf_package_rw_string_indexes)
|
|||
/* package with string indexes will contain two more bytes holding indexes
|
||||
* of string parameter locations.
|
||||
*/
|
||||
zassert_equal(len0 + 2, len1, NULL);
|
||||
zassert_equal(len0 + 2, len1);
|
||||
|
||||
uint8_t __aligned(CBPRINTF_PACKAGE_ALIGNMENT) package0[len0];
|
||||
uint8_t __aligned(CBPRINTF_PACKAGE_ALIGNMENT) package1[len1];
|
||||
|
|
@ -1214,19 +1214,19 @@ ZTEST(prf, test_cbprintf_package_rw_string_indexes)
|
|||
union cbprintf_package_hdr *desc1 = (union cbprintf_package_hdr *)package1;
|
||||
|
||||
/* Compare descriptor content. Second package has one ro string index. */
|
||||
zassert_equal(desc0->desc.ro_str_cnt, 0, NULL);
|
||||
zassert_equal(desc1->desc.ro_str_cnt, 2, NULL);
|
||||
zassert_equal(len0 + 2, len1, NULL);
|
||||
zassert_equal(desc0->desc.ro_str_cnt, 0);
|
||||
zassert_equal(desc1->desc.ro_str_cnt, 2);
|
||||
zassert_equal(len0 + 2, len1);
|
||||
|
||||
int *p = (int *)package1;
|
||||
|
||||
str_idx = package1[len0];
|
||||
addr = *(char **)&p[str_idx];
|
||||
zassert_equal(addr, test_str, NULL);
|
||||
zassert_equal(addr, test_str);
|
||||
|
||||
str_idx = package1[len0 + 1];
|
||||
addr = *(char **)&p[str_idx];
|
||||
zassert_equal(addr, test_str1, NULL);
|
||||
zassert_equal(addr, test_str1);
|
||||
}
|
||||
|
||||
static int fsc_package_cb(int c, void *ctx)
|
||||
|
|
@ -1268,7 +1268,7 @@ ZTEST(prf, test_cbprintf_fsc_package)
|
|||
CBPRINTF_PACKAGE_ADD_STRING_IDXS,
|
||||
test_str, 100, test_str1);
|
||||
|
||||
zassert_true(len > 0, NULL);
|
||||
zassert_true(len > 0);
|
||||
uint8_t __aligned(CBPRINTF_PACKAGE_ALIGNMENT) package[len];
|
||||
|
||||
CBPRINTF_STATIC_PACKAGE(package, sizeof(package), len, 0,
|
||||
|
|
@ -1280,15 +1280,15 @@ ZTEST(prf, test_cbprintf_fsc_package)
|
|||
|
||||
int exp_len = len + (int)strlen(test_str) + 1 + (int)strlen(test_str1) + 1;
|
||||
|
||||
zassert_equal(exp_len, fsc_len, NULL);
|
||||
zassert_equal(exp_len, fsc_len);
|
||||
|
||||
uint8_t __aligned(CBPRINTF_PACKAGE_ALIGNMENT) fsc_package[fsc_len];
|
||||
|
||||
err = cbprintf_fsc_package(package, len, fsc_package, fsc_len - 1);
|
||||
zassert_equal(err, -ENOSPC, NULL);
|
||||
zassert_equal(err, -ENOSPC);
|
||||
|
||||
err = cbprintf_fsc_package(package, len, fsc_package, fsc_len);
|
||||
zassert_equal(err, fsc_len, NULL);
|
||||
zassert_equal(err, fsc_len);
|
||||
|
||||
/* Now overwrite a char in original string, confirm that fsc package
|
||||
* contains string without that change because ro string is copied into
|
||||
|
|
@ -1301,14 +1301,14 @@ ZTEST(prf, test_cbprintf_fsc_package)
|
|||
cbpprintf(fsc_package_cb, &pout, package);
|
||||
*pout = '\0';
|
||||
|
||||
zassert_equal(strcmp(out_str, exp_str1), 0, NULL);
|
||||
zassert_true(strcmp(exp_str0, exp_str1) != 0, NULL);
|
||||
zassert_equal(strcmp(out_str, exp_str1), 0);
|
||||
zassert_true(strcmp(exp_str0, exp_str1) != 0);
|
||||
|
||||
/* FSC package contains original content. */
|
||||
pout = out_str;
|
||||
cbpprintf(fsc_package_cb, &pout, fsc_package);
|
||||
*pout = '\0';
|
||||
zassert_equal(strcmp(out_str, exp_str0), 0, NULL);
|
||||
zassert_equal(strcmp(out_str, exp_str0), 0);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_cbpprintf)
|
||||
|
|
@ -1326,7 +1326,7 @@ ZTEST(prf, test_cbpprintf)
|
|||
*/
|
||||
reset_out();
|
||||
rc = cbpprintf(out, &outbuf, NULL);
|
||||
zassert_equal(rc, -EINVAL, NULL);
|
||||
zassert_equal(rc, -EINVAL);
|
||||
}
|
||||
|
||||
ZTEST(prf, test_nop)
|
||||
|
|
|
|||
|
|
@ -45,9 +45,9 @@ ZTEST(crc, test_crc32_ieee)
|
|||
uint8_t test2[] = { '1', '2', '3', '4', '5', '6', '7', '8', '9' };
|
||||
uint8_t test3[] = { 'Z', 'e', 'p', 'h', 'y', 'r' };
|
||||
|
||||
zassert_equal(crc32_ieee(test1, sizeof(test1)), 0xD3D99E8B, NULL);
|
||||
zassert_equal(crc32_ieee(test2, sizeof(test2)), 0xCBF43926, NULL);
|
||||
zassert_equal(crc32_ieee(test3, sizeof(test3)), 0x20089AA4, NULL);
|
||||
zassert_equal(crc32_ieee(test1, sizeof(test1)), 0xD3D99E8B);
|
||||
zassert_equal(crc32_ieee(test2, sizeof(test2)), 0xCBF43926);
|
||||
zassert_equal(crc32_ieee(test3, sizeof(test3)), 0x20089AA4);
|
||||
}
|
||||
|
||||
ZTEST(crc, test_crc16)
|
||||
|
|
@ -59,13 +59,13 @@ ZTEST(crc, test_crc16)
|
|||
* check=0x2189
|
||||
* poly is 0x1021, reflected 0x8408
|
||||
*/
|
||||
zassert_equal(crc16_reflect(0x8408, 0x0, test, sizeof(test)), 0x2189, NULL);
|
||||
zassert_equal(crc16_reflect(0x8408, 0x0, test, sizeof(test)), 0x2189);
|
||||
|
||||
/* CRC-16/DECT-X
|
||||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-dect-x
|
||||
* check=0x007f
|
||||
*/
|
||||
zassert_equal(crc16(0x0589, 0x0, test, sizeof(test)), 0x007f, NULL);
|
||||
zassert_equal(crc16(0x0589, 0x0, test, sizeof(test)), 0x007f);
|
||||
}
|
||||
|
||||
ZTEST(crc, test_crc16_ansi)
|
||||
|
|
@ -79,8 +79,8 @@ ZTEST(crc, test_crc16_ansi)
|
|||
* check=0x4b37
|
||||
* poly is 0x1021, reflected 0xA001
|
||||
*/
|
||||
zassert_equal(crc16_c, 0x4b37, NULL);
|
||||
zassert_equal(crc16_reflect(0xA001, 0xffff, test, sizeof(test)), crc16_c, NULL);
|
||||
zassert_equal(crc16_c, 0x4b37);
|
||||
zassert_equal(crc16_reflect(0xA001, 0xffff, test, sizeof(test)), crc16_c);
|
||||
}
|
||||
|
||||
ZTEST(crc, test_crc16_ccitt)
|
||||
|
|
@ -91,13 +91,13 @@ ZTEST(crc, test_crc16_ccitt)
|
|||
uint8_t test3[] = { 'Z', 'e', 'p', 'h', 'y', 'r', 0, 0 };
|
||||
uint16_t crc;
|
||||
|
||||
zassert_equal(crc16_ccitt(0, test0, sizeof(test0)), 0x0, NULL);
|
||||
zassert_equal(crc16_ccitt(0, test1, sizeof(test1)), 0x538d, NULL);
|
||||
zassert_equal(crc16_ccitt(0, test0, sizeof(test0)), 0x0);
|
||||
zassert_equal(crc16_ccitt(0, test1, sizeof(test1)), 0x538d);
|
||||
/* CRC-16/CCITT, CRC-16/CCITT-TRUE, CRC-16/KERMIT
|
||||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-kermit
|
||||
* check=0x2189
|
||||
*/
|
||||
zassert_equal(crc16_ccitt(0, test2, sizeof(test2)), 0x2189, NULL);
|
||||
zassert_equal(crc16_ccitt(0, test2, sizeof(test2)), 0x2189);
|
||||
/* CRC-16/X-25, CRC-16/IBM-SDLC, CRC-16/ISO-HDLC
|
||||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-ibm-sdlc
|
||||
* check=0x906e
|
||||
|
|
@ -112,7 +112,7 @@ ZTEST(crc, test_crc16_ccitt)
|
|||
test3[sizeof(test3)-2] = (uint8_t)(crc >> 0);
|
||||
test3[sizeof(test3)-1] = (uint8_t)(crc >> 8);
|
||||
|
||||
zassert_equal(crc16_ccitt(0, test3, sizeof(test3)), 0, NULL);
|
||||
zassert_equal(crc16_ccitt(0, test3, sizeof(test3)), 0);
|
||||
}
|
||||
|
||||
ZTEST(crc, test_crc16_ccitt_for_ppp)
|
||||
|
|
@ -142,17 +142,17 @@ ZTEST(crc, test_crc16_itu_t)
|
|||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-xmodem
|
||||
* check=0x31c3
|
||||
*/
|
||||
zassert_equal(crc16_itu_t(0, test2, sizeof(test2)), 0x31c3, NULL);
|
||||
zassert_equal(crc16_itu_t(0, test2, sizeof(test2)), 0x31c3);
|
||||
/* CRC16/CCITT-FALSE, CRC-16/IBM-3740, CRC-16/AUTOSAR
|
||||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-ibm-3740
|
||||
* check=0x29b1
|
||||
*/
|
||||
zassert_equal(crc16_itu_t(0xffff, test2, sizeof(test2)), 0x29b1, NULL);
|
||||
zassert_equal(crc16_itu_t(0xffff, test2, sizeof(test2)), 0x29b1);
|
||||
/* CRC-16/GSM
|
||||
* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-gsm
|
||||
* check=0xce3c
|
||||
*/
|
||||
zassert_equal(crc16_itu_t(0, test2, sizeof(test2)) ^ 0xffff, 0xce3c, NULL);
|
||||
zassert_equal(crc16_itu_t(0, test2, sizeof(test2)) ^ 0xffff, 0xce3c);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -176,9 +176,9 @@ ZTEST(crc, test_crc7_be)
|
|||
uint8_t test1[] = { 'A' };
|
||||
uint8_t test2[] = { '1', '2', '3', '4', '5', '6', '7', '8', '9' };
|
||||
|
||||
zassert_equal(crc7_be(0, test0, sizeof(test0)), 0, NULL);
|
||||
zassert_equal(crc7_be(0, test1, sizeof(test1)), 0xDA, NULL);
|
||||
zassert_equal(crc7_be(0, test2, sizeof(test2)), 0xEA, NULL);
|
||||
zassert_equal(crc7_be(0, test0, sizeof(test0)), 0);
|
||||
zassert_equal(crc7_be(0, test1, sizeof(test1)), 0xDA);
|
||||
zassert_equal(crc7_be(0, test2, sizeof(test2)), 0xEA);
|
||||
}
|
||||
|
||||
ZTEST(crc, test_crc8)
|
||||
|
|
|
|||
|
|
@ -12,168 +12,168 @@ static void VNAME(u32_add)(void)
|
|||
{
|
||||
uint32_t result = 42;
|
||||
|
||||
zassert_false(u32_add_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 5, NULL);
|
||||
zassert_false(u32_add_overflow(2, 3, &result));
|
||||
zassert_equal(result, 5);
|
||||
|
||||
zassert_false(u32_add_overflow(2, 0, &result), NULL);
|
||||
zassert_equal(result, 2, NULL);
|
||||
zassert_false(u32_add_overflow(2, 0, &result));
|
||||
zassert_equal(result, 2);
|
||||
|
||||
zassert_false(u32_add_overflow(0, 3, &result), NULL);
|
||||
zassert_equal(result, 3, NULL);
|
||||
zassert_false(u32_add_overflow(0, 3, &result));
|
||||
zassert_equal(result, 3);
|
||||
|
||||
zassert_false(u32_add_overflow(0, UINT32_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX, NULL);
|
||||
zassert_true(u32_add_overflow(1, UINT32_MAX, &result), NULL);
|
||||
zassert_equal(result, 0, NULL);
|
||||
zassert_false(u32_add_overflow(0, UINT32_MAX, &result));
|
||||
zassert_equal(result, UINT32_MAX);
|
||||
zassert_true(u32_add_overflow(1, UINT32_MAX, &result));
|
||||
zassert_equal(result, 0);
|
||||
|
||||
zassert_false(u32_add_overflow(UINT32_MAX, 0, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX, NULL);
|
||||
zassert_true(u32_add_overflow(UINT32_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, 1, NULL);
|
||||
zassert_false(u32_add_overflow(UINT32_MAX, 0, &result));
|
||||
zassert_equal(result, UINT32_MAX);
|
||||
zassert_true(u32_add_overflow(UINT32_MAX, 2, &result));
|
||||
zassert_equal(result, 1);
|
||||
}
|
||||
|
||||
static void VNAME(u32_mul)(void)
|
||||
{
|
||||
uint32_t result = 42;
|
||||
|
||||
zassert_false(u32_mul_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 6, NULL);
|
||||
zassert_false(u32_mul_overflow(2, 3, &result));
|
||||
zassert_equal(result, 6);
|
||||
|
||||
zassert_false(u32_mul_overflow(UINT32_MAX, 1, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX, NULL);
|
||||
zassert_true(u32_mul_overflow(UINT32_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX * 2, NULL);
|
||||
zassert_false(u32_mul_overflow(UINT32_MAX, 1, &result));
|
||||
zassert_equal(result, UINT32_MAX);
|
||||
zassert_true(u32_mul_overflow(UINT32_MAX, 2, &result));
|
||||
zassert_equal(result, UINT32_MAX * 2);
|
||||
|
||||
zassert_false(u32_mul_overflow(1, UINT32_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX, NULL);
|
||||
zassert_true(u32_mul_overflow(2, UINT32_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT32_MAX * 2, NULL);
|
||||
zassert_false(u32_mul_overflow(1, UINT32_MAX, &result));
|
||||
zassert_equal(result, UINT32_MAX);
|
||||
zassert_true(u32_mul_overflow(2, UINT32_MAX, &result));
|
||||
zassert_equal(result, UINT32_MAX * 2);
|
||||
}
|
||||
|
||||
static void VNAME(u64_add)(void)
|
||||
{
|
||||
uint64_t result = 42;
|
||||
|
||||
zassert_false(u64_add_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 5, NULL);
|
||||
zassert_false(u64_add_overflow(2, 3, &result));
|
||||
zassert_equal(result, 5);
|
||||
|
||||
zassert_false(u64_add_overflow(2, 0, &result), NULL);
|
||||
zassert_equal(result, 2, NULL);
|
||||
zassert_false(u64_add_overflow(2, 0, &result));
|
||||
zassert_equal(result, 2);
|
||||
|
||||
zassert_false(u64_add_overflow(0, 3, &result), NULL);
|
||||
zassert_equal(result, 3, NULL);
|
||||
zassert_false(u64_add_overflow(0, 3, &result));
|
||||
zassert_equal(result, 3);
|
||||
|
||||
zassert_false(u64_add_overflow(0, UINT64_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX, NULL);
|
||||
zassert_true(u64_add_overflow(1, UINT64_MAX, &result), NULL);
|
||||
zassert_equal(result, 0, NULL);
|
||||
zassert_false(u64_add_overflow(0, UINT64_MAX, &result));
|
||||
zassert_equal(result, UINT64_MAX);
|
||||
zassert_true(u64_add_overflow(1, UINT64_MAX, &result));
|
||||
zassert_equal(result, 0);
|
||||
|
||||
zassert_false(u64_add_overflow(UINT64_MAX, 0, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX, NULL);
|
||||
zassert_true(u64_add_overflow(UINT64_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, 1, NULL);
|
||||
zassert_false(u64_add_overflow(UINT64_MAX, 0, &result));
|
||||
zassert_equal(result, UINT64_MAX);
|
||||
zassert_true(u64_add_overflow(UINT64_MAX, 2, &result));
|
||||
zassert_equal(result, 1);
|
||||
}
|
||||
|
||||
static void VNAME(u64_mul)(void)
|
||||
{
|
||||
uint64_t result = 42;
|
||||
|
||||
zassert_false(u64_mul_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 6, NULL);
|
||||
zassert_false(u64_mul_overflow(2, 3, &result));
|
||||
zassert_equal(result, 6);
|
||||
|
||||
zassert_false(u64_mul_overflow(UINT64_MAX, 1, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX, NULL);
|
||||
zassert_true(u64_mul_overflow(UINT64_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX * 2, NULL);
|
||||
zassert_false(u64_mul_overflow(UINT64_MAX, 1, &result));
|
||||
zassert_equal(result, UINT64_MAX);
|
||||
zassert_true(u64_mul_overflow(UINT64_MAX, 2, &result));
|
||||
zassert_equal(result, UINT64_MAX * 2);
|
||||
|
||||
zassert_false(u64_mul_overflow(1, UINT64_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX, NULL);
|
||||
zassert_true(u64_mul_overflow(2, UINT64_MAX, &result), NULL);
|
||||
zassert_equal(result, UINT64_MAX * 2, NULL);
|
||||
zassert_false(u64_mul_overflow(1, UINT64_MAX, &result));
|
||||
zassert_equal(result, UINT64_MAX);
|
||||
zassert_true(u64_mul_overflow(2, UINT64_MAX, &result));
|
||||
zassert_equal(result, UINT64_MAX * 2);
|
||||
}
|
||||
|
||||
static void VNAME(size_add)(void)
|
||||
{
|
||||
size_t result = 42;
|
||||
|
||||
zassert_false(size_add_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 5, NULL);
|
||||
zassert_false(size_add_overflow(2, 3, &result));
|
||||
zassert_equal(result, 5);
|
||||
|
||||
zassert_false(size_add_overflow(2, 0, &result), NULL);
|
||||
zassert_equal(result, 2, NULL);
|
||||
zassert_false(size_add_overflow(2, 0, &result));
|
||||
zassert_equal(result, 2);
|
||||
|
||||
zassert_false(size_add_overflow(0, 3, &result), NULL);
|
||||
zassert_equal(result, 3, NULL);
|
||||
zassert_false(size_add_overflow(0, 3, &result));
|
||||
zassert_equal(result, 3);
|
||||
|
||||
zassert_false(size_add_overflow(0, SIZE_MAX, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX, NULL);
|
||||
zassert_true(size_add_overflow(1, SIZE_MAX, &result), NULL);
|
||||
zassert_equal(result, 0, NULL);
|
||||
zassert_false(size_add_overflow(0, SIZE_MAX, &result));
|
||||
zassert_equal(result, SIZE_MAX);
|
||||
zassert_true(size_add_overflow(1, SIZE_MAX, &result));
|
||||
zassert_equal(result, 0);
|
||||
|
||||
zassert_false(size_add_overflow(SIZE_MAX, 0, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX, NULL);
|
||||
zassert_true(size_add_overflow(SIZE_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, 1, NULL);
|
||||
zassert_false(size_add_overflow(SIZE_MAX, 0, &result));
|
||||
zassert_equal(result, SIZE_MAX);
|
||||
zassert_true(size_add_overflow(SIZE_MAX, 2, &result));
|
||||
zassert_equal(result, 1);
|
||||
}
|
||||
|
||||
static void VNAME(size_mul)(void)
|
||||
{
|
||||
size_t result = 42;
|
||||
|
||||
zassert_false(size_mul_overflow(2, 3, &result), NULL);
|
||||
zassert_equal(result, 6, NULL);
|
||||
zassert_false(size_mul_overflow(2, 3, &result));
|
||||
zassert_equal(result, 6);
|
||||
|
||||
zassert_false(size_mul_overflow(SIZE_MAX, 1, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX, NULL);
|
||||
zassert_true(size_mul_overflow(SIZE_MAX, 2, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX * 2, NULL);
|
||||
zassert_false(size_mul_overflow(SIZE_MAX, 1, &result));
|
||||
zassert_equal(result, SIZE_MAX);
|
||||
zassert_true(size_mul_overflow(SIZE_MAX, 2, &result));
|
||||
zassert_equal(result, SIZE_MAX * 2);
|
||||
|
||||
zassert_false(size_mul_overflow(1, SIZE_MAX, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX, NULL);
|
||||
zassert_true(size_mul_overflow(2, SIZE_MAX, &result), NULL);
|
||||
zassert_equal(result, SIZE_MAX * 2, NULL);
|
||||
zassert_false(size_mul_overflow(1, SIZE_MAX, &result));
|
||||
zassert_equal(result, SIZE_MAX);
|
||||
zassert_true(size_mul_overflow(2, SIZE_MAX, &result));
|
||||
zassert_equal(result, SIZE_MAX * 2);
|
||||
}
|
||||
|
||||
static void VNAME(u32_clz)(void)
|
||||
{
|
||||
zassert_equal(u32_count_leading_zeros(0), 32, NULL);
|
||||
zassert_equal(u32_count_leading_zeros(1), 31, NULL);
|
||||
zassert_equal(u32_count_leading_zeros(0xf00f), 16, NULL);
|
||||
zassert_equal(u32_count_leading_zeros(0xf00ff00f), 0, NULL);
|
||||
zassert_equal(u32_count_leading_zeros(0xffffffff), 0, NULL);
|
||||
zassert_equal(u32_count_leading_zeros(0), 32);
|
||||
zassert_equal(u32_count_leading_zeros(1), 31);
|
||||
zassert_equal(u32_count_leading_zeros(0xf00f), 16);
|
||||
zassert_equal(u32_count_leading_zeros(0xf00ff00f), 0);
|
||||
zassert_equal(u32_count_leading_zeros(0xffffffff), 0);
|
||||
}
|
||||
|
||||
static void VNAME(u64_clz)(void)
|
||||
{
|
||||
zassert_equal(u64_count_leading_zeros(0), 64, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(1), 63, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00f), 48, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00ff00f), 32, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xffffffff), 32, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00f00000000ull), 16, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00ff00f00000000ull), 0, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0xffffffff00000000ull), 0, NULL);
|
||||
zassert_equal(u64_count_leading_zeros(0), 64);
|
||||
zassert_equal(u64_count_leading_zeros(1), 63);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00f), 48);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00ff00f), 32);
|
||||
zassert_equal(u64_count_leading_zeros(0xffffffff), 32);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00f00000000ull), 16);
|
||||
zassert_equal(u64_count_leading_zeros(0xf00ff00f00000000ull), 0);
|
||||
zassert_equal(u64_count_leading_zeros(0xffffffff00000000ull), 0);
|
||||
}
|
||||
|
||||
static void VNAME(u32_ctz)(void)
|
||||
{
|
||||
zassert_equal(u32_count_trailing_zeros(0), 32, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(1), 0, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(6), 1, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(0x00f00f00), 8, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(0xf00ffc00), 10, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(0xffffffff), 0, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(0x80000000), 31, NULL);
|
||||
zassert_equal(u32_count_trailing_zeros(0), 32);
|
||||
zassert_equal(u32_count_trailing_zeros(1), 0);
|
||||
zassert_equal(u32_count_trailing_zeros(6), 1);
|
||||
zassert_equal(u32_count_trailing_zeros(0x00f00f00), 8);
|
||||
zassert_equal(u32_count_trailing_zeros(0xf00ffc00), 10);
|
||||
zassert_equal(u32_count_trailing_zeros(0xffffffff), 0);
|
||||
zassert_equal(u32_count_trailing_zeros(0x80000000), 31);
|
||||
}
|
||||
|
||||
static void VNAME(u64_ctz)(void)
|
||||
{
|
||||
zassert_equal(u64_count_trailing_zeros(0), 64, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(1), 0, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(6), 1, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(0x00f00f00), 8, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(0xf00ffc00), 10, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(0xffffffffffffffffull), 0, NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(0), 64);
|
||||
zassert_equal(u64_count_trailing_zeros(1), 0);
|
||||
zassert_equal(u64_count_trailing_zeros(6), 1);
|
||||
zassert_equal(u64_count_trailing_zeros(0x00f00f00), 8);
|
||||
zassert_equal(u64_count_trailing_zeros(0xf00ffc00), 10);
|
||||
zassert_equal(u64_count_trailing_zeros(0xffffffffffffffffull), 0);
|
||||
zassert_equal(u64_count_trailing_zeros(0x8000000080000000ull), 31,
|
||||
NULL);
|
||||
zassert_equal(u64_count_trailing_zeros(0xc000000000000000ull), 62,
|
||||
|
|
|
|||
|
|
@ -52,17 +52,17 @@ ZTEST(net_timeout, test_set)
|
|||
/* Zero is a special case. */
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, 0, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 0, NULL);
|
||||
zassert_equal(nto.timer_timeout, 0, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 0);
|
||||
zassert_equal(nto.timer_timeout, 0);
|
||||
|
||||
/* Less than the max is straightforward. */
|
||||
lifetime = NTO_MAX_S / 2;
|
||||
++now;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 0, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 0);
|
||||
zassert_equal(nto.timer_timeout, lifetime * MSEC_PER_SEC,
|
||||
NULL);
|
||||
|
||||
|
|
@ -71,8 +71,8 @@ ZTEST(net_timeout, test_set)
|
|||
++now;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 0, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 0);
|
||||
zassert_equal(nto.timer_timeout, lifetime * MSEC_PER_SEC,
|
||||
NULL);
|
||||
|
||||
|
|
@ -81,8 +81,8 @@ ZTEST(net_timeout, test_set)
|
|||
++now;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 1U, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 1U);
|
||||
zassert_equal(nto.timer_timeout,
|
||||
(lifetime * MSEC_PER_SEC) % NET_TIMEOUT_MAX_VALUE,
|
||||
NULL);
|
||||
|
|
@ -92,8 +92,8 @@ ZTEST(net_timeout, test_set)
|
|||
++now;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 1U, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 1U);
|
||||
zassert_equal(nto.timer_timeout,
|
||||
(lifetime * (uint64_t)MSEC_PER_SEC) % NET_TIMEOUT_MAX_VALUE,
|
||||
NULL);
|
||||
|
|
@ -103,9 +103,9 @@ ZTEST(net_timeout, test_set)
|
|||
++now;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, MSEC_PER_SEC - 1, NULL);
|
||||
zassert_equal(nto.timer_timeout, NET_TIMEOUT_MAX_VALUE, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, MSEC_PER_SEC - 1);
|
||||
zassert_equal(nto.timer_timeout, NET_TIMEOUT_MAX_VALUE);
|
||||
}
|
||||
|
||||
ZTEST(net_timeout, test_deadline)
|
||||
|
|
@ -163,7 +163,7 @@ ZTEST(net_timeout, test_remaining)
|
|||
lifetime = NTO_MAX_S / 2;
|
||||
memset(&nto, 0xa5, sizeof(nto));
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.wrap_counter, 0, NULL);
|
||||
zassert_equal(nto.wrap_counter, 0);
|
||||
zassert_equal(net_timeout_remaining(&nto, now), lifetime,
|
||||
NULL);
|
||||
|
||||
|
|
@ -184,7 +184,7 @@ ZTEST(net_timeout, test_remaining)
|
|||
/* Works when wrap is involved */
|
||||
lifetime = 4 * FULLMAX_S;
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.wrap_counter, 7, NULL);
|
||||
zassert_equal(nto.wrap_counter, 7);
|
||||
zassert_equal(net_timeout_remaining(&nto, now), lifetime,
|
||||
NULL);
|
||||
}
|
||||
|
|
@ -307,15 +307,15 @@ ZTEST(net_timeout, test_evaluate_whitebox)
|
|||
uint32_t lifetime = 3 * HALFMAX_S + 2;
|
||||
|
||||
net_timeout_set(&nto, lifetime, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 3, NULL);
|
||||
zassert_equal(nto.timer_timeout, 59, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 3);
|
||||
zassert_equal(nto.timer_timeout, 59);
|
||||
|
||||
/* Preserve the deadline for validation */
|
||||
uint64_t deadline = net_timeout_deadline(&nto, now);
|
||||
|
||||
uint32_t delay = net_timeout_evaluate(&nto, now);
|
||||
zassert_equal(delay, NET_TIMEOUT_MAX_VALUE, NULL);
|
||||
zassert_equal(delay, NET_TIMEOUT_MAX_VALUE);
|
||||
zassert_equal(net_timeout_deadline(&nto, now),
|
||||
deadline, NULL);
|
||||
|
||||
|
|
@ -324,30 +324,30 @@ ZTEST(net_timeout, test_evaluate_whitebox)
|
|||
*/
|
||||
now += delay + 100U;
|
||||
delay = net_timeout_evaluate(&nto, now);
|
||||
zassert_equal(nto.timer_start, now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 1, NULL);
|
||||
zassert_equal(nto.timer_timeout, 2147483606, NULL);
|
||||
zassert_equal(nto.timer_start, now);
|
||||
zassert_equal(nto.wrap_counter, 1);
|
||||
zassert_equal(nto.timer_timeout, 2147483606);
|
||||
zassert_equal(net_timeout_deadline(&nto, now),
|
||||
deadline, NULL);
|
||||
zassert_equal(delay, NET_TIMEOUT_MAX_VALUE, NULL);
|
||||
zassert_equal(delay, NET_TIMEOUT_MAX_VALUE);
|
||||
|
||||
/* Another late evaluation finishes the wrap leaving some extra.
|
||||
*/
|
||||
now += delay + 123U;
|
||||
delay = net_timeout_evaluate(&nto, now);
|
||||
zassert_equal(nto.timer_start, (uint32_t)now, NULL);
|
||||
zassert_equal(nto.wrap_counter, 0, NULL);
|
||||
zassert_equal(nto.timer_timeout, 2147483483, NULL);
|
||||
zassert_equal(nto.timer_start, (uint32_t)now);
|
||||
zassert_equal(nto.wrap_counter, 0);
|
||||
zassert_equal(nto.timer_timeout, 2147483483);
|
||||
zassert_equal(net_timeout_deadline(&nto, now),
|
||||
deadline, NULL);
|
||||
zassert_equal(delay, nto.timer_timeout, NULL);
|
||||
zassert_equal(delay, nto.timer_timeout);
|
||||
|
||||
/* Complete the timeout. This does *not* adjust the internal
|
||||
* state.
|
||||
*/
|
||||
now += delay + 234U;
|
||||
delay = net_timeout_evaluate(&nto, now);
|
||||
zassert_equal(delay, 0, NULL);
|
||||
zassert_equal(delay, 0);
|
||||
zassert_equal(net_timeout_deadline(&nto, now),
|
||||
deadline, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -80,16 +80,16 @@ void test_COND_CODE_1(void)
|
|||
* be seen in compilation (lack of variable or ununsed variable.
|
||||
*/
|
||||
COND_CODE_1(1, (uint32_t x0 = 1;), (uint32_t y0;))
|
||||
zassert_true((x0 == 1), NULL);
|
||||
zassert_true((x0 == 1));
|
||||
|
||||
COND_CODE_1(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;))
|
||||
zassert_true((y1 == 1), NULL);
|
||||
zassert_true((y1 == 1));
|
||||
|
||||
COND_CODE_1(TEST_DEFINE_1, (uint32_t x2 = 1;), (uint32_t y2 = 1;))
|
||||
zassert_true((x2 == 1), NULL);
|
||||
zassert_true((x2 == 1));
|
||||
|
||||
COND_CODE_1(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;))
|
||||
zassert_true((y3 == 1), NULL);
|
||||
zassert_true((y3 == 1));
|
||||
}
|
||||
|
||||
void test_COND_CODE_0(void)
|
||||
|
|
@ -98,16 +98,16 @@ void test_COND_CODE_0(void)
|
|||
* be seen in compilation (lack of variable or ununsed variable.
|
||||
*/
|
||||
COND_CODE_0(0, (uint32_t x0 = 1;), (uint32_t y0;))
|
||||
zassert_true((x0 == 1), NULL);
|
||||
zassert_true((x0 == 1));
|
||||
|
||||
COND_CODE_0(NOT_EXISTING_DEFINE, (uint32_t x1 = 1;), (uint32_t y1 = 1;))
|
||||
zassert_true((y1 == 1), NULL);
|
||||
zassert_true((y1 == 1));
|
||||
|
||||
COND_CODE_0(TEST_DEFINE_0, (uint32_t x2 = 1;), (uint32_t y2 = 1;))
|
||||
zassert_true((x2 == 1), NULL);
|
||||
zassert_true((x2 == 1));
|
||||
|
||||
COND_CODE_0(2, (uint32_t x3 = 1;), (uint32_t y3 = 1;))
|
||||
zassert_true((y3 == 1), NULL);
|
||||
zassert_true((y3 == 1));
|
||||
}
|
||||
|
||||
#undef ZERO
|
||||
|
|
@ -119,28 +119,28 @@ void test_COND_CODE_0(void)
|
|||
|
||||
void test_UTIL_OR(void)
|
||||
{
|
||||
zassert_equal(UTIL_OR(SEVEN, A_BUILD_ERROR), 7, NULL);
|
||||
zassert_equal(UTIL_OR(7, 0), 7, NULL);
|
||||
zassert_equal(UTIL_OR(SEVEN, ZERO), 7, NULL);
|
||||
zassert_equal(UTIL_OR(0, 7), 7, NULL);
|
||||
zassert_equal(UTIL_OR(ZERO, SEVEN), 7, NULL);
|
||||
zassert_equal(UTIL_OR(0, 0), 0, NULL);
|
||||
zassert_equal(UTIL_OR(ZERO, ZERO), 0, NULL);
|
||||
zassert_equal(UTIL_OR(SEVEN, A_BUILD_ERROR), 7);
|
||||
zassert_equal(UTIL_OR(7, 0), 7);
|
||||
zassert_equal(UTIL_OR(SEVEN, ZERO), 7);
|
||||
zassert_equal(UTIL_OR(0, 7), 7);
|
||||
zassert_equal(UTIL_OR(ZERO, SEVEN), 7);
|
||||
zassert_equal(UTIL_OR(0, 0), 0);
|
||||
zassert_equal(UTIL_OR(ZERO, ZERO), 0);
|
||||
}
|
||||
|
||||
void test_UTIL_AND(void)
|
||||
{
|
||||
zassert_equal(UTIL_AND(ZERO, A_BUILD_ERROR), 0, NULL);
|
||||
zassert_equal(UTIL_AND(7, 0), 0, NULL);
|
||||
zassert_equal(UTIL_AND(SEVEN, ZERO), 0, NULL);
|
||||
zassert_equal(UTIL_AND(0, 7), 0, NULL);
|
||||
zassert_equal(UTIL_AND(ZERO, SEVEN), 0, NULL);
|
||||
zassert_equal(UTIL_AND(0, 0), 0, NULL);
|
||||
zassert_equal(UTIL_AND(ZERO, ZERO), 0, NULL);
|
||||
zassert_equal(UTIL_AND(7, 7), 7, NULL);
|
||||
zassert_equal(UTIL_AND(7, SEVEN), 7, NULL);
|
||||
zassert_equal(UTIL_AND(SEVEN, 7), 7, NULL);
|
||||
zassert_equal(UTIL_AND(SEVEN, SEVEN), 7, NULL);
|
||||
zassert_equal(UTIL_AND(ZERO, A_BUILD_ERROR), 0);
|
||||
zassert_equal(UTIL_AND(7, 0), 0);
|
||||
zassert_equal(UTIL_AND(SEVEN, ZERO), 0);
|
||||
zassert_equal(UTIL_AND(0, 7), 0);
|
||||
zassert_equal(UTIL_AND(ZERO, SEVEN), 0);
|
||||
zassert_equal(UTIL_AND(0, 0), 0);
|
||||
zassert_equal(UTIL_AND(ZERO, ZERO), 0);
|
||||
zassert_equal(UTIL_AND(7, 7), 7);
|
||||
zassert_equal(UTIL_AND(7, SEVEN), 7);
|
||||
zassert_equal(UTIL_AND(SEVEN, 7), 7);
|
||||
zassert_equal(UTIL_AND(SEVEN, SEVEN), 7);
|
||||
}
|
||||
|
||||
void test_IF_ENABLED(void)
|
||||
|
|
@ -170,9 +170,9 @@ void test_LISTIFY(void)
|
|||
|
||||
int *a[] = { LISTIFY(2, A_PTR, (,), a, b) };
|
||||
|
||||
zassert_equal(ARRAY_SIZE(a), 2, NULL);
|
||||
zassert_equal(a[0], &ab0, NULL);
|
||||
zassert_equal(a[1], &ab1, NULL);
|
||||
zassert_equal(ARRAY_SIZE(a), 2);
|
||||
zassert_equal(a[0], &ab0);
|
||||
zassert_equal(a[1], &ab1);
|
||||
}
|
||||
|
||||
void test_MACRO_MAP_CAT(void)
|
||||
|
|
@ -404,9 +404,9 @@ static void test_nested_FOR_EACH(void)
|
|||
|
||||
FOR_EACH(FOO_2, (;), FOR_EACH(FOO_1, (,), 0, 1, 2));
|
||||
|
||||
zassert_equal(a0, 0, NULL);
|
||||
zassert_equal(a1, 1, NULL);
|
||||
zassert_equal(a2, 2, NULL);
|
||||
zassert_equal(a0, 0);
|
||||
zassert_equal(a1, 1);
|
||||
zassert_equal(a2, 2);
|
||||
}
|
||||
|
||||
static void test_GET_ARG_N(void)
|
||||
|
|
@ -415,9 +415,9 @@ static void test_GET_ARG_N(void)
|
|||
int b = GET_ARG_N(2, 10, 100, 1000);
|
||||
int c = GET_ARG_N(3, 10, 100, 1000);
|
||||
|
||||
zassert_equal(a, 10, NULL);
|
||||
zassert_equal(b, 100, NULL);
|
||||
zassert_equal(c, 1000, NULL);
|
||||
zassert_equal(a, 10);
|
||||
zassert_equal(b, 100);
|
||||
zassert_equal(c, 1000);
|
||||
}
|
||||
|
||||
static void test_GET_ARGS_LESS_N(void)
|
||||
|
|
@ -426,14 +426,14 @@ static void test_GET_ARGS_LESS_N(void)
|
|||
uint8_t b[] = { GET_ARGS_LESS_N(1, 1, 2, 3) };
|
||||
uint8_t c[] = { GET_ARGS_LESS_N(2, 1, 2, 3) };
|
||||
|
||||
zassert_equal(sizeof(a), 3, NULL);
|
||||
zassert_equal(sizeof(a), 3);
|
||||
|
||||
zassert_equal(sizeof(b), 2, NULL);
|
||||
zassert_equal(b[0], 2, NULL);
|
||||
zassert_equal(b[1], 3, NULL);
|
||||
zassert_equal(sizeof(b), 2);
|
||||
zassert_equal(b[0], 2);
|
||||
zassert_equal(b[1], 3);
|
||||
|
||||
zassert_equal(sizeof(c), 1, NULL);
|
||||
zassert_equal(c[0], 3, NULL);
|
||||
zassert_equal(sizeof(c), 1);
|
||||
zassert_equal(c[0], 3);
|
||||
}
|
||||
|
||||
static void test_mixing_GET_ARG_and_FOR_EACH(void)
|
||||
|
|
@ -443,10 +443,10 @@ static void test_mixing_GET_ARG_and_FOR_EACH(void)
|
|||
int i;
|
||||
|
||||
i = GET_ARG_N(3, FOR_EACH(TEST_MACRO, (), 1, 2, 3, 4, 5));
|
||||
zassert_equal(i, 3, NULL);
|
||||
zassert_equal(i, 3);
|
||||
|
||||
i = GET_ARG_N(2, 1, GET_ARGS_LESS_N(2, 1, 2, 3, 4, 5));
|
||||
zassert_equal(i, 3, NULL);
|
||||
zassert_equal(i, 3);
|
||||
|
||||
#undef TEST_MACRO
|
||||
#undef TEST_MACRO2
|
||||
|
|
@ -456,12 +456,12 @@ static void test_mixing_GET_ARG_and_FOR_EACH(void)
|
|||
LIST_DROP_EMPTY(TEST_MACRO2(1, 2, 3, 4)), 5
|
||||
};
|
||||
|
||||
zassert_equal(ARRAY_SIZE(a), 5, NULL);
|
||||
zassert_equal(a[0], 1, NULL);
|
||||
zassert_equal(a[1], 2, NULL);
|
||||
zassert_equal(a[2], 3, NULL);
|
||||
zassert_equal(a[3], 4, NULL);
|
||||
zassert_equal(a[4], 5, NULL);
|
||||
zassert_equal(ARRAY_SIZE(a), 5);
|
||||
zassert_equal(a[0], 1);
|
||||
zassert_equal(a[1], 2);
|
||||
zassert_equal(a[2], 3);
|
||||
zassert_equal(a[3], 4);
|
||||
zassert_equal(a[4], 5);
|
||||
}
|
||||
|
||||
#if __cplusplus
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue