|
|
|
@ -736,6 +736,384 @@ static void overflow_size_helpers_test(struct kunit *test)
|
|
|
|
|
#undef check_one_size_helper
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void overflows_type_test(struct kunit *test)
|
|
|
|
|
{
|
|
|
|
|
int count = 0;
|
|
|
|
|
unsigned int var;
|
|
|
|
|
|
|
|
|
|
#define __TEST_OVERFLOWS_TYPE(func, arg1, arg2, of) do { \
|
|
|
|
|
bool __of = func(arg1, arg2); \
|
|
|
|
|
KUNIT_EXPECT_EQ_MSG(test, __of, of, \
|
|
|
|
|
"expected " #func "(" #arg1 ", " #arg2 " to%s overflow\n",\
|
|
|
|
|
of ? "" : " not"); \
|
|
|
|
|
count++; \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
/* Args are: first type, second type, value, overflow expected */
|
|
|
|
|
#define TEST_OVERFLOWS_TYPE(__t1, __t2, v, of) do { \
|
|
|
|
|
__t1 t1 = (v); \
|
|
|
|
|
__t2 t2; \
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type, t1, t2, of); \
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type, t1, __t2, of); \
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, t2, of); \
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, __t2, of);\
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, u16, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, s8, U8_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, s8, (u8)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u8, s16, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u8, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u8, S8_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u16, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u16, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u16, S8_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u32, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u32, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u32, S8_MIN, true);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u64, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u64, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, u64, S8_MIN, true);
|
|
|
|
|
#endif
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, s8, S8_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, s16, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s8, s16, S8_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, u8, (u16)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, u8, U16_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s8, (u16)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s8, U16_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s16, (u16)S16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s16, U16_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, u32, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u16, s32, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u8, (s16)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u8, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u8, S16_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u16, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u16, S16_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u32, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u32, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u32, S16_MIN, true);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u64, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u64, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, u64, S16_MIN, true);
|
|
|
|
|
#endif
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, S8_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, (s16)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, (s16)S8_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, S16_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s8, S16_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s16, S16_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s32, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s16, s32, S16_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u8, (u32)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u8, U32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s8, (u32)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s8, U32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u16, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u16, U16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u16, U32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s16, (u32)S16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s16, U32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u32, U32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s32, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s32, U32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s32, (u32)S32_MAX + 1, true);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, u64, U32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u32, s64, U32_MAX, false);
|
|
|
|
|
#endif
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u8, (s32)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, S32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u8, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u8, S32_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, (s32)U16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, S32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u16, S32_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u32, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u32, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u32, S32_MIN, true);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u64, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u64, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, u64, S32_MIN, true);
|
|
|
|
|
#endif
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, S8_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, (s32)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, (s32)S8_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, S32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s8, S32_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, S16_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, (s32)S16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, (s32)S16_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, S32_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s16, S32_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s32, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s32, S32_MIN, false);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s64, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s32, s64, S32_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u8, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u8, (u64)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u16, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u16, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u16, (u64)U16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u32, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u32, U32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u32, (u64)U32_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, u64, U64_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s8, (u64)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s8, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s16, (u64)S16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s16, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s32, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s32, (u64)S32_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s32, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s64, S64_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s64, U64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(u64, s64, (u64)S64_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u8, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u8, S64_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u8, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u8, U8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u8, (s64)U8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u16, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u16, S64_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u16, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u16, U16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u16, (s64)U16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u32, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u32, S64_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u32, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u32, U32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u32, (s64)U32_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u64, S64_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u64, S64_MIN, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, u64, -1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s8, S8_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s8, S8_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s8, (s64)S8_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s8, (s64)S8_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s8, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s16, S16_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s16, S16_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s16, (s64)S16_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s16, (s64)S16_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s16, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s32, S32_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s32, S32_MIN, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s32, (s64)S32_MAX + 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s32, (s64)S32_MIN - 1, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s32, S64_MAX, true);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s64, S64_MAX, false);
|
|
|
|
|
TEST_OVERFLOWS_TYPE(s64, s64, S64_MIN, false);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Check for macro side-effects. */
|
|
|
|
|
var = INT_MAX - 1;
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type, var++, int, false);
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type, var++, int, false);
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(__overflows_type, var++, int, true);
|
|
|
|
|
var = INT_MAX - 1;
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(overflows_type, var++, int, false);
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(overflows_type, var++, int, false);
|
|
|
|
|
__TEST_OVERFLOWS_TYPE(overflows_type, var++, int, true);
|
|
|
|
|
|
|
|
|
|
kunit_info(test, "%d overflows_type() tests finished\n", count);
|
|
|
|
|
#undef TEST_OVERFLOWS_TYPE
|
|
|
|
|
#undef __TEST_OVERFLOWS_TYPE
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void same_type_test(struct kunit *test)
|
|
|
|
|
{
|
|
|
|
|
int count = 0;
|
|
|
|
|
int var;
|
|
|
|
|
|
|
|
|
|
#define TEST_SAME_TYPE(t1, t2, same) do { \
|
|
|
|
|
typeof(t1) __t1h = type_max(t1); \
|
|
|
|
|
typeof(t1) __t1l = type_min(t1); \
|
|
|
|
|
typeof(t2) __t2h = type_max(t2); \
|
|
|
|
|
typeof(t2) __t2l = type_min(t2); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1h)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1l)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(__t1h, t1)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(__t1l, t1)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2h)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2l)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(__t2h, t2)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, true, __same_type(__t2l, t2)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(t1, t2)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1h)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1l)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(__t1h, t2)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(__t1l, t2)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2h)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2l)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(__t2h, t1)); \
|
|
|
|
|
KUNIT_EXPECT_EQ(test, same, __same_type(__t2l, t1)); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
# define TEST_SAME_TYPE64(base, t, m) TEST_SAME_TYPE(base, t, m)
|
|
|
|
|
#else
|
|
|
|
|
# define TEST_SAME_TYPE64(base, t, m) do { } while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define TEST_TYPE_SETS(base, mu8, mu16, mu32, ms8, ms16, ms32, mu64, ms64) \
|
|
|
|
|
do { \
|
|
|
|
|
TEST_SAME_TYPE(base, u8, mu8); \
|
|
|
|
|
TEST_SAME_TYPE(base, u16, mu16); \
|
|
|
|
|
TEST_SAME_TYPE(base, u32, mu32); \
|
|
|
|
|
TEST_SAME_TYPE(base, s8, ms8); \
|
|
|
|
|
TEST_SAME_TYPE(base, s16, ms16); \
|
|
|
|
|
TEST_SAME_TYPE(base, s32, ms32); \
|
|
|
|
|
TEST_SAME_TYPE64(base, u64, mu64); \
|
|
|
|
|
TEST_SAME_TYPE64(base, s64, ms64); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
TEST_TYPE_SETS(u8, true, false, false, false, false, false, false, false);
|
|
|
|
|
TEST_TYPE_SETS(u16, false, true, false, false, false, false, false, false);
|
|
|
|
|
TEST_TYPE_SETS(u32, false, false, true, false, false, false, false, false);
|
|
|
|
|
TEST_TYPE_SETS(s8, false, false, false, true, false, false, false, false);
|
|
|
|
|
TEST_TYPE_SETS(s16, false, false, false, false, true, false, false, false);
|
|
|
|
|
TEST_TYPE_SETS(s32, false, false, false, false, false, true, false, false);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_TYPE_SETS(u64, false, false, false, false, false, false, true, false);
|
|
|
|
|
TEST_TYPE_SETS(s64, false, false, false, false, false, false, false, true);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Check for macro side-effects. */
|
|
|
|
|
var = 4;
|
|
|
|
|
KUNIT_EXPECT_EQ(test, var, 4);
|
|
|
|
|
KUNIT_EXPECT_TRUE(test, __same_type(var++, int));
|
|
|
|
|
KUNIT_EXPECT_EQ(test, var, 4);
|
|
|
|
|
KUNIT_EXPECT_TRUE(test, __same_type(int, var++));
|
|
|
|
|
KUNIT_EXPECT_EQ(test, var, 4);
|
|
|
|
|
KUNIT_EXPECT_TRUE(test, __same_type(var++, var++));
|
|
|
|
|
KUNIT_EXPECT_EQ(test, var, 4);
|
|
|
|
|
|
|
|
|
|
kunit_info(test, "%d __same_type() tests finished\n", count);
|
|
|
|
|
|
|
|
|
|
#undef TEST_TYPE_SETS
|
|
|
|
|
#undef TEST_SAME_TYPE64
|
|
|
|
|
#undef TEST_SAME_TYPE
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void castable_to_type_test(struct kunit *test)
|
|
|
|
|
{
|
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
|
|
#define TEST_CASTABLE_TO_TYPE(arg1, arg2, pass) do { \
|
|
|
|
|
bool __pass = castable_to_type(arg1, arg2); \
|
|
|
|
|
KUNIT_EXPECT_EQ_MSG(test, __pass, pass, \
|
|
|
|
|
"expected castable_to_type(" #arg1 ", " #arg2 ") to%s pass\n",\
|
|
|
|
|
pass ? "" : " not"); \
|
|
|
|
|
count++; \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, u8, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, u16, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, u32, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, s8, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, s16, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, s32, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(-16, s8, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(-16, s16, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(-16, s32, true);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(16, u64, true);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(-16, s64, true);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define TEST_CASTABLE_TO_TYPE_VAR(width) do { \
|
|
|
|
|
u ## width u ## width ## var = 0; \
|
|
|
|
|
s ## width s ## width ## var = 0; \
|
|
|
|
|
\
|
|
|
|
|
/* Constant expressions that fit types. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(u ## width), u ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(u ## width), u ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(u ## width), u ## width ## var, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(u ## width), u ## width ## var, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(s ## width), s ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(s ## width), s ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(s ## width), s ## width ## var, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(u ## width), s ## width ## var, true); \
|
|
|
|
|
/* Constant expressions that do not fit types. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(u ## width), s ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_max(u ## width), s ## width ## var, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(s ## width), u ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(type_min(s ## width), u ## width ## var, false); \
|
|
|
|
|
/* Non-constant expression with mismatched type. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(s ## width ## var, u ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(u ## width ## var, s ## width, false); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define TEST_CASTABLE_TO_TYPE_RANGE(width) do { \
|
|
|
|
|
unsigned long big = U ## width ## _MAX; \
|
|
|
|
|
signed long small = S ## width ## _MIN; \
|
|
|
|
|
u ## width u ## width ## var = 0; \
|
|
|
|
|
s ## width s ## width ## var = 0; \
|
|
|
|
|
\
|
|
|
|
|
/* Constant expression in range. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(U ## width ## _MAX, u ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(U ## width ## _MAX, u ## width ## var, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(S ## width ## _MIN, s ## width, true); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(S ## width ## _MIN, s ## width ## var, true); \
|
|
|
|
|
/* Constant expression out of range. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE((unsigned long)U ## width ## _MAX + 1, u ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE((unsigned long)U ## width ## _MAX + 1, u ## width ## var, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE((signed long)S ## width ## _MIN - 1, s ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE((signed long)S ## width ## _MIN - 1, s ## width ## var, false); \
|
|
|
|
|
/* Non-constant expression with mismatched type. */ \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(big, u ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(big, u ## width ## var, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(small, s ## width, false); \
|
|
|
|
|
TEST_CASTABLE_TO_TYPE(small, s ## width ## var, false); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_VAR(8);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_VAR(16);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_VAR(32);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_VAR(64);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_RANGE(8);
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_RANGE(16);
|
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
|
TEST_CASTABLE_TO_TYPE_RANGE(32);
|
|
|
|
|
#endif
|
|
|
|
|
kunit_info(test, "%d castable_to_type() tests finished\n", count);
|
|
|
|
|
|
|
|
|
|
#undef TEST_CASTABLE_TO_TYPE_RANGE
|
|
|
|
|
#undef TEST_CASTABLE_TO_TYPE_VAR
|
|
|
|
|
#undef TEST_CASTABLE_TO_TYPE
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct kunit_case overflow_test_cases[] = {
|
|
|
|
|
KUNIT_CASE(u8_u8__u8_overflow_test),
|
|
|
|
|
KUNIT_CASE(s8_s8__s8_overflow_test),
|
|
|
|
@ -755,6 +1133,9 @@ static struct kunit_case overflow_test_cases[] = {
|
|
|
|
|
KUNIT_CASE(shift_nonsense_test),
|
|
|
|
|
KUNIT_CASE(overflow_allocation_test),
|
|
|
|
|
KUNIT_CASE(overflow_size_helpers_test),
|
|
|
|
|
KUNIT_CASE(overflows_type_test),
|
|
|
|
|
KUNIT_CASE(same_type_test),
|
|
|
|
|
KUNIT_CASE(castable_to_type_test),
|
|
|
|
|
{}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|