path: root/test/testFuncs1.c

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

/*include*/
/**********************************************************************************************************************/
#include "testFuncs1.h"
#if 0
#include <string.h>
#endif
/**************************************************MACROS & DEFS*******************************************************/
/**********************************************************************************************************************/
#define LUPO 1U
#define LOCO 2U

typedef unsigned int ut_int;
typedef signed int t_int;
typedef unsigned char BYTE;

const unsigned int shift = 10U;

/******************************************************Globals*********************************************************/

/**********************************************************************************************************************/
void test (void);
void test2 (void);
void test11 (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*/
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?!*/
}


/*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*/
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.*/
#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++;
	}
}

void test6 (void)
{
	int a[100];
	int *p = a;

	int i = 0;

	for (i = 0; i < 100; ++i)
	{
		a[i] = i;
	}
}

void test7(void)
{
	double a[100];

	double b[100];

	char c[100];

	double *pointer;

	double* pointerb;

	char* pointerc;

	pointerb = b;

	pointer = a;

	pointerc = c;

	if (a - b >= a)
	{}
	else if (b - a < a)
	{}

	if (a < b)
	{}

	if (pointer < pointerb)
	{}

	if (pointer > pointerb)
	{}

	if (pointerb <= pointer)
	{}

	if (pointer >= pointerb)
	{}

	if (pointer < pointerc)
	{}

	int i = 0;

	for (i = 0; i < 50; i++)
	{
		*(a + i) = i;
	}

}

void test8 (void)
{
	union uni uni2;
}

void test9 (void)
{
	/*im a comment*/
	//im also a comment
}

void test10 (void)
{
	struct {
		unsigned int r1 : 1;
		unsigned int r2 : 2;
	} reg1;

	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;
}

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

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

int test13(void)
{
	static int a;
	int b;

	return (a * b);
}

void test14 (void)
{
	int arr[3][2] = {{2, 3}, {4, 5}, {6, 7}};

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

	int arr3[2][3];

	/*illegal forms.*/
#if 0
	arr3 = {0};

	arr3 = {{1, 2, 3}, {4, 5, 6}};
#endif
}

void test15(void)
{
	enum colour {red = 3, blue, yellow, green = 5};

	enum anotherset {black, grey, white};

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

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

	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;

	return sum;
}

void test17(void)
{
	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;

	if (c && (a = b))
	{
		/*yada yada*/
	}

	if ((c = a) || a)
	{
		/*yada*/
	}
	if (c && (a || c))
	{

	}

	d = c && (a = c);

}

void test19(void)
{
	const int a = 100;

	unsigned char flag = 1;

	unsigned char flag2;

	unsigned char flag3;

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

	const double pi = 3.54;

	if ((flag) && pi)
	{}

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

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

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

	if (!flag || flag2)
	{}

}

void test20(void)
{
	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;
}

void test21(void)
{
	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;

	b = -a;
	b = -c;
	b = -d;
}

void test23 (void)
{
	int a, b, c;

	a = b, c = a;
}

void test24(void)
{
	int a;
	int b;
	int c;

	c = ++a - b--;
	c = a++;
	b++;
	--a;
}

void test25(void)
{
	int a;
	int b;
	int c;

	if (a - b)
	{
		/*i dont care.*/
	}
}

void test26 (void)
{
	double a;
	double b;
	double c;
	unsigned char d;

	if (a == b)
	{}

	if (a < b)
	{}

	if (c >= a)
	{}

	d = (a <= c);
}

void test27(void)
{
	double 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 test29(int a)
{
	goto loco;

loco:
	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 test31(void)
{
	int a;

	if (a == 1)
		return 2;
	else if (a == 2)
		return 3;
	else
		return 1;
}

void test32(void)
{
	int a;

	switch (a == 1)
	{
	case 1:
		a++;
	case 0:
		a--;
	}
}

void test33(void)
{
	short int a;
	long int b;

	b = (int)a;
}

void test34(void)
{
	int i, a;

	i >= 3;

	for (;; i++)
	{
		a++;
	}

	; /*yadayada*/
	;/*:P*/

	; int b;

	test33();
}


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