added tdd tests for automatic refactoring

6 files changed, 457 insertions, 583 deletions

diff --git a/test/auto-refac-tdd/auto-refac-tdd01.c b/test/auto-refac-tdd/auto-refac-tdd01.c
new file mode 100644
index 0000000..40e60d1
--- /dev/null
+++ b/test/auto-refac-tdd/auto-refac-tdd01.c
@@ -0,0 +1,49 @@
+
+/*first line's intentionally left blank.*/
+/**********************************************************************************************************************/
+/*inclusion directives*/
+#include "auto-refac-tdd01.h"
+/**********************************************************************************************************************/
+/**************************************************MACROS & DEFS*******************************************************/
+#define MACRO1 100U
+
+/**********************************************************************************************************************/
+/******************************************************Globals*********************************************************/
+
+
+/**********************************************************************************************************************/
+/***********************************************Function Definitions***************************************************/
+void tdd_forfixer(void)
+{
+  int loopcounter;
+  int counter;
+
+  for (loopcounter = 0; loopcounter < 10; ++loopcounter)
+    counter;
+
+  for (loopcounter = 0; loopcounter < 10; ++loopcounter)
+    counter--       ;
+}
+
+void tdd_ifconstswapper(void)
+{
+  int a;
+
+  if (a = 10)
+  {
+    /*blah blah*/
+  }
+
+  if (a == MACRO1)
+  {
+
+  }
+
+  if (MACRO1 == a)
+  {
+
+  }
+}
+/**********************************************************************************************************************/
+/**********************************************************************************************************************/
+/*last line's intntionally left blank.*/
diff --git a/test/auto-refac-tdd/auto-refac-tdd01.h b/test/auto-refac-tdd/auto-refac-tdd01.h
new file mode 100644
index 0000000..7acdb65
--- /dev/null
+++ b/test/auto-refac-tdd/auto-refac-tdd01.h
@@ -0,0 +1,17 @@
+
+/*first line's been intentionally left blank.*/
+#ifndef AUTO_REFAC_TDD_01_H
+#define AUTO_REFAC_TDD_01_H
+/*********************************************************************************************************************/
+/**************************************************MACROS & DEFS*******************************************************/
+
+/*********************************************************************************************************************/
+/***************************************************Globals***********************************************************/
+
+/*********************************************************************************************************************/
+/********************************************Function Declarations****************************************************/
+
+
+/*********************************************************************************************************************/
+#endif
+/*last line's intentionally lefg blank.*/
diff --git a/test/auto-refac-tdd/mut.c b/test/auto-refac-tdd/mut.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/auto-refac-tdd/mut.c
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.*/

diff --git a/test/testFuncs2.c b/test/testFuncs2.c
index f6dadb6..f8c9bd2 100644
--- a/test/testFuncs2.c
+++ b/test/testFuncs2.c
@@ -4,15 +4,15 @@
 /*inclusion directives*/
 #include "testFuncs2.h"
 #if 0
-#include <stdlib.h>
-#include <stdio.h>
-#include <stddef.h>
 #include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <time.h>
 #endif
 /*********************************************************************************************************************/
 /*macro and definitions*/
-typedef const* INTPTR;
+typedef const *INTPTR;
 /*clang wont let it through*/
 #if 0
 typedef int dummytypedef;
@@ -29,12 +29,12 @@ typedef gaga incompletearr1;
 #define ABSOLUTE(X) (((X) >= 0) ? (X) : -(X))
 #define ABSOLUTE2(X) ((X >= 0) ? X : -X)
 #define ABSOLUTE3(XMACRO) (((XMACRO) <= 0) ? (XMACRO) : -(XMACRO))
-#define MINUS(X,Y) ((X) - (Y))
+#define MINUS(X, Y) ((X) - (Y))
 #define PRINT(bubba) printf(#bubba "%d\n", bubba)
 #define LOCO i##nt
 #define LOCO2 #LOCO2
 #define LOCO3(bubba) printf(#bubba "%d\n", bu##bba)
-#define DEFINEVAR(X,Y) int X##Y
+#define DEFINEVAR(X, Y) int X##Y
 #define PI 3.14
 #define PI2 (a)
 #define charchar char
@@ -72,7 +72,6 @@ typedef gaga incompletearr1;
 #if defined LOCOLUPO || LOCO
 #endif
 
-
 #define LOCOLUPO
 #if 1
 #undef LOCOLUPO
@@ -112,14 +111,12 @@ int incompletearr1[10];
 union u3;
 union u4;
 
-union u3
-{
+union u3 {
   int ua;
   char ub;
 };
 
-union yizzy
-{
+union yizzy {
   int ua;
   char ub;
 };
@@ -134,8 +131,7 @@ int s10;
 struct s10;
 struct s11;
 
-struct s10
-{
+struct s10 {
   int sa[10];
   char sb;
   int sc;
@@ -145,8 +141,7 @@ const unsigned int cint = 0xFFFFFFFF;
 
 /*********************************************************************************************************************/
 /*functions go here.*/
-static void test33(void)
-{
+static void test33(void) {
 
   short int a;
   long int b;
@@ -157,21 +152,19 @@ static void test33(void)
   sum = dudu + bubu + fufu;
 
   MINUS(a, b);
-  //MINUS(a);
+  // MINUS(a);
 
   b = (int)a;
 
   /* contrast the above START + LEN with the following */
-  if ((START + LEN) > END)
-  {
-    //error ("Buffer overrun");
+  if ((START + LEN) > END) {
+    // error ("Buffer overrun");
     /* Not OK: START + LEN wraps around to 0x0000
     due to unsigned int arithmetic */
   }
 }
 
-void testfunc1(void)
-{
+void testfunc1(void) {
   unsigned char a;
   unsigned char b;
   char c;
@@ -180,7 +173,7 @@ void testfunc1(void)
 
   sum = sum + dudu + fufu;
 
-  b =  a;
+  b = a;
   c = 123;
   d = 123;
   c = 'c';
@@ -190,8 +183,11 @@ void testfunc1(void)
   a = 123;
   c = '\n';
 
-  ;;;;
-  ;/*comment*/
+  ;
+  ;
+  ;
+  ;
+  ; /*comment*/
   ; /*comment*/
 
   c = '5';
@@ -200,8 +196,7 @@ void testfunc1(void)
 #if CRAZYMACRO < 0
 #endif
 
-testfunc2(void)
-{
+testfunc2(void) {
   int a;
   int b;
   int sum;
@@ -209,8 +204,7 @@ testfunc2(void)
   sum = a + b + dudu;
 }
 
-void testfunc3()
-{
+void testfunc3() {
   int a;
   int b;
   int c;
@@ -225,26 +219,23 @@ void testfunc3()
   /*do stuff*/
 }
 
-int testfunc6(void)
-{
+int testfunc6(void) {
   int a;
   int b;
-  //return ();
+  // return ();
 }
 
-int testfunc7(void)
-{
+int testfunc7(void) {
   int a;
   int b;
-  //return;
+  // return;
 }
 
-int testfunc8(void)
-{
+int testfunc8(void) {
   int a[10];
   int b[10];
 
-  int* p;
+  int *p;
 
   p = &a[0];
 
@@ -256,82 +247,74 @@ int testfunc8(void)
   int garbage;
   int garbage2;
 
-  for (i = 0; i < 10; ++i)
-  {
+  for (i = 0; i < 10; ++i) {
     sum += *(a + i);
     sum2 += *(p + i);
-    //garbage = *(a - b);
+    // garbage = *(a - b);
   }
 
-  for (i = 10; i < 1; i++)
-  {
+  for (i = 10; i < 1; i++) {
     sum += *(a - i);
     sum2 += *(p - i);
-    //garbage2 = *(p - a);
+    // garbage2 = *(p - a);
   }
 }
 
-void testfunc9(void)
-{
-  int** p1;
-  int*** p2;
+void testfunc9(void) {
+  int **p1;
+  int ***p2;
 
-  int* pointer1;
+  int *pointer1;
   double d2;
 
   pointer1 = &d2;
 
-  struct
-  {
-    int* sp1;
-    int** sp2;
-    int*** sp3;
+  struct {
+    int *sp1;
+    int **sp2;
+    int ***sp3;
   };
 
-  struct s* ps1;
-  /*these two should not be tagged by 18.1 since they are pointers(to pointers) to an incomplete type. the pointer itself is a complete type.*/
-  struct s** ps2;
-  struct s*** ps3;
+  struct s *ps1;
+  /*these two should not be tagged by 18.1 since they are pointers(to pointers)
+   * to an incomplete type. the pointer itself is a complete type.*/
+  struct s **ps2;
+  struct s ***ps3;
 
-  INTPTR *const* const fedupp1;
+  INTPTR *const *const fedupp1;
 
-  int ** (*pfunc1)();
+  int **(*pfunc1)();
   int crazycast1 = (int)pfunc1;
   int crazycast2;
-  pfunc1 = (int ** (*)())crazycast2;
-  int ** (**pfunc2)();
+  pfunc1 = (int **(*)())crazycast2;
+  int **(**pfunc2)();
   pfunc2 = pfunc1;
-  pfunc2 = (int ** (*)())pfunc1;
-  int ** (***pfunc3)();
-  int *** (**pfunc4)();
-  int ** (**pfunc5)(int**, int**);
-  int ** (**pfunc6)(int**, int***);
+  pfunc2 = (int **(*)())pfunc1;
+  int **(***pfunc3)();
+  int ***(**pfunc4)();
+  int **(**pfunc5)(int **, int **);
+  int **(**pfunc6)(int **, int ***);
 }
 
-void testfunc10 (int ** (**p5)(int**, int**), int ** (**p6)(int**, int***))
-{
-
-}
+void testfunc10(int **(**p5)(int **, int **), int **(**p6)(int **, int ***)) {}
 
-void testfunc11(void)
-{
+void testfunc11(void) {
   long int a;
   double dd;
   short unsigned int b;
-  short int* p1;
-  long int* p2;
+  short int *p1;
+  long int *p2;
   int normalint;
 
-  p2 = (long int*)p1;
-  p1 = (short int*)p2;
+  p2 = (long int *)p1;
+  p1 = (short int *)p2;
   b = a;
   dd = b;
   normalint = a;
 }
 
-void testfunc12(void)
-{
-  const char* stringlit = "date should be in the form ??-??-??";
+void testfunc12(void) {
+  const char *stringlit = "date should be in the form ??-??-??";
 
   short unsigned int port = 0x005aU;
   unsigned char portchar = 0x005aU;
@@ -356,26 +339,24 @@ void testfunc12(void)
 }
 
 /*the test are from the misrac doc for 11.5*/
-void testfunc13(void)
-{
+void testfunc13(void) {
   int x;
-  int * const cpi = &x; /* const pointer */
-  int * const * pcpi; /* pointer to const pointer */
-  const int * * ppci; /* pointer to pointer to const */
-  int * * ppi;
-  const int * pci; /* pointer to const */
-  volatile int * pvi; /* pointer to volatile */
-  int * pi;
-  pi = cpi; /* Compliant - no conversion
-no cast required */
-  pi = (int *)pci; /* Not compliant */
-  pi = (int *)pvi; /* Not compliant */
-  ppi = (int * *)pcpi; /* Not compliant */
-  ppi = (int * *)ppci; /* Not compliant */
+  int *const cpi = &x; /* const pointer */
+  int *const *pcpi;    /* pointer to const pointer */
+  const int **ppci;    /* pointer to pointer to const */
+  int **ppi;
+  const int *pci;    /* pointer to const */
+  volatile int *pvi; /* pointer to volatile */
+  int *pi;
+  pi = cpi;           /* Compliant - no conversion
+          no cast required */
+  pi = (int *)pci;    /* Not compliant */
+  pi = (int *)pvi;    /* Not compliant */
+  ppi = (int **)pcpi; /* Not compliant */
+  ppi = (int **)ppci; /* Not compliant */
 }
 
-void testfunc14(void)
-{
+void testfunc14(void) {
   char a;
   long int b;
   long int b2;
@@ -386,8 +367,7 @@ void testfunc14(void)
   a = (int)(b + b2);
   a = b + b2;
   a = b++;
-  if ((int)(b + b2))
-  {
+  if ((int)(b + b2)) {
     /*somethi/*ng*/
   }
 
@@ -397,23 +377,19 @@ void testfunc14(void)
   d = e;
 }
 
-void testfunc15 (void)
-{
+void testfunc15(void) {
   int a[10];
 
   a[1] = 041;
   a[2] = 052;
 }
 
-void testfunc16(int* p1, int* p2, int* const p3, const int* p4, int* p5)
-{
-  if (*p1 > 100)
-  {
+void testfunc16(int *p1, int *p2, int *const p3, const int *p4, int *p5) {
+  if (*p1 > 100) {
     /*do something*/
   }
 
-  if (*p5 > 100)
-  {
+  if (*p5 > 100) {
     /*do something*/
   }
 
@@ -423,21 +399,18 @@ void testfunc16(int* p1, int* p2, int* const p3, const int* p4, int* p5)
   *p2++;
   *p2 = *p2 + 100;
 
-  if (*p3 > 1000)
-  {
+  if (*p3 > 1000) {
     /*do something else*/
   }
 
-  if (*p4 < 100)
-  {
+  if (*p4 < 100) {
     /*yet another task*/
   }
-}
-
-void externfunc (void)
-{
 
+  asm("add %al, (%rax)");
 }
 
+void externfunc(void) {}
+
 /*********************************************************************************************************************/
 /*last line intentionally left blank.*/
diff --git a/test/testFuncs3.c b/test/testFuncs3.c
index baf3f37..24b7ac6 100644
--- a/test/testFuncs3.c
+++ b/test/testFuncs3.c
@@ -15,10 +15,8 @@ int intarray4[3][2] = MACRO2;
 int answer = ANSWER;
 float floatbitaccess;
 
-
 /*********************************************************************************************************************/
-void tddfunc1 (void)
-{
+void tddfunc1(void) {
 	double complex z1 = 10.0 + 10.0 * I;
 	double complex z2 = 1.0 - 4.0 * I;
 
@@ -43,19 +41,17 @@ void tddfunc1 (void)
 	n1 = n2;
 }
 
-void tddfunc2(void)
-{
+void tddfunc2(void) {
 	static int staticint1;
 
 	unsigned short int port = 0x5aU;
 	unsigned short int result_8;
-	//uint16_t result_16;
-	//uint16_t mode;
+	// uint16_t result_16;
+	// uint16_t mode;
 	result_8 = (~port) >> 4;
 }
 
-void tddfunc3(void)
-{
+void tddfunc3(void) {
 	int a = 1;
 
 	READ_TIME_32();
@@ -63,14 +59,12 @@ void tddfunc3(void)
 	READ_TIME_34();
 }
 
-int* tddfunc4(void)
-{
+int *tddfunc4(void) {
 	int localauto;
 	return (&localauto);
 }
 
-void tddfunc5(void)
-{
+void tddfunc5(void) {
 	int arrint[4];
 	arrint[0] = 052;
 	arrint[1] = 067;
@@ -79,27 +73,29 @@ void tddfunc5(void)
 }
 
 /*12.12 tdd*/
-void tddfunc6(void)
-{
+void tddfunc6(void) {
 	float floatbitaccess;
-	int* pointertofloat;
+	int *pointertofloat;
 	int apartoffloat;
-	/*@DEVI-you cannot get away with this since c90 and c99 both specify that operands to & need to both be of integral types.*/
-	/*embedded compilers might not necessarily be ISO-C-complete so apparently this might be actually viable in some cases but
-	if the clang parser won't let this through, i can't analyze it so we can't check for this.*/
+	/*@DEVI-you cannot get away with this since c90 and c99 both specify that
+	 * operands to & need to both be of integral types.*/
+	/*embedded compilers might not necessarily be ISO-C-complete so apparently this
+	might be actually viable in some cases but
+	if the clang parser won't let this through, i can't analyze it so we can't check
+	for this.*/
 #if 0
 	apartoffloat = floatbitaccess & 0x000000FF;
 #endif
-	/*this results in a bticast castexpr which we are already tagging,clang does too, so im not overly concerned with this one
+	/*this results in a bticast castexpr which we are already tagging,clang does
+	too, so im not overly concerned with this one
 	though its fairly east to implement.*/
 	pointertofloat = &floatbitaccess;
 
-	/*we could literally just tag all unions having float members as possible violations.*/
-	union aunion
-	{
+	/*we could literally just tag all unions having float members as possible
+	 * violations.*/
+	union aunion {
 		float member1;
-		union member2
-		{
+		union member2 {
 			unsigned char member3;
 			unsigned char member4;
 			unsigned char member5;
@@ -111,13 +107,9 @@ void tddfunc6(void)
 	apartoffloat = aunionproto.member22.member5 & 0x000000FF;
 }
 
-int externfunc(int arg)
-{
-	return arg;
-}
+int externfunc(int arg) { return arg; }
 
-void testfunc7(void)
-{
+void testfunc7(void) {
 	unsigned char chararroct[7U];
 
 	chararroct[0U] = '\100';
@@ -127,5 +119,9 @@ void testfunc7(void)
 	chararroct[4U] = 125;
 	chararroct[5U] = '\x12';
 }
+
+void tddfunc8(void) {
+	// asm("add %al, (%rax)");
+}
 /*********************************************************************************************************************/
 /*last line intnetionally left blank.*/