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

   1 /** test one byte mul/div/mod operations.
   2
   3   attrL: volatile,
   4   attrR: volatile,
   5 */
   6 #include <testfwk.h>
   7
   8 void
   9 testMul (void)
  10 {
  11   {attrL}            char  cL;
  12   {attrL}  unsigned  char ucL;
  13   {attrR}            char  cR;
  14   {attrR}  unsigned  char ucR;
  15   volatile           char   r8 , r8b;
  16   volatile unsigned  char  ur8, ur8b;
  17   volatile           short r16, r16b;
  18
  19   cL = -127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 ==  635); ASSERT (r16b ==  635);
  20   cL =  127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 == -635); ASSERT (r16b == -635);
  21   cL = -127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 == -635); ASSERT (r16b == -635);
  22   cL =  127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 ==  635); ASSERT (r16b ==  635);
  23
  24   cL = -128; cR =   -1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT (ur8  ==  128); ASSERT (ur8b  ==  128);
  25   cL =  128; cR =   -1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT ( r8  == -128); ASSERT ( r8b  == -128);
  26   cL = -128; cR =    1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT ( r8  == -128); ASSERT ( r8b  == -128);
  27   cL =  128; cR =    1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT (ur8  ==  128); ASSERT (ur8b  ==  128);
  28
  29   ucL = 128; cR =   -5; r16 = ucL * cR; r16b = cR * ucL; ASSERT (r16 == -640); ASSERT (r16b == -640);
  30   ucL = 128; cR =    5; r16 = ucL * cR; r16b = cR * ucL; ASSERT (r16 ==  640); ASSERT (r16b ==  640);
  31
  32   ucL = 127;  cR =  -1;  r8 = ucL * cR;   r8b  = cR * ucL; ASSERT ( r8 == -127); ASSERT ( r8b  == -127);
  33   ucL = 128;  cR =   1; ur8 = ucL * cR;  ur8b  = cR * ucL; ASSERT (ur8 ==  128); ASSERT (ur8b  ==  128);
  34   ucL = 128; ucR =   5; r16 = ucL * ucR; r16b = ucR * ucL; ASSERT (r16 ==  640); ASSERT (r16b ==  640);
  35   ucL = 128; ucR =   1; ur8 = ucL * ucR; ur8b = ucR * ucL; ASSERT (ur8 ==  128); ASSERT (ur8b ==  128);
  36
  37   ucL =  254;  cR = -1; r16 = ucL *  cR; ASSERT (r16 == -254);
  38    cL = -128;  cR = -1; r16 =  cL *  cR; ASSERT (r16 ==  128);
  39 }
  40
  41 void
  42 testDiv (void)
  43 {
  44   {attrL}           char  cL;
  45   {attrL}  unsigned char ucL;
  46   {attrR}           char  cR;
  47   {attrR}  unsigned char ucR;
  48   volatile          char  r8;
  49   volatile unsigned char ur8;
  50   volatile         short r16;
  51
  52    cL = -128;  cR =   -2; r8  = cL / cR; ASSERT (r8  ==  64);
  53    cL = -128;  cR =   -2; r16 = cL / cR; ASSERT (r16 ==  64);
  54
  55   ucL =  255; ucR =    3; r8 = ucL / ucR; ASSERT (r8 ==  85);
  56   ucL =  255; ucR =  255; r8 = ucL / ucR; ASSERT (r8 ==   1);
  57   ucL =    3; ucR =  255; r8 = ucL / ucR; ASSERT (r8 ==   0);
  58
  59    cL =  127;  cR =    3; r8 =  cL /  cR; ASSERT (r8 ==  42);
  60    cL = -127;  cR =    3; r8 =  cL /  cR; ASSERT (r8 == -42);
  61    cL =  127;  cR =   -3; r8 =  cL /  cR; ASSERT (r8 == -42);
  62    cL = -127;  cR =   -3; r8 =  cL /  cR; ASSERT (r8 ==  42);
  63
  64   ucL =  127;  cR =    3; r8 = ucL /  cR; ASSERT (r8 ==  42);
  65   ucL =  255;  cR =    3; r8 = ucL /  cR; ASSERT (r8 ==  85);
  66   ucL =  127;  cR =   -3; r8 = ucL /  cR; ASSERT (r8 == -42);
  67   ucL =  255;  cR =   -3; r8 = ucL /  cR; ASSERT (r8 == -85);
  68
  69    cL =  127; ucR =    3; r8 =  cL / ucR; ASSERT (r8 ==  42);
  70    cL = -127; ucR =    3; r8 =  cL / ucR; ASSERT (r8 == -42);
  71    cL =  127; ucR =  128; r8 =  cL / ucR; ASSERT (r8 ==   0);
  72    cL = -127; ucR =  128; r8 =  cL / ucR; ASSERT (r8 ==   0);
  73
  74    cL =  127;  cR =    1; r8  =  cL /  cR; ASSERT (r8  == 127);
  75    cL =  127;  cR =    1; r16 =  cL /  cR; ASSERT (r16 == 127);
  76
  77   ucL = 251;   cR =    1; ur8 = ucL /  cR; ASSERT (ur8 == 251);
  78   ucL = 251;   cR =    1; r16 = ucL /  cR; ASSERT (r16 == 251);
  79
  80   ucL = 253;   cR =   -3; r8  = ucL /  cR; ASSERT (r8  == -84);
  81   ucL = 253;   cR =   -3; r16 = ucL /  cR; ASSERT (r16 == -84);
  82
  83   ucL =  254;  cR =   -1; r16 = ucL /  cR; ASSERT (r16 == -254);
  84    cL = -128;  cR =   -1; r16 =  cL /  cR; ASSERT (r16 ==  128);
  85 }
  86
  87 void
  88 testMod (void)
  89 {
  90   {attrL}           char  cL;
  91   {attrL}  unsigned char ucL;
  92   {attrR}           char  cR;
  93   {attrR}  unsigned char ucR;
  94   volatile          char  r8;
  95   volatile unsigned char ur8;
  96   volatile         short r16;
  97
  98   ucL =  128;  cR =    5; r16 = ucL %  cR; ASSERT (r16 ==  3);
  99   ucL =  128;  cR =   -5; r16 = ucL %  cR; ASSERT (r16 ==  3);
 100   ucL =  128; ucR =    5; r16 = ucL % ucR; ASSERT (r16 ==  3);
 101
 102   ucL =  128; ucR =  255; ur8 = ucL % ucR; ASSERT (ur8 == 128);
 103   ucL =  128; ucR =  255; r16 = ucL % ucR; ASSERT (r16 == 128);
 104
 105   ucL =  128;  cR =  127; r8  = ucL %  cR; ASSERT (r8  ==  1);
 106
 107    cL =  127;  cR =    5; r16 =  cL %  cR; ASSERT (r16 ==  2);
 108    r16 = -1;
 109    cL =  127;  cR =   -5; r16 =  cL %  cR; ASSERT (r16 ==  2);
 110    r16 = -1;
 111    cL =  127; ucR =    5; r16 =  cL % ucR; ASSERT (r16 ==  2);
 112
 113    cL = -128;  cR =    5; r16 =  cL %  cR; ASSERT (r16 == -3);
 114    r16 = 0;
 115    cL = -128;  cR =   -5; r16 =  cL %  cR; ASSERT (r16 == -3);
 116    r16 = 0;
 117    cL = -128; ucR =    5; r16 =  cL % ucR; ASSERT (r16 == -3);
 118 }
 119
 120 void
 121 testOr (void)
 122 {
 123   {attrL}           char  cL;
 124   {attrL}  unsigned char ucL;
 125   {attrR}           char  cR;
 126   {attrR}  unsigned char ucR;
 127   volatile         short r16, r16b;
 128
 129    cL = 0x00;  cR = 0x80; r16 =  cL |  cR; r16b =  cR |  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 130   ucL = 0x80;  cR = 0x00; r16 = ucL |  cR; r16b =  cR | ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 131   ucL = 0x80; ucR = 0x80; r16 = ucL | ucR; r16b = ucR | ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 132 }
 133
 134 void
 135 testXor (void)
 136 {
 137   {attrL}           char  cL;
 138   {attrL}  unsigned char ucL;
 139   {attrR}           char  cR;
 140   {attrR}  unsigned char ucR;
 141   volatile         short r16, r16b;
 142
 143    cL = 0x80;  cR = 0x80; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT (r16 ==              0); ASSERT (r16b ==              0);
 144    cL = 0x80;  cR = 0x00; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 145
 146   ucL = 0x80;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 == (short) 0xff00); ASSERT (r16b == (short) 0xff00);
 147   ucL = 0x80;  cR =    0; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 148   ucL =    0;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 149
 150   ucL = 0x80; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT (r16 ==      0); ASSERT (r16b ==      0);
 151   ucL =    0; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT (r16 ==   0x80); ASSERT (r16b ==   0x80);
 152 }
 153
 154 void
 155 testAnd (void)
 156 {
 157   {attrL}           char  cL;
 158   {attrL}  unsigned char ucL;
 159   {attrR}           char  cR;
 160   {attrR}  unsigned char ucR;
 161   volatile         short r16, r16b;
 162
 163    cL = 0x80;  cR = 0x80; r16 =  cL &  cR; r16b =  cR &  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 164   ucL = 0x80;  cR = 0x80; r16 = ucL &  cR; r16b =  cR & ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 165   ucL = 0x80; ucR = 0x80; r16 = ucL & ucR; r16b = ucR & ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 166 }
 167
 168 void
 169 testComplement (void)
 170 {
 171   {attrR}           char  c;
 172   {attrR}  unsigned char uc;
 173   volatile         short r16;
 174
 175    c = 0x00;  r16 = ~ c; ASSERT (r16    == (short) 0xffff); ASSERT (~ c < 0);
 176   uc = 0x00;  r16 = ~uc; ASSERT (r16    == (short) 0xffff); ASSERT (~uc < 0);
 177   ASSERT (~ (char)          0x00 == (short) 0xffff); ASSERT (~ (char)          0x00 < 0);
 178   ASSERT (~ (unsigned char) 0x00 == (short) 0xffff); ASSERT (~ (unsigned char) 0x00 < 0);
 179    c = 0x80;  r16 = ~ c; ASSERT (r16 == (short) 0x007f); ASSERT (~ c > 0);
 180   uc = 0x80;  r16 = ~uc; ASSERT (r16 == (short) 0xff7f); ASSERT (~uc < 0);
 181   ASSERT (~ (char)          0x80 == (short) 0x007f); ASSERT (~ (char)          0x80 > 0);
 182   ASSERT (~ (unsigned char) 0x80 == (short) 0xff7f); ASSERT (~ (unsigned char) 0x80 < 0);
 183
 184   ASSERT (~ 1   < 0);
 185   ASSERT (~ 1u  > 0);
 186   ASSERT (~ 1l  < 0);
 187   ASSERT (~ 1ul > 0);
 188 }
 189
 190 void
 191 testCompare (void)
 192 {
 193   {attrL}   signed char  c;
 194   {attrR} unsigned char uc;
 195
 196    c = 0x80; /* -128 */
 197   uc = 0x80; /* +128 */
 198
 199   ASSERT (!(c == uc));
 200   ASSERT (  c != uc );
 201   ASSERT (  c <  uc );
 202   ASSERT (  c <= uc );
 203   ASSERT (!(c >  uc));
 204   ASSERT (!(c >= uc));
 205 }
 206
 207 void
 208 testUMinus (void)
 209 {
 210     signed char  {attrL} sc;
 211   unsigned char  {attrL} uc;
 212     signed int   {attrL} si;
 213   unsigned int   {attrL} ui;
 214     signed long  {attrL} sl;
 215   unsigned long  {attrL} ul;
 216
 217   ASSERT (-(53l ) < 0);
 218   ASSERT (-(53ul) > 0);
 219   ul = 53;
 220   ASSERT (-ul > 0);
 221   sl = 53;
 222   ASSERT (-sl < 0);
 223
 224   ASSERT (-(53  ) < 0);
 225   ASSERT (-(53u ) > 0);
 226   ui = 53;
 227   ASSERT (-ui > 0);
 228   si = 53;
 229   ASSERT (-si < 0);
 230
 231   ASSERT (-( 250 ) == -250);
 232   uc = 250;
 233   ASSERT (-uc == -250);
 234
 235   ASSERT (-(-128 ) ==  128);
 236   sc = -128;
 237   ASSERT (-sc == 128);
 238 }
 239
 240 void
 241 testBug1571231 (void)
 242 {
 243   unsigned char  {attrL} uc;
 244
 245   /* bug-1571231 */
 246   uc = 0x80;
 247   if (uc + 0x80)
 248     ASSERT (1);
 249   else
 250     ASSERT (0);
 251 }