int main(int argc, char *argv[]) {
const char *outfile = NULL;
FILE *out;
const struct symbol *sym_table;
const unsigned long *cov_bitmap;
int opt, i, sym_n;
getopt_init();
while (-1 != (opt = getopt(argc, argv, "o:h"))) {
switch (opt) {
case 'h':
printf("Usage: %s [-h] [-o output_file]\n", argv[0]);
return 0;
case 'o':
outfile = optarg;
default:
break;
}
}
if (outfile) {
out = fopen(outfile, "w");
if (!out) {
perror("fopen");
return -errno;
}
} else {
out = stdout;
}
sym_n = coverage_getstat(&sym_table, &cov_bitmap);
if (sym_n <= 0) {
if (outfile)
fclose(out);
return sym_n;
}
fprintf(out, "%32s\t%8s\n", "FUNCTION", "EXECUTED");
for (i = 0; i < sym_n; i++) {
fprintf(out, "%21s@0x%08lx\t%8s\n", sym_table[i].name,
(unsigned long) sym_table[i].addr,
bitmap_test_bit(cov_bitmap, i) ? "true" : "false");
}
if (outfile)
fclose(out);
return 0;
}
bool eratosthenes_isprime(const struct eratosthenes *s, unsigned long n)
{
assert(n < s->limit);
if ((n % 2) == 0)
return (n == 2);
if (n < 3) {
assert(n == 1);
return false;
}
return bitmap_test_bit(s->b, VAL_TO_BIT(n));
}
static void test_size(int nbits)
{
BITMAP_DECLARE(bitmap, nbits);
uint32_t marker = 0xdeadbeef;
int i, j, k;
bool wrong;
for (i = 0; i < nbits; i++) {
for (j = i; j <= nbits; j++) {
bitmap_zero(bitmap, nbits);
bitmap_fill_range(bitmap, i, j);
wrong = false;
for (k = 0; k < nbits; k++) {
bool inrange = (k >= i) && (k < j);
wrong = wrong || (bitmap_test_bit(bitmap, k) != inrange);
}
ok1(!wrong);
}
}
for (i = 0; i < nbits; i++) {
for (j = i; j <= nbits; j++) {
bitmap_fill(bitmap, nbits);
bitmap_zero_range(bitmap, i, j);
wrong = false;
for (k = 0; k < nbits; k++) {
bool inrange = (k >= i) && (k < j);
wrong = wrong || (bitmap_test_bit(bitmap, k) == inrange);
}
ok1(!wrong);
}
}
ok1(marker == 0xdeadbeef);
}
void
tests(void)
{
#ifndef USING_WOLFSSL
struct bitmap *b;
BIGNUM *bn;
size_t len;
int i, j, k, n;
u_char bbuf[1024], bnbuf[1024];
int r;
#else
struct bitmap *b;
BIGNUM *bn;
#endif
TEST_START("bitmap_new");
b = bitmap_new();
ASSERT_PTR_NE(b, NULL);
bn = BN_new();
ASSERT_PTR_NE(bn, NULL);
TEST_DONE();
TEST_START("bitmap_set_bit / bitmap_test_bit");
#ifndef USING_WOLFSSL
for (i = -1; i < NTESTS; i++) {
for (j = -1; j < NTESTS; j++) {
for (k = -1; k < NTESTS; k++) {
bitmap_zero(b);
/* wolfSSL does not have support for BN_clear at this time */
BN_clear(bn);
test_subtest_info("set %d/%d/%d", i, j, k);
/* Set bits */
if (i >= 0) {
ASSERT_INT_EQ(bitmap_set_bit(b, i), 0);
ASSERT_INT_EQ(BN_set_bit(bn, i), 1);
}
if (j >= 0) {
ASSERT_INT_EQ(bitmap_set_bit(b, j), 0);
ASSERT_INT_EQ(BN_set_bit(bn, j), 1);
}
if (k >= 0) {
ASSERT_INT_EQ(bitmap_set_bit(b, k), 0);
ASSERT_INT_EQ(BN_set_bit(bn, k), 1);
}
/* Check perfect match between bitmap and bn */
test_subtest_info("match %d/%d/%d", i, j, k);
for (n = 0; n < NTESTS; n++) {
ASSERT_INT_EQ(BN_is_bit_set(bn, n),
bitmap_test_bit(b, n));
}
/* Test length calculations */
test_subtest_info("length %d/%d/%d", i, j, k);
ASSERT_INT_EQ(BN_num_bits(bn),
(int)bitmap_nbits(b));
ASSERT_INT_EQ(BN_num_bytes(bn),
(int)bitmap_nbytes(b));
/* Test serialisation */
test_subtest_info("serialise %d/%d/%d",
i, j, k);
len = bitmap_nbytes(b);
memset(bbuf, 0xfc, sizeof(bbuf));
ASSERT_INT_EQ(bitmap_to_string(b, bbuf,
sizeof(bbuf)), 0);
for (n = len; n < (int)sizeof(bbuf); n++)
ASSERT_U8_EQ(bbuf[n], 0xfc);
r = BN_bn2bin(bn, bnbuf);
ASSERT_INT_GE(r, 0);
ASSERT_INT_EQ(r, (int)len);
ASSERT_MEM_EQ(bbuf, bnbuf, len);
/* Test deserialisation */
test_subtest_info("deserialise %d/%d/%d",
i, j, k);
bitmap_zero(b);
ASSERT_INT_EQ(bitmap_from_string(b, bnbuf,
len), 0);
for (n = 0; n < NTESTS; n++) {
ASSERT_INT_EQ(BN_is_bit_set(bn, n),
bitmap_test_bit(b, n));
}
/* Test clearing bits */
test_subtest_info("clear %d/%d/%d",
i, j, k);
for (n = 0; n < NTESTS; n++) {
ASSERT_INT_EQ(bitmap_set_bit(b, n), 0);
ASSERT_INT_EQ(BN_set_bit(bn, n), 1);
}
if (i >= 0) {
bitmap_clear_bit(b, i);
/* wolfSSL does not have support for BN_clear_bit at this time */
BN_clear_bit(bn, i);
}
if (j >= 0) {
bitmap_clear_bit(b, j);
/* wolfSSL does not have support for BN_clear_bit at this time */
BN_clear_bit(bn, j);
}
if (k >= 0) {
bitmap_clear_bit(b, k);
/* wolfSSL does not have support for BN_clear_bit at this time */
BN_clear_bit(bn, k);
}
for (n = 0; n < NTESTS; n++) {
ASSERT_INT_EQ(BN_is_bit_set(bn, n),
bitmap_test_bit(b, n));
}
}
}
}
#endif /* USING_WOLFSSL */
bitmap_free(b);
BN_free(bn);
TEST_DONE();
}
