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