git.gag.com Git - debian/cc1111/blob - support/regression/tests/compare.c

   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} {type} i;
  13
  14     i = 5;
  15
  16     ASSERT(0 < i);
  17     ASSERT(i > 0);
  18     ASSERT(0 <= i);
  19     ASSERT(i >= 0);
  20
  21     i = -33;
  22     ASSERT(0 > i);
  23     ASSERT(i < 0);
  24     ASSERT(0 >= i);
  25     ASSERT(i <= 0);
  26
  27     i = 0;
  28     ASSERT(0 == i);
  29     ASSERT(0 <= i);
  30     ASSERT(0 >= i);
  31 }
  32
  33 static void
  34 testCompareConstants(void)
  35 {
  36     {attr} {storage} {type} i;
  37
  38     i = 12;
  39     ASSERT(i < 23);
  40     ASSERT(i > 3);
  41     ASSERT(i > -14);
  42     ASSERT(i <= 23);
  43     ASSERT(i >= 3);
  44     ASSERT(i >= -14);
  45     ASSERT(i <= 12);
  46     ASSERT(i >= 12);
  47     ASSERT(i == 12);
  48
  49     i = -34;
  50     ASSERT(i > -126);
  51     ASSERT(i < -3);
  52     ASSERT(i < 47);
  53     ASSERT(i >= -126);
  54     ASSERT(i <= -3);
  55     ASSERT(i <= 47);
  56     ASSERT(i <= -34);
  57     ASSERT(i >= -34);
  58     ASSERT(i == -34);
  59 }
  60
  61 static void
  62 testCompareVariables(void)
  63 {
  64     {attr} {storage} {type} left, right;
  65
  66     left = 12;
  67     right = 47;
  68     ASSERT(left < right);
  69     ASSERT(left <= right);
  70     ASSERT(right > left);
  71     ASSERT(right >= left);
  72
  73     right = -8;
  74     ASSERT(left > right);
  75     ASSERT(left >= right);
  76     ASSERT(right < left);
  77     ASSERT(right <= left);
  78
  79     right = 0;
  80     ASSERT(left > right);
  81     ASSERT(left >= right);
  82     ASSERT(right < left);
  83     ASSERT(right <= left);
  84
  85     right = left;
  86     ASSERT(left == right);
  87     ASSERT(left <= right);
  88     ASSERT(left >= right);
  89 }
  90
  91 static void
  92 testUnsignedCompare(void)
  93 {
  94     {attr} {storage} unsigned {type} left, right;
  95
  96     left = 0;
  97     right = (unsigned {type})-1;
  98
  99     ASSERT(left < right);
 100     ASSERT(left <= right);
 101     ASSERT(right > left);
 102     ASSERT(right >= left);
 103 }
 104 /*
 105                 Common cases:
 106                         Around zero
 107                         Constants on either side (reversal)
 108                 <=
 109                 >=
 110                 ==
 111                 !=
 112                 <
 113                 >
 114 */