sdcc/support/regression/tests/compare.c.in

   1 /** Test the comparison operators.
   2
   3     type: char, int, long
   4     storage: static,
   5     attr: volatile
   6  */
   7 #include <testfwk.h>
   8
   9 static void
  10 testCmpAroundZero(void)
  11 {
  12     {attr} {storage} signed {type} i;
  13
  14     i = 5;
  15
  16     ASSERT(0 < i);
  17     ASSERT(i > 0);
  18     ASSERT(0 <= i);
  19     ASSERT(i >= 0);
  20 #if !defined(__SDCC_pdk14) // Lack of memory
  21 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
  22     i = -33;
  23     ASSERT(0 > i);
  24     ASSERT(i < 0);
  25     ASSERT(0 >= i);
  26     ASSERT(i <= 0);
  27
  28     i = 0;
  29     ASSERT(0 == i);
  30     ASSERT(0 <= i);
  31     ASSERT(0 >= i);
  32 #endif
  33 #endif
  34 }
  35
  36 static void
  37 testCompareConstants(void)
  38 {
  39     {attr} {storage} signed {type} i;
  40
  41     i = 12;
  42     ASSERT(i < 23);
  43     ASSERT(i > 3);
  44     ASSERT(i > -14);
  45 #if !defined(__SDCC_pdk14) // Lack of memory
  46 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
  47     ASSERT(i <= 23);
  48     ASSERT(i >= 3);
  49     ASSERT(i >= -14);
  50     ASSERT(i <= 12);
  51     ASSERT(i >= 12);
  52     ASSERT(i == 12);
  53 #endif
  54 #endif
  55
  56     i = -34;
  57     ASSERT(i > -126);
  58     ASSERT(i < -3);
  59 #if !defined(__SDCC_pdk14) // Lack of memory
  60 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
  61     ASSERT(i < 47);
  62     ASSERT(i >= -126);
  63     ASSERT(i <= -3);
  64     ASSERT(i <= 47);
  65     ASSERT(i <= -34);
  66     ASSERT(i >= -34);
  67     ASSERT(i == -34);
  68 #endif
  69 #endif
  70 }
  71
  72 static void
  73 testCompareVariables(void)
  74 {
  75     {attr} {storage} signed {type} left, right;
  76
  77     left = 12;
  78     right = 47;
  79     ASSERT(left < right);
  80     ASSERT(left <= right);
  81     ASSERT(right > left);
  82     ASSERT(right >= left);
  83
  84     right = -8;
  85     ASSERT(left > right);
  86     ASSERT(left >= right);
  87     ASSERT(right < left);
  88     ASSERT(right <= left);
  89 #if !defined(__SDCC_pdk14) // Lack of memory
  90 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
  91     right = 0;
  92     ASSERT(left > right);
  93     ASSERT(left >= right);
  94     ASSERT(right < left);
  95     ASSERT(right <= left);
  96
  97     right = left;
  98     ASSERT(left == right);
  99     ASSERT(left <= right);
 100     ASSERT(left >= right);
 101 #endif
 102 #endif
 103 }
 104
 105 static void
 106 testUnsignedCompare(void)
 107 {
 108     {attr} {storage} unsigned {type} left, right;
 109
 110     left = 0;
 111     right = (unsigned {type})-1;
 112
 113     ASSERT(left < right);
 114     ASSERT(left <= right);
 115     ASSERT(right > left);
 116     ASSERT(right >= left);
 117 }
 118
 119 void (*fptr)(void);
 120 int *volatile iptr;
 121
 122 #if !defined(__SDCC_pdk14) // Lack of memory
 123 signed {type} s;
 124 unsigned {type} u;
 125
 126 void set ({type} v)
 127 {
 128         s = v;
 129         u = v;
 130 }
 131 #endif
 132
 133 /* Test optimization for eliminating redundant loads in range tests. s and u should not be volatile. */
 134 void testRange(void)
 135 {
 136 #if !defined(__SDCC_pdk14) // Lack of memory
 137 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
 138     set (17);
 139
 140     ASSERT (s >= 17 && s <= 20);
 141     ASSERT (u >= 17 && u <= 20);
 142
 143     set (21);
 144
 145     ASSERT (!(s >= 17 && s <= 20));
 146     ASSERT (!(u >= 17 && u <= 20));
 147
 148     set (18);
 149
 150     ASSERT (s > 17 && s < 20);
 151     ASSERT (u > 17 && u < 20);
 152
 153     set (20);
 154
 155     ASSERT (!(s > 17 && s < 20));
 156     ASSERT (!(u > 17 && u < 20));
 157 #endif
 158 #endif
 159 }
 160
 161 void testPointerCompare(void)
 162 {
 163         int i;
 164         fptr = &testPointerCompare;
 165         iptr = &i;
 166         ASSERT(iptr == &i);
 167         ASSERT(fptr == &testPointerCompare);
 168 }
 169
 170
 171
 172 /*
 173                 Common cases:
 174                         Around zero
 175                         Constants on either side (reversal)
 176                 <=
 177                 >=
 178                 ==
 179                 !=
 180                 <
 181                 >
 182 */