git.gag.com Git - fw/sdcc/blob - support/regression/tests/constantRange.c

   1 /** constant range tests.
   2
   3 */
   4
   5 #include <testfwk.h>
   6 #include <stdbool.h>
   7 #ifdef __sun__
   8 #include <inttypes.h>
   9 #else
  10 #include <stdint.h>
  11 #endif
  12
  13 #if defined (__GNUC__) && defined (__alpha__) && (__GNUC__ < 3)
  14 /* bool should be casted to int in order to pass the test. Is this a gcc bug? */
  15 #define INT_CAST  (int)
  16 #else
  17 #define INT_CAST
  18 #endif
  19
  20  int8_t s8;
  21 uint8_t u8;
  22
  23  int16_t s16;
  24 uint16_t u16;
  25
  26  int32_t s32;
  27 uint32_t u32;
  28
  29 void
  30 testConstantRange (void)
  31 {
  32   ASSERT (! (INT8_MIN - 1 == s8));
  33   ASSERT (! (INT8_MAX + 1 == s8));
  34   ASSERT (  (INT8_MIN - 1 != s8));
  35   ASSERT (  (INT8_MAX + 1 != s8));
  36   ASSERT (  (INT8_MIN - 1 <  s8));
  37   ASSERT (! (INT8_MAX     <  s8));
  38   ASSERT (  (INT8_MIN     <= s8));
  39   ASSERT (! (INT8_MAX     <= s8));
  40   ASSERT (! (INT8_MIN     >  s8));
  41   ASSERT (  (INT8_MAX + 1 >  s8));
  42   ASSERT (! (INT8_MIN - 1 >= s8));
  43   ASSERT (  (INT8_MAX     >= s8));
  44
  45   ASSERT (! (        0 - 1 == u8));
  46   ASSERT (! (UINT8_MAX + 1 == u8));
  47   ASSERT (  (        0 - 1 != u8));
  48   ASSERT (  (UINT8_MAX + 1 != u8));
  49   ASSERT (  (        0 - 1 <  u8));
  50   ASSERT (! (UINT8_MAX     <  u8));
  51   ASSERT (  (        0     <= u8));
  52   ASSERT (! (UINT8_MAX + 1 <= u8));
  53   ASSERT (! (        0     >  u8));
  54   ASSERT (  (UINT8_MAX + 1 >  u8));
  55   ASSERT (! (        0 - 1 >= u8));
  56   ASSERT (  (UINT8_MAX     >= u8));
  57
  58   /* force extension to long to avoid int (16 bit) overflow */
  59   ASSERT (! (INT16_MIN - 1L == s16));
  60   ASSERT (! (INT16_MAX + 1L == s16));
  61   ASSERT (  (INT16_MIN - 1L != s16));
  62   ASSERT (  (INT16_MAX + 1L != s16));
  63   ASSERT (  (INT16_MIN - 1L <  s16));
  64   ASSERT (! (INT16_MAX      <  s16));
  65   ASSERT (  (INT16_MIN      <= s16));
  66   ASSERT (! (INT16_MAX      <= s16));
  67   ASSERT (! (INT16_MIN      >  s16));
  68   ASSERT (  (INT16_MAX + 1L >  s16));
  69   ASSERT (! (INT16_MIN - 1L >= s16));
  70   ASSERT (  (INT16_MAX      >= s16));
  71
  72   ASSERT (! (         0 - 1  == u16));
  73   ASSERT (! (UINT16_MAX + 1L == u16));
  74   ASSERT (  (         0 - 1  != u16));
  75   ASSERT (  (UINT16_MAX + 1L != u16));
  76   ASSERT (  (         0 - 1  <  u16));
  77   ASSERT (! (UINT16_MAX      <  u16));
  78   ASSERT (  (         0      <= u16));
  79   ASSERT (! (UINT16_MAX + 1L <= u16));
  80   ASSERT (! (         0      >  u16));
  81   ASSERT (  (UINT16_MAX + 1L >  u16));
  82   ASSERT (! (         0 - 1  >= u16));
  83   ASSERT (  (UINT16_MAX      >= u16));
  84
  85    /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
  86       there's no 'double' or 'long long' */
  87 /* ASSERT (! (INT32_MIN - 1 == s32)); */
  88 /* ASSERT (! (INT32_MAX + 1 == s32)); */
  89 /* ASSERT (  (INT32_MIN - 1 != s32)); */
  90 /* ASSERT (  (INT32_MAX + 1 != s32)); */
  91 /* ASSERT (  (INT32_MIN - 1 <  s32)); */
  92    ASSERT (! (INT32_MAX     <  s32));
  93    ASSERT (  (INT32_MIN     <= s32));
  94    ASSERT (! (INT32_MAX     <= s32));
  95    ASSERT (! (INT32_MIN     >  s32));
  96 /* ASSERT (  (INT32_MAX + 1 >  s32)); */
  97 /* ASSERT (! (INT32_MIN - 1 >= s32)); */
  98    ASSERT (  (INT32_MAX     >= s32));
  99
 100    ASSERT (! (         0 - 1 == u32));
 101 /* ASSERT (! (UINT32_MAX + 1 == u32)); */
 102    ASSERT (  (         0 - 1 != u32));
 103 /* ASSERT (  (UINT32_MAX + 1 != u32)); */
 104    ASSERT (  (         0 - 1 <  u32));
 105    ASSERT (! (UINT32_MAX     <  u32));
 106    ASSERT (  (         0     <= u32));
 107 /* ASSERT (! (UINT32_MAX + 1 <= u32)); */
 108    ASSERT (! (         0     >  u32));
 109 /* ASSERT (  (UINT32_MAX + 1 >  u32)); */
 110    ASSERT (! (         0 - 1 >= u32));
 111    ASSERT (  (UINT32_MAX     >= u32));
 112 }
 113
 114 void
 115 testFoo1(void)
 116 {
 117 #if defined(PORT_HOST)
 118    volatile bool sb, ub;
 119 #else
 120    volatile   signed bool sb;
 121    volatile unsigned bool ub;
 122 #endif
 123
 124   sb = 0;
 125   ub = 0;
 126
 127   ASSERT (! (-1 == sb));
 128   ASSERT (  ( 0 == sb));
 129   ASSERT (! ( 1 == sb));
 130
 131   ASSERT (  (-1 != sb));
 132   ASSERT (! ( 0 != sb));
 133   ASSERT (  ( 1 != sb));
 134
 135   ASSERT (  (-1 <  INT_CAST sb));
 136   ASSERT (! ( 0 <  sb));
 137
 138   ASSERT (  ( 0 <= sb));
 139   ASSERT (! ( 1 <= sb));
 140
 141   ASSERT (! ( 0 >  sb));
 142   ASSERT (  ( 1 >  sb));
 143
 144   ASSERT (! (-1 >= INT_CAST sb));
 145   ASSERT (  ( 0 >= sb));
 146
 147
 148   ASSERT (! (-1 == ub));
 149   ASSERT (  ( 0 == ub));
 150   ASSERT (! ( 1 == ub));
 151
 152   ASSERT (  (-1 != ub));
 153   ASSERT (! ( 0 != ub));
 154   ASSERT (  ( 1 != ub));
 155
 156   ASSERT (  (-1 <  INT_CAST ub));
 157   ASSERT (! ( 0 <  ub));
 158
 159   ASSERT (  ( 0 <= ub));
 160   ASSERT (! ( 1 <= ub));
 161
 162   ASSERT (! ( 0 >  ub));
 163   ASSERT (  ( 1 >  ub));
 164
 165   ASSERT (! (-1 >= INT_CAST ub));
 166   ASSERT (  ( 0 >= ub));
 167 }
 168
 169 void
 170 testFoo2(void)
 171 {
 172   volatile struct {
 173       signed sb1:1;
 174       signed sb3:3;
 175     unsigned ub1:1;
 176     unsigned ub3:3;
 177   } str;
 178
 179   str.sb1 = 0;
 180   str.ub1 = 0;
 181   str.sb3 = 0;
 182   str.ub3 = 0;
 183
 184   ASSERT (! (-2 == str.sb1));
 185   ASSERT (! (-1 == str.sb1));
 186   ASSERT (  ( 0 == str.sb1));
 187   ASSERT (! ( 1 == str.sb1));
 188
 189   ASSERT (! (-1 == str.ub1));
 190   ASSERT (  ( 0 == str.ub1));
 191   ASSERT (! ( 1 == str.ub1));
 192   ASSERT (! ( 2 == str.ub1));
 193
 194   ASSERT (! (-5 == str.sb3));
 195   ASSERT (! (-4 == str.sb3));
 196   ASSERT (  ( 0 == str.sb3));
 197   ASSERT (! ( 3 == str.sb3));
 198   ASSERT (! ( 4 == str.sb3));
 199
 200   ASSERT (! (-1 == str.ub3));
 201   ASSERT (  ( 0 == str.ub3));
 202   ASSERT (! ( 7 == str.ub3));
 203   ASSERT (! ( 8 == str.ub3));
 204 }