* support/regression/tests/bug-895992.c,

  support/regression/tests/onebyte.c:
  enabled pic16 regression testing since the bugs
  1511794: pic16: regression test bug-895992.c fails
  1444425: onebyte.c regression tes fails on pic16
  are fiexed, probably by fixing
  2048464: PIC16: fix genUminus - addresses not.c regression test

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@5224 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/ChangeLog b/ChangeLog
index c3a9771bff3627782e4b97453b73b4d5945c70e8..7beca775b86a1d4a2b2c6c8ad8db7fe2d9b21b87 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2008-08-31 Borut Razem <borut.razem AT siol.net>
+
+       * support/regression/tests/bug-895992.c,
+         support/regression/tests/onebyte.c:
+         enabled pic16 regression testing since the bugs
+         1511794: pic16: regression test bug-895992.c fails
+         1444425: onebyte.c regression tes fails on pic16
+         are fiexed, probably by fixing
+         2048464: PIC16: fix genUminus - addresses not.c regression test
+
 2008-08-30 Borut Razem <borut.razem AT siol.net>
 
        * support/cpp/libcpp/files.c: SDCPP synchronized with GCC CPP

diff --git a/support/regression/tests/bug-895992.c b/support/regression/tests/bug-895992.c
index 77018e072f26d5497fc49fe07c8b477abdcb6806..8492327b8785a38891d48a21348cca02ea43378a 100644 (file)
--- a/support/regression/tests/bug-895992.c
+++ b/support/regression/tests/bug-895992.c
@@ -28,13 +28,8 @@ wait (void)
 #endif
 
 static void
-testLR(void)
+testLR (void)
 {
-/*
- * excluded for pic16 due to bug:
- * [ 1511794 ] pic16: regression test bug-895992.c fails
- */
-#ifndef SDCC_pic16
   unsigned char number;
   unsigned char start = 1;
   unsigned char i;
@@ -42,7 +37,7 @@ testLR(void)
   do
     {
       for (i = 1; i > 0 ; i--)
-        wait();         /* destroys all registers */
+        wait ();        /* destroys all registers */
       if (start)
         {
           number = p0;
@@ -55,6 +50,5 @@ testLR(void)
     }
   while (number != 0);
 
-  ASSERT(loops == p0);
-#endif
+  ASSERT (loops == p0);
 }

diff --git a/support/regression/tests/onebyte.c b/support/regression/tests/onebyte.c
index d0cc08d765dbc4eb724806b9c88917078d21ee44..8cee113945574095cd17dc2edcd058f4481e33ce 100644 (file)
--- a/support/regression/tests/onebyte.c
+++ b/support/regression/tests/onebyte.c
@@ -6,9 +6,8 @@
 #include <testfwk.h>
 
 void
-testMul(void)
+testMul (void)
 {
-#ifndef SDCC_pic16  /* bug [ 1444425 ] onebyte.c regression tes fails on pic16 */
   {attrL}            char  cL;
   {attrL}  unsigned  char ucL;
   {attrR}            char  cR;
@@ -17,30 +16,29 @@ testMul(void)
   volatile unsigned  char  ur8, ur8b;
   volatile           short r16, r16b;
 
-  cL = -127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 ==  635); ASSERT(r16b ==  635);
-  cL =  127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 == -635); ASSERT(r16b == -635);
-  cL = -127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 == -635); ASSERT(r16b == -635);
-  cL =  127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 ==  635); ASSERT(r16b ==  635);
+  cL = -127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 ==  635); ASSERT (r16b ==  635);
+  cL =  127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 == -635); ASSERT (r16b == -635);
+  cL = -127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 == -635); ASSERT (r16b == -635);
+  cL =  127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT (r16 ==  635); ASSERT (r16b ==  635);
 
-  cL = -128; cR =   -1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
-  cL =  128; cR =   -1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
-  cL = -128; cR =    1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
-  cL =  128; cR =    1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
+  cL = -128; cR =   -1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT (ur8  ==  128); ASSERT (ur8b  ==  128);
+  cL =  128; cR =   -1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT ( r8  == -128); ASSERT ( r8b  == -128);
+  cL = -128; cR =    1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT ( r8  == -128); ASSERT ( r8b  == -128);
+  cL =  128; cR =    1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT (ur8  ==  128); ASSERT (ur8b  ==  128);
 
 #ifndef SDCC_z80
-  ucL = 128; cR =   -5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 == -640); ASSERT(r16b == -640);
-  ucL = 128; cR =    5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
+  ucL = 128; cR =   -5; r16 = ucL * cR; r16b = cR * ucL; ASSERT (r16 == -640); ASSERT (r16b == -640);
+  ucL = 128; cR =    5; r16 = ucL * cR; r16b = cR * ucL; ASSERT (r16 ==  640); ASSERT (r16b ==  640);
 #endif
 
-  ucL = 127;  cR =  -1;  r8 = ucL * cR;   r8b  = cR * ucL; ASSERT( r8 == -127); ASSERT( r8b  == -127);
-  ucL = 128;  cR =   1; ur8 = ucL * cR;  ur8b  = cR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b  ==  128);
-  ucL = 128; ucR =   5; r16 = ucL * ucR; r16b = ucR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
-  ucL = 128; ucR =   1; ur8 = ucL * ucR; ur8b = ucR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b ==  128);
-#endif
+  ucL = 127;  cR =  -1;  r8 = ucL * cR;   r8b  = cR * ucL; ASSERT ( r8 == -127); ASSERT ( r8b  == -127);
+  ucL = 128;  cR =   1; ur8 = ucL * cR;  ur8b  = cR * ucL; ASSERT (ur8 ==  128); ASSERT (ur8b  ==  128);
+  ucL = 128; ucR =   5; r16 = ucL * ucR; r16b = ucR * ucL; ASSERT (r16 ==  640); ASSERT (r16b ==  640);
+  ucL = 128; ucR =   1; ur8 = ucL * ucR; ur8b = ucR * ucL; ASSERT (ur8 ==  128); ASSERT (ur8b ==  128);
 }
 
 void
-testDiv(void)
+testDiv (void)
 {
   {attrL}           char  cL;
   {attrL}  unsigned char ucL;
@@ -50,47 +48,47 @@ testDiv(void)
   volatile unsigned char ur8;
   volatile         short r16;
 
-   cL = -128;  cR =   -2; r8  = cL / cR; ASSERT(r8  ==  64);
-   cL = -128;  cR =   -2; r16 = cL / cR; ASSERT(r16 ==  64);
- 
-  ucL =  255; ucR =    3; r8 = ucL / ucR; ASSERT(r8 ==  85);
-  ucL =  255; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   1);
-  ucL =    3; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   0);
+   cL = -128;  cR =   -2; r8  = cL / cR; ASSERT (r8  ==  64);
+   cL = -128;  cR =   -2; r16 = cL / cR; ASSERT (r16 ==  64);
+
+  ucL =  255; ucR =    3; r8 = ucL / ucR; ASSERT (r8 ==  85);
+  ucL =  255; ucR =  255; r8 = ucL / ucR; ASSERT (r8 ==   1);
+  ucL =    3; ucR =  255; r8 = ucL / ucR; ASSERT (r8 ==   0);
 
-   cL =  127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 ==  42);
-   cL = -127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 == -42);
-   cL =  127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 == -42);
-   cL = -127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 ==  42);
+   cL =  127;  cR =    3; r8 =  cL /  cR; ASSERT (r8 ==  42);
+   cL = -127;  cR =    3; r8 =  cL /  cR; ASSERT (r8 == -42);
+   cL =  127;  cR =   -3; r8 =  cL /  cR; ASSERT (r8 == -42);
+   cL = -127;  cR =   -3; r8 =  cL /  cR; ASSERT (r8 ==  42);
 
-  ucL =  127;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  42);
-  ucL =  255;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  85);
+  ucL =  127;  cR =    3; r8 = ucL /  cR; ASSERT (r8 ==  42);
+  ucL =  255;  cR =    3; r8 = ucL /  cR; ASSERT (r8 ==  85);
 #ifndef SDCC_z80
-  ucL =  127;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -42);
-  ucL =  255;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -85);
+  ucL =  127;  cR =   -3; r8 = ucL /  cR; ASSERT (r8 == -42);
+  ucL =  255;  cR =   -3; r8 = ucL /  cR; ASSERT (r8 == -85);
 #endif
-   
-   cL =  127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 ==  42);
-   cL = -127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 == -42);
-   cL =  127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
-   cL = -127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
-
-   cL =  127;  cR =    1; r8  =  cL /  cR; ASSERT(r8  == 127);
-   cL =  127;  cR =    1; r16 =  cL /  cR; ASSERT(r16 == 127);
-
-  ucL = 251;   cR =    1; ur8 = ucL /  cR; ASSERT(ur8 == 251);
-  ucL = 251;   cR =    1; r16 = ucL /  cR; ASSERT(r16 == 251);
-  
+
+   cL =  127; ucR =    3; r8 =  cL / ucR; ASSERT (r8 ==  42);
+   cL = -127; ucR =    3; r8 =  cL / ucR; ASSERT (r8 == -42);
+   cL =  127; ucR =  128; r8 =  cL / ucR; ASSERT (r8 ==   0);
+   cL = -127; ucR =  128; r8 =  cL / ucR; ASSERT (r8 ==   0);
+
+   cL =  127;  cR =    1; r8  =  cL /  cR; ASSERT (r8  == 127);
+   cL =  127;  cR =    1; r16 =  cL /  cR; ASSERT (r16 == 127);
+
+  ucL = 251;   cR =    1; ur8 = ucL /  cR; ASSERT (ur8 == 251);
+  ucL = 251;   cR =    1; r16 = ucL /  cR; ASSERT (r16 == 251);
+
 #ifndef SDCC_z80
-  ucL = 253;   cR =   -3; r8  = ucL /  cR; ASSERT(r8  == -84);
-  ucL = 253;   cR =   -3; r16 = ucL /  cR; ASSERT(r16 == -84);
-  
-  ucL =  254;  cR =   -1; r16 = ucL /  cR; ASSERT(r16 == -254);
+  ucL = 253;   cR =   -3; r8  = ucL /  cR; ASSERT (r8  == -84);
+  ucL = 253;   cR =   -3; r16 = ucL /  cR; ASSERT (r16 == -84);
+
+  ucL =  254;  cR =   -1; r16 = ucL /  cR; ASSERT (r16 == -254);
 #endif
-   cL = -128;  cR =   -1; r16 =  cL /  cR; ASSERT(r16 ==  128);
+   cL = -128;  cR =   -1; r16 =  cL /  cR; ASSERT (r16 ==  128);
 }
 
 void
-testMod(void)
+testMod (void)
 {
   {attrL}           char  cL;
   {attrL}  unsigned char ucL;
@@ -100,32 +98,32 @@ testMod(void)
   volatile unsigned char ur8;
   volatile         short r16;
 
-  ucL =  128;  cR =    5; r16 = ucL %  cR; ASSERT(r16 ==  3);
+  ucL =  128;  cR =    5; r16 = ucL %  cR; ASSERT (r16 ==  3);
 #ifndef SDCC_z80
-  ucL =  128;  cR =   -5; r16 = ucL %  cR; ASSERT(r16 ==  3);
+  ucL =  128;  cR =   -5; r16 = ucL %  cR; ASSERT (r16 ==  3);
 #endif
-  ucL =  128; ucR =    5; r16 = ucL % ucR; ASSERT(r16 ==  3);
+  ucL =  128; ucR =    5; r16 = ucL % ucR; ASSERT (r16 ==  3);
 
-  ucL =  128; ucR =  255; ur8 = ucL % ucR; ASSERT(ur8 == 128);
-  ucL =  128; ucR =  255; r16 = ucL % ucR; ASSERT(r16 == 128);
+  ucL =  128; ucR =  255; ur8 = ucL % ucR; ASSERT (ur8 == 128);
+  ucL =  128; ucR =  255; r16 = ucL % ucR; ASSERT (r16 == 128);
 
-  ucL =  128;  cR =  127; r8  = ucL %  cR; ASSERT(r8  ==  1);
-   
-   cL =  127;  cR =    5; r16 =  cL %  cR; ASSERT(r16 ==  2);
+  ucL =  128;  cR =  127; r8  = ucL %  cR; ASSERT (r8  ==  1);
+
+   cL =  127;  cR =    5; r16 =  cL %  cR; ASSERT (r16 ==  2);
    r16 = -1;
-   cL =  127;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 ==  2);
+   cL =  127;  cR =   -5; r16 =  cL %  cR; ASSERT (r16 ==  2);
    r16 = -1;
-   cL =  127; ucR =    5; r16 =  cL % ucR; ASSERT(r16 ==  2);
-  
-   cL = -128;  cR =    5; r16 =  cL %  cR; ASSERT(r16 == -3);
+   cL =  127; ucR =    5; r16 =  cL % ucR; ASSERT (r16 ==  2);
+
+   cL = -128;  cR =    5; r16 =  cL %  cR; ASSERT (r16 == -3);
    r16 = 0;
-   cL = -128;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 == -3);
+   cL = -128;  cR =   -5; r16 =  cL %  cR; ASSERT (r16 == -3);
    r16 = 0;
-   cL = -128; ucR =    5; r16 =  cL % ucR; ASSERT(r16 == -3);
+   cL = -128; ucR =    5; r16 =  cL % ucR; ASSERT (r16 == -3);
 }
 
 void
-testOr(void)
+testOr (void)
 {
   {attrL}           char  cL;
   {attrL}  unsigned char ucL;
@@ -133,13 +131,13 @@ testOr(void)
   {attrR}  unsigned char ucR;
   volatile         short r16, r16b;
 
-   cL = 0x00;  cR = 0x80; r16 =  cL |  cR; r16b =  cR |  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
-  ucL = 0x80;  cR = 0x00; r16 = ucL |  cR; r16b =  cR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
-  ucL = 0x80; ucR = 0x80; r16 = ucL | ucR; r16b = ucR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
+   cL = 0x00;  cR = 0x80; r16 =  cL |  cR; r16b =  cR |  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
+  ucL = 0x80;  cR = 0x00; r16 = ucL |  cR; r16b =  cR | ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
+  ucL = 0x80; ucR = 0x80; r16 = ucL | ucR; r16b = ucR | ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 }
 
 void
-testXor(void)
+testXor (void)
 {
   {attrL}           char  cL;
   {attrL}  unsigned char ucL;
@@ -147,19 +145,19 @@ testXor(void)
   {attrR}  unsigned char ucR;
   volatile         short r16, r16b;
 
-   cL = 0x80;  cR = 0x80; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 ==              0); ASSERT(r16b ==              0);
-   cL = 0x80;  cR = 0x00; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
+   cL = 0x80;  cR = 0x80; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT (r16 ==              0); ASSERT (r16b ==              0);
+   cL = 0x80;  cR = 0x00; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 
-  ucL = 0x80;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff00); ASSERT(r16b == (short) 0xff00);
-  ucL = 0x80;  cR =    0; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
-  ucL =    0;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
+  ucL = 0x80;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 == (short) 0xff00); ASSERT (r16b == (short) 0xff00);
+  ucL = 0x80;  cR =    0; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
+  ucL =    0;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
 
-  ucL = 0x80; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==      0); ASSERT(r16b ==      0);
-  ucL =    0; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==   0x80); ASSERT(r16b ==   0x80);
+  ucL = 0x80; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT (r16 ==      0); ASSERT (r16b ==      0);
+  ucL =    0; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT (r16 ==   0x80); ASSERT (r16b ==   0x80);
 }
 
 void
-testAnd(void)
+testAnd (void)
 {
   {attrL}           char  cL;
   {attrL}  unsigned char ucL;
@@ -167,35 +165,35 @@ testAnd(void)
   {attrR}  unsigned char ucR;
   volatile         short r16, r16b;
 
-   cL = 0x80;  cR = 0x80; r16 =  cL &  cR; r16b =  cR &  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
-  ucL = 0x80;  cR = 0x80; r16 = ucL &  cR; r16b =  cR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
-  ucL = 0x80; ucR = 0x80; r16 = ucL & ucR; r16b = ucR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
+   cL = 0x80;  cR = 0x80; r16 =  cL &  cR; r16b =  cR &  cL; ASSERT (r16 == (short) 0xff80); ASSERT (r16b == (short) 0xff80);
+  ucL = 0x80;  cR = 0x80; r16 = ucL &  cR; r16b =  cR & ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
+  ucL = 0x80; ucR = 0x80; r16 = ucL & ucR; r16b = ucR & ucL; ASSERT (r16 ==           0x80); ASSERT (r16b ==           0x80);
 }
 
 void
-testComplement(void)
+testComplement (void)
 {
   {attrR}           char  c;
   {attrR}  unsigned char uc;
   volatile         short r16;
 
-   c = 0x00;  r16 = ~ c; ASSERT(r16    == (short) 0xffff); ASSERT(  ~ c < 0);
-  uc = 0x00;  r16 = ~uc; ASSERT(r16    == (short) 0xffff); ASSERT(  ~uc < 0);
-  ASSERT(~ (char)          0x00 == (short) 0xffff); ASSERT(~ (char)          0x00 < 0);
-  ASSERT(~ (unsigned char) 0x00 == (short) 0xffff); ASSERT(~ (unsigned char) 0x00 < 0);
-   c = 0x80;  r16 = ~ c; ASSERT(r16 == (short) 0x007f); ASSERT(~ c > 0);
-  uc = 0x80;  r16 = ~uc; ASSERT(r16 == (short) 0xff7f); ASSERT(~uc < 0);
-  ASSERT(~ (char)          0x80 == (short) 0x007f); ASSERT(~ (char)          0x80 > 0);
-  ASSERT(~ (unsigned char) 0x80 == (short) 0xff7f); ASSERT(~ (unsigned char) 0x80 < 0);
-
-  ASSERT(~ 1   < 0);
-  ASSERT(~ 1u  > 0);
-  ASSERT(~ 1l  < 0);
-  ASSERT(~ 1ul > 0);
+   c = 0x00;  r16 = ~ c; ASSERT (r16    == (short) 0xffff); ASSERT (~ c < 0);
+  uc = 0x00;  r16 = ~uc; ASSERT (r16    == (short) 0xffff); ASSERT (~uc < 0);
+  ASSERT (~ (char)          0x00 == (short) 0xffff); ASSERT (~ (char)          0x00 < 0);
+  ASSERT (~ (unsigned char) 0x00 == (short) 0xffff); ASSERT (~ (unsigned char) 0x00 < 0);
+   c = 0x80;  r16 = ~ c; ASSERT (r16 == (short) 0x007f); ASSERT (~ c > 0);
+  uc = 0x80;  r16 = ~uc; ASSERT (r16 == (short) 0xff7f); ASSERT (~uc < 0);
+  ASSERT (~ (char)          0x80 == (short) 0x007f); ASSERT (~ (char)          0x80 > 0);
+  ASSERT (~ (unsigned char) 0x80 == (short) 0xff7f); ASSERT (~ (unsigned char) 0x80 < 0);
+
+  ASSERT (~ 1   < 0);
+  ASSERT (~ 1u  > 0);
+  ASSERT (~ 1l  < 0);
+  ASSERT (~ 1ul > 0);
 }
 
 void
-testCompare(void)
+testCompare (void)
 {
   {attrL}   signed char  c;
   {attrR} unsigned char uc;
@@ -203,16 +201,16 @@ testCompare(void)
    c = 0x80; /* -128 */
   uc = 0x80; /* +128 */
 
-  ASSERT(!(c == uc));
-  ASSERT(  c != uc );
-  ASSERT(  c <  uc );
-  ASSERT(  c <= uc );
-  ASSERT(!(c >  uc));
-  ASSERT(!(c >= uc));
+  ASSERT (!(c == uc));
+  ASSERT (  c != uc );
+  ASSERT (  c <  uc );
+  ASSERT (  c <= uc );
+  ASSERT (!(c >  uc));
+  ASSERT (!(c >= uc));
 }
 
 void
-testUMinus(void)
+testUMinus (void)
 {
     signed char  {attrL} sc;
   unsigned char  {attrL} uc;
@@ -221,38 +219,38 @@ testUMinus(void)
     signed long  {attrL} sl;
   unsigned long  {attrL} ul;
 
-  ASSERT(-(53l ) < 0);
-  ASSERT(-(53ul) > 0);
+  ASSERT (-(53l ) < 0);
+  ASSERT (-(53ul) > 0);
   ul = 53;
-  ASSERT(-ul > 0);
+  ASSERT (-ul > 0);
   sl = 53;
-  ASSERT(-sl < 0);
+  ASSERT (-sl < 0);
 
-  ASSERT(-(53  ) < 0);
-  ASSERT(-(53u ) > 0);
+  ASSERT (-(53  ) < 0);
+  ASSERT (-(53u ) > 0);
   ui = 53;
-  ASSERT(-ui > 0);
+  ASSERT (-ui > 0);
   si = 53;
-  ASSERT(-si < 0);
+  ASSERT (-si < 0);
 
-  ASSERT(-( 250 ) == -250);
+  ASSERT (-( 250 ) == -250);
   uc = 250;
-  ASSERT(-uc == -250);
+  ASSERT (-uc == -250);
 
-  ASSERT(-(-128 ) ==  128);
+  ASSERT (-(-128 ) ==  128);
   sc = -128;
-  ASSERT(-sc == 128);
+  ASSERT (-sc == 128);
 }
 
 void
-testBug1571231(void)
+testBug1571231 (void)
 {
   unsigned char  {attrL} uc;
 
   /* bug-1571231 */
   uc = 0x80;
   if (uc + 0x80)
-    ASSERT(1);
+    ASSERT (1);
   else
-    ASSERT(0);
+    ASSERT (0);
 }