fout = 19;
f = v[i];
ret = sr_analog_to_float(&analog, &fout);
- fail_unless(ret == SR_OK, "sr_analog_to_float() failed: %d.", ret);
- fail_unless(fabs(f - fout) <= 0.001, "%f != %f", f, fout);
+ ck_assert_msg(ret == SR_OK,
+ "sr_analog_to_float() failed: %d.", ret);
+ ck_assert_msg(fabs(f - fout) <= 0.001, "%f != %f", f, fout);
}
}
END_TEST
analog.data = &f;
ret = sr_analog_to_float(NULL, &fout);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
ret = sr_analog_to_float(&analog, NULL);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
ret = sr_analog_to_float(NULL, NULL);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
analog.data = NULL;
ret = sr_analog_to_float(&analog, &fout);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
analog.data = &f;
analog.meaning = NULL;
ret = sr_analog_to_float(&analog, &fout);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
analog.meaning = &meaning;
analog.encoding = NULL;
ret = sr_analog_to_float(&analog, &fout);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
analog.encoding = &encoding;
}
END_TEST
int digits = v[i].input_digits;
const char *si_prefix = sr_analog_si_prefix(&value, &digits);
- fail_unless(fabs(value - v[i].output_value) <= 0.00001,
- "sr_analog_si_prefix() unexpected output value %f (i=%d).",
- value , i);
- fail_unless(digits == v[i].output_digits,
- "sr_analog_si_prefix() unexpected output digits %d (i=%d).",
- digits, i);
- fail_unless(!strcmp(si_prefix, v[i].output_si_prefix),
- "sr_analog_si_prefix() unexpected output prefix \"%s\" (i=%d).",
- si_prefix, i);
+ ck_assert_msg(fabs(value - v[i].output_value) <= 0.00001,
+ "sr_analog_si_prefix() unexpected output value %f (i=%d).",
+ value, i);
+ ck_assert_msg(digits == v[i].output_digits,
+ "sr_analog_si_prefix() unexpected output digits %d (i=%d).",
+ digits, i);
+ ck_assert_msg(!strcmp(si_prefix, v[i].output_si_prefix),
+ "sr_analog_si_prefix() unexpected output prefix \"%s\" (i=%d).",
+ si_prefix, i);
}
}
END_TEST
const char *si_prefix;
si_prefix = sr_analog_si_prefix(NULL, &digits);
- fail_unless(!strcmp(si_prefix, ""));
+ ck_assert(!strcmp(si_prefix, ""));
si_prefix = sr_analog_si_prefix(&value, NULL);
- fail_unless(!strcmp(si_prefix, ""));
+ ck_assert(!strcmp(si_prefix, ""));
si_prefix = sr_analog_si_prefix(NULL, NULL);
- fail_unless(!strcmp(si_prefix, ""));
+ ck_assert(!strcmp(si_prefix, ""));
}
END_TEST
meaning.unit = u[i];
meaning.mqflags = f[i];
ret = sr_analog_unit_to_string(&analog, &result);
- fail_unless(ret == SR_OK);
- fail_unless(result != NULL);
- fail_unless(!strcmp(result, r[i]), "%s != %s", result, r[i]);
+ ck_assert(ret == SR_OK);
+ ck_assert(result != NULL);
+ ck_assert_msg(!strcmp(result, r[i]), "%s != %s", result, r[i]);
g_free(result);
}
}
meaning.mqflags = SR_MQFLAG_RMS;
ret = sr_analog_unit_to_string(NULL, &result);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
ret = sr_analog_unit_to_string(&analog, NULL);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
ret = sr_analog_unit_to_string(NULL, NULL);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
analog.meaning = NULL;
ret = sr_analog_unit_to_string(&analog, &result);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
}
END_TEST
for (i = 0; i < ARRAY_SIZE(p); i++) {
sr_rational_set(&r, p[i], q[i]);
- fail_unless(r.p == p[i] && r.q == q[i]);
+ ck_assert(r.p == p[i] && r.q == q[i]);
}
}
END_TEST
{ INT64_MIN, UINT64_MAX },
};
- fail_unless(sr_rational_eq(&r[0], &r[0]) == 1);
- fail_unless(sr_rational_eq(&r[0], &r[1]) == 1);
- fail_unless(sr_rational_eq(&r[1], &r[2]) == 1);
- fail_unless(sr_rational_eq(&r[2], &r[3]) == 1);
- fail_unless(sr_rational_eq(&r[3], &r[3]) == 1);
+ ck_assert(sr_rational_eq(&r[0], &r[0]) == 1);
+ ck_assert(sr_rational_eq(&r[0], &r[1]) == 1);
+ ck_assert(sr_rational_eq(&r[1], &r[2]) == 1);
+ ck_assert(sr_rational_eq(&r[2], &r[3]) == 1);
+ ck_assert(sr_rational_eq(&r[3], &r[3]) == 1);
- fail_unless(sr_rational_eq(&r[4], &r[4]) == 1);
- fail_unless(sr_rational_eq(&r[4], &r[5]) == 1);
- fail_unless(sr_rational_eq(&r[5], &r[5]) == 1);
+ ck_assert(sr_rational_eq(&r[4], &r[4]) == 1);
+ ck_assert(sr_rational_eq(&r[4], &r[5]) == 1);
+ ck_assert(sr_rational_eq(&r[5], &r[5]) == 1);
- fail_unless(sr_rational_eq(&r[6], &r[6]) == 1);
- fail_unless(sr_rational_eq(&r[7], &r[7]) == 1);
+ ck_assert(sr_rational_eq(&r[6], &r[6]) == 1);
+ ck_assert(sr_rational_eq(&r[7], &r[7]) == 1);
- fail_unless(sr_rational_eq(&r[1], &r[4]) == 0);
+ ck_assert(sr_rational_eq(&r[1], &r[4]) == 0);
}
END_TEST
for (i = 0; i < ARRAY_SIZE(r); i++) {
rc = sr_rational_mult(&res, &r[i][0], &r[i][1]);
- fail_unless(rc == SR_OK);
- fail_unless(sr_rational_eq(&res, &r[i][2]) == 1,
- "sr_rational_mult() failed: [%zu] %" PRIi64 "/%" PRIu64 " != %" PRIi64 "/%" PRIu64 ".",
- i, res.p, res.q, r[i][2].p, r[i][2].q);
+ ck_assert(rc == SR_OK);
+ ck_assert_msg(sr_rational_eq(&res, &r[i][2]) == 1,
+ "sr_rational_mult() failed: [%zu] %" PRIi64 "/%" PRIu64 " != %" PRIi64 "/%" PRIu64 ".",
+ i, res.p, res.q, r[i][2].p, r[i][2].q);
}
}
END_TEST
for (i = 0; i < ARRAY_SIZE(r); i++) {
rc = sr_rational_div(&res, &r[i][0], &r[i][1]);
- fail_unless(rc == SR_OK);
- fail_unless(sr_rational_eq(&res, &r[i][2]) == 1,
- "sr_rational_mult() failed: [%zu] %" PRIi64 "/%" PRIu64 " != %" PRIi64 "/%" PRIu64 ".",
- i, res.p, res.q, r[i][2].p, r[i][2].q);
+ ck_assert(rc == SR_OK);
+ ck_assert_msg(sr_rational_eq(&res, &r[i][2]) == 1,
+ "sr_rational_mult() failed: [%zu] %" PRIi64 "/%" PRIu64 " != %" PRIi64 "/%" PRIu64 ".",
+ i, res.p, res.q, r[i][2].p, r[i][2].q);
}
{
rc = sr_rational_div(&res, &r[0][0], &((struct sr_rational){ 0, 5 }));
- fail_unless(rc == SR_ERR_ARG);
+ ck_assert(rc == SR_ERR_ARG);
}
}
END_TEST
const uint32_t *p32;
p8 = (const void *)&buff1234[0];
- fail_unless(R8(&p8[0]) == 0x11);
- fail_unless(R8(&p8[1]) == 0x22);
- fail_unless(R8(&p8[2]) == 0x33);
- fail_unless(R8(&p8[3]) == 0x44);
+ ck_assert(R8(&p8[0]) == 0x11);
+ ck_assert(R8(&p8[1]) == 0x22);
+ ck_assert(R8(&p8[2]) == 0x33);
+ ck_assert(R8(&p8[3]) == 0x44);
p16 = (const void *)&buff1234[0];
- fail_unless(RB16(&p16[0]) == 0x1122);
- fail_unless(RB16(&p16[1]) == 0x3344);
+ ck_assert(RB16(&p16[0]) == 0x1122);
+ ck_assert(RB16(&p16[1]) == 0x3344);
p16 = (const void *)&buff1234[0];
- fail_unless(RL16(&p16[0]) == 0x2211);
- fail_unless(RL16(&p16[1]) == 0x4433);
+ ck_assert(RL16(&p16[0]) == 0x2211);
+ ck_assert(RL16(&p16[1]) == 0x4433);
p32 = (const void *)&buff1234[0];
- fail_unless(RB32(&p32[0]) == 0x11223344);
- fail_unless(RB32(&p32[1]) == 0x55667788);
+ ck_assert(RB32(&p32[0]) == 0x11223344);
+ ck_assert(RB32(&p32[1]) == 0x55667788);
p32 = (const void *)&buff1234[0];
- fail_unless(RL32(&p32[0]) == 0x44332211);
- fail_unless(RL32(&p32[1]) == 0x88776655);
+ ck_assert(RL32(&p32[0]) == 0x44332211);
+ ck_assert(RL32(&p32[1]) == 0x88776655);
p16 = (const void *)&buff1234[0];
- fail_unless(RB16(p16++) == 0x1122);
- fail_unless(RB16(p16++) == 0x3344);
+ ck_assert(RB16(p16++) == 0x1122);
+ ck_assert(RB16(p16++) == 0x3344);
}
END_TEST
START_TEST(test_endian_read)
{
- fail_unless(read_u8(&buff1234[0]) == 0x11);
- fail_unless(read_u8(&buff1234[3]) == 0x44);
- fail_unless(read_u8(&buff1234[7]) == 0x88);
+ ck_assert(read_u8(&buff1234[0]) == 0x11);
+ ck_assert(read_u8(&buff1234[3]) == 0x44);
+ ck_assert(read_u8(&buff1234[7]) == 0x88);
- fail_unless(read_u16be(&buff1234[0]) == 0x1122);
- fail_unless(read_u16be(&buff1234[6]) == 0x7788);
+ ck_assert(read_u16be(&buff1234[0]) == 0x1122);
+ ck_assert(read_u16be(&buff1234[6]) == 0x7788);
- fail_unless(read_u16le(&buff1234[0]) == 0x2211);
- fail_unless(read_u16le(&buff1234[6]) == 0x8877);
+ ck_assert(read_u16le(&buff1234[0]) == 0x2211);
+ ck_assert(read_u16le(&buff1234[6]) == 0x8877);
- fail_unless(read_i16be(&buff1234[6]) == 0x7788);
- fail_unless(read_i16le(&buff1234[6]) == (int16_t)0x8877);
+ ck_assert(read_i16be(&buff1234[6]) == 0x7788);
+ ck_assert(read_i16le(&buff1234[6]) == (int16_t)0x8877);
- fail_unless(read_u32be(&buff1234[0]) == 0x11223344);
- fail_unless(read_u32be(&buff1234[4]) == 0x55667788);
+ ck_assert(read_u32be(&buff1234[0]) == 0x11223344);
+ ck_assert(read_u32be(&buff1234[4]) == 0x55667788);
- fail_unless(read_u32le(&buff1234[0]) == 0x44332211);
- fail_unless(read_u32le(&buff1234[4]) == 0x88776655);
+ ck_assert(read_u32le(&buff1234[0]) == 0x44332211);
+ ck_assert(read_u32le(&buff1234[4]) == 0x88776655);
- fail_unless(read_i32be(&buff1234[0]) == 0x11223344);
- fail_unless(read_i32be(&buff1234[4]) == 0x55667788);
- fail_unless(read_i32le(&buff1234[4]) == (int32_t)0x88776655ull);
+ ck_assert(read_i32be(&buff1234[0]) == 0x11223344);
+ ck_assert(read_i32be(&buff1234[4]) == 0x55667788);
+ ck_assert(read_i32le(&buff1234[4]) == (int32_t)0x88776655ull);
- fail_unless(read_u64be(&buff1234[0]) == 0x1122334455667788ull);
- fail_unless(read_u64le(&buff1234[0]) == 0x8877665544332211ull);
- fail_unless(read_i64be(&buff1234[0]) == 0x1122334455667788ull);
- fail_unless(read_i64le(&buff1234[0]) == (int64_t)0x8877665544332211ull);
+ ck_assert(read_u64be(&buff1234[0]) == 0x1122334455667788ull);
+ ck_assert(read_u64le(&buff1234[0]) == 0x8877665544332211ull);
+ ck_assert(read_i64be(&buff1234[0]) == 0x1122334455667788ull);
+ ck_assert(read_i64le(&buff1234[0]) == (int64_t)0x8877665544332211ull);
- fail_unless(read_fltbe(&buff8125fb[0]) == 8.125);
- fail_unless(read_fltle(&buff8125fl[0]) == 8.125);
+ ck_assert(read_fltbe(&buff8125fb[0]) == 8.125);
+ ck_assert(read_fltle(&buff8125fl[0]) == 8.125);
}
END_TEST
l = sizeof(buff1234);
/* Read several fields of known type and values. */
- fail_unless(l == 8);
- fail_unless(read_u8_inc_len(&p, &l) == 0x11);
- fail_unless(l == 7);
- fail_unless(read_u8_inc_len(&p, &l) == 0x22);
- fail_unless(l == 6);
- fail_unless(read_u16le_inc_len(&p, &l) == 0x4433);
- fail_unless(l == 4);
- fail_unless(read_u16le_inc_len(&p, &l) == 0x6655);
- fail_unless(l == 2);
- fail_unless(read_u16le_inc_len(&p, &l) == 0x8877);
- fail_unless(l == 0);
+ ck_assert(l == 8);
+ ck_assert(read_u8_inc_len(&p, &l) == 0x11);
+ ck_assert(l == 7);
+ ck_assert(read_u8_inc_len(&p, &l) == 0x22);
+ ck_assert(l == 6);
+ ck_assert(read_u16le_inc_len(&p, &l) == 0x4433);
+ ck_assert(l == 4);
+ ck_assert(read_u16le_inc_len(&p, &l) == 0x6655);
+ ck_assert(l == 2);
+ ck_assert(read_u16le_inc_len(&p, &l) == 0x8877);
+ ck_assert(l == 0);
/* Read beyond the end of the input stream. */
- fail_unless(read_u8_inc_len(&p, &l) == 0x0);
- fail_unless(l == 0);
- fail_unless(read_u16le_inc_len(&p, &l) == 0x0);
- fail_unless(l == 0);
+ ck_assert(read_u8_inc_len(&p, &l) == 0x0);
+ ck_assert(l == 0);
+ ck_assert(read_u16le_inc_len(&p, &l) == 0x0);
+ ck_assert(l == 0);
}
END_TEST
const uint8_t *p;
p = &buff1234[0];
- fail_unless(read_u8_inc(&p) == 0x11);
- fail_unless(read_u8_inc(&p) == 0x22);
- fail_unless(read_u8_inc(&p) == 0x33);
- fail_unless(p == &buff1234[3 * sizeof(uint8_t)]);
+ ck_assert(read_u8_inc(&p) == 0x11);
+ ck_assert(read_u8_inc(&p) == 0x22);
+ ck_assert(read_u8_inc(&p) == 0x33);
+ ck_assert(p == &buff1234[3 * sizeof(uint8_t)]);
p = &buff1234[0];
- fail_unless(read_u16be_inc(&p) == 0x1122);
- fail_unless(read_u16be_inc(&p) == 0x3344);
- fail_unless(p == &buff1234[2 * sizeof(uint16_t)]);
+ ck_assert(read_u16be_inc(&p) == 0x1122);
+ ck_assert(read_u16be_inc(&p) == 0x3344);
+ ck_assert(p == &buff1234[2 * sizeof(uint16_t)]);
p = &buff1234[0];
- fail_unless(read_u16le_inc(&p) == 0x2211);
- fail_unless(read_u16le_inc(&p) == 0x4433);
- fail_unless(p == &buff1234[2 * sizeof(uint16_t)]);
+ ck_assert(read_u16le_inc(&p) == 0x2211);
+ ck_assert(read_u16le_inc(&p) == 0x4433);
+ ck_assert(p == &buff1234[2 * sizeof(uint16_t)]);
p = &buff1234[0];
- fail_unless(read_u24le_inc(&p) == 0x332211);
- fail_unless(read_u24le_inc(&p) == 0x665544);
- fail_unless(p == &buff1234[2 * 3 * sizeof(uint8_t)]);
+ ck_assert(read_u24le_inc(&p) == 0x332211);
+ ck_assert(read_u24le_inc(&p) == 0x665544);
+ ck_assert(p == &buff1234[2 * 3 * sizeof(uint8_t)]);
p = &buff1234[0];
- fail_unless(read_u32be_inc(&p) == 0x11223344ul);
- fail_unless(read_u32be_inc(&p) == 0x55667788ul);
- fail_unless(p == &buff1234[2 * sizeof(uint32_t)]);
+ ck_assert(read_u32be_inc(&p) == 0x11223344ul);
+ ck_assert(read_u32be_inc(&p) == 0x55667788ul);
+ ck_assert(p == &buff1234[2 * sizeof(uint32_t)]);
p = &buff1234[0];
- fail_unless(read_u32le_inc(&p) == 0x44332211ul);
- fail_unless(read_u32le_inc(&p) == 0x88776655ul);
- fail_unless(p == &buff1234[2 * sizeof(uint32_t)]);
+ ck_assert(read_u32le_inc(&p) == 0x44332211ul);
+ ck_assert(read_u32le_inc(&p) == 0x88776655ul);
+ ck_assert(p == &buff1234[2 * sizeof(uint32_t)]);
p = &buff1234[0];
- fail_unless(read_u64be_inc(&p) == 0x1122334455667788);
- fail_unless(p == &buff1234[sizeof(uint64_t)]);
+ ck_assert(read_u64be_inc(&p) == 0x1122334455667788);
+ ck_assert(p == &buff1234[sizeof(uint64_t)]);
p = &buff1234[0];
- fail_unless(read_u64le_inc(&p) == 0x8877665544332211ull);
- fail_unless(p == &buff1234[sizeof(uint64_t)]);
+ ck_assert(read_u64le_inc(&p) == 0x8877665544332211ull);
+ ck_assert(p == &buff1234[sizeof(uint64_t)]);
}
END_TEST
memset(buff, 0, sizeof(buff));
write_u8(&buff[0], 0x11);
- fail_unless(memcmp(&buff[0], &buff1234[0], sizeof(uint8_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[0], sizeof(uint8_t)) == 0);
memset(buff, 0, sizeof(buff));
write_u8(&buff[0], 0x22);
write_u8(&buff[1], 0x33);
write_u8(&buff[2], 0x44);
write_u8(&buff[3], 0x55);
- fail_unless(memcmp(&buff[0], &buff1234[1], 4 * sizeof(uint8_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[1], 4 * sizeof(uint8_t)) == 0);
memset(buff, 0, sizeof(buff));
write_u16be(&buff[0 * sizeof(uint16_t)], 0x1122);
write_u16be(&buff[1 * sizeof(uint16_t)], 0x3344);
- fail_unless(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint16_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint16_t)) == 0);
memset(buff, 0, sizeof(buff));
write_u16le(&buff[0 * sizeof(uint16_t)], 0x4433);
write_u16le(&buff[1 * sizeof(uint16_t)], 0x6655);
- fail_unless(memcmp(&buff[0], &buff1234[2], 2 * sizeof(uint16_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[2], 2 * sizeof(uint16_t)) == 0);
memset(buff, 0, sizeof(buff));
write_u32be(&buff[0 * sizeof(uint32_t)], 0x11223344);
write_u32be(&buff[1 * sizeof(uint32_t)], 0x55667788);
- fail_unless(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint32_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint32_t)) == 0);
memset(buff, 0, sizeof(buff));
write_u32le(&buff[0 * sizeof(uint32_t)], 0x44332211);
write_u32le(&buff[1 * sizeof(uint32_t)], 0x88776655);
- fail_unless(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint32_t)) == 0);
+ ck_assert(memcmp(&buff[0], &buff1234[0], 2 * sizeof(uint32_t)) == 0);
memset(buff, 0, sizeof(buff));
write_fltbe(&buff[0], 8.125);
- fail_unless(memcmp(&buff[0], &buff8125fb[0], sizeof(float)) == 0);
+ ck_assert(memcmp(&buff[0], &buff8125fb[0], sizeof(float)) == 0);
memset(buff, 0, sizeof(buff));
write_fltle(&buff[0], 8.125);
- fail_unless(memcmp(&buff[0], &buff8125fl[0], sizeof(float)) == 0);
+ ck_assert(memcmp(&buff[0], &buff8125fl[0], sizeof(float)) == 0);
}
END_TEST
write_u16be_inc(&p, 0x2233);
write_u32be_inc(&p, 0x44556677);
l = p - &buff[0];
- fail_unless(l == sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t));
- fail_unless(memcmp(&buff[0], &buff1234[0], l) == 0);
+ ck_assert(l == sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t));
+ ck_assert(memcmp(&buff[0], &buff1234[0], l) == 0);
p = &buff[0];
write_u48le_inc(&p, 0x060504030201);
write_u48le_inc(&p, 0x1211100f0e0d);
write_u48le_inc(&p, 0x181716151413);
l = p - &buff[0];
- fail_unless(l == 4 * 48 / 8 * sizeof(uint8_t));
- fail_unless(memcmp(&buff[0], &buff1234large[0], l) == 0);
+ ck_assert(l == 4 * 48 / 8 * sizeof(uint8_t));
+ ck_assert(memcmp(&buff[0], &buff1234large[0], l) == 0);
p = &buff[0];
write_u24le_inc(&p, 0xfe030201);
write_u40le_inc(&p, 0xdcba0807060504ul);
l = p - &buff[0];
- fail_unless(l == 24 / 8 + 40 / 8);
- fail_unless(memcmp(&buff[0], &buff1234large[0], l) == 0);
+ ck_assert(l == 24 / 8 + 40 / 8);
+ ck_assert(memcmp(&buff[0], &buff1234large[0], l) == 0);
}
END_TEST
struct sr_context *sr_ctx;
ret = sr_init(&sr_ctx);
- fail_unless(ret == SR_OK, "sr_init() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() failed: %d.", ret);
ret = sr_exit(sr_ctx);
- fail_unless(ret == SR_OK, "sr_exit() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() failed: %d.", ret);
}
END_TEST
struct sr_context *sr_ctx1, *sr_ctx2;
ret = sr_init(&sr_ctx1);
- fail_unless(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
ret = sr_init(&sr_ctx2);
- fail_unless(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
ret = sr_exit(sr_ctx2);
- fail_unless(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
ret = sr_exit(sr_ctx1);
- fail_unless(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
}
END_TEST
struct sr_context *sr_ctx1, *sr_ctx2;
ret = sr_init(&sr_ctx1);
- fail_unless(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
ret = sr_init(&sr_ctx2);
- fail_unless(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
ret = sr_exit(sr_ctx1);
- fail_unless(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
ret = sr_exit(sr_ctx2);
- fail_unless(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
}
END_TEST
struct sr_context *sr_ctx1, *sr_ctx2, *sr_ctx3;
ret = sr_init(&sr_ctx1);
- fail_unless(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
ret = sr_init(&sr_ctx2);
- fail_unless(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
ret = sr_init(&sr_ctx3);
- fail_unless(ret == SR_OK, "sr_init() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 3 failed: %d.", ret);
ret = sr_exit(sr_ctx3);
- fail_unless(ret == SR_OK, "sr_exit() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 3 failed: %d.", ret);
ret = sr_exit(sr_ctx2);
- fail_unless(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
ret = sr_exit(sr_ctx1);
- fail_unless(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
}
END_TEST
struct sr_context *sr_ctx1, *sr_ctx2, *sr_ctx3;
ret = sr_init(&sr_ctx1);
- fail_unless(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 1 failed: %d.", ret);
ret = sr_init(&sr_ctx2);
- fail_unless(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 2 failed: %d.", ret);
ret = sr_init(&sr_ctx3);
- fail_unless(ret == SR_OK, "sr_init() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() 3 failed: %d.", ret);
ret = sr_exit(sr_ctx1);
- fail_unless(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 1 failed: %d.", ret);
ret = sr_exit(sr_ctx2);
- fail_unless(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 2 failed: %d.", ret);
ret = sr_exit(sr_ctx3);
- fail_unless(ret == SR_OK, "sr_exit() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() 3 failed: %d.", ret);
}
END_TEST
int ret;
ret = sr_log_loglevel_set(SR_LOG_NONE);
- fail_unless(ret == SR_OK, "sr_log_loglevel_set() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_log_loglevel_set() failed: %d.", ret);
ret = sr_init(NULL);
- fail_unless(ret != SR_OK, "sr_init(NULL) should have failed.");
+ ck_assert_msg(ret != SR_OK, "sr_init(NULL) should have failed.");
}
END_TEST
int ret;
ret = sr_log_loglevel_set(SR_LOG_NONE);
- fail_unless(ret == SR_OK, "sr_log_loglevel_set() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_log_loglevel_set() failed: %d.", ret);
ret = sr_exit(NULL);
- fail_unless(ret != SR_OK, "sr_exit(NULL) should have failed.");
+ ck_assert_msg(ret != SR_OK, "sr_exit(NULL) should have failed.");
}
END_TEST
sdi = sr_dev_inst_user_new("Vendor", "Model", "Version");
- fail_unless(sdi != NULL, "sr_dev_inst_user_new() failed.");
+ ck_assert_msg(sdi != NULL, "sr_dev_inst_user_new() failed.");
- fail_unless(!strcmp("Vendor", sr_dev_inst_vendor_get(sdi)));
- fail_unless(!strcmp("Model", sr_dev_inst_model_get(sdi)));
- fail_unless(!strcmp("Version", sr_dev_inst_version_get(sdi)));
+ ck_assert(!strcmp("Vendor", sr_dev_inst_vendor_get(sdi)));
+ ck_assert(!strcmp("Model", sr_dev_inst_model_get(sdi)));
+ ck_assert(!strcmp("Version", sr_dev_inst_version_get(sdi)));
}
END_TEST
GSList *channels;
sdi = sr_dev_inst_user_new("Vendor", "Model", "Version");
- fail_unless(sdi != NULL, "sr_dev_inst_user_new() failed.");
+ ck_assert_msg(sdi != NULL, "sr_dev_inst_user_new() failed.");
channels = sr_dev_inst_channels_get(sdi);
- fail_unless(g_slist_length(channels) == 0, "More than 0 channels.");
+ ck_assert_msg(g_slist_length(channels) == 0, "More than 0 channels.");
ret = sr_dev_inst_channel_add(sdi, 0, SR_CHANNEL_LOGIC, "D1");
channels = sr_dev_inst_channels_get(sdi);
- fail_unless(ret == SR_OK);
- fail_unless(g_slist_length(channels) == 1);
+ ck_assert(ret == SR_OK);
+ ck_assert(g_slist_length(channels) == 1);
ret = sr_dev_inst_channel_add(sdi, 1, SR_CHANNEL_ANALOG, "A1");
channels = sr_dev_inst_channels_get(sdi);
- fail_unless(ret == SR_OK);
- fail_unless(g_slist_length(channels) == 2);
+ ck_assert(ret == SR_OK);
+ ck_assert(g_slist_length(channels) == 2);
}
END_TEST
struct sr_dev_driver **drivers;
drivers = sr_driver_list(srtest_ctx);
- fail_unless(drivers != NULL, "No drivers found.");
+ ck_assert_msg(drivers != NULL, "No drivers found.");
}
END_TEST
const struct sr_input_module **inputs;
inputs = sr_input_list();
- fail_unless(inputs != NULL, "No input modules found.");
+ ck_assert_msg(inputs != NULL, "No input modules found.");
}
END_TEST
for (i = 0; i < logic->length; i++) {
data = logic->data;
- if (data[i * logic->unitsize] != 0)
- fail("Logic data was not all-0x00.");
+ if (data[i * logic->unitsize] != 0) {
+ ck_abort_msg("Logic data was not all-0x00.");
+ }
}
}
for (i = 0; i < logic->length; i++) {
data = logic->data;
- if (data[i * logic->unitsize] != 0xff)
- fail("Logic data was not all-0xff.");
+ if (data[i * logic->unitsize] != 0xff) {
+ ck_abort_msg("Logic data was not all-0xff.");
+ }
}
}
for (i = 0; i < logic->length; i++) {
data = logic->data;
b = data[sample_counter + i];
- if (b != h[sample_counter + i])
- fail("Logic data was not 'Hello world'.");
+ if (b != h[sample_counter + i]) {
+ ck_abort_msg("Logic data was not 'Hello world'.");
+ }
}
}
(void)cb_data;
- fail_unless(sdi != NULL);
- fail_unless(packet != NULL);
+ ck_assert(sdi != NULL);
+ ck_assert(packet != NULL);
- if (df_packet_counter++ == 0)
- fail_unless(packet->type == SR_DF_HEADER,
- "The first packet must be an SR_DF_HEADER.");
+ if (df_packet_counter++ == 0) {
+ ck_assert_msg(packet->type == SR_DF_HEADER,
+ "The first packet must be an SR_DF_HEADER.");
+ }
- if (have_seen_df_end)
- fail("There must be no packets after an SR_DF_END, but we "
- "received a packet of type %d.", packet->type);
+ if (have_seen_df_end) {
+ ck_abort_msg("There must be no packets after an SR_DF_END, but we "
+ "received a packet of type %d.", packet->type);
+ }
p = packet->payload;
// fail_unless(p != NULL, "SR_DF_HEADER payload was NULL.");
logic_channellist = srtest_get_enabled_logic_channels(sdi);
- fail_unless(logic_channellist != NULL);
- fail_unless(logic_channellist->len != 0);
+ ck_assert(logic_channellist != NULL);
+ ck_assert(logic_channellist->len != 0);
// g_debug("Enabled channels: %d.", logic_channellist->len);
break;
case SR_DF_META:
// g_debug("Received SR_DF_META.");
meta = packet->payload;
- fail_unless(p != NULL, "SR_DF_META payload was NULL.");
+ ck_assert_msg(p != NULL, "SR_DF_META payload was NULL.");
for (l = meta->config; l; l = l->next) {
src = l->data;
samplerate = g_variant_get_uint64(src->data);
if (!expected_samplerate)
break;
- fail_unless(samplerate == *expected_samplerate,
- "Expected samplerate=%" PRIu64 ", "
- "got %" PRIu64 "", samplerate,
- *expected_samplerate);
+ ck_assert_msg(samplerate == *expected_samplerate,
+ "Expected samplerate=%" PRIu64 ", "
+ "got %" PRIu64 "", samplerate,
+ *expected_samplerate);
// g_debug("samplerate = %" PRIu64 " Hz.",
// samplerate);
break;
break;
case SR_DF_LOGIC:
logic = packet->payload;
- fail_unless(p != NULL, "SR_DF_LOGIC payload was NULL.");
+ ck_assert_msg(p != NULL, "SR_DF_LOGIC payload was NULL.");
// g_debug("Received SR_DF_LOGIC (%" PRIu64 " bytes, "
// "unitsize %d).", logic->length, logic->unitsize);
// g_debug("Received SR_DF_END.");
// fail_unless(p != NULL, "SR_DF_END payload was NULL.");
have_seen_df_end = TRUE;
- if (sample_counter != expected_samples)
- fail("Expected %" PRIu64 " samples, got %" PRIu64 "",
- expected_samples, sample_counter);
+ if (sample_counter != expected_samples) {
+ ck_abort_msg("Expected %" PRIu64 " samples, got %" PRIu64 "",
+ expected_samples, sample_counter);
+ }
break;
default:
/*
* Note: The binary input format doesn't support SR_DF_TRIGGER
* and some other types, those should yield an error.
*/
- fail("Invalid packet type: %d.", packet->type);
+ ck_abort_msg("Invalid packet type: %d.", packet->type);
break;
}
}
gbuf = g_string_new_len((gchar *)buf, (gssize)samples);
imod = sr_input_find("binary");
- fail_unless(imod != NULL, "Failed to find input module.");
+ ck_assert_msg(imod != NULL, "Failed to find input module.");
in = sr_input_new(imod, options);
- fail_unless(in != NULL, "Failed to create input instance.");
+ ck_assert_msg(in != NULL, "Failed to create input instance.");
sdi = sr_input_dev_inst_get(in);
sr_session_dev_add(session, sdi);
ret = sr_input_send(in, gbuf);
- fail_unless(ret == SR_OK, "sr_input_send() error: %d", ret);
+ ck_assert_msg(ret == SR_OK, "sr_input_send() error: %d", ret);
sr_input_free(in);
sr_session_destroy(session);
int ret;
ret = sr_init(&srtest_ctx);
- fail_unless(ret == SR_OK, "sr_init() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_init() failed: %d.", ret);
}
void srtest_teardown(void)
int ret;
ret = sr_exit(srtest_ctx);
- fail_unless(ret == SR_OK, "sr_exit() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_exit() failed: %d.", ret);
}
/* Get a libsigrok driver by name. */
int i;
drivers = sr_driver_list(srtest_ctx);
- fail_unless(drivers != NULL, "No drivers found.");
+ ck_assert_msg(drivers != NULL, "No drivers found.");
for (i = 0; drivers[i]; i++) {
if (strcmp(drivers[i]->name, drivername))
continue;
driver = drivers[i];
}
- fail_unless(driver != NULL, "Driver '%s' not found.", drivername);
+ ck_assert_msg(driver != NULL, "Driver '%s' not found.", drivername);
return driver;
}
int ret;
ret = sr_driver_init(sr_ctx, driver);
- fail_unless(ret == SR_OK, "Failed to init '%s' driver: %d.",
- driver->name, ret);
+ ck_assert_msg(ret == SR_OK, "Failed to init '%s' driver: %d.",
+ driver->name, ret);
}
/* Initialize all libsigrok drivers. */
int i, ret;
drivers = sr_driver_list(srtest_ctx);
- fail_unless(drivers != NULL, "No drivers found.");
+ ck_assert_msg(drivers != NULL, "No drivers found.");
for (i = 0; drivers[i]; i++) {
driver = drivers[i];
ret = sr_driver_init(sr_ctx, driver);
- fail_unless(ret == SR_OK, "Failed to init '%s' driver: %d.",
- driver->name, ret);
+ ck_assert_msg(ret == SR_OK, "Failed to init '%s' driver: %d.",
+ driver->name, ret);
}
}
ret = driver->config_set(SR_CONF_SAMPLERATE, gvar, sdi, NULL);
g_variant_unref(gvar);
- fail_unless(ret == SR_OK, "%s: Failed to set SR_CONF_SAMPLERATE: %d.",
- driver->name, ret);
+ ck_assert_msg(ret == SR_OK,
+ "%s: Failed to set SR_CONF_SAMPLERATE: %d.",
+ driver->name, ret);
}
/* Get the respective driver's current samplerate. */
samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
- fail_unless(ret == SR_OK, "%s: Failed to get SR_CONF_SAMPLERATE: %d.",
- driver->name, ret);
+ ck_assert_msg(ret == SR_OK,
+ "%s: Failed to get SR_CONF_SAMPLERATE: %d.",
+ driver->name, ret);
return samplerate;
}
srtest_driver_init(sr_ctx, driver);;
srtest_set_samplerate(driver, samplerate);
s = srtest_get_samplerate(driver);
- fail_unless(s == samplerate, "%s: Incorrect samplerate: %" PRIu64 ".",
- drivername, s);
+ ck_assert_msg(s == samplerate,
+ "%s: Incorrect samplerate: %" PRIu64 ".", drivername, s);
}
GArray *srtest_get_enabled_logic_channels(const struct sr_dev_inst *sdi)
const struct sr_output_module **outputs;
outputs = sr_output_list();
- fail_unless(outputs != NULL, "No output modules found.");
+ ck_assert_msg(outputs != NULL, "No output modules found.");
}
END_TEST
outputs = sr_output_list();
id = sr_output_id_get(outputs[0]);
- fail_unless(id != NULL, "No id found in output module.");
+ ck_assert_msg(id != NULL, "No id found in output module.");
}
END_TEST
outputs = sr_output_list();
name = sr_output_name_get(outputs[0]);
- fail_unless(name != NULL, "No name found in output module.");
+ ck_assert_msg(name != NULL, "No name found in output module.");
}
END_TEST
outputs = sr_output_list();
desc = sr_output_description_get(outputs[0]);
- fail_unless(desc != NULL, "No description found in output module.");
+ ck_assert_msg(desc != NULL, "No description found in output module.");
}
END_TEST
const char *id;
omod = sr_output_find("bits");
- fail_unless(omod != NULL, "Couldn't find the 'bits' output module.");
+ ck_assert_msg(omod != NULL, "Couldn't find the 'bits' output module.");
id = sr_output_id_get(omod);
- fail_unless(!strcmp(id, "bits"), "That is not the 'bits' module!");
+ ck_assert_msg(!strcmp(id, "bits"), "That is not the 'bits' module!");
}
END_TEST
const struct sr_option **opt;
opt = sr_output_options_get(sr_output_find("bits"));
- fail_unless(opt != NULL, "Couldn't find 'bits' options.");
- fail_unless(!strcmp((*opt)->id, "width"), "Wrong 'bits' option found!");
+ ck_assert_msg(opt != NULL, "Couldn't find 'bits' options.");
+ ck_assert_msg(!strcmp((*opt)->id, "width"),
+ "Wrong 'bits' option found!");
}
END_TEST
struct sr_session *sess;
ret = sr_session_new(srtest_ctx, &sess);
- fail_unless(ret == SR_OK, "sr_session_new() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_new() failed: %d.", ret);
sr_session_destroy(sess);
}
END_TEST
int ret;
ret = sr_session_new(srtest_ctx, NULL);
- fail_unless(ret != SR_OK, "sr_session_new(NULL) worked.");
+ ck_assert_msg(ret != SR_OK, "sr_session_new(NULL) worked.");
}
END_TEST
/* Multiple sr_session_new() calls must work. */
ret = sr_session_new(srtest_ctx, &sess1);
- fail_unless(ret == SR_OK, "sr_session_new() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_new() 1 failed: %d.", ret);
ret = sr_session_new(srtest_ctx, &sess2);
- fail_unless(ret == SR_OK, "sr_session_new() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_new() 2 failed: %d.", ret);
ret = sr_session_new(srtest_ctx, &sess3);
- fail_unless(ret == SR_OK, "sr_session_new() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_new() 3 failed: %d.", ret);
/* The returned session pointers must all be non-NULL. */
- fail_unless(sess1 != NULL);
- fail_unless(sess2 != NULL);
- fail_unless(sess3 != NULL);
+ ck_assert(sess1 != NULL);
+ ck_assert(sess2 != NULL);
+ ck_assert(sess3 != NULL);
/* The returned session pointers must not be the same. */
- fail_unless(sess1 != sess2);
- fail_unless(sess1 != sess3);
- fail_unless(sess2 != sess3);
+ ck_assert(sess1 != sess2);
+ ck_assert(sess1 != sess3);
+ ck_assert(sess2 != sess3);
/* Destroying any of the sessions must work. */
ret = sr_session_destroy(sess1);
- fail_unless(ret == SR_OK, "sr_session_destroy() 1 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_destroy() 1 failed: %d.", ret);
ret = sr_session_destroy(sess2);
- fail_unless(ret == SR_OK, "sr_session_destroy() 2 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_destroy() 2 failed: %d.", ret);
ret = sr_session_destroy(sess3);
- fail_unless(ret == SR_OK, "sr_session_destroy() 3 failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_destroy() 3 failed: %d.", ret);
}
END_TEST
sr_session_new(srtest_ctx, &sess);
ret = sr_session_destroy(sess);
- fail_unless(ret == SR_OK, "sr_session_destroy() failed: %d.", ret);
+ ck_assert_msg(ret == SR_OK, "sr_session_destroy() failed: %d.", ret);
}
END_TEST
int ret;
ret = sr_session_destroy(NULL);
- fail_unless(ret != SR_OK, "sr_session_destroy() worked.");
+ ck_assert_msg(ret != SR_OK, "sr_session_destroy() worked.");
}
END_TEST
/* Set a trigger and see if getting it works OK. */
ret = sr_session_trigger_set(sess, t1);
- fail_unless(ret == SR_OK);
+ ck_assert(ret == SR_OK);
t2 = sr_session_trigger_get(sess);
- fail_unless(t2 != NULL);
- fail_unless(t1 == t2);
- fail_unless(g_slist_length(t1->stages) == g_slist_length(t2->stages));
- fail_unless(!strcmp(t1->name, t2->name));
+ ck_assert(t2 != NULL);
+ ck_assert(t1 == t2);
+ ck_assert(g_slist_length(t1->stages) == g_slist_length(t2->stages));
+ ck_assert(!strcmp(t1->name, t2->name));
sr_session_destroy(sess);
}
/* Adding a NULL trigger is allowed. */
ret = sr_session_trigger_set(sess, NULL);
- fail_unless(ret == SR_OK);
+ ck_assert(ret == SR_OK);
t = sr_session_trigger_get(sess);
- fail_unless(t == NULL);
+ ck_assert(t == NULL);
sr_session_destroy(sess);
}
/* NULL session, must not segfault. */
ret = sr_session_trigger_set(NULL, t);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
/* NULL session and NULL trigger, must not segfault. */
ret = sr_session_trigger_set(NULL, NULL);
- fail_unless(ret == SR_ERR_ARG);
+ ck_assert(ret == SR_ERR_ARG);
}
END_TEST
/* NULL session, must not segfault. */
t = sr_session_trigger_get(NULL);
- fail_unless(t == NULL);
+ ck_assert(t == NULL);
}
END_TEST
len = sr_vsnprintf_ascii(s, len, format, args);
va_end(args);
- fail_unless(s != NULL,
- "Invalid result for '%s': len = %i.", expected, len);
- fail_unless(!strcmp(s, expected),
- "Invalid result for '%s': %s.", expected, s);
+ ck_assert_msg(s != NULL, "Invalid result for '%s': len = %i.",
+ expected, len);
+ ck_assert_msg(!strcmp(s, expected), "Invalid result for '%s': %s.",
+ expected, s);
g_free(s);
}
len = sr_vsprintf_ascii(s, format, args_copy);
va_end(args_copy);
- fail_unless(s != NULL,
- "Invalid result for '%s': len = %i.", expected, len);
- fail_unless(!strcmp(s, expected),
- "Invalid result for '%s': %s.", expected, s);
+ ck_assert_msg(s != NULL, "Invalid result for '%s': len = %i.",
+ expected, len);
+ ck_assert_msg(!strcmp(s, expected), "Invalid result for '%s': %s.",
+ expected, s);
g_free(s);
}
char *s;
s = sr_samplerate_string(samplerate);
- fail_unless(s != NULL);
- fail_unless(!strcmp(s, expected),
- "Invalid result for '%s': %s.", expected, s);
+ ck_assert(s != NULL);
+ ck_assert_msg(!strcmp(s, expected), "Invalid result for '%s': %s.",
+ expected, s);
g_free(s);
}
char *s;
s = sr_period_string(v_p, v_q);
- fail_unless(s != NULL);
- fail_unless(!strcmp(s, expected),
- "Invalid result for '%s': %s.", expected, s);
+ ck_assert(s != NULL);
+ ck_assert_msg(!strcmp(s, expected), "Invalid result for '%s': %s.",
+ expected, s);
g_free(s);
}
struct sr_rational rational;
ret = sr_parse_rational(input, &rational);
- fail_unless(ret == SR_OK, "Unexpected rc for '%s': %d, errno %d.",
- input, ret, errno);
- fail_unless((expected.p == rational.p) && (expected.q == rational.q),
- "Invalid result for '%s': %" PRIi64 "/%" PRIu64 "'.",
- input, rational.p, rational.q);
+ ck_assert_msg(ret == SR_OK, "Unexpected rc for '%s': %d, errno %d.",
+ input, ret, errno);
+ ck_assert_msg((expected.p == rational.p) && (expected.q == rational.q),
+ "Invalid result for '%s': %" PRIi64 "/%" PRIu64 "'.",
+ input, rational.p, rational.q);
}
static void test_rational_fail(const char *input)
struct sr_rational rational;
ret = sr_parse_rational(input, &rational);
- fail_unless(ret != SR_OK, "Unexpected success for '%s'.", input);
+ ck_assert_msg(ret != SR_OK, "Unexpected success for '%s'.", input);
}
static void test_voltage(uint64_t v_p, uint64_t v_q, const char *expected)
char *s;
s = sr_voltage_string(v_p, v_q);
- fail_unless(s != NULL);
- fail_unless(!strcmp(s, expected),
- "Invalid result for '%s': %s.", expected, s);
+ ck_assert(s != NULL);
+ ck_assert_msg(!strcmp(s, expected), "Invalid result for '%s': %s.",
+ expected, s);
g_free(s);
}
/* Cover first line in tests. */
taken = 0;
line = sr_text_next_line(read_pos, input_len, &next_pos, &taken);
- fail_unless(line, "Text line not found");
- fail_unless(strcmp(line, TEXT_CORE_1) == 0, "Unexpected line content");
- fail_unless(next_pos, "No next line found");
- fail_unless(strncmp(next_pos, TEXT_LINE_2, strlen(TEXT_LINE_2)) == 0,
- "Unexpected next line content");
- fail_unless(taken == strlen(TEXT_LINE_1),
- "Unexpected consumed count");
+ ck_assert_msg(line, "Text line not found");
+ ck_assert_msg(strcmp(line, TEXT_CORE_1) == 0,
+ "Unexpected line content");
+ ck_assert_msg(next_pos, "No next line found");
+ ck_assert_msg(strncmp(next_pos, TEXT_LINE_2, strlen(TEXT_LINE_2)) == 0,
+ "Unexpected next line content");
+ ck_assert_msg(taken == strlen(TEXT_LINE_1),
+ "Unexpected consumed count");
read_pos = next_pos;
input_len -= taken;
taken = 0;
/* Cover second line in tests. DO NOT void 'taken' yet. */
line = sr_text_next_line(read_pos, input_len, &next_pos, &taken);
- fail_unless(line, "Text line not found");
- fail_unless(strcmp(line, TEXT_CORE_2) == 0,
- "Unexpected text line content");
- fail_unless(next_pos, "No next line found");
- fail_unless(strncmp(next_pos, TEXT_LINE_3, strlen(TEXT_LINE_3)) == 0,
- "Unexpected next line content");
- fail_unless(taken == strlen(TEXT_LINE_2),
- "Unexpected consumed count");
+ ck_assert_msg(line, "Text line not found");
+ ck_assert_msg(strcmp(line, TEXT_CORE_2) == 0,
+ "Unexpected text line content");
+ ck_assert_msg(next_pos, "No next line found");
+ ck_assert_msg(strncmp(next_pos, TEXT_LINE_3, strlen(TEXT_LINE_3)) == 0,
+ "Unexpected next line content");
+ ck_assert_msg(taken == strlen(TEXT_LINE_2),
+ "Unexpected consumed count");
input_len -= next_pos - read_pos;
read_pos = next_pos;
/* Cover third line in tests. Accumulates 'taken'. */
line = sr_text_next_line(read_pos, input_len, &next_pos, &taken);
- fail_unless(line, "Text line not found");
- fail_unless(strcmp(line, TEXT_CORE_3) == 0, "Unexpected line content");
- fail_unless(next_pos, "No next line found");
- fail_unless(strncmp(next_pos, TEXT_LINE_4, strlen(TEXT_LINE_4)) == 0,
- "Unexpected next line content");
- fail_unless(taken == strlen(TEXT_LINE_2) + strlen(TEXT_LINE_3),
- "Unexpected consumed count (totalled)");
+ ck_assert_msg(line, "Text line not found");
+ ck_assert_msg(strcmp(line, TEXT_CORE_3) == 0,
+ "Unexpected line content");
+ ck_assert_msg(next_pos, "No next line found");
+ ck_assert_msg(strncmp(next_pos, TEXT_LINE_4, strlen(TEXT_LINE_4)) == 0,
+ "Unexpected next line content");
+ ck_assert_msg(taken == strlen(TEXT_LINE_2) + strlen(TEXT_LINE_3),
+ "Unexpected consumed count (totalled)");
input_len -= next_pos - read_pos;
read_pos = next_pos;
taken = 0;
/* Cover last line in tests. */
line = sr_text_next_line(read_pos, input_len, &next_pos, &taken);
- fail_unless(line, "Text line not found");
- fail_unless(strcmp(line, TEXT_CORE_4) == 0,
- "Unexpected text line content");
- fail_unless(!next_pos, "Next line found, unexpected");
- fail_unless(taken == strlen(TEXT_LINE_4),
- "Unexpected consumed count");
+ ck_assert_msg(line, "Text line not found");
+ ck_assert_msg(strcmp(line, TEXT_CORE_4) == 0,
+ "Unexpected text line content");
+ ck_assert_msg(!next_pos, "Next line found, unexpected");
+ ck_assert_msg(taken == strlen(TEXT_LINE_4),
+ "Unexpected consumed count");
input_len -= taken;
read_pos = next_pos;
/* All input must have been consumed. */
- fail_unless(!read_pos);
- fail_unless(!input_len);
+ ck_assert(!read_pos);
+ ck_assert(!input_len);
g_free(input_text);
}
want = words[word_idx];
have = sr_text_next_word(read_pos, &next_pos);
if (!want) {
- fail_unless(!have, "word found, unexpected");
- fail_unless(!next_pos, "next found after end");
+ ck_assert_msg(!have, "word found, unexpected");
+ ck_assert_msg(!next_pos,
+ "next found after end");
break;
}
word_idx++;
read_pos = next_pos;
- fail_unless(have, "word not found");
- fail_unless(strcmp(have, want) == 0,
- "unexpected word found");
+ ck_assert_msg(have, "word not found");
+ ck_assert_msg(strcmp(have, want) == 0,
+ "unexpected word found");
}
- fail_unless(!words[word_idx], "missed expected words");
+ ck_assert_msg(!words[word_idx], "missed expected words");
g_free(line);
}
for (case_idx = 0; case_idx < ARRAY_SIZE(power_cases); case_idx++) {
tcase = &power_cases[case_idx];
ret = sr_next_power_of_two(tcase->value, &bits, &power);
- fail_unless(ret == SR_OK, "bits count not found");
- fail_unless(bits == tcase->want_bits, "bits count differs");
- fail_unless(power == tcase->want_power, "power differs");
+ ck_assert_msg(ret == SR_OK, "bits count not found");
+ ck_assert_msg(bits == tcase->want_bits, "bits count differs");
+ ck_assert_msg(power == tcase->want_power, "power differs");
}
}
END_TEST
const struct sr_transform_module **transforms;
transforms = sr_transform_list();
- fail_unless(transforms != NULL, "No transform modules found.");
+ ck_assert_msg(transforms != NULL, "No transform modules found.");
}
END_TEST
transforms = sr_transform_list();
id = sr_transform_id_get(transforms[0]);
- fail_unless(id != NULL, "No ID found in transform module.");
+ ck_assert_msg(id != NULL, "No ID found in transform module.");
}
END_TEST
transforms = sr_transform_list();
name = sr_transform_name_get(transforms[0]);
- fail_unless(name != NULL, "No name found in transform module.");
+ ck_assert_msg(name != NULL, "No name found in transform module.");
}
END_TEST
transforms = sr_transform_list();
desc = sr_transform_description_get(transforms[0]);
- fail_unless(desc != NULL, "No description found in transform module.");
+ ck_assert_msg(desc != NULL,
+ "No description found in transform module.");
}
END_TEST
const char *id;
tmod = sr_transform_find("nop");
- fail_unless(tmod != NULL, "Couldn't find the 'nop' transform module.");
+ ck_assert_msg(tmod != NULL,
+ "Couldn't find the 'nop' transform module.");
id = sr_transform_id_get(tmod);
- fail_unless(id != NULL, "No ID found in transform module.");
- fail_unless(!strcmp(id, "nop"), "That is not the 'nop' module!");
+ ck_assert_msg(id != NULL, "No ID found in transform module.");
+ ck_assert_msg(!strcmp(id, "nop"), "That is not the 'nop' module!");
}
END_TEST
const struct sr_option **opt;
opt = sr_transform_options_get(sr_transform_find("nop"));
- fail_unless(opt == NULL, "Transform module 'nop' doesn't have options.");
+ ck_assert_msg(opt == NULL,
+ "Transform module 'nop' doesn't have options.");
}
END_TEST
for (i = 0; i < NUM_TRIGGERS; i++) {
sprintf((char *)&name, "T%d", i);
t[i] = sr_trigger_new((const char *)&name);
- fail_unless(t[i] != NULL);
- fail_unless(!strcmp(t[i]->name, (const char *)&name));
- fail_unless(t[i]->stages == NULL);
+ ck_assert(t[i] != NULL);
+ ck_assert(!strcmp(t[i]->name, (const char *)&name));
+ ck_assert(t[i]->stages == NULL);
}
/* Free the triggers again (must not segfault). */
/* Create a few triggers with a NULL name (which is allowed). */
for (i = 0; i < NUM_TRIGGERS; i++) {
t[i] = sr_trigger_new(NULL);
- fail_unless(t[i] != NULL);
- fail_unless(t[i]->name == NULL);
- fail_unless(t[i]->stages == NULL);
+ ck_assert(t[i] != NULL);
+ ck_assert(t[i]->name == NULL);
+ ck_assert(t[i]->stages == NULL);
}
/* Free the triggers again (must not segfault). */
/* Add a bunch of trigger stages to this trigger. */
for (j = 0; j < NUM_STAGES; j++) {
s[j] = sr_trigger_stage_add(t[i]);
- fail_unless(s[j] != NULL);
- fail_unless(t[i]->stages != NULL);
- fail_unless((int)g_slist_length(t[i]->stages) == (j + 1));
- fail_unless(s[j]->stage == j);
- fail_unless(s[j]->matches == NULL);
+ ck_assert(s[j] != NULL);
+ ck_assert(t[i]->stages != NULL);
+ ck_assert((int)g_slist_length(t[i]->stages) == (j + 1));
+ ck_assert(s[j]->stage == j);
+ ck_assert(s[j]->matches == NULL);
}
}
START_TEST(test_trigger_stage_add_null)
{
/* Should not segfault, but rather return NULL. */
- fail_unless(sr_trigger_stage_add(NULL) == NULL);
+ ck_assert(sr_trigger_stage_add(NULL) == NULL);
}
END_TEST
/* Logic channel matches. */
tm = 1 + (k % 5); /* *_ZERO .. *_EDGE */
ret = sr_trigger_match_add(s[j], chl[k], tm, 0);
- fail_unless(ret == SR_OK);
+ ck_assert(ret == SR_OK);
/* Analog channel matches. */
tm = 3 + (k % 4); /* *_RISING .. *_UNDER */
ret = sr_trigger_match_add(s[j], cha[k],
tm, ((rand() % 500) - 500) * 1.739);
- fail_unless(ret == SR_OK);
+ ck_assert(ret == SR_OK);
}
}
}
/* Initially we have no matches at all. */
sl = t->stages->data;
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(g_slist_length(sl->matches) == 0);
/* NULL stage */
ret = sr_trigger_match_add(NULL, chl, SR_TRIGGER_ZERO, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
/* NULL channel */
ret = sr_trigger_match_add(s, NULL, SR_TRIGGER_ZERO, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
/* Invalid trigger matches for logic channels. */
ret = sr_trigger_match_add(s, chl, SR_TRIGGER_OVER, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
ret = sr_trigger_match_add(s, chl, SR_TRIGGER_UNDER, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
/* Invalid trigger matches for analog channels. */
ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ZERO, 9.4);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ONE, -9.4);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
/* Invalid channel type. */
chl->type = -1;
ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
chl->type = 270;
ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
- fail_unless(ret == SR_ERR_ARG);
- fail_unless(g_slist_length(sl->matches) == 0);
+ ck_assert(ret == SR_ERR_ARG);
+ ck_assert(g_slist_length(sl->matches) == 0);
sr_trigger_free(t);
g_free(chl->name);
int ver;
ver = sr_package_version_major_get();
- fail_unless(ver == SR_PACKAGE_VERSION_MAJOR);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_PACKAGE_VERSION_MAJOR);
+ ck_assert(ver >= 0 && ver <= 20);
ver = sr_package_version_minor_get();
- fail_unless(ver == SR_PACKAGE_VERSION_MINOR);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_PACKAGE_VERSION_MINOR);
+ ck_assert(ver >= 0 && ver <= 20);
ver = sr_package_version_micro_get();
- fail_unless(ver == SR_PACKAGE_VERSION_MICRO);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_PACKAGE_VERSION_MICRO);
+ ck_assert(ver >= 0 && ver <= 20);
ver = sr_lib_version_current_get();
- fail_unless(ver == SR_LIB_VERSION_CURRENT);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_LIB_VERSION_CURRENT);
+ ck_assert(ver >= 0 && ver <= 20);
ver = sr_lib_version_revision_get();
- fail_unless(ver == SR_LIB_VERSION_REVISION);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_LIB_VERSION_REVISION);
+ ck_assert(ver >= 0 && ver <= 20);
ver = sr_lib_version_age_get();
- fail_unless(ver == SR_LIB_VERSION_AGE);
- fail_unless(ver >= 0 && ver <= 20);
+ ck_assert(ver == SR_LIB_VERSION_AGE);
+ ck_assert(ver >= 0 && ver <= 20);
}
END_TEST
const size_t len_max = 2 + 1 + 2 + 1 + 2 + 5 + 12 + 6;
str = sr_package_version_string_get();
- fail_unless(str != NULL);
- fail_unless(strlen(str) >= len_min);
- fail_unless(strlen(str) <= len_max,
- "Max len exceeded, max %zu, text %s", len_max, str);
+ ck_assert(str != NULL);
+ ck_assert(strlen(str) >= len_min);
+ ck_assert_msg(strlen(str) <= len_max,
+ "Max len exceeded, max %zu, text %s", len_max, str);
str = sr_lib_version_string_get();
- fail_unless(str != NULL);
- fail_unless(strlen(str) >= len_min);
- fail_unless(strlen(str) <= len_max,
- "Max len exceeded, max %zu, text %s", len_max, str);
+ ck_assert(str != NULL);
+ ck_assert(strlen(str) >= len_min);
+ ck_assert_msg(strlen(str) <= len_max,
+ "Max len exceeded, max %zu, text %s", len_max, str);
}
END_TEST
projects / libsigrok.git / commitdiff