added tdd tests for automatic refactoring

1 files changed, 277 insertions, 438 deletions

diff --git a/test/testFuncs1.c b/test/testFuncs1.c
index fc1c25d..e0d35f1 100644
--- a/test/testFuncs1.c
+++ b/test/testFuncs1.c
@@ -7,7 +7,8 @@
 #if 0

 #include <string.h>

 #endif

-/**************************************************MACROS & DEFS*******************************************************/

+/**************************************************MACROS &

+ * DEFS*******************************************************/

 /**********************************************************************************************************************/

 #define LUPO 1U

 #define LOCO 2U

@@ -25,18 +26,16 @@ const unsigned int shift = 10U;
 /******************************************************Globals*********************************************************/

 

 /**********************************************************************************************************************/

-void test (void);

-void test2 (void);

-void test11 (void);

+void test(void);

+void test2(void);

+void test11(void);

 

 double badboy = 0.0;

 

-

 /**********************************************************************************************************************/

 

 /*testing for simple statement coverage*/

-void testFuncStatementsinmple (void)

-{

+void testFuncStatementsinmple(void) {

   int int1 = 1U;

   int int2 = 2U;

   int int3 = 3U;

@@ -50,102 +49,84 @@ void testFuncStatementsinmple (void)
 }

 

 /*testing for complex statement coverage*/

-void testFuncStatementComplexIf (void)

-{

+void testFuncStatementComplexIf(void) {

   int int1 = 1U;

   int int2 = 2U;

   int int3 = 3U;

   int int4 = 4U;

 

-  if ( int4 > int3 )

-    if ( int3 > int2 )

-      if ( int2 > int1 )

-        if ( int2 > int1 )

+  if (int4 > int3)

+    if (int3 > int2)

+      if (int2 > int1)

+        if (int2 > int1)

           im_a_minion_02();

 }

 

 /*testing to see whether the tool recognizes not covering statements*/

-void testFuncStatementNotCoverage (void)

-{

+void testFuncStatementNotCoverage(void) {

   int int1 = 1U;

   int int2 = 2U;

   int int3 = 3U;

   int int4 = 4U;

 

-  if (int4 < int3)

-  {

+  if (int4 < int3) {

     int4 = int3;

   }

 

   /*do note that your compiler might optimize this by completely erasing this*/

-  if (int2 > int1)

-  {

-    if (int1 > int2)

-    {

+  if (int2 > int1) {

+    if (int1 > int2) {

       im_a_minion_01();

     }

   }

 

-  if (int2 > int1)

-  {

-    if (int3 < int2)

-    {

+  if (int2 > int1) {

+    if (int3 < int2) {

       im_a_minion_02();

     }

   }

-

 }

 

 /*verifying for loops*/

-void testFuncLoopFor (void)

-{

+void testFuncLoopFor(void) {

   int i = 1U;

 

-  for (i = 1; i < 10; i++)

-  {

+  for (i = 1; i < 10; i++) {

     im_a_minion_01();

   }

 

   i = 1U;

 

-  for (i = 1; i < 10; i++)

-  {

-    if (1U == (i % 2U) )

-    {

+  for (i = 1; i < 10; i++) {

+    if (1U == (i % 2U)) {

       im_a_minion_01();

     }

   }

 }

 

 /*verifying while loops*/

-void testFuncLoopWhile (void)

-{

+void testFuncLoopWhile(void) {

   int i = 20U;

 

-  while (i > 10U)

-  {

+  while (i > 10U) {

     i = i - 1U;

   }

 

   i = 20;

 

 #if (TRUE == INF_LOOP)

-  while (20U == i)

-  {

+  while (20U == i) {

     im_a_minion_03();

   }

 #endif

 }

 

 /*verifying the correct handling of continue*/

-void testFuncContinue (void)

-{

+void testFuncContinue(void) {

   int i = 1U;

 

-  for (i = 1U; i < 20U; i++)

-  {

-    if (i < 19U)

-    {

+  for (i = 1U; i < 20U; i++) {

+    if (i < 19U) {

       continue;

     }

     im_a_minion_01();

@@ -153,14 +134,11 @@ void testFuncContinue (void)
 }

 

 /*verifying the correct handling of break*/

-void testFuncBreak (void)

-{

+void testFuncBreak(void) {

   int i = 1U;

 

-  for (i = 1U; i < 10U ; i++)

-  {

-    if (i > 0U)

-    {

+  for (i = 1U; i < 10U; i++) {

+    if (i > 0U) {

       break;

     }

     im_a_minion_03();

@@ -168,8 +146,7 @@ void testFuncBreak (void)
 }

 

 /*checking whether goto is handled correctly*/

-void testFuncGoto (void)

-{

+void testFuncGoto(void) {

   im_a_minion_01();

   goto jumpy;

   im_a_minion_02();

@@ -177,19 +154,16 @@ jumpy:
   im_a_minion_03();

 }

 

-/*checking whether the basic blocks do not complete execution due to return statements*/

-int testFuncNotReturn (int a, int b)

-{

+/*checking whether the basic blocks do not complete execution due to return

+ * statements*/

+int testFuncNotReturn(int a, int b) {

   int sum = 0U;

 

   sum = a + b;

 

-  if (10U == sum)

-  {

+  if (10U == sum) {

     return (sum);

-  }

-  else

-  {

+  } else {

     im_a_dummy();

   }

 

@@ -199,67 +173,66 @@ int testFuncNotReturn (int a, int b)
 }

 

 /*checking whether the tool handles multi-line statements correctly*/

-void testFuncMultiLineStatement (void)

-{

-  im_a_minion_01();

-}

+void testFuncMultiLineStatement(void) { im_a_minion_01(); }

 

 /*checking how the tool handles multiple statements on the same line*/

-void testFuncMultipleStatement (void)

-{

+void testFuncMultipleStatement(void) {

   int a = 1U;

   int b = 2U;

   int c = 3U;

   int d = 4U;

 

-  a = a + b; b = b + c; c = c + d; d = d + a;

+  a = a + b;

+  b = b + c;

+  c = c + d;

+  d = d + a;

 }

 

 /*checking whether multiple statements are handled correctly on the same line*/

-void testFuncMultipleStatementNot (void)

-{

+void testFuncMultipleStatementNot(void) {

   int a = 10U;

 

-  if (a < 10U) {im_a_minion_01();} else {im_a_minion_02();}

+  if (a < 10U) {

+    im_a_minion_01();

+  } else {

+    im_a_minion_02();

+  }

 

   testFuncMultipleStatementNot();

 }

 

-/*checking how compiler optimizations may affect the coverage reported-killed assignment elimination*/

-void testFuncCompOpti1 (void)

-{

+/*checking how compiler optimizations may affect the coverage reported-killed

+ * assignment elimination*/

+void testFuncCompOpti1(void) {

   int a = 1U;

   int b = 2U;

 }

 

-/*checking how compiler optimizations may affect the coverage reported-common subexpression optimization*/

-void testFuncCompOpti2 (void)

-{

+/*checking how compiler optimizations may affect the coverage reported-common

+ * subexpression optimization*/

+void testFuncCompOpti2(void) {

   int a = 1U;

   int b = 1U;

 

-  if ( 0U == (((a * b) + (a / b) - a) - b) )

-  {

+  if (0U == (((a * b) + (a / b) - a) - b)) {

     im_a_benign_func();

   }

 

-  if ( 0U == (((a * b) + (a / b) - a) - b) )

-  {

+  if (0U == (((a * b) + (a / b) - a) - b)) {

     im_a_mlaign_func();

   }

 }

 

-/*checking how compiler optimizations may affect the coverage reported-loop invariant optimization*/

-void testFuncCompOpti3 (void)

-{

+/*checking how compiler optimizations may affect the coverage reported-loop

+ * invariant optimization*/

+void testFuncCompOpti3(void) {

   int i = 1U;

   int counter = 0U;

   int a = 0U;

   int b = 10U;

   int sum = 0U;

 

-  for (i = 1U; i < 100U ; i++)

-  {

+  for (i = 1U; i < 100U; i++) {

     counter = counter + 1U;

     sum = a + b;

   }

@@ -267,99 +240,91 @@ void testFuncCompOpti3 (void)
   sum = sum * 2U;

 }

 

-/*checking how compiler optimizations may affect the coverage reported-dead code optimization*/

-void testFuncCompOpti4 (void)

-{

+/*checking how compiler optimizations may affect the coverage reported-dead code

+ * optimization*/

+void testFuncCompOpti4(void) {

   im_a_minion_01();

   im_a_minion_02();

   im_a_minion_03();

 }

 

-/*testing if declarative statements that have a run-time footprint are covered by statement coverage.*/

-void testFuncStatementDecl1 (void)

-{

+/*testing if declarative statements that have a run-time footprint are covered

+ * by statement coverage.*/

+void testFuncStatementDecl1(void) {

   int declaration1 = 1001U;

   int declaration2 = 666U;

 }

 

-

 /*testing to see whether statement coverage covers the return.*/

-int testFuncStatementInt1 (int int1, int int2)

-{

+int testFuncStatementInt1(int int1, int int2) {

   int sum = 0U;

   sum = int1 + int2;

   return (sum);

 }

 

-

 /* to test this one we need two test cases:*/

 /* bool1 = FALSE and bool2 = whatever*/

 /* bool1 = TRUE and bool2 = whatever*/

-/* obviously if you get a full coverage with just the first test case, your tool didnt understand*/

-/* the short-circuit. if you need both test cases for a full coverage, then your tool is doing decision coverage,*/

+/* obviously if you get a full coverage with just the first test case, your tool

+ * didnt understand*/

+/* the short-circuit. if you need both test cases for a full coverage, then your

+ * tool is doing decision coverage,*/

 /* not branch coverage so good for you!*/

-blreplacement testFuncStatementbool1 (blreplacement bool1 , blreplacement bool2)

-{

+blreplacement testFuncStatementbool1(blreplacement bool1, blreplacement bool2) {

   return (bool1 && bool2);

 }

 

-

 /*same as above but with these test cases*/

 /*bool1 = TRUE and bool2 = whatever*/

 /*bool1 = FALSE and bool2 = whatever*/

-/* obviously if you get a full coverage with just the first test case, your tool didnt understand*/

-/* the short-circuit. if you need both test cases for a full coverage, then your tool is doing decision coverage,*/

+/* obviously if you get a full coverage with just the first test case, your tool

+ * didnt understand*/

+/* the short-circuit. if you need both test cases for a full coverage, then your

+ * tool is doing decision coverage,*/

 /* not branch coverage so good for you!*/

-blreplacement testFuncStatementbool2 (blreplacement bool1, blreplacement bool2)

-{

+blreplacement testFuncStatementbool2(blreplacement bool1, blreplacement bool2) {

   return (bool1 || bool2);

 }

 

-

-/*the fault will only be generated only if decision1 is FALSE. if we get a full coverage by running*/

-/* d1 = d2 = FALSE and d1 = FALSE and d2 = TRUE, then we dont have decision coverage. for a decision*/

-/* coverage we need to have an extra test case, wehre d1 = TRUE and d2 = whatever.*/

-void testFuncStatementDecision1 (blreplacement decision1 , blreplacement decision2)

-{

-  if ( decision1 || decision2 )

-  {

+/*the fault will only be generated only if decision1 is FALSE. if we get a full

+ * coverage by running*/

+/* d1 = d2 = FALSE and d1 = FALSE and d2 = TRUE, then we dont have decision

+ * coverage. for a decision*/

+/* coverage we need to have an extra test case, wehre d1 = TRUE and d2 =

+ * whatever.*/

+void testFuncStatementDecision1(blreplacement decision1,

+                                blreplacement decision2) {

+  if (decision1 || decision2) {

     /*this function will supposedly casue a bug if decision1 is true*/

     im_a_mlaign_func();

-  }

-  else

-  {

+  } else {

     im_a_benign_func();

   }

 }

 

-

 /* short-circuit!*/

-/* the compiler could go for short-cuircuit for both conditions.if it does, then we can see if we still get*/

-/* a full coverage. if the compiler doesnt go for a short-circuit, then all this dont apply.*/

-void testFuncShortCircuit (blreplacement bool1, blreplacement bool2)

-{

-  if (FALSE == bool1 && TRUE == bool2)

-  {

-    im_a_dummy ();

+/* the compiler could go for short-cuircuit for both conditions.if it does, then

+ * we can see if we still get*/

+/* a full coverage. if the compiler doesnt go for a short-circuit, then all this

+ * dont apply.*/

+void testFuncShortCircuit(blreplacement bool1, blreplacement bool2) {

+  if (FALSE == bool1 && TRUE == bool2) {

+    im_a_dummy();

   }

-  if (TRUE == bool2 || FALSE == bool1)

-  {

+  if (TRUE == bool2 || FALSE == bool1) {

     im_a_dummy();

   }

 }

 

-

 /*checking MCDC coverage behavior of the tool for multiply occuring conditions*/

-void testFuncMCDC1 (blreplacement decision1, blreplacement decision2)

-{

-  if (decision1 &&  (( decision2 || decision1) || (!decision1 || decision2)) )

-  {

+void testFuncMCDC1(blreplacement decision1, blreplacement decision2) {

+  if (decision1 && ((decision2 || decision1) || (!decision1 || decision2))) {

     im_a_dummy();

   }

 }

 

-

-/* this one is to test how the tool handles inline functions.do  all instances get covered separately or they get*/

+/* this one is to test how the tool handles inline functions.do  all instances

+ * get covered separately or they get*/

 /* covered accumulatively*/

 #if 0

 void testFuncMultiInstantiation (int level)

@@ -401,84 +366,56 @@ void testFuncMultiInstantiation (int level)
 #endif

 

 /* this function will check how the tool handles the "?" operator*/

-void testFuncQMark (int int1, int int2)

-{

+void testFuncQMark(int int1, int int2) {

   (int1 > int2) ? im_a_minion_01() : im_a_minion_02();

 }

 

-

 /* checking how the tool handles calling a function that returns boolean*/

-void testFuncCallBool (void)

-{

+void testFuncCallBool(void) {

   int local1 = 0U;

   int local2 = 0U;

-  local1 = testFuncStatementbool1(1U , 0U);

-  local2 = testFuncStatementbool2(1U , 0U);

+  local1 = testFuncStatementbool1(1U, 0U);

+  local2 = testFuncStatementbool2(1U, 0U);

 }

 

-

 /**********************************************************************************************************************/

 /* where all the fakes go.*/

 

-

 /*the function that is *supposedly* carrying a bug*/

-static void im_a_mlaign_func (void)

-{

-  /* KATSU!*/

+static void im_a_mlaign_func(void) { /* KATSU!*/

 }

 

-

 /*the function that is *supposedly* the good guy here*/

-static void im_a_benign_func (void)

-{

-  /* see the light ring?!*/

+static void im_a_benign_func(void) { /* see the light ring?!*/

 }

 

-

 /*the dummy function.*/

-void im_a_dummy (void)

-{

-  /* dumb dumb*/

+void im_a_dummy(void) { /* dumb dumb*/

 }

 

-

 /* minion function number #01*/

-void im_a_minion_01 (void)

-{

-  /* minion1*/

+void im_a_minion_01(void) { /* minion1*/

 }

 

-

 /* minion function number #02*/

-void im_a_minion_02 (void)

-{

-  /* minion1*/

+void im_a_minion_02(void) { /* minion1*/

 }

 

-

 /* minion function number #03*/

-static void im_a_minion_03 (void)

-{

-  /* minion1*/

+static void im_a_minion_03(void) { /* minion1*/

 }

 

-

 /* the only thing special about this one is that it has been inlined.*/

-/*since different compilers have different methods of inlining a function, this function has multiple versions.*/

+/*since different compilers have different methods of inlining a function, this

+ * function has multiple versions.*/

 #if (TRUE == INLINE)

 #if (MPC == COMPILER)

-inline void babeFunk (int entry)

-{

-  if (10U > entry)

-  {

+inline void babeFunk(int entry) {

+  if (10U > entry) {

     im_a_minion_01();

-  }

-  else if (10U == entry)

-  {

+  } else if (10U == entry) {

     im_a_minion_02();

-  }

-  else

-  {

+  } else {

     im_a_minion_03();

   }

 }

@@ -486,53 +423,44 @@ inline void babeFunk (int entry)
 

 #if (HCS12 == COMPILER)

 #pragma INLINE

-void babeFunk (int entry)

-{

-  if (10U > entry)

-  {

+void babeFunk(int entry) {

+  if (10U > entry) {

     im_a_minion_01();

-  }

-  else if (10U == entry)

-  {

+  } else if (10U == entry) {

     im_a_minion_02();

-  }

-  else

-  {

+  } else {

     im_a_minion_03();

   }

 }

 #endif

 #endif

-/*RL78s dont have inline for all functions, so no use trying to test the functionality*/

+/*RL78s dont have inline for all functions, so no use trying to test the

+ * functionality*/

 

-void test (void)

-{

+void test(void) {

   int i = 0U;

   int j = 0U;

   int a, b;

   int c, d;

 

-  for (;;)

-  {

+  for (;;) {

     a = b;

   }

 

   for (i = 1; i < 100U; i++)

-    b++              ;

+    b++;

 

   while (a > 10U)

-    im_a_minion_01()   ;

+    im_a_minion_01();

 

-  while (a == 90U)

-  {

+  while (a == 90U) {

     b++;

   }

 

   if (a == d)

     b = c;

 

-  if (a == d)

-  {

+  if (a == d) {

     a = d;

   }

 

@@ -546,42 +474,32 @@ void test (void)
     c++;

   else if (a > d)

     d++;

-

-

 }

 

-void test2 (void)

-{

+void test2(void) {

   int a = 0U;

   int b = 10U;

   int c, d;

 

-  if (a == b)

-  {

+  if (a == b) {

     /*do something*/

-  }

-  else

+  } else

     b = a;

 

-  if (20U == a)

-  {

+  if (20U == a) {

     /*kill all mutants.*/

   }

 

-  if (20U == a)

-  {

+  if (20U == a) {

     /*do somethin good*/

     a = b;

-  }

-  else if (30U == a)

-  {

+  } else if (30U == a) {

     /*do something else*/

     b = a;

   }

 

-  if (10U == a)

-  {/*die*/}

-  else if (15U == a)

+  if (10U == a) { /*die*/

+  } else if (15U == a)

     a = b;

   else if (17U == a)

     a = 10000000U;

@@ -589,79 +507,74 @@ void test2 (void)
     a = 50U;

 

   if (b == a) {

-    if (10U == b)

-    {}

-    else

-    {}

+    if (10U == b) {

+    } else {

+    }

   }

 

-

-

   if (a > b) {

-    if (a > d)

-    {}

-    else

+    if (a > d) {

+    } else

       a++;

   }

 

-  if (a > b)

-  {a++;}

-  else if (b > a)

-  {b++;}

-  else if (a == b)

-  {a++;}

+  if (a > b) {

+    a++;

+  } else if (b > a) {

+    b++;

+  } else if (a == b) {

+    a++;

+  }

 

   int level = 10U;

 

-  switch (level)

-  {

-  case 10U:

-  { level++;

+  switch (level) {

+  case 10U: {

+    level++;

     test();

     break;

   }

-  case 20U:

-  { level = 10000U;

+  case 20U: {

+    level = 10000U;

     break;

   }

-  case 30U:

-  { level++;

+  case 30U: {

+    level++;

     break;

   }

-  case 40U:

-  { level++;

+  case 40U: {

+    level++;

     break;

   }

-  case 50U:

-  { level++;

+  case 50U: {

+    level++;

     break;

   }

-  case 60U:

-  { level = 1000U;

+  case 60U: {

+    level = 1000U;

     break;

   }

-  case 70U:

-  { level++;

+  case 70U: {

+    level++;

     break;

   }

-  case 80U:

-  { level++;

+  case 80U: {

+    level++;

     break;

   }

-  case 90U:

-  { level++;

+  case 90U: {

+    level++;

     break;

   }

-  default:

-  { level++;

+  default: {

+    level++;

     break;

   }

   }

 

-  switch (level)

-  {

-  case 1:

-  { level++;

+  switch (level) {

+  case 1: {

+    level++;

     break;

   }

   case 2:

@@ -675,8 +588,7 @@ void test2 (void)
     }

   }

 

-  switch (level)

-  {

+  switch (level) {

   case 1:

     level++;

   case 2:

@@ -687,10 +599,7 @@ void test2 (void)
     level++;

   }

 

-  switch (level)

-  {}

-

-

+  switch (level) {}

 }

 

 #if 0

@@ -700,41 +609,32 @@ void test3 (int a, int, ...)
 }

 #endif

 

-test3()

-{

+test3() {

   int a;

   int b;

 }

 

-double test4 (int a, int b, double c)

-{

-  return a + b + c;

-}

+double test4(int a, int b, double c) { return a + b + c; }

 

-void test5(void)

-{

+void test5(void) {

   int i = 0;

-  if (test4)

-  {

+  if (test4) {

     i++;

   }

 }

 

-void test6 (void)

-{

+void test6(void) {

   int a[100];

   int *p = a;

 

   int i = 0;

 

-  for (i = 0; i < 100; ++i)

-  {

+  for (i = 0; i < 100; ++i) {

     a[i] = i;

   }

 }

 

-void test7(void)

-{

+void test7(void) {

   double a[100];

 

   double b[100];

@@ -743,9 +643,9 @@ void test7(void)
 

   double *pointer;

 

-  double* pointerb;

+  double *pointerb;

 

-  char* pointerc;

+  char *pointerc;

 

   pointerb = b;

 

@@ -753,51 +653,43 @@ void test7(void)
 

   pointerc = c;

 

-  if (a - b >= a)

-  {}

-  else if (b - a < a)

-  {}

+  if (a - b >= a) {

+  } else if (b - a < a) {

+  }

 

-  if (a < b)

-  {}

+  if (a < b) {

+  }

 

-  if (pointer < pointerb)

-  {}

+  if (pointer < pointerb) {

+  }

 

-  if (pointer > pointerb)

-  {}

+  if (pointer > pointerb) {

+  }

 

-  if (pointerb <= pointer)

-  {}

+  if (pointerb <= pointer) {

+  }

 

-  if (pointer >= pointerb)

-  {}

+  if (pointer >= pointerb) {

+  }

 

-  if (pointer < pointerc)

-  {}

+  if (pointer < pointerc) {

+  }

 

   int i = 0;

 

-  for (i = 0; i < 50; i++)

-  {

+  for (i = 0; i < 50; i++) {

     *(a + i) = i;

   }

-

 }

 

-void test8 (void)

-{

-  union uni uni2;

-}

+void test8(void) { union uni uni2; }

 

-void test9 (void)

-{

+void test9(void) {

   /*im a comment*/

-  //im also a comment

+  // im also a comment

 }

 

-void test10 (void)

-{

+void test10(void) {

   struct {

     unsigned int r1 : 1;

     unsigned int r2 : 2;

@@ -817,26 +709,19 @@ void test10 (void)
   } reg3;

 }

 

-void test11 (void)

-{

-  /*empty*/

+void test11(void) { /*empty*/

 }

 

-double test12(double a)

-{

-  return a * 2;

-}

+double test12(double a) { return a * 2; }

 

-int test13(void)

-{

+int test13(void) {

   static int a;

   int b;

 

   return (a * b);

 }

 

-void test14 (void)

-{

+void test14(void) {

   int arr[3][2] = {{2, 3}, {4, 5}, {6, 7}};

 

   int arr2[4][4] = {0};

@@ -851,21 +736,19 @@ void test14 (void)
 #endif

 }

 

-void test15(void)

-{

-  enum colour {red = 3, blue, yellow, green = 5};

+void test15(void) {

+  enum colour { red = 3, blue, yellow, green = 5 };

 

-  enum anotherset {black, grey, white};

+  enum anotherset { black, grey, white };

 

-  enum yetanotherset {pink = 7, purple, magenta, maroon};

+  enum yetanotherset { pink = 7, purple, magenta, maroon };

 

-  enum loco {verrueckt, crazy = 3, divune};

+  enum loco { verrueckt, crazy = 3, divune };

 

-  enum primeevil {diablo = 2, mephisto = 3, baal = 4};

+  enum primeevil { diablo = 2, mephisto = 3, baal = 4 };

 }

 

-short int test16(int a, int b)

-{

+short int test16(int a, int b) {

   short int sum;

   short unsigned int sumus;

   sum = a + b;

@@ -874,41 +757,33 @@ short int test16(int a, int b)
   return sum;

 }

 

-void test17(void)

-{

+void test17(void) {

   int a = 100;

   int b = 1000;

   long int longa;

-  a = sizeof (b = 2000U);

+  a = sizeof(b = 2000U);

 }

 

-void test18(void)

-{

+void test18(void) {

   int a;

   int b;

   int c;

   unsigned char d;

 

-  if (c && (a = b))

-  {

+  if (c && (a = b)) {

     /*yada /*yada*/

   }

 

-  if ((c = a) || a)

-  {

+  if ((c = a) || a) {

     /*yada*/

   }

-  if (c && (a || c))

-  {

-

+  if (c && (a || c)) {

   }

 

   d = c && (a = c);

-

 }

 

-void test19(void)

-{

+void test19(void) {

   const int a = 100;

 

   unsigned char flag = 1;

@@ -917,29 +792,27 @@ void test19(void)
 

   unsigned char flag3;

 

-  //char *str = "loco\0";

+  // char *str = "loco\0";

 

   const double pi = 3.54;

 

-  if ((flag) && pi)

-  {}

-

-  if (flag || flag2 && flag3)

-  {}

+  if ((flag) && pi) {

+  }

 

-  if (a == 0 && flag)

-  {}

+  if (flag || flag2 && flag3) {

+  }

 

-  if (flag || (a == 0))

-  {}

+  if (a == 0 && flag) {

+  }

 

-  if (!flag || flag2)

-  {}

+  if (flag || (a == 0)) {

+  }

 

+  if (!flag || flag2) {

+  }

 }

 

-void test20(void)

-{

+void test20(void) {

   signed int a;

   unsigned int b;

   signed char c;

@@ -956,8 +829,7 @@ void test20(void)
   f = f << 4U;

 }

 

-void test21(void)

-{

+void test21(void) {

   unsigned int a;

   a = a >> 44U;

   a = a >> shift;

@@ -965,8 +837,7 @@ void test21(void)
   a << 45U;

 }

 

-void test22(void)

-{

+void test22(void) {

   unsigned int a;

   int b;

   t_int c;

@@ -977,15 +848,13 @@ void test22(void)
   b = -d;

 }

 

-void test23 (void)

-{

+void test23(void) {

   int a, b, c;

 

   a = b, c = a;

 }

 

-void test24(void)

-{

+void test24(void) {

   int a;

   int b;

   int c;

@@ -996,117 +865,100 @@ void test24(void)
   --a;

 }

 

-void test25(void)

-{

+void test25(void) {

   int a;

   int b;

   int c;

 

-  if (a - b)

-  {

+  if (a - b) {

     /*i dont care.*/

   }

 }

 

-void test26 (void)

-{

+void test26(void) {

   double a;

   double b;

   double c;

   unsigned char d;

 

-  if (a == b)

-  {}

+  if (a == b) {

+  }

 

-  if (a < b)

-  {}

+  if (a < b) {

+  }

 

-  if (c >= a)

-  {}

+  if (c >= a) {

+  }

 

   d = (a <= c);

 }

 

-void test27(void)

-{

+void test27(void) {

   double a;

 

-  for (a = 0.0; a < 10.0; ++a)

-  {}

+  for (a = 0.0; a < 10.0; ++a) {

+  }

 }

 

-void test28(void)

-{

+void test28(void) {

   int i;

   int j;

   int k;

   int flag = 0;

   int counter = 0;

 

-  for (i = 0; i < 10; i++)

-  {

+  for (i = 0; i < 10; i++) {

     i = i + 3;

   }

 

-  for (j = 0; j < 20; ++j)

-  {

+  for (j = 0; j < 20; ++j) {

     j++;

   }

 

-  for (k = 0; k < 10; ++k)

-  {

+  for (k = 0; k < 10; ++k) {

     k = i + j;

     --j;

     i = j - k;

   }

 

-  for (i = 0; flag == 1; i++)

-  {

-    if (i > 10)

-    {

+  for (i = 0; flag == 1; i++) {

+    if (i > 10) {

       flag = 1;

     }

   }

 

-  for (i = 0; flag == 1, counter++; i++)

-  {

-    if (i > 10)

-    {

+  for (i = 0; flag == 1, counter++; i++) {

+    if (i > 10) {

       flag = 1;

     }

   }

 

-  for (k = 0, i = 0; i < 10, k < 10; ++i, k++)

-  {

+  for (k = 0, i = 0; i < 10, k < 10; ++i, k++) {

     k = i + j;

     --j;

     i = j - k;

   }

 

-  for (i = 0, k = 0; i < 10, k < 10; ++i, k++)

-  {

+  for (i = 0, k = 0; i < 10, k < 10; ++i, k++) {

     k = i + j;

     --j;

     i = j - k;

   }

 }

 

-int test29(int a)

-{

+int test29(int a) {

   goto loco;

 

 loco:

   return a;

 }

 

-void test30(void)

-{

+void test30(void) {

   int a;

   int b;

   int c;

 

-  for (a = 0; a < 10; ++a)

-  {

+  for (a = 0; a < 10; ++a) {

     a++;

 

     if (a == 5)

@@ -1115,15 +967,13 @@ void test30(void)
       break;

   }

 

-  for (a = 0; a < 10; a++)

-  {

+  for (a = 0; a < 10; a++) {

     a++;

     if (a == 6)

       break;

   }

 

-  while (a < 10)

-  {

+  while (a < 10) {

     if (b == 1)

       break;

     if (c == 1)

@@ -1139,29 +989,24 @@ void test30(void)
       break;

   } while (a < 10);

 

-  for (a = 0; a < 100; a++)

-  {

-    for (b = 0; b < 100; b++)

-    {

+  for (a = 0; a < 100; a++) {

+    for (b = 0; b < 100; b++) {

       c++;

       if (a == 1)

         break;

     }

-    for (c = 0; c < 100; c++)

-    {

+    for (c = 0; c < 100; c++) {

       b++;

       if (a == 10)

         break;

     }

   }

 

-  for (a = 0; a < 100; a++)

-  {

+  for (a = 0; a < 100; a++) {

     if (a == 1)

       break;

 

-    while (a < 10)

-    {

+    while (a < 10) {

       b++;

       if (c == 10)

         break;

@@ -1169,8 +1014,7 @@ void test30(void)
   }

 }

 

-int test31(void)

-{

+int test31(void) {

   int a;

 

   if (a == 1)

@@ -1181,12 +1025,10 @@ int test31(void)
     return 1;

 }

 

-void test32(void)

-{

+void test32(void) {

   int a;

 

-  switch (a == 1)

-  {

+  switch (a == 1) {

   case 1:

     a++;

   case 0:

@@ -1194,29 +1036,27 @@ void test32(void)
   }

 }

 

-void test33(void)

-{

+void test33(void) {

   short int a;

   long int b;

 

   b = (int)a;

 }

 

-void test34(void)

-{

+void test34(void) {

   int i, a;

 

   i >= 3;

 

-  for (;; i++)

-  {

+  for (;; i++) {

     a++;

   }

 

   ; /*yadayada*/

-  ;/*:P*/

+  ; /*:P*/

 

-  ; int b;

+  ;

+  int b;

 

   int ut_int = 0;

 

@@ -1230,6 +1070,5 @@ void malloc (void)
 }

 #endif

 

-

 /**********************************************************************************************************************/

 /*the last line's been intentionally left blank.*/