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;
/*5.3:clang doesnt allow typedef redifinition*/
#if 0
typedef const int dummytypedef;
#endif

const unsigned int shift = 10U;

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

/**********************************************************************************************************************/
void test(void);
void test2(void);
void test11(void);

double badboy = 0.0;

/**********************************************************************************************************************/

/*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;
  int flag = 0;
  int counter = 0;

  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 (i = 0; flag == 1; i++) {
    if (i > 10) {
      flag = 1;
    }
  }

  for (i = 0; flag == 1, counter++; i++) {
    if (i > 10) {
      flag = 1;
    }
  }

  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;

  int ut_int = 0;

  test33();
}

#if 0
void malloc (void)
{

}
#endif

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