aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--test/main.c122
-rw-r--r--test/testFuncs1.c1409
-rw-r--r--test/testFuncs1.h20
-rw-r--r--test/testFuncs2.c179
-rw-r--r--test/testFuncs2.h10
5 files changed, 892 insertions, 848 deletions
diff --git a/test/main.c b/test/main.c
index 7b7c6d6..89bccc2 100644
--- a/test/main.c
+++ b/test/main.c
@@ -11,70 +11,72 @@
/*main*/
main()
{
- int a;
- int b;
- int int1;
- int int2;
- blreplacement bool1;
- blreplacement bool2;
- blreplacement decision1;
- blreplacement decision2;
- int level;
- int aa;
- int bb;
- double cc;
+ int a;
+ int b;
+ int int1;
+ int int2;
+ blreplacement bool1;
+ blreplacement bool2;
+ blreplacement decision1;
+ blreplacement decision2;
+ int level;
+ int aa;
+ int bb;
+ double cc;
- testFuncStatementsinmple();
- testFuncStatementComplexIf();
- testFuncStatementNotCoverage ();
- testFuncLoopFor ();
- testFuncLoopWhile ();
- testFuncContinue ();
- testFuncBreak ();
- testFuncGoto ();
- testFuncNotReturn (a, b);
- testFuncMultiLineStatement ();
- testFuncMultipleStatement ();
- testFuncMultipleStatementNot ();
- testFuncCompOpti1 ();
- testFuncCompOpti2 ();
- testFuncCompOpti3 ();
- testFuncCompOpti4 ();
- testFuncStatementDecl1 ();
- testFuncStatementInt1 (int1, int2);
- testFuncStatementbool1 (bool1 , bool2);
- testFuncStatementbool2 (bool1 , bool2);
- testFuncStatementDecision1 (decision1, decision2);
- testFuncShortCircuit (bool1, bool2);
- testFuncMCDC1 (decision1, decision2);
+ testFuncStatementsinmple();
+ testFuncStatementComplexIf();
+ testFuncStatementNotCoverage ();
+ testFuncLoopFor ();
+ testFuncLoopWhile ();
+ testFuncContinue ();
+ testFuncBreak ();
+ testFuncGoto ();
+ testFuncNotReturn (a, b);
+ testFuncMultiLineStatement ();
+ testFuncMultipleStatement ();
+ testFuncMultipleStatementNot ();
+ testFuncCompOpti1 ();
+ testFuncCompOpti2 ();
+ testFuncCompOpti3 ();
+ testFuncCompOpti4 ();
+ testFuncStatementDecl1 ();
+ testFuncStatementInt1 (int1, int2);
+ testFuncStatementbool1 (bool1 , bool2);
+ testFuncStatementbool2 (bool1 , bool2);
+ testFuncStatementDecision1 (decision1, decision2);
+ testFuncShortCircuit (bool1, bool2);
+ testFuncMCDC1 (decision1, decision2);
#if (TRUE == INLINE)
- testFuncMultiInstantiation (level);
+ testFuncMultiInstantiation (level);
#endif
- testFuncQMark (int1, int2);
- testFuncCallBool ();
+ testFuncQMark (int1, int2);
+ testFuncCallBool ();
- test3();
- test4 (aa, bb, cc);
- test5();
- test6();
- test7();
- test8();
- test10();
- test13();
- test15();
- test17();
- test19();
- test20();
- test21();
- test22();
- test23();
- test24();
- test25();
- test26();
- test27();
- test28();
- test29(a);
- test31();
+ test3();
+ test4 (aa, bb, cc);
+ test5();
+ test6();
+ test7();
+ test8();
+ test10();
+ test13();
+ test15();
+ test17();
+ test19();
+ test20();
+ test21();
+ test22();
+ test23();
+ test24();
+ test25();
+ test26();
+ test27();
+ test28();
+ test29(a);
+ test31();
+
+ malloc();
}
/*********************************************************************************************************************/
/*intentionally left blank.*/
diff --git a/test/testFuncs1.c b/test/testFuncs1.c
index e0522e8..cb950a0 100644
--- a/test/testFuncs1.c
+++ b/test/testFuncs1.c
@@ -31,258 +31,258 @@ void test11 (void);
/*testing for simple statement coverage*/
void testFuncStatementsinmple (void)
{
- int int1 = 1U;
- int int2 = 2U;
- int int3 = 3U;
+ int int1 = 1U;
+ int int2 = 2U;
+ int int3 = 3U;
- int1 = int2 + int3;
- int2 = int1 + int2;
- int3 = int2 + int3;
- im_a_minion_01();
- im_a_minion_02();
- im_a_minion_03();
+ int1 = int2 + int3;
+ int2 = int1 + int2;
+ int3 = int2 + int3;
+ im_a_minion_01();
+ im_a_minion_02();
+ im_a_minion_03();
}
/*testing for complex statement coverage*/
void testFuncStatementComplexIf (void)
{
- int int1 = 1U;
- int int2 = 2U;
- int int3 = 3U;
- int int4 = 4U;
+ int int1 = 1U;
+ int int2 = 2U;
+ int int3 = 3U;
+ int int4 = 4U;
- if ( int4 > int3 )
- if ( int3 > int2 )
- if ( int2 > int1 )
- if ( int2 > int1 )
- im_a_minion_02();
+ 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)
{
- int int1 = 1U;
- int int2 = 2U;
- int int3 = 3U;
- int int4 = 4U;
+ int int1 = 1U;
+ int int2 = 2U;
+ int int3 = 3U;
+ int int4 = 4U;
- if (int4 < int3)
- {
- 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)
- {
- im_a_minion_01();
- }
- }
+ /*do note that your compiler might optimize this by completely erasing this*/
+ if (int2 > int1)
+ {
+ if (int1 > int2)
+ {
+ im_a_minion_01();
+ }
+ }
- if (int2 > int1)
- {
- if (int3 < int2)
- {
- im_a_minion_02();
- }
- }
+ if (int2 > int1)
+ {
+ if (int3 < int2)
+ {
+ im_a_minion_02();
+ }
+ }
}
/*verifying for loops*/
void testFuncLoopFor (void)
{
- int i = 1U;
+ int i = 1U;
- for (i = 1; i < 10; i++)
- {
- im_a_minion_01();
- }
+ for (i = 1; i < 10; i++)
+ {
+ im_a_minion_01();
+ }
- i = 1U;
+ i = 1U;
- for (i = 1; i < 10; i++)
- {
- if (1U == (i % 2U) )
- {
- im_a_minion_01();
- }
- }
+ for (i = 1; i < 10; i++)
+ {
+ if (1U == (i % 2U) )
+ {
+ im_a_minion_01();
+ }
+ }
}
/*verifying while loops*/
void testFuncLoopWhile (void)
{
- int i = 20U;
+ int i = 20U;
- while (i > 10U)
- {
- i = i - 1U;
- }
+ while (i > 10U)
+ {
+ i = i - 1U;
+ }
- i = 20;
+ i = 20;
#if (TRUE == INF_LOOP)
- while (20U == i)
- {
- im_a_minion_03();
- }
+ while (20U == i)
+ {
+ im_a_minion_03();
+ }
#endif
}
/*verifying the correct handling of continue*/
void testFuncContinue (void)
{
- int i = 1U;
+ int i = 1U;
- for (i = 1U; i < 20U; i++)
- {
- if (i < 19U)
- {
- continue;
- }
- im_a_minion_01();
- }
+ for (i = 1U; i < 20U; i++)
+ {
+ if (i < 19U)
+ {
+ continue;
+ }
+ im_a_minion_01();
+ }
}
/*verifying the correct handling of break*/
void testFuncBreak (void)
{
- int i = 1U;
+ int i = 1U;
- for (i = 1U; i < 10U ; i++)
- {
- if (i > 0U)
- {
- break;
- }
- im_a_minion_03();
- }
+ for (i = 1U; i < 10U ; i++)
+ {
+ if (i > 0U)
+ {
+ break;
+ }
+ im_a_minion_03();
+ }
}
/*checking whether goto is handled correctly*/
void testFuncGoto (void)
{
- im_a_minion_01();
- goto jumpy;
- im_a_minion_02();
+ im_a_minion_01();
+ goto jumpy;
+ im_a_minion_02();
jumpy:
- im_a_minion_03();
+ im_a_minion_03();
}
/*checking whether the basic blocks do not complete execution due to return statements*/
int testFuncNotReturn (int a, int b)
{
- int sum = 0U;
+ int sum = 0U;
- sum = a + b;
+ sum = a + b;
- if (10U == sum)
- {
- return (sum);
- }
- else
- {
- im_a_dummy();
- }
+ if (10U == sum)
+ {
+ return (sum);
+ }
+ else
+ {
+ im_a_dummy();
+ }
- im_a_minion_01();
+ im_a_minion_01();
- return (sum);
+ return (sum);
}
/*checking whether the tool handles multi-line statements correctly*/
void testFuncMultiLineStatement (void)
{
- im_a_minion_01();
+ im_a_minion_01();
}
/*checking how the tool handles multiple statements on the same line*/
void testFuncMultipleStatement (void)
{
- int a = 1U;
- int b = 2U;
- int c = 3U;
- int d = 4U;
+ 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)
{
- int a = 10U;
+ 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();
+ testFuncMultipleStatementNot();
}
/*checking how compiler optimizations may affect the coverage reported-killed assignment elimination*/
void testFuncCompOpti1 (void)
{
- int a = 1U;
- int b = 2U;
+ int a = 1U;
+ int b = 2U;
}
/*checking how compiler optimizations may affect the coverage reported-common subexpression optimization*/
void testFuncCompOpti2 (void)
{
- int a = 1U;
- int b = 1U;
+ int a = 1U;
+ int b = 1U;
- if ( 0U == (((a * b) + (a / b) - a) - b) )
- {
- im_a_benign_func();
- }
+ if ( 0U == (((a * b) + (a / b) - a) - b) )
+ {
+ im_a_benign_func();
+ }
- if ( 0U == (((a * b) + (a / b) - a) - b) )
- {
- im_a_mlaign_func();
- }
+ 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)
{
- int i = 1U;
- int counter = 0U;
- int a = 0U;
- int b = 10U;
- int sum = 0U;
+ int i = 1U;
+ int counter = 0U;
+ int a = 0U;
+ int b = 10U;
+ int sum = 0U;
- for (i = 1U; i < 100U ; i++)
- {
- counter = counter + 1U;
- sum = a + b;
- }
+ for (i = 1U; i < 100U ; i++)
+ {
+ counter = counter + 1U;
+ sum = a + b;
+ }
- sum = sum * 2U;
+ sum = sum * 2U;
}
/*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();
+ 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)
{
- int declaration1 = 1001U;
- int declaration2 = 666U;
+ int declaration1 = 1001U;
+ int declaration2 = 666U;
}
/*testing to see whether statement coverage covers the return.*/
int testFuncStatementInt1 (int int1, int int2)
{
- int sum = 0U;
- sum = int1 + int2;
- return (sum);
+ int sum = 0U;
+ sum = int1 + int2;
+ return (sum);
}
@@ -294,7 +294,7 @@ int testFuncStatementInt1 (int int1, int int2)
/* not branch coverage so good for you!*/
blreplacement testFuncStatementbool1 (blreplacement bool1 , blreplacement bool2)
{
- return (bool1 && bool2);
+ return (bool1 && bool2);
}
@@ -306,7 +306,7 @@ blreplacement testFuncStatementbool1 (blreplacement bool1 , blreplacement bool2)
/* not branch coverage so good for you!*/
blreplacement testFuncStatementbool2 (blreplacement bool1, blreplacement bool2)
{
- return (bool1 || bool2);
+ return (bool1 || bool2);
}
@@ -315,15 +315,15 @@ blreplacement testFuncStatementbool2 (blreplacement bool1, blreplacement bool2)
/* 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
- {
- im_a_benign_func();
- }
+ if ( decision1 || decision2 )
+ {
+ /*this function will supposedly casue a bug if decision1 is true*/
+ im_a_mlaign_func();
+ }
+ else
+ {
+ im_a_benign_func();
+ }
}
@@ -332,24 +332,24 @@ void testFuncStatementDecision1 (blreplacement decision1 , blreplacement decisio
/* 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)
- {
- im_a_dummy();
- }
+ if (FALSE == bool1 && TRUE == bool2)
+ {
+ im_a_dummy ();
+ }
+ 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)) )
- {
- im_a_dummy();
- }
+ if (decision1 && (( decision2 || decision1) || (!decision1 || decision2)) )
+ {
+ im_a_dummy();
+ }
}
@@ -358,56 +358,56 @@ void testFuncMCDC1 (blreplacement decision1, blreplacement decision2)
#if 0
void testFuncMultiInstantiation (int level)
{
- switch (level)
- {
- case 10U:
- babeFunk(20);
- break;
- case 20U:
- babeFunk(10);
- break;
- case 30U:
- babeFunk(5);
- break;
- case 40U:
- im_a_dummy();
- break;
- case 50U:
- im_a_dummy();
- break;
- case 60U:
- im_a_dummy();
- break;
- case 70U:
- im_a_dummy();
- break;
- case 80U:
- im_a_dummy();
- break;
- case 90U:
- im_a_dummy();
- break;
- default:
- im_a_dummy();
- break;
- }
+ switch (level)
+ {
+ case 10U:
+ babeFunk(20);
+ break;
+ case 20U:
+ babeFunk(10);
+ break;
+ case 30U:
+ babeFunk(5);
+ break;
+ case 40U:
+ im_a_dummy();
+ break;
+ case 50U:
+ im_a_dummy();
+ break;
+ case 60U:
+ im_a_dummy();
+ break;
+ case 70U:
+ im_a_dummy();
+ break;
+ case 80U:
+ im_a_dummy();
+ break;
+ case 90U:
+ im_a_dummy();
+ break;
+ default:
+ im_a_dummy();
+ break;
+ }
}
#endif
/* this function will check how the tool handles the "?" operator*/
void testFuncQMark (int int1, int int2)
{
- (int1 > int2) ? im_a_minion_01() : im_a_minion_02();
+ (int1 > int2) ? im_a_minion_01() : im_a_minion_02();
}
/* checking how the tool handles calling a function that returns boolean*/
void testFuncCallBool (void)
{
- int local1 = 0U;
- int local2 = 0U;
- local1 = testFuncStatementbool1(1U , 0U);
- local2 = testFuncStatementbool2(1U , 0U);
+ int local1 = 0U;
+ int local2 = 0U;
+ local1 = testFuncStatementbool1(1U , 0U);
+ local2 = testFuncStatementbool2(1U , 0U);
}
@@ -418,42 +418,42 @@ void testFuncCallBool (void)
/*the function that is *supposedly* carrying a bug*/
static void im_a_mlaign_func (void)
{
- /* KATSU!*/
+ /* KATSU!*/
}
/*the function that is *supposedly* the good guy here*/
static void im_a_benign_func (void)
{
- /* see the light ring?!*/
+ /* see the light ring?!*/
}
/*the dummy function.*/
void im_a_dummy (void)
{
- /* dumb dumb*/
+ /* dumb dumb*/
}
/* minion function number #01*/
void im_a_minion_01 (void)
{
- /* minion1*/
+ /* minion1*/
}
/* minion function number #02*/
void im_a_minion_02 (void)
{
- /* minion1*/
+ /* minion1*/
}
/* minion function number #03*/
static void im_a_minion_03 (void)
{
- /* minion1*/
+ /* minion1*/
}
@@ -463,18 +463,18 @@ static void im_a_minion_03 (void)
#if (MPC == COMPILER)
inline void babeFunk (int entry)
{
- if (10U > entry)
- {
- im_a_minion_01();
- }
- else if (10U == entry)
- {
- im_a_minion_02();
- }
- else
- {
- im_a_minion_03();
- }
+ if (10U > entry)
+ {
+ im_a_minion_01();
+ }
+ else if (10U == entry)
+ {
+ im_a_minion_02();
+ }
+ else
+ {
+ im_a_minion_03();
+ }
}
#endif
@@ -482,18 +482,18 @@ inline void babeFunk (int entry)
#pragma INLINE
void babeFunk (int entry)
{
- if (10U > entry)
- {
- im_a_minion_01();
- }
- else if (10U == entry)
- {
- im_a_minion_02();
- }
- else
- {
- im_a_minion_03();
- }
+ if (10U > entry)
+ {
+ im_a_minion_01();
+ }
+ else if (10U == entry)
+ {
+ im_a_minion_02();
+ }
+ else
+ {
+ im_a_minion_03();
+ }
}
#endif
#endif
@@ -501,188 +501,188 @@ void babeFunk (int entry)
void test (void)
{
- int i = 0U;
- int j = 0U;
- int a, b;
- int c, d;
+ int i = 0U;
+ int j = 0U;
+ int a, b;
+ int c, d;
- for (;;)
- {
- a = b;
- }
+ for (;;)
+ {
+ a = b;
+ }
- for (i = 1; i < 100U; i++)
- b++ ;
+ for (i = 1; i < 100U; i++)
+ b++ ;
- while (a > 10U)
- im_a_minion_01() ;
+ while (a > 10U)
+ im_a_minion_01() ;
- while (a == 90U)
- {
- b++;
- }
+ while (a == 90U)
+ {
+ b++;
+ }
- if (a == d)
- b = c;
+ if (a == d)
+ b = c;
- if (a == d)
- {
- a = d;
- }
+ if (a == d)
+ {
+ a = d;
+ }
- if (d > a)
- if (c > b)
- a++;
+ if (d > a)
+ if (c > b)
+ a++;
- if (a > c)
- b++;
- else if (a > b)
- c++;
- else if (a > d)
- d++;
+ if (a > c)
+ b++;
+ else if (a > b)
+ c++;
+ else if (a > d)
+ d++;
}
void test2 (void)
{
- int a = 0U;
- int b = 10U;
- int c, d;
-
- if (a == b)
- {
- /*do something*/
- }
- else
- b = a;
-
- if (20U == a)
- {
- /*kill all mutants.*/
- }
-
- if (20U == a)
- {
- /*do somethin good*/
- a = b;
- }
- else if (30U == a)
- {
- /*do something else*/
- b = a;
- }
-
- if (10U == a)
- {/*die*/}
- else if (15U == a)
- a = b;
- else if (17U == a)
- a = 10000000U;
- else if (19U == a)
- a = 50U;
-
- if (b == a) {
- if (10U == b)
- {}
- else
- {}
- }
-
-
-
- if (a > b) {
- if (a > d)
- {}
- else
- a++;
- }
-
- if (a > b)
- {a++;}
- else if (b > a)
- {b++;}
- else if (a == b)
- {a++;}
-
- int level = 10U;
-
- switch (level)
- {
- case 10U:
- { level++;
- test();
- break;
- }
- case 20U:
- { level = 10000U;
- break;
- }
- case 30U:
- { level++;
- break;
- }
- case 40U:
- { level++;
- break;
- }
- case 50U:
- { level++;
- break;
- }
- case 60U:
- { level = 1000U;
- break;
- }
- case 70U:
- { level++;
- break;
- }
- case 80U:
- { level++;
- break;
- }
- case 90U:
- { level++;
- break;
- }
- default:
- { level++;
- break;
- }
- }
-
- switch (level)
- {
- case 1:
- { level++;
- break;
- }
- case 2:
- level = 10;
- level--;
- {
- case 3:
- level = 10U;
- level++;
- break;
- }
- }
-
- switch (level)
- {
- case 1:
- level++;
- case 2:
- level = 1;
- case 3:
- level = 2;
- default:
- level++;
- }
-
- switch (level)
- {}
+ int a = 0U;
+ int b = 10U;
+ int c, d;
+
+ if (a == b)
+ {
+ /*do something*/
+ }
+ else
+ b = a;
+
+ if (20U == a)
+ {
+ /*kill all mutants.*/
+ }
+
+ if (20U == a)
+ {
+ /*do somethin good*/
+ a = b;
+ }
+ else if (30U == a)
+ {
+ /*do something else*/
+ b = a;
+ }
+
+ if (10U == a)
+ {/*die*/}
+ else if (15U == a)
+ a = b;
+ else if (17U == a)
+ a = 10000000U;
+ else if (19U == a)
+ a = 50U;
+
+ if (b == a) {
+ if (10U == b)
+ {}
+ else
+ {}
+ }
+
+
+
+ if (a > b) {
+ if (a > d)
+ {}
+ else
+ a++;
+ }
+
+ if (a > b)
+ {a++;}
+ else if (b > a)
+ {b++;}
+ else if (a == b)
+ {a++;}
+
+ int level = 10U;
+
+ switch (level)
+ {
+ case 10U:
+ { level++;
+ test();
+ break;
+ }
+ case 20U:
+ { level = 10000U;
+ break;
+ }
+ case 30U:
+ { level++;
+ break;
+ }
+ case 40U:
+ { level++;
+ break;
+ }
+ case 50U:
+ { level++;
+ break;
+ }
+ case 60U:
+ { level = 1000U;
+ break;
+ }
+ case 70U:
+ { level++;
+ break;
+ }
+ case 80U:
+ { level++;
+ break;
+ }
+ case 90U:
+ { level++;
+ break;
+ }
+ default:
+ { level++;
+ break;
+ }
+ }
+
+ switch (level)
+ {
+ case 1:
+ { level++;
+ break;
+ }
+ case 2:
+ level = 10;
+ level--;
+ {
+ case 3:
+ level = 10U;
+ level++;
+ break;
+ }
+ }
+
+ switch (level)
+ {
+ case 1:
+ level++;
+ case 2:
+ level = 1;
+ case 3:
+ level = 2;
+ default:
+ level++;
+ }
+
+ switch (level)
+ {}
}
@@ -696,505 +696,510 @@ void test3 (int a, int, ...)
test3()
{
- int a;
- int b;
+ int a;
+ int b;
}
double test4 (int a, int b, double c)
{
- return a + b + c;
+ return a + b + c;
}
void test5(void)
{
- int i = 0;
- if (test4)
- {
- i++;
- }
+ int i = 0;
+ if (test4)
+ {
+ i++;
+ }
}
void test6 (void)
{
- int a[100];
- int *p = a;
+ int a[100];
+ int *p = a;
- int i = 0;
+ int i = 0;
- for (i = 0; i < 100; ++i)
- {
- a[i] = i;
- }
+ for (i = 0; i < 100; ++i)
+ {
+ a[i] = i;
+ }
}
void test7(void)
{
- double a[100];
+ double a[100];
- double b[100];
+ double b[100];
- char c[100];
+ char c[100];
- double *pointer;
+ double *pointer;
- double* pointerb;
+ double* pointerb;
- char* pointerc;
+ char* pointerc;
- pointerb = b;
+ pointerb = b;
- pointer = a;
+ pointer = a;
- pointerc = c;
+ 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;
+ int i = 0;
- for (i = 0; i < 50; i++)
- {
- *(a + i) = i;
- }
+ for (i = 0; i < 50; i++)
+ {
+ *(a + i) = i;
+ }
}
void test8 (void)
{
- union uni uni2;
+ union uni uni2;
}
void test9 (void)
{
- /*im a comment*/
- //im also a comment
+ /*im a comment*/
+ //im also a comment
}
void test10 (void)
{
- struct {
- unsigned int r1 : 1;
- unsigned int r2 : 2;
- } reg1;
+ struct {
+ unsigned int r1 : 1;
+ unsigned int r2 : 2;
+ } reg1;
- struct {
- signed int r3 : 1;
- signed int r4 : 15;
- } reg2;
+ struct {
+ signed int r3 : 1;
+ signed int r4 : 15;
+ } reg2;
- struct {
- char a : 8;
- signed int r5 : 14;
- unsigned int r6 : 5;
- ut_int r7 : 32;
- BYTE r8 : 8;
- } reg3;
+ struct {
+ char a : 8;
+ signed int r5 : 14;
+ unsigned int r6 : 5;
+ ut_int r7 : 32;
+ BYTE r8 : 8;
+ } reg3;
}
void test11 (void)
{
- /*empty*/
+ /*empty*/
}
double test12(double a)
{
- return a * 2;
+ return a * 2;
}
int test13(void)
{
- static int a;
- int b;
+ static int a;
+ int b;
- return (a * b);
+ return (a * b);
}
void test14 (void)
{
- int arr[3][2] = {{2, 3}, {4, 5}, {6, 7}};
+ int arr[3][2] = {{2, 3}, {4, 5}, {6, 7}};
- int arr2[4][4] = {0};
+ int arr2[4][4] = {0};
- int arr3[2][3];
+ int arr3[2][3];
- /*illegal forms.*/
+ /*illegal forms.*/
#if 0
- arr3 = {0};
+ arr3 = {0};
- arr3 = {{1, 2, 3}, {4, 5, 6}};
+ arr3 = {{1, 2, 3}, {4, 5, 6}};
#endif
}
void test15(void)
{
- enum colour {red = 3, blue, yellow, green = 5};
+ 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 sum;
- short unsigned int sumus;
- sum = a + b;
- sumus = a + b;
+ short int sum;
+ short unsigned int sumus;
+ sum = a + b;
+ sumus = a + b;
- return sum;
+ return sum;
}
void test17(void)
{
- int a = 100;
- int b = 1000;
- long int longa;
- a = sizeof (b = 2000U);
+ int a = 100;
+ int b = 1000;
+ long int longa;
+ a = sizeof (b = 2000U);
}
void test18(void)
{
- int a;
- int b;
- int c;
- unsigned char d;
+ int a;
+ int b;
+ int c;
+ unsigned char d;
- if (c && (a = b))
- {
- /*yada yada*/
- }
+ if (c && (a = b))
+ {
+ /*yada yada*/
+ }
- if ((c = a) || a)
- {
- /*yada*/
- }
- if (c && (a || c))
- {
+ if ((c = a) || a)
+ {
+ /*yada*/
+ }
+ if (c && (a || c))
+ {
- }
+ }
- d = c && (a = c);
+ d = c && (a = c);
}
void test19(void)
{
- const int a = 100;
+ const int a = 100;
- unsigned char flag = 1;
+ unsigned char flag = 1;
- unsigned char flag2;
+ unsigned char flag2;
- unsigned char flag3;
+ unsigned char flag3;
- //char *str = "loco\0";
+ //char *str = "loco\0";
- const double pi = 3.54;
+ const double pi = 3.54;
- if ((flag) && pi)
- {}
+ if ((flag) && pi)
+ {}
- if (flag || flag2 && flag3)
- {}
+ if (flag || flag2 && flag3)
+ {}
- if (a == 0 && flag)
- {}
+ if (a == 0 && flag)
+ {}
- if (flag || (a == 0))
- {}
+ if (flag || (a == 0))
+ {}
- if (!flag || flag2)
- {}
+ if (!flag || flag2)
+ {}
}
void test20(void)
{
- signed int a;
- unsigned int b;
- signed char c;
- unsigned char d;
- t_int e;
- ut_int f;
+ signed int a;
+ unsigned int b;
+ signed char c;
+ unsigned char d;
+ t_int e;
+ ut_int f;
- b = b >> 2;
- a = a << 3U;
- b = b ^ 2U;
- c = c & 6U;
- d = d | 2U;
- e = e >> 2U;
- f = f << 4U;
+ b = b >> 2;
+ a = a << 3U;
+ b = b ^ 2U;
+ c = c & 6U;
+ d = d | 2U;
+ e = e >> 2U;
+ f = f << 4U;
}
void test21(void)
{
- unsigned int a;
- a = a >> 44U;
- a = a >> shift;
- a <<= 10U;
- a << 45U;
+ unsigned int a;
+ a = a >> 44U;
+ a = a >> shift;
+ a <<= 10U;
+ a << 45U;
}
void test22(void)
{
- unsigned int a;
- int b;
- t_int c;
- ut_int d;
+ unsigned int a;
+ int b;
+ t_int c;
+ ut_int d;
- b = -a;
- b = -c;
- b = -d;
+ b = -a;
+ b = -c;
+ b = -d;
}
void test23 (void)
{
- int a, b, c;
+ int a, b, c;
- a = b, c = a;
+ a = b, c = a;
}
void test24(void)
{
- int a;
- int b;
- int c;
+ int a;
+ int b;
+ int c;
- c = ++a - b--;
- c = a++;
- b++;
- --a;
+ c = ++a - b--;
+ c = a++;
+ b++;
+ --a;
}
void test25(void)
{
- int a;
- int b;
- int c;
+ int a;
+ int b;
+ int c;
- if (a - b)
- {
- /*i dont care.*/
- }
+ if (a - b)
+ {
+ /*i dont care.*/
+ }
}
void test26 (void)
{
- double a;
- double b;
- double c;
- unsigned char d;
+ 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);
+ d = (a <= c);
}
void test27(void)
{
- double a;
+ double a;
- for (a = 0.0; a < 10.0; ++a)
- {}
+ for (a = 0.0; a < 10.0; ++a)
+ {}
}
void test28(void)
{
- int i;
- int j;
- int k;
-
- for (i = 0; i < 10; i++)
- {
- i = i + 3;
- }
-
- for (j = 0; j < 20; ++j)
- {
- j++;
- }
-
- for (k = 0; k < 10; ++k)
- {
- k = i + j;
- --j;
- i = j - 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++)
- {
- k = i + j;
- --j;
- i = j - k;
- }
+ int i;
+ int j;
+ int k;
+
+ for (i = 0; i < 10; i++)
+ {
+ i = i + 3;
+ }
+
+ for (j = 0; j < 20; ++j)
+ {
+ j++;
+ }
+
+ for (k = 0; k < 10; ++k)
+ {
+ k = i + j;
+ --j;
+ i = j - 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++)
+ {
+ k = i + j;
+ --j;
+ i = j - k;
+ }
}
int test29(int a)
{
- goto loco;
+ goto loco;
loco:
- return a;
+ return a;
}
void test30(void)
{
- int a;
- int b;
- int c;
-
- for (a = 0; a < 10; ++a)
- {
- a++;
-
- if (a == 5)
- break;
- if (a == 6)
- break;
- }
-
- for (a = 0; a < 10; a++)
- {
- a++;
- if (a == 6)
- break;
- }
-
- while (a < 10)
- {
- if (b == 1)
- break;
- if (c == 1)
- break;
- }
-
- do {
- if (a == 5)
- break;
- if (b == 6)
- break;
- if (c == 10)
- break;
- } while (a < 10);
-
- for (a = 0; a < 100; a++)
- {
- for (b = 0; b < 100; b++)
- {
- c++;
- if (a == 1)
- break;
- }
- for (c = 0; c < 100; c++)
- {
- b++;
- if (a == 10)
- break;
- }
- }
-
- for (a = 0; a < 100; a++)
- {
- if (a == 1)
- break;
-
- while (a < 10)
- {
- b++;
- if (c == 10)
- break;
- }
- }
+ int a;
+ int b;
+ int c;
+
+ for (a = 0; a < 10; ++a)
+ {
+ a++;
+
+ if (a == 5)
+ break;
+ if (a == 6)
+ break;
+ }
+
+ for (a = 0; a < 10; a++)
+ {
+ a++;
+ if (a == 6)
+ break;
+ }
+
+ while (a < 10)
+ {
+ if (b == 1)
+ break;
+ if (c == 1)
+ break;
+ }
+
+ do {
+ if (a == 5)
+ break;
+ if (b == 6)
+ break;
+ if (c == 10)
+ break;
+ } while (a < 10);
+
+ for (a = 0; a < 100; a++)
+ {
+ for (b = 0; b < 100; b++)
+ {
+ c++;
+ if (a == 1)
+ break;
+ }
+ for (c = 0; c < 100; c++)
+ {
+ b++;
+ if (a == 10)
+ break;
+ }
+ }
+
+ for (a = 0; a < 100; a++)
+ {
+ if (a == 1)
+ break;
+
+ while (a < 10)
+ {
+ b++;
+ if (c == 10)
+ break;
+ }
+ }
}
int test31(void)
{
- int a;
+ int a;
- if (a == 1)
- return 2;
- else if (a == 2)
- return 3;
- else
- return 1;
+ if (a == 1)
+ return 2;
+ else if (a == 2)
+ return 3;
+ else
+ return 1;
}
void test32(void)
{
- int a;
+ int a;
- switch (a == 1)
- {
- case 1:
- a++;
- case 0:
- a--;
- }
+ switch (a == 1)
+ {
+ case 1:
+ a++;
+ case 0:
+ a--;
+ }
}
void test33(void)
{
- short int a;
- long int b;
+ short int a;
+ long int b;
- b = (int)a;
+ b = (int)a;
}
void test34(void)
{
- int i, a;
+ int i, a;
- i >= 3;
+ i >= 3;
- for (;; i++)
- {
- a++;
- }
+ for (;; i++)
+ {
+ a++;
+ }
- ; /*yadayada*/
- ;/*:P*/
+ ; /*yadayada*/
+ ;/*:P*/
- ; int b;
+ ; int b;
+
+ test33();
+}
+
+void malloc (void)
+{
- test33();
}
diff --git a/test/testFuncs1.h b/test/testFuncs1.h
index ec88050..262a565 100644
--- a/test/testFuncs1.h
+++ b/test/testFuncs1.h
@@ -10,21 +10,21 @@
/***********************************************Global******************************************************/
extern union uni {
- int a;
- double b;
- char str[20];
+ int a;
+ double b;
+ char str[20];
} uni1;
extern cucu;
/***********************************************************************************************************/
/*choose the compiler*/
-#define COMPILER GCC
+#define COMPILER GCC
-#define HCS12 1U
-#define MPC 2U
-#define RL78 3U
-#define GCC 4U
-#define CLANG 5U
+#define HCS12 1U
+#define MPC 2U
+#define RL78 3U
+#define GCC 4U
+#define CLANG 5U
/***********************************************************************************************************/
/*options*/
@@ -129,6 +129,8 @@ void test27(void);
void test28(void);
int test29(int a);
int test31(void);
+
+void malloc (void);
#endif
/***********************************************************************************************************/
/*ive been intentionally left blank. dont touch me.*/
diff --git a/test/testFuncs2.c b/test/testFuncs2.c
index e15085b..c7cbacc 100644
--- a/test/testFuncs2.c
+++ b/test/testFuncs2.c
@@ -25,9 +25,40 @@ typedef const* INTPTR;
#define LOCO2 #LOCO2
#define LOCO3(bubba) printf(#bubba "%d\n", bu##bba)
#define DEFINEVAR(X,Y) int X##Y
+#define PI 3.14
+#define PI2 (a)
+
+#define __FILE__
+#define __DATE__
+#define __TIME__
+#undef __STDC__
+#undef __FILE__
+
+#define int int
+#undef int
+
+#if defined PI2
+#endif
+
+#if 0
+#if defined LOCO2
+#endif
+#endif
+
+#if defined LOCOLUPO
+#endif
+
+#if defined LOCO
+#endif
+
+#if defined LOCOLUPO || LOCO
+#endif
+
#define LOCOLUPO
+#if 1
#undef LOCOLUPO
+#endif
/*********************************************************************************************************************/
/*Globals*/
@@ -36,21 +67,21 @@ typedef const* INTPTR;
static void test33(void)
{
- short int a;
- long int b;
+ short int a;
+ long int b;
- MINUS(a, b);
- //MINUS(a);
+ MINUS(a, b);
+ //MINUS(a);
- b = (int)a;
+ b = (int)a;
}
void testfunc1(void)
{
- unsigned char a;
- unsigned char b;
+ unsigned char a;
+ unsigned char b;
- b = a;
+ b = a;
}
#if CRAZYMACRO < 0
@@ -58,93 +89,97 @@ void testfunc1(void)
testfunc2(void)
{
- int a;
- int b;
- int sum;
+ int a;
+ int b;
+ int sum;
- sum = a + b;
+ sum = a + b;
}
void testfunc3()
{
- int a;
- int b;
- int c;
+ int a;
+ int b;
+ int c;
+
+#define LUPO wolf
- int abcdefghijklmnopqrstuvwxyz1234567890;
- int abcdefghijklmnopqrstuvwxyz12345678902;
+ int abcdefghijklmnopqrstuvwxyz1234567890;
+ int abcdefghijklmnopqrstuvwxyz12345678902;
- /*do stuff*/
+ /*do stuff*/
}
int testfunc6(void)
{
- int a;
- int b;
- //return ();
+ int a;
+ int b;
+ //return ();
}
int testfunc7(void)
{
- int a;
- int b;
- //return;
+ int a;
+ int b;
+ //return;
}
int testfunc8(void)
{
- int a[10];
- int b[10];
-
- int* p;
-
- p = &a[0];
-
- int i;
- int sum;
- int sum2;
- int garbage;
- int garbage2;
-
- for (i = 0; i < 10; ++i)
- {
- sum += *(a + i);
- sum2 += *(p + i);
- //garbage = *(a - b);
- }
-
- for (i = 10; i < 1; i++)
- {
- sum += *(a - i);
- sum2 += *(p - i);
- //garbage2 = *(p - a);
- }
+ int a[10];
+ int b[10];
+
+ int* p;
+
+ p = &a[0];
+
+#undef LUPO
+
+ int i;
+ int sum;
+ int sum2;
+ int garbage;
+ int garbage2;
+
+ for (i = 0; i < 10; ++i)
+ {
+ sum += *(a + i);
+ sum2 += *(p + i);
+ //garbage = *(a - b);
+ }
+
+ for (i = 10; i < 1; i++)
+ {
+ sum += *(a - i);
+ sum2 += *(p - i);
+ //garbage2 = *(p - a);
+ }
}
void testfunc9(void)
{
- int** p1;
- int*** p2;
-
- struct
- {
- int* sp1;
- int** sp2;
- int*** sp3;
- };
-
- struct s* ps1;
- struct s** ps2;
- struct s*** ps3;
-
- INTPTR *const* const fedupp1;
-
- int ** (*pfunc1)();
- int ** (**pfunc2)();
- int ** (***pfunc3)();
- int *** (**pfunc4)();
- int ** (**pfunc5)(int**, int**);
- int ** (**pfunc6)(int**, int***);
+ int** p1;
+ int*** p2;
+
+ struct
+ {
+ int* sp1;
+ int** sp2;
+ int*** sp3;
+ };
+
+ struct s* ps1;
+ struct s** ps2;
+ struct s*** ps3;
+
+ INTPTR *const* const fedupp1;
+
+ int ** (*pfunc1)();
+ int ** (**pfunc2)();
+ int ** (***pfunc3)();
+ int *** (**pfunc4)();
+ int ** (**pfunc5)(int**, int**);
+ int ** (**pfunc6)(int**, int***);
}
void testfunc10 (int ** (**p5)(int**, int**), int ** (**p6)(int**, int***))
diff --git a/test/testFuncs2.h b/test/testFuncs2.h
index fa4ce13..8f01004 100644
--- a/test/testFuncs2.h
+++ b/test/testFuncs2.h
@@ -21,15 +21,15 @@ void testFunc1(void);
void testFunc4()
{
- /*do shit*/
+ /*do shit*/
}
testFunc5( void)
{
- //different kind of comment
- ///another kind
- /*this kind*/
- /**that kind*/
+ //different kind of comment
+ ///another kind
+ /*this kind*/
+ /**that kind*/
}
void testFunc9(void);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 07:13:46 +0000