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

void malloc (void)
{

}


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