mirror of
https://gitlab.freedesktop.org/wayland/weston.git
synced 2025-12-20 04:40:07 +01:00
shared: add many weston assert that were missing
This adds a ton of weston assert macros that were missing, as well as tests for all of that. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
This commit is contained in:
Leandro Ribeiro
parent
81d68a561e
commit
6d8a15839d
2 changed files with 675 additions and 70 deletions
|
|
@ -85,13 +85,40 @@ weston_assert_fail_(const struct weston_compositor *compositor, const char *fmt,
|
|||
#define weston_assert_ptr_not_null(comp, a) weston_assert_(comp, a, NULL, const void *, "%p", !=)
|
||||
#define weston_assert_ptr_null(comp, a) weston_assert_(comp, a, NULL, const void *, "%p", ==)
|
||||
#define weston_assert_ptr_eq(comp, a, b) weston_assert_(comp, a, b, const void *, "%p", ==)
|
||||
#define weston_assert_ptr_ne(comp, a, b) weston_assert_(comp, a, b, const void *, "%p", !=)
|
||||
|
||||
/* Floating-point asserts. */
|
||||
|
||||
#define weston_assert_f32_eq(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", ==)
|
||||
#define weston_assert_f32_ne(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", !=)
|
||||
#define weston_assert_f32_gt(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", >)
|
||||
#define weston_assert_f32_ge(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", >=)
|
||||
#define weston_assert_f32_lt(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", <)
|
||||
#define weston_assert_f32_le(comp, a, b) weston_assert_(comp, a, b, float, "%.10g", <=)
|
||||
|
||||
#define weston_assert_f64_eq(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", ==)
|
||||
#define weston_assert_f64_ne(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", !=)
|
||||
#define weston_assert_f64_gt(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", >)
|
||||
#define weston_assert_f64_ge(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", >=)
|
||||
#define weston_assert_f64_lt(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", <)
|
||||
#define weston_assert_f64_le(comp, a, b) weston_assert_(comp, a, b, double, "%.10g", <=)
|
||||
|
||||
/* Unsigned int asserts. */
|
||||
|
||||
#define weston_assert_u8_eq(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, ==)
|
||||
#define weston_assert_u8_ne(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, !=)
|
||||
#define weston_assert_u8_gt(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, >)
|
||||
#define weston_assert_u8_ge(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, >=)
|
||||
#define weston_assert_u8_lt(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, <)
|
||||
#define weston_assert_u8_le(comp, a, b) weston_assert_(comp, a, b, uint8_t, "%" PRIu8, <=)
|
||||
|
||||
#define weston_assert_u16_eq(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, ==)
|
||||
#define weston_assert_u16_ne(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, !=)
|
||||
#define weston_assert_u16_gt(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, >)
|
||||
#define weston_assert_u16_ge(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, >=)
|
||||
#define weston_assert_u16_lt(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, <)
|
||||
#define weston_assert_u16_le(comp, a, b) weston_assert_(comp, a, b, uint16_t, "%" PRIu16, <=)
|
||||
|
||||
#define weston_assert_u32_eq(comp, a, b) weston_assert_(comp, a, b, uint32_t, "%" PRIu32, ==)
|
||||
#define weston_assert_u32_ne(comp, a, b) weston_assert_(comp, a, b, uint32_t, "%" PRIu32, !=)
|
||||
#define weston_assert_u32_gt(comp, a, b) weston_assert_(comp, a, b, uint32_t, "%" PRIu32, >)
|
||||
|
|
@ -100,6 +127,55 @@ weston_assert_fail_(const struct weston_compositor *compositor, const char *fmt,
|
|||
#define weston_assert_u32_le(comp, a, b) weston_assert_(comp, a, b, uint32_t, "%" PRIu32, <=)
|
||||
|
||||
#define weston_assert_u64_eq(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, ==)
|
||||
#define weston_assert_u64_ne(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, !=)
|
||||
#define weston_assert_u64_gt(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, >)
|
||||
#define weston_assert_u64_ge(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, >=)
|
||||
#define weston_assert_u64_lt(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, <)
|
||||
#define weston_assert_u64_le(comp, a, b) weston_assert_(comp, a, b, uint64_t, "%" PRIu64, <=)
|
||||
|
||||
#define weston_assert_uint_eq(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", ==)
|
||||
#define weston_assert_uint_ne(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", !=)
|
||||
#define weston_assert_uint_gt(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", >)
|
||||
#define weston_assert_uint_ge(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", >=)
|
||||
#define weston_assert_uint_lt(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", <)
|
||||
#define weston_assert_uint_le(comp, a, b) weston_assert_(comp, a, b, unsigned int, "%u", <=)
|
||||
|
||||
/* Signed int asserts. */
|
||||
|
||||
#define weston_assert_s8_eq(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, ==)
|
||||
#define weston_assert_s8_ne(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, !=)
|
||||
#define weston_assert_s8_gt(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, >)
|
||||
#define weston_assert_s8_ge(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, >=)
|
||||
#define weston_assert_s8_lt(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, <)
|
||||
#define weston_assert_s8_le(comp, a, b) weston_assert_(comp, a, b, int8_t, "%" PRId8, <=)
|
||||
|
||||
#define weston_assert_s16_eq(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, ==)
|
||||
#define weston_assert_s16_ne(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, !=)
|
||||
#define weston_assert_s16_gt(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, >)
|
||||
#define weston_assert_s16_ge(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, >=)
|
||||
#define weston_assert_s16_lt(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, <)
|
||||
#define weston_assert_s16_le(comp, a, b) weston_assert_(comp, a, b, int16_t, "%" PRId16, <=)
|
||||
|
||||
#define weston_assert_s32_eq(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, ==)
|
||||
#define weston_assert_s32_ne(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, !=)
|
||||
#define weston_assert_s32_gt(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, >)
|
||||
#define weston_assert_s32_ge(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, >=)
|
||||
#define weston_assert_s32_lt(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, <)
|
||||
#define weston_assert_s32_le(comp, a, b) weston_assert_(comp, a, b, int32_t, "%" PRId32, <=)
|
||||
|
||||
#define weston_assert_s64_eq(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, ==)
|
||||
#define weston_assert_s64_ne(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, !=)
|
||||
#define weston_assert_s64_gt(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, >)
|
||||
#define weston_assert_s64_ge(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, >=)
|
||||
#define weston_assert_s64_lt(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, <)
|
||||
#define weston_assert_s64_le(comp, a, b) weston_assert_(comp, a, b, int64_t, "%" PRId64, <=)
|
||||
|
||||
#define weston_assert_int_eq(comp, a, b) weston_assert_(comp, a, b, int, "%d", ==)
|
||||
#define weston_assert_int_ne(comp, a, b) weston_assert_(comp, a, b, int, "%d", !=)
|
||||
#define weston_assert_int_gt(comp, a, b) weston_assert_(comp, a, b, int, "%d", >)
|
||||
#define weston_assert_int_ge(comp, a, b) weston_assert_(comp, a, b, int, "%d", >=)
|
||||
#define weston_assert_int_lt(comp, a, b) weston_assert_(comp, a, b, int, "%d", <)
|
||||
#define weston_assert_int_le(comp, a, b) weston_assert_(comp, a, b, int, "%d", <=)
|
||||
|
||||
/* String asserts. */
|
||||
|
||||
|
|
@ -156,3 +232,5 @@ do { \
|
|||
custom_assert_fail_(ec, "%s:%u: Assertion failed! This should not be reached: %s\n", \
|
||||
__FILE__, __LINE__, reason); \
|
||||
} while (0)
|
||||
|
||||
#define weston_assert_enum(comp, a, b) weston_assert_u64_eq(comp, a, b)
|
||||
|
|
|
|||
|
|
@ -37,6 +37,11 @@ abort_if_not(bool cond)
|
|||
abort();
|
||||
}
|
||||
|
||||
enum my_enum {
|
||||
MY_ENUM_A,
|
||||
MY_ENUM_B,
|
||||
};
|
||||
|
||||
struct my_type {
|
||||
int x;
|
||||
float y;
|
||||
|
|
@ -60,88 +65,610 @@ my_type_cmp(const struct my_type *a, const struct my_type *b)
|
|||
#define weston_assert_my_type_lt(compositor, a, b) \
|
||||
weston_assert_fn_(compositor, my_type_cmp, a, b, const struct my_type *, "my_type %p", <)
|
||||
|
||||
TEST(asserts)
|
||||
TEST(asserts_custom)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
ret = weston_assert_true(compositor, false);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_true(compositor, true);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_false(compositor, true);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_false(compositor, false);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_true(compositor, true && false);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_not_null(compositor, &ret);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_ptr_not_null(compositor, NULL);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_null(compositor, NULL);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_ptr_null(compositor, &ret);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_eq(compositor, &ret, &ret);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_ptr_eq(compositor, &ret, &ret + 1);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
double fifteen = 15.0;
|
||||
ret = weston_assert_f64_eq(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f64_eq(compositor, fifteen, 15);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_u32_le(compositor, 0, 0);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_le(compositor, 1, 0);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
const char *nom = "bar";
|
||||
ret = weston_assert_str_eq(compositor, nom, "bar");
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_str_eq(compositor, nom, "baz");
|
||||
abort_if_not(ret == false);
|
||||
|
||||
struct my_type a = { 1, 2.0 };
|
||||
struct my_type b = { 0, 2.0 };
|
||||
|
||||
ret = weston_assert_my_type_lt(compositor, &b, &a);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_my_type_lt(compositor, &a, &b);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
uint32_t bitfield = 0xffff;
|
||||
ret = weston_assert_bit_set(compositor, bitfield, 1ull << 2);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_bit_set(compositor, bitfield, 1ull << 57);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
uint64_t max_uint64 = UINT64_MAX;
|
||||
ret = weston_assert_u64_eq(compositor, max_uint64, 0);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
uint64_t val = 0x200010001000ffff;
|
||||
uint64_t msk = 0x00000000fffffff3;
|
||||
ret = weston_assert_legal_bits(compositor, val, msk);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_legal_bits(compositor, val, UINT64_MAX);
|
||||
abort_if_not(ret);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_boolean)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
ret = weston_assert_true(compositor, false);
|
||||
abort_if_not(ret == false);
|
||||
ret = weston_assert_true(compositor, true);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_false(compositor, true);
|
||||
abort_if_not(ret == false);
|
||||
ret = weston_assert_false(compositor, false);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_true(compositor, true && false);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_pointer)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
ret = weston_assert_ptr_not_null(compositor, &ret);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_ptr_not_null(compositor, NULL);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_null(compositor, NULL);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_ptr_null(compositor, &ret);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_eq(compositor, &ret, &ret);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_ptr_eq(compositor, &ret, &ret + 1);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_ptr_ne(compositor, &ret, &ret + 1);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_ptr_ne(compositor, &ret, &ret);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_string)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
const char *nom = "bar";
|
||||
|
||||
ret = weston_assert_str_eq(compositor, nom, "bar");
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_str_eq(compositor, nom, "baz");
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_bitmask)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
uint32_t bitfield = 0xffff;
|
||||
|
||||
ret = weston_assert_bit_set(compositor, bitfield, 1ull << 2);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_bit_set(compositor, bitfield, 1ull << 57);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_misc)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
ret = weston_assert_enum(compositor, MY_ENUM_A, MY_ENUM_A);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_enum(compositor, MY_ENUM_A, MY_ENUM_B);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* weston_assert_not_reached is a bit awkward to test, so let's skip */
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_floating_point)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
/* Float asserts. */
|
||||
|
||||
float sixteen = 16.0;
|
||||
ret = weston_assert_f32_eq(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret == false);
|
||||
ret = weston_assert_f32_eq(compositor, sixteen, 16);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_f32_ne(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_ne(compositor, sixteen, sixteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f32_gt(compositor, 16.000001, sixteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_gt(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f32_ge(compositor, sixteen, sixteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_ge(compositor, 16.000001, sixteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_ge(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f32_lt(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_lt(compositor, 16.000001, sixteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f32_le(compositor, sixteen, sixteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_le(compositor, sixteen, 16.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f32_le(compositor, 16.000001, sixteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* Double asserts. */
|
||||
|
||||
double fifteen = 15.0;
|
||||
ret = weston_assert_f64_eq(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret == false);
|
||||
ret = weston_assert_f64_eq(compositor, fifteen, 15);
|
||||
abort_if_not(ret);
|
||||
|
||||
ret = weston_assert_f64_ne(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_ne(compositor, fifteen, fifteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f64_gt(compositor, 15.000001, fifteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_gt(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f64_ge(compositor, fifteen, fifteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_ge(compositor, 15.000001, fifteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_ge(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f64_lt(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_lt(compositor, 15.000001, fifteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_f64_le(compositor, fifteen, fifteen);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_le(compositor, fifteen, 15.000001);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_f64_le(compositor, 15.000001, fifteen);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_unsigned_int)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
/* uint8_t asserts. */
|
||||
|
||||
ret = weston_assert_u8_eq(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_eq(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u8_ne(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_ne(compositor, 5, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u8_gt(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_gt(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u8_ge(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_ge(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_ge(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u8_lt(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_lt(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u8_le(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_le(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u8_le(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* uint16_t asserts. */
|
||||
|
||||
ret = weston_assert_u16_eq(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_eq(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u16_ne(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_ne(compositor, 5, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u16_gt(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_gt(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u16_ge(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_ge(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_ge(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u16_lt(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_lt(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u16_le(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_le(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u16_le(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* uint32_t asserts. */
|
||||
|
||||
ret = weston_assert_u32_eq(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_eq(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u32_ne(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_ne(compositor, 5, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u32_gt(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_gt(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u32_ge(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_ge(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_ge(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u32_lt(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_lt(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u32_le(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_le(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u32_le(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* uint64_t asserts. */
|
||||
|
||||
ret = weston_assert_u64_eq(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_eq(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u64_ne(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_ne(compositor, 5, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u64_gt(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_gt(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u64_ge(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_ge(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_ge(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u64_lt(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_lt(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_u64_le(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_le(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_u64_le(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* unsigned int asserts. */
|
||||
|
||||
ret = weston_assert_uint_eq(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_eq(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_uint_ne(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_ne(compositor, 5, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_uint_gt(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_gt(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_uint_ge(compositor, 6, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_ge(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_ge(compositor, 5, 6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_uint_lt(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_lt(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_uint_le(compositor, 5, 6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_le(compositor, 5, 5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_uint_le(compositor, 6, 5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
||||
return RESULT_OK;
|
||||
}
|
||||
|
||||
TEST(asserts_signed_int)
|
||||
{
|
||||
/* Unused by the macros for now, so let's just use NULL. */
|
||||
struct weston_compositor *compositor = NULL;
|
||||
bool ret;
|
||||
|
||||
/* int8_t asserts. */
|
||||
|
||||
ret = weston_assert_s8_eq(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_eq(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s8_ne(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_ne(compositor, -5, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s8_gt(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_gt(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s8_ge(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_ge(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_ge(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s8_lt(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_lt(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s8_le(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_le(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s8_le(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* int16_t asserts. */
|
||||
|
||||
ret = weston_assert_s16_eq(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_eq(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s16_ne(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_ne(compositor, -5, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s16_gt(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_gt(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s16_ge(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_ge(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_ge(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s16_lt(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_lt(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s16_le(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_le(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s16_le(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* int32_t asserts. */
|
||||
|
||||
ret = weston_assert_s32_eq(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_eq(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s32_ne(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_ne(compositor, -5, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s32_gt(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_gt(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s32_ge(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_ge(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_ge(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s32_lt(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_lt(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s32_le(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_le(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s32_le(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* int64_t asserts. */
|
||||
|
||||
ret = weston_assert_s64_eq(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_eq(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s64_ne(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_ne(compositor, -5, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s64_gt(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_gt(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s64_ge(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_ge(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_ge(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s64_lt(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_lt(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_s64_le(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_le(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_s64_le(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* int asserts. */
|
||||
|
||||
ret = weston_assert_int_eq(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_eq(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_int_ne(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_ne(compositor, -5, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_int_gt(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_gt(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_int_ge(compositor, -5, -6);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_ge(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_ge(compositor, -6, -5);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_int_lt(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_lt(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
ret = weston_assert_int_le(compositor, -6, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_le(compositor, -5, -5);
|
||||
abort_if_not(ret);
|
||||
ret = weston_assert_int_le(compositor, -5, -6);
|
||||
abort_if_not(ret == false);
|
||||
|
||||
/* If we reach that point, it's a success so reset the assert counter
|
||||
* that's been incremented to check that assertions work. */
|
||||
weston_assert_counter_reset();
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue