From d137bf9a7fd5152cdc5f2cd817b56da9b40e6b44 Mon Sep 17 00:00:00 2001 From: bernhardheld Date: Sun, 4 Jun 2006 20:18:29 +0000 Subject: [PATCH] * support/regression/tests/constantRange.c: added * support/valdiag/tests/constantRange.c: added git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4207 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- support/regression/tests/constantRange.c | 193 +++++++++++++++++ support/valdiag/tests/constantRange.c | 265 +++++++++++++++++++++++ 2 files changed, 458 insertions(+) create mode 100644 support/regression/tests/constantRange.c create mode 100644 support/valdiag/tests/constantRange.c diff --git a/support/regression/tests/constantRange.c b/support/regression/tests/constantRange.c new file mode 100644 index 00000000..15c3ea05 --- /dev/null +++ b/support/regression/tests/constantRange.c @@ -0,0 +1,193 @@ +/** constant range tests. + +*/ + +#include +#include +#include + + int8_t s8; +uint8_t u8; + + int16_t s16; +uint16_t u16; + + int32_t s32; +uint32_t u32; + +void +testConstantRange (void) +{ + ASSERT (! (INT8_MIN - 1 == s8)); + ASSERT (! (INT8_MAX + 1 == s8)); + ASSERT ( (INT8_MIN - 1 != s8)); + ASSERT ( (INT8_MAX + 1 != s8)); + ASSERT ( (INT8_MIN - 1 < s8)); + ASSERT (! (INT8_MAX < s8)); + ASSERT ( (INT8_MIN <= s8)); + ASSERT (! (INT8_MAX <= s8)); + ASSERT (! (INT8_MIN > s8)); + ASSERT ( (INT8_MAX + 1 > s8)); + ASSERT (! (INT8_MIN - 1 >= s8)); + ASSERT ( (INT8_MAX >= s8)); + + ASSERT (! ( 0 - 1 == u8)); + ASSERT (! (UINT8_MAX + 1 == u8)); + ASSERT ( ( 0 - 1 != u8)); + ASSERT ( (UINT8_MAX + 1 != u8)); + ASSERT ( ( 0 - 1 < u8)); + ASSERT (! (UINT8_MAX < u8)); + ASSERT ( ( 0 <= u8)); + ASSERT (! (UINT8_MAX + 1 <= u8)); + ASSERT (! ( 0 > u8)); + ASSERT ( (UINT8_MAX + 1 > u8)); + ASSERT (! ( 0 - 1 >= u8)); + ASSERT ( (UINT8_MAX >= u8)); + + /* force extension to long to avoid int (16 bit) overflow */ + ASSERT (! (INT16_MIN - 1L == s16)); + ASSERT (! (INT16_MAX + 1L == s16)); + ASSERT ( (INT16_MIN - 1L != s16)); + ASSERT ( (INT16_MAX + 1L != s16)); + ASSERT ( (INT16_MIN - 1L < s16)); + ASSERT (! (INT16_MAX < s16)); + ASSERT ( (INT16_MIN <= s16)); + ASSERT (! (INT16_MAX <= s16)); + ASSERT (! (INT16_MIN > s16)); + ASSERT ( (INT16_MAX + 1L > s16)); + ASSERT (! (INT16_MIN - 1L >= s16)); + ASSERT ( (INT16_MAX >= s16)); + + ASSERT (! ( 0 - 1 == u16)); + ASSERT (! (UINT16_MAX + 1L == u16)); + ASSERT ( ( 0 - 1 != u16)); + ASSERT ( (UINT16_MAX + 1L != u16)); + ASSERT ( ( 0 - 1 < u16)); + ASSERT (! (UINT16_MAX < u16)); + ASSERT ( ( 0 <= u16)); + ASSERT (! (UINT16_MAX + 1L <= u16)); + ASSERT (! ( 0 > u16)); + ASSERT ( (UINT16_MAX + 1L > u16)); + ASSERT (! ( 0 - 1 >= u16)); + ASSERT ( (UINT16_MAX >= u16)); + + /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1), + there's no 'double' or 'long long' */ +/* ASSERT (! (INT32_MIN - 1 == s32)); */ +/* ASSERT (! (INT32_MAX + 1 == s32)); */ +/* ASSERT ( (INT32_MIN - 1 != s32)); */ +/* ASSERT ( (INT32_MAX + 1 != s32)); */ +/* ASSERT ( (INT32_MIN - 1 < s32)); */ + ASSERT (! (INT32_MAX < s32)); + ASSERT ( (INT32_MIN <= s32)); + ASSERT (! (INT32_MAX <= s32)); + ASSERT (! (INT32_MIN > s32)); +/* ASSERT ( (INT32_MAX + 1 > s32)); */ +/* ASSERT (! (INT32_MIN - 1 >= s32)); */ + ASSERT ( (INT32_MAX >= s32)); + + ASSERT (! ( 0 - 1 == u32)); +/* ASSERT (! (UINT32_MAX + 1 == u32)); */ + ASSERT ( ( 0 - 1 != u32)); +/* ASSERT ( (UINT32_MAX + 1 != u32)); */ + ASSERT ( ( 0 - 1 < u32)); + ASSERT (! (UINT32_MAX < u32)); + ASSERT ( ( 0 <= u32)); +/* ASSERT (! (UINT32_MAX + 1 <= u32)); */ + ASSERT (! ( 0 > u32)); +/* ASSERT ( (UINT32_MAX + 1 > u32)); */ + ASSERT (! ( 0 - 1 >= u32)); + ASSERT ( (UINT32_MAX >= u32)); +} + +void +testFoo1(void) +{ +#if defined(PORT_HOST) + volatile bool sb, ub; +#else + volatile signed bool sb; + volatile unsigned bool ub; +#endif + + sb = 0; + ub = 0; + + ASSERT (! (-1 == sb)); + ASSERT ( ( 0 == sb)); + ASSERT (! ( 1 == sb)); + + ASSERT ( (-1 != sb)); + ASSERT (! ( 0 != sb)); + ASSERT ( ( 1 != sb)); + + ASSERT ( (-1 < sb)); + ASSERT (! ( 0 < sb)); + + ASSERT ( ( 0 <= sb)); + ASSERT (! ( 1 <= sb)); + + ASSERT (! ( 0 > sb)); + ASSERT ( ( 1 > sb)); + + ASSERT (! (-1 >= sb)); + ASSERT ( ( 0 >= sb)); + + + ASSERT (! (-1 == ub)); + ASSERT ( ( 0 == ub)); + ASSERT (! ( 1 == ub)); + + ASSERT ( (-1 != ub)); + ASSERT (! ( 0 != ub)); + ASSERT ( ( 1 != ub)); + + ASSERT ( (-1 < ub)); + ASSERT (! ( 0 < ub)); + + ASSERT ( ( 0 <= ub)); + ASSERT (! ( 1 <= ub)); + + ASSERT (! ( 0 > ub)); + ASSERT ( ( 1 > ub)); + + ASSERT (! (-1 >= ub)); + ASSERT ( ( 0 >= ub)); +} + +void +testFoo2(void) +{ + volatile struct { + signed sb1:1; + signed sb3:3; + unsigned ub1:1; + unsigned ub3:3; + } str; + + str.sb1 = 0; + str.ub1 = 0; + str.sb3 = 0; + str.ub3 = 0; + + ASSERT (! (-2 == str.sb1)); + ASSERT (! (-1 == str.sb1)); + ASSERT ( ( 0 == str.sb1)); + ASSERT (! ( 1 == str.sb1)); + + ASSERT (! (-1 == str.ub1)); + ASSERT ( ( 0 == str.ub1)); + ASSERT (! ( 1 == str.ub1)); + ASSERT (! ( 2 == str.ub1)); + + ASSERT (! (-5 == str.sb3)); + ASSERT (! (-4 == str.sb3)); + ASSERT ( ( 0 == str.sb3)); + ASSERT (! ( 3 == str.sb3)); + ASSERT (! ( 4 == str.sb3)); + + ASSERT (! (-1 == str.ub3)); + ASSERT ( ( 0 == str.ub3)); + ASSERT (! ( 7 == str.ub3)); + ASSERT (! ( 8 == str.ub3)); +} diff --git a/support/valdiag/tests/constantRange.c b/support/valdiag/tests/constantRange.c new file mode 100644 index 00000000..9253aefd --- /dev/null +++ b/support/valdiag/tests/constantRange.c @@ -0,0 +1,265 @@ +#include + +volatile int8_t c; + +/* sorry about the uggly source, + but this way it can be the same as in the regression tests */ +#define ASSERT(x) c = (x) + + int8_t s8; +uint8_t u8; + + int16_t s16; +uint16_t u16; + + int32_t s32; +uint32_t u32; + +#ifdef TEST1 +void foo(void) +{ + ASSERT (! (INT8_MIN - 1 == s8)); /* WARNING */ + ASSERT (! (INT8_MAX + 1 == s8)); /* WARNING */ + ASSERT ( (INT8_MIN - 1 != s8)); /* WARNING */ + ASSERT ( (INT8_MAX + 1 != s8)); /* WARNING */ + ASSERT ( (INT8_MIN - 1 < s8)); /* WARNING */ + ASSERT (! (INT8_MAX < s8)); /* WARNING */ + ASSERT ( (INT8_MIN <= s8)); /* WARNING */ + ASSERT (! (INT8_MAX + 1 <= s8)); /* WARNING */ + ASSERT (! (INT8_MIN > s8)); /* WARNING */ + ASSERT ( (INT8_MAX + 1 > s8)); /* WARNING */ + ASSERT (! (INT8_MIN - 1 >= s8)); /* WARNING */ + ASSERT ( (INT8_MAX >= s8)); /* WARNING */ + + ASSERT (! ( 0 - 1 == u8)); /* WARNING */ + ASSERT (! (UINT8_MAX + 1 == u8)); /* WARNING */ + ASSERT ( ( 0 - 1 != u8)); /* WARNING */ + ASSERT ( (UINT8_MAX + 1 != u8)); /* WARNING */ + ASSERT ( ( 0 - 1 < u8)); /* WARNING */ + ASSERT (! (UINT8_MAX < u8)); /* WARNING */ + ASSERT ( ( 0 <= u8)); /* WARNING */ + ASSERT (! (UINT8_MAX + 1 <= u8)); /* WARNING */ + ASSERT (! ( 0 > u8)); /* WARNING */ + ASSERT ( (UINT8_MAX + 1 > u8)); /* WARNING */ + ASSERT (! ( 0 - 1 >= u8)); /* WARNING */ + ASSERT ( (UINT8_MAX >= u8)); /* WARNING */ + + /* force extension to long to avoid int (16 bit) overflow */ + ASSERT (! (INT16_MIN - 1L == s16)); /* WARNING */ + ASSERT (! (INT16_MAX + 1L == s16)); /* WARNING */ + ASSERT ( (INT16_MIN - 1L != s16)); /* WARNING */ + ASSERT ( (INT16_MAX + 1L != s16)); /* WARNING */ + ASSERT ( (INT16_MIN - 1L < s16)); /* WARNING */ + ASSERT (! (INT16_MAX < s16)); /* WARNING */ + ASSERT ( (INT16_MIN <= s16)); /* WARNING */ + ASSERT (! (INT16_MAX + 1L <= s16)); /* WARNING */ + ASSERT (! (INT16_MIN > s16)); /* WARNING */ + ASSERT ( (INT16_MAX + 1L > s16)); /* WARNING */ + ASSERT (! (INT16_MIN - 1L >= s16)); /* WARNING */ + ASSERT ( (INT16_MAX >= s16)); /* WARNING */ + + ASSERT (! ( 0 - 1L == u16)); /* WARNING */ + ASSERT (! (UINT16_MAX + 1L == u16)); /* WARNING */ + ASSERT ( ( 0 - 1L != u16)); /* WARNING */ + ASSERT ( (UINT16_MAX + 1L != u16)); /* WARNING */ + ASSERT ( ( 0 - 1L < u16)); /* WARNING */ + ASSERT (! (UINT16_MAX < u16)); /* WARNING */ + ASSERT ( ( 0 <= u16)); /* WARNING */ + ASSERT (! (UINT16_MAX + 1L <= u16)); /* WARNING */ + ASSERT (! ( 0 > u16)); /* WARNING */ + ASSERT ( (UINT16_MAX + 1L > u16)); /* WARNING */ + ASSERT (! ( 0 - 1L >= u16)); /* WARNING */ + ASSERT ( (UINT16_MAX >= u16)); /* WARNING */ + + /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1), + there's no 'double' or 'long long' */ +/* ASSERT (! (INT32_MIN - 1 == s32)); */ +/* ASSERT (! (INT32_MAX + 1 == s32)); */ +/* ASSERT ( (INT32_MIN - 1 != s32)); */ +/* ASSERT ( (INT32_MAX + 1 != s32)); */ +/* ASSERT ( (INT32_MIN - 1 < s32)); */ + ASSERT (! (INT32_MAX < s32)); /* WARNING(SDCC) */ + ASSERT ( (INT32_MIN <= s32)); /* WARNING(SDCC) */ +/* ASSERT (! (INT32_MAX + 1 <= s32)); */ + ASSERT (! (INT32_MIN > s32)); /* WARNING(SDCC) */ +/* ASSERT ( (INT32_MAX + 1 > s32)); */ +/* ASSERT (! (INT32_MIN - 1 >= s32)); */ + ASSERT ( (INT32_MAX >= s32)); /* WARNING(SDCC) */ + + /* (0 - 1) wraps around to UINT32_MAX -> untestable */ +/* ASSERT (! ( 0 - 1 == u32)); */ +/* ASSERT (! (UINT32_MAX + 1 == u32)); */ +/* ASSERT ( ( 0 - 1 != u32)); */ +/* ASSERT ( (UINT32_MAX + 1 != u32)); */ +/* ASSERT ( ( 0 - 1 < u32)); */ + ASSERT (! (UINT32_MAX < u32)); /* WARNING(SDCC) */ + ASSERT ( ( 0 <= u32)); /* WARNING(SDCC) */ +/* ASSERT (! (UINT32_MAX + 1 <= u32)); */ + ASSERT (! ( 0 > u32)); /* WARNING(SDCC) */ +/* ASSERT ( (UINT32_MAX + 1 > u32)); */ +/* ASSERT (! ( 0 - 1 >= u32)); */ + ASSERT ( (UINT32_MAX >= u32)); /* WARNING(SDCC) */ +} +#endif + +#ifdef TEST2 +void foo(void) +{ + s8 = -129; /* WARNING */ + s8 = INT8_MIN; + s8 = UINT8_MAX; + s8 = 256; /* WARNING */ + + s8 = -129; /* WARNING */ + u8 = INT8_MIN; + u8 = UINT8_MAX; + u8 = 256; /* WARNING */ + + s16 = -32769L; /* WARNING */ + s16 = INT16_MIN; + s16 = UINT16_MAX; + s16 = 65536L; /* WARNING */ + + s16 = -32769L; /* WARNING */ + u16 = INT16_MIN; + u16 = UINT16_MAX; + u16 = 65536L; /* WARNING */ + + /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1), + there's no 'double' or 'long long' */ + s32 = INT32_MIN; + s32 = UINT32_MAX; + + u32 = INT32_MIN; + u32 = UINT32_MAX; +} +#endif + +#ifdef TEST3 +#include + +void foo(void) +{ +#if defined(PORT_HOST) + volatile bool sb, ub; +#else + volatile signed bool sb; + volatile unsigned bool ub; +#endif + + sb = -2; + sb = -1; + sb = 0; + sb = 1; + + ub = -1; + ub = 0; + ub = 1; + ub = 2; + + ASSERT (! (-2 == sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( (-1 == sb)); + ASSERT ( ( 0 == sb)); + ASSERT (! ( 1 == sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( (-2 != sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( (-1 != sb)); + ASSERT ( ( 0 != sb)); + ASSERT ( ( 1 != sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( (-2 < sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( (-1 < sb)); + ASSERT (! ( 0 < sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( (-1 <= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( ( 0 <= sb)); + ASSERT (! ( 1 <= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT (! (-1 > sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( ( 0 > sb)); + ASSERT ( ( 1 > sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT (! (-2 >= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + ASSERT ( (-1 >= sb)); + ASSERT ( ( 0 >= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + + ASSERT (! (-1 == ub)); /* WARNING(SDCC) */ + ASSERT ( ( 0 == ub)); + ASSERT ( ( 1 == ub)); + ASSERT (! ( 2 == ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( (-1 != ub)); /* WARNING(SDCC) */ + ASSERT ( ( 0 != ub)); + ASSERT ( ( 1 != ub)); + ASSERT ( ( 2 != ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( (-1 < ub)); /* WARNING(SDCC) */ + ASSERT ( ( 0 < ub)); + ASSERT (! ( 1 < ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT ( ( 0 <= ub)); /* WARNING(SDCC) */ + ASSERT ( ( 1 <= ub)); + ASSERT (! ( 2 <= ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT (! ( 0 > ub)); /* WARNING(SDCC) */ + ASSERT ( ( 1 > ub)); + ASSERT ( ( 2 > ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ + + ASSERT (! (-1 >= ub)); /* WARNING(SDCC) */ + ASSERT ( ( 0 >= ub)); + ASSERT ( ( 1 >= ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ +} +#endif + +#ifdef TEST4 +void foo(void) +{ + volatile struct { + signed sb1:1; + signed sb3:3; + unsigned ub1:1; + unsigned ub3:3; + } str; + + str.sb1 = -2; /* WARNING(SDCC) */ + str.sb1 = -1; + str.sb1 = 1; + str.sb1 = 2; /* WARNING(SDCC) */ + + str.ub1 = -2; /* WARNING(SDCC) */ + str.ub1 = -1; + str.ub1 = 1; + str.ub1 = 2; /* WARNING(SDCC) */ + + str.sb3 = -5; /* WARNING(SDCC) */ + str.sb3 = -4; + str.sb3 = 7; + str.sb3 = 8; /* WARNING(SDCC) */ + + str.ub3 = -5; /* WARNING(SDCC) */ + str.ub3 = -4; + str.ub3 = 7; + str.ub3 = 8; /* WARNING(SDCC) */ + + ASSERT (! (-2 == str.sb1)); /* WARNING */ + ASSERT ( (-1 == str.sb1)); + ASSERT ( ( 0 == str.sb1)); + ASSERT (! ( 1 == str.sb1)); /* WARNING */ + + ASSERT (! (-1 == str.ub1)); /* WARNING(SDCC) */ + ASSERT ( ( 0 == str.ub1)); + ASSERT ( ( 1 == str.ub1)); + ASSERT (! ( 2 == str.ub1)); /* WARNING(SDCC) */ + + ASSERT (! (-5 == str.sb3)); /* WARNING */ + ASSERT ( (-4 == str.sb3)); + ASSERT ( ( 3 == str.sb3)); + ASSERT (! ( 4 == str.sb3)); /* WARNING */ + + ASSERT (! (-1 == str.ub3)); /* WARNING(SDCC) */ + ASSERT ( ( 0 == str.ub3)); + ASSERT ( ( 7 == str.ub3)); + ASSERT (! ( 8 == str.ub3)); /* WARNING(SDCC) */ +} +#endif -- 2.30.2