diff --git a/shared/weston-assert.h b/shared/weston-assert.h
index ba78e9f52..f72752acc 100644
--- a/shared/weston-assert.h
+++ b/shared/weston-assert.h
@@ -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)
diff --git a/tests/assert-test.c b/tests/assert-test.c
index 9c8ed4a5d..c357c6529 100644
--- a/tests/assert-test.c
+++ b/tests/assert-test.c
@@ -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();