diff options
| -rw-r--r-- | test/testFuncs1.c | 706 | ||||
| -rw-r--r-- | test/testFuncs1.h | 112 |
2 files changed, 818 insertions, 0 deletions
diff --git a/test/testFuncs1.c b/test/testFuncs1.c new file mode 100644 index 0000000..e90c088 --- /dev/null +++ b/test/testFuncs1.c @@ -0,0 +1,706 @@ +
+/* the first line's been intentionally left blank.*/
+
+/*include*/
+/**********************************************************************************************************************/
+#include "testFuncs1.h"
+
+/**************************************************MACROS & DEFS*******************************************************/
+/**********************************************************************************************************************/
+
+/**********************************************************************************************************************/
+/**********************************************************************************************************************/
+void test (void);
+void test2 (void);
+
+
+/**********************************************************************************************************************/
+
+/*testing for simple statement coverage*/
+void testFuncStatementsinmple (void)
+{
+ 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();
+}
+
+/*testing for complex statement coverage*/
+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 )
+ 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;
+
+ 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();
+ }
+ }
+
+ if (int2 > int1)
+ {
+ if (int3 < int2)
+ {
+ im_a_minion_02();
+ }
+ }
+
+}
+
+/*verifying for loops*/
+void testFuncLoopFor (void)
+{
+ int i = 1U;
+
+ for (i = 1; i < 10; i++)
+ {
+ im_a_minion_01();
+ }
+
+ i = 1U;
+
+ for (i = 1; i < 10; i++)
+ {
+ if (1U == (i % 2U) )
+ {
+ im_a_minion_01();
+ }
+ }
+}
+
+/*verifying while loops*/
+void testFuncLoopWhile (void)
+{
+ int i = 20U;
+
+ while (i > 10U)
+ {
+ i = i - 1U;
+ }
+
+ i = 20;
+
+#if (TRUE == INF_LOOP)
+ while (20U == i)
+ {
+ im_a_minion_03();
+ }
+#endif
+}
+
+/*verifying the correct handling of continue*/
+void testFuncContinue (void)
+{
+ int i = 1U;
+
+ 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;
+
+ 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();
+jumpy:
+ 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;
+
+ sum = a + b;
+
+ if (10U == sum)
+ {
+ return (sum);
+ }
+ else
+ {
+ im_a_dummy();
+ }
+
+ im_a_minion_01();
+
+ return (sum);
+}
+
+/*checking whether the tool handles multi-line statements correctly*/
+void testFuncMultiLineStatement (void)
+{
+ 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;
+
+ 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;
+
+ 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)
+{
+ 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;
+
+ if ( 0U == (((a * b) + (a / b) - a) - b) )
+ {
+ im_a_benign_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;
+
+ for (i = 1U; i < 100U ; i++)
+ {
+ counter = counter + 1U;
+ sum = a + b;
+ }
+
+ 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();
+}
+
+/*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 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,*/
+/* not branch coverage so good for you!*/
+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,*/
+/* not branch coverage so good for you!*/
+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 )
+ {
+ /*this function will supposedly casue a bug if decision1 is true*/
+ im_a_mlaign_func();
+ }
+ 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 ();
+ }
+ 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();
+ }
+}
+
+
+/* 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)
+{
+ 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();
+}
+
+
+/* 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);
+}
+
+
+/**********************************************************************************************************************/
+/* where all the fakes go.*/
+
+
+/*the function that is *supposedly* carrying a bug*/
+void im_a_mlaign_func (void)
+{
+ /* KATSU!*/
+}
+
+
+/*the function that is *supposedly* the good guy here*/
+void im_a_benign_func (void)
+{
+ /* see the light ring?!*/
+}
+
+
+/*the dummy function.*/
+void im_a_dummy (void)
+{
+ /* dumb dumb*/
+}
+
+
+/* minion function number #01*/
+void im_a_minion_01 (void)
+{
+ /* minion1*/
+}
+
+
+/* minion function number #02*/
+void im_a_minion_02 (void)
+{
+ /* minion1*/
+}
+
+
+/* minion function number #03*/
+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.*/
+#if (TRUE == INLINE)
+#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();
+ }
+}
+#endif
+
+#if (HCS12 == COMPILER)
+#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();
+ }
+}
+#endif
+#endif
+/*RL78s dont have inline for all functions, so no use trying to test the functionality*/
+
+void test (void)
+{
+ int i = 0U;
+ int j = 0U;
+ int a, b;
+ int c, d;
+
+ for (;;)
+ {
+ a = b;
+ }
+
+ for (i = 1; i < 100U; i++)
+ b++ ;
+
+ while (a > 10U)
+ im_a_minion_01() ;
+
+ while (a == 90U)
+ {
+ b++;
+ }
+
+ if (a == d)
+ b = c;
+
+ if (a == d)
+ {
+ a = d;
+ }
+
+ if (d > a)
+ if (c > b)
+ a++;
+
+ 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)
+ {}
+
+
+}
+
+#if 0
+void test3 (int a, int, ...)
+{
+
+}
+#endif
+
+test3()
+{
+ int a;
+ int b;
+}
+
+double test4 (int a, int b, double c)
+{
+ return a + b + c;
+}
+
+void test5(void)
+{
+ int i = 0;
+ if (test4)
+ {
+ i++;
+ }
+}
+
+/**********************************************************************************************************************/
+/*the last line's been intentionally left blank.*/
diff --git a/test/testFuncs1.h b/test/testFuncs1.h new file mode 100644 index 0000000..8276c18 --- /dev/null +++ b/test/testFuncs1.h @@ -0,0 +1,112 @@ +
+/*the first line's been intentionally left blank.*/
+/***********************************************************************************************************/
+/*defines*/
+#define FALSE 0
+#define TRUE 1
+
+
+/***********************************************************************************************************/
+/*choose the compiler*/
+
+#define COMPILER GCC
+
+#define HCS12 1U
+#define MPC 2U
+#define RL78 3U
+#define GCC 4U
+#define CLANG 5U
+
+/***********************************************************************************************************/
+/*options*/
+
+/*this option sets the infinite while loop to see how your tool reacts to it.*/
+/*setting it to ON enables it. setting it to anything else disables it but go with OFF for good taste.*/
+/*setting this option to ON will practically disable the rest of the tests.*/
+#define INF_LOOP FALSE
+
+/*turn on the testing of inline functions*/
+#define INLINE FALSE
+
+/***********************************************************************************************************/
+/*the compiler's gonna be needing some sorta pragmas to handle some keywords correctly or altogether.*/
+/*you need pragmas for inlining, boolean, etc.*/
+/*if your compiler needs em, put em here.*/
+
+
+
+
+/***********************************************************************************************************/
+
+#if (HCS12 == COMPILER)
+#define blreplacement unsigned char
+#endif
+#if (MPC == COMPILER)
+#define blreplacement unsigned char
+#endif
+#if (RL78 == COMPILER)
+#define blreplacement unsigned char
+#endif
+#if (GCC == COMPILER)
+#define blreplacement unsigned char
+#endif
+
+
+
+
+
+/***********************************************************************************************************/
+/*all the test function prototypes are here.*/
+
+void testFuncStatementsinmple (void);
+void testFuncStatementComplexIf (void);
+void testFuncStatementNotCoverage (void);
+void testFuncLoopFor (void);
+void testFuncLoopWhile (void);
+void testFuncContinue (void);
+void testFuncBreak (void);
+void testFuncGoto (void);
+int testFuncNotReturn (int a, int b);
+void testFuncMultiLineStatement (void);
+void testFuncMultipleStatement (void);
+void testFuncMultipleStatementNot (void);
+void testFuncCompOpti1 (void);
+void testFuncCompOpti2 (void);
+void testFuncCompOpti3 (void);
+void testFuncCompOpti4 (void);
+void testFuncStatementDecl1 (void);
+int testFuncStatementInt1 (int int1, int int2);
+blreplacement testFuncStatementbool1 (blreplacement bool1 , blreplacement bool2);
+blreplacement testFuncStatementbool2 (blreplacement bool1 , blreplacement bool2);
+void testFuncStatementDecision1 (blreplacement decision1 , blreplacement decision2);
+void testFuncShortCircuit (blreplacement bool1 , blreplacement bool2);
+void testFuncMCDC1 (blreplacement decision1 , blreplacement decision2);
+#if (TRUE == INLINE)
+void testFuncMultiInstantiation (int level);
+#endif
+void testFuncQMark (int int1, int int2);
+void testFuncCallBool (void);
+
+void im_a_mlaign_func (void);
+void im_a_benign_func (void);
+void im_a_dummy (void);
+void im_a_minion_01 (void);
+void im_a_minion_02 (void);
+void im_a_minion_03 (void);
+
+#if (TRUE == INLINE)
+#if (MPC == COMPILER)
+inline void babeFunk (int entry);
+#endif
+
+#if (HCS12 == COMPILER)
+void babeFunk (int entry);
+#endif
+#endif
+
+test3();
+double test4 (int aa, int bb, double cc);
+void test5(void);
+
+/***********************************************************************************************************/
+/*ive been intentionally left blank. dont touch me.*/
|