diff options
Diffstat (limited to '')
| -rw-r--r-- | test/testFuncs1.c | 715 |
1 files changed, 277 insertions, 438 deletions
diff --git a/test/testFuncs1.c b/test/testFuncs1.c index fc1c25d..e0d35f1 100644 --- a/test/testFuncs1.c +++ b/test/testFuncs1.c @@ -7,7 +7,8 @@ #if 0
#include <string.h>
#endif
-/**************************************************MACROS & DEFS*******************************************************/
+/**************************************************MACROS &
+ * DEFS*******************************************************/
/**********************************************************************************************************************/
#define LUPO 1U
#define LOCO 2U
@@ -25,18 +26,16 @@ const unsigned int shift = 10U; /******************************************************Globals*********************************************************/
/**********************************************************************************************************************/
-void test (void);
-void test2 (void);
-void test11 (void);
+void test(void);
+void test2(void);
+void test11(void);
double badboy = 0.0;
-
/**********************************************************************************************************************/
/*testing for simple statement coverage*/
-void testFuncStatementsinmple (void)
-{
+void testFuncStatementsinmple(void) {
int int1 = 1U;
int int2 = 2U;
int int3 = 3U;
@@ -50,102 +49,84 @@ void testFuncStatementsinmple (void) }
/*testing for complex statement coverage*/
-void testFuncStatementComplexIf (void)
-{
+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 )
+ 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)
-{
+void testFuncStatementNotCoverage(void) {
int int1 = 1U;
int int2 = 2U;
int int3 = 3U;
int int4 = 4U;
- if (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)
- {
+ if (int2 > int1) {
+ if (int1 > int2) {
im_a_minion_01();
}
}
- if (int2 > int1)
- {
- if (int3 < int2)
- {
+ if (int2 > int1) {
+ if (int3 < int2) {
im_a_minion_02();
}
}
-
}
/*verifying for loops*/
-void testFuncLoopFor (void)
-{
+void testFuncLoopFor(void) {
int i = 1U;
- for (i = 1; i < 10; i++)
- {
+ for (i = 1; i < 10; i++) {
im_a_minion_01();
}
i = 1U;
- for (i = 1; i < 10; i++)
- {
- if (1U == (i % 2U) )
- {
+ for (i = 1; i < 10; i++) {
+ if (1U == (i % 2U)) {
im_a_minion_01();
}
}
}
/*verifying while loops*/
-void testFuncLoopWhile (void)
-{
+void testFuncLoopWhile(void) {
int i = 20U;
- while (i > 10U)
- {
+ while (i > 10U) {
i = i - 1U;
}
i = 20;
#if (TRUE == INF_LOOP)
- while (20U == i)
- {
+ while (20U == i) {
im_a_minion_03();
}
#endif
}
/*verifying the correct handling of continue*/
-void testFuncContinue (void)
-{
+void testFuncContinue(void) {
int i = 1U;
- for (i = 1U; i < 20U; i++)
- {
- if (i < 19U)
- {
+ for (i = 1U; i < 20U; i++) {
+ if (i < 19U) {
continue;
}
im_a_minion_01();
@@ -153,14 +134,11 @@ void testFuncContinue (void) }
/*verifying the correct handling of break*/
-void testFuncBreak (void)
-{
+void testFuncBreak(void) {
int i = 1U;
- for (i = 1U; i < 10U ; i++)
- {
- if (i > 0U)
- {
+ for (i = 1U; i < 10U; i++) {
+ if (i > 0U) {
break;
}
im_a_minion_03();
@@ -168,8 +146,7 @@ void testFuncBreak (void) }
/*checking whether goto is handled correctly*/
-void testFuncGoto (void)
-{
+void testFuncGoto(void) {
im_a_minion_01();
goto jumpy;
im_a_minion_02();
@@ -177,19 +154,16 @@ jumpy: im_a_minion_03();
}
-/*checking whether the basic blocks do not complete execution due to return statements*/
-int testFuncNotReturn (int a, int b)
-{
+/*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)
- {
+ if (10U == sum) {
return (sum);
- }
- else
- {
+ } else {
im_a_dummy();
}
@@ -199,67 +173,66 @@ int testFuncNotReturn (int a, int b) }
/*checking whether the tool handles multi-line statements correctly*/
-void testFuncMultiLineStatement (void)
-{
- im_a_minion_01();
-}
+void testFuncMultiLineStatement(void) { im_a_minion_01(); }
/*checking how the tool handles multiple statements on the same line*/
-void testFuncMultipleStatement (void)
-{
+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;
+ 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)
-{
+void testFuncMultipleStatementNot(void) {
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();
}
-/*checking how compiler optimizations may affect the coverage reported-killed assignment elimination*/
-void testFuncCompOpti1 (void)
-{
+/*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)
-{
+/*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) )
- {
+ if (0U == (((a * b) + (a / b) - a) - b)) {
im_a_benign_func();
}
- if ( 0U == (((a * b) + (a / b) - a) - b) )
- {
+ 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)
-{
+/*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++)
- {
+ for (i = 1U; i < 100U; i++) {
counter = counter + 1U;
sum = a + b;
}
@@ -267,99 +240,91 @@ void testFuncCompOpti3 (void) sum = sum * 2U;
}
-/*checking how compiler optimizations may affect the coverage reported-dead code optimization*/
-void testFuncCompOpti4 (void)
-{
+/*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)
-{
+/*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 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,*/
+/* 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)
-{
+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,*/
+/* 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)
-{
+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 )
- {
+/*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
- {
+ } 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 ();
+/* 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)
- {
+ 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)) )
- {
+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*/
+/* 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)
@@ -401,84 +366,56 @@ void testFuncMultiInstantiation (int level) #endif
/* this function will check how the tool handles the "?" operator*/
-void testFuncQMark (int int1, int int2)
-{
+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)
-{
+void testFuncCallBool(void) {
int local1 = 0U;
int local2 = 0U;
- local1 = testFuncStatementbool1(1U , 0U);
- local2 = testFuncStatementbool2(1U , 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!*/
+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?!*/
+static void im_a_benign_func(void) { /* see the light ring?!*/
}
-
/*the dummy function.*/
-void im_a_dummy (void)
-{
- /* dumb dumb*/
+void im_a_dummy(void) { /* dumb dumb*/
}
-
/* minion function number #01*/
-void im_a_minion_01 (void)
-{
- /* minion1*/
+void im_a_minion_01(void) { /* minion1*/
}
-
/* minion function number #02*/
-void im_a_minion_02 (void)
-{
- /* minion1*/
+void im_a_minion_02(void) { /* minion1*/
}
-
/* minion function number #03*/
-static void im_a_minion_03 (void)
-{
- /* minion1*/
+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.*/
+/*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)
- {
+inline void babeFunk(int entry) {
+ if (10U > entry) {
im_a_minion_01();
- }
- else if (10U == entry)
- {
+ } else if (10U == entry) {
im_a_minion_02();
- }
- else
- {
+ } else {
im_a_minion_03();
}
}
@@ -486,53 +423,44 @@ inline void babeFunk (int entry) #if (HCS12 == COMPILER)
#pragma INLINE
-void babeFunk (int entry)
-{
- if (10U > entry)
- {
+void babeFunk(int entry) {
+ if (10U > entry) {
im_a_minion_01();
- }
- else if (10U == entry)
- {
+ } else if (10U == entry) {
im_a_minion_02();
- }
- else
- {
+ } else {
im_a_minion_03();
}
}
#endif
#endif
-/*RL78s dont have inline for all functions, so no use trying to test the functionality*/
+/*RL78s dont have inline for all functions, so no use trying to test the
+ * functionality*/
-void test (void)
-{
+void test(void) {
int i = 0U;
int j = 0U;
int a, b;
int c, d;
- for (;;)
- {
+ for (;;) {
a = b;
}
for (i = 1; i < 100U; i++)
- b++ ;
+ b++;
while (a > 10U)
- im_a_minion_01() ;
+ im_a_minion_01();
- while (a == 90U)
- {
+ while (a == 90U) {
b++;
}
if (a == d)
b = c;
- if (a == d)
- {
+ if (a == d) {
a = d;
}
@@ -546,42 +474,32 @@ void test (void) c++;
else if (a > d)
d++;
-
-
}
-void test2 (void)
-{
+void test2(void) {
int a = 0U;
int b = 10U;
int c, d;
- if (a == b)
- {
+ if (a == b) {
/*do something*/
- }
- else
+ } else
b = a;
- if (20U == a)
- {
+ if (20U == a) {
/*kill all mutants.*/
}
- if (20U == a)
- {
+ if (20U == a) {
/*do somethin good*/
a = b;
- }
- else if (30U == a)
- {
+ } else if (30U == a) {
/*do something else*/
b = a;
}
- if (10U == a)
- {/*die*/}
- else if (15U == a)
+ if (10U == a) { /*die*/
+ } else if (15U == a)
a = b;
else if (17U == a)
a = 10000000U;
@@ -589,79 +507,74 @@ void test2 (void) a = 50U;
if (b == a) {
- if (10U == b)
- {}
- else
- {}
+ if (10U == b) {
+ } else {
+ }
}
-
-
if (a > b) {
- if (a > d)
- {}
- else
+ if (a > d) {
+ } else
a++;
}
- if (a > b)
- {a++;}
- else if (b > a)
- {b++;}
- else if (a == b)
- {a++;}
+ if (a > b) {
+ a++;
+ } else if (b > a) {
+ b++;
+ } else if (a == b) {
+ a++;
+ }
int level = 10U;
- switch (level)
- {
- case 10U:
- { level++;
+ switch (level) {
+ case 10U: {
+ level++;
test();
break;
}
- case 20U:
- { level = 10000U;
+ case 20U: {
+ level = 10000U;
break;
}
- case 30U:
- { level++;
+ case 30U: {
+ level++;
break;
}
- case 40U:
- { level++;
+ case 40U: {
+ level++;
break;
}
- case 50U:
- { level++;
+ case 50U: {
+ level++;
break;
}
- case 60U:
- { level = 1000U;
+ case 60U: {
+ level = 1000U;
break;
}
- case 70U:
- { level++;
+ case 70U: {
+ level++;
break;
}
- case 80U:
- { level++;
+ case 80U: {
+ level++;
break;
}
- case 90U:
- { level++;
+ case 90U: {
+ level++;
break;
}
- default:
- { level++;
+ default: {
+ level++;
break;
}
}
- switch (level)
- {
- case 1:
- { level++;
+ switch (level) {
+ case 1: {
+ level++;
break;
}
case 2:
@@ -675,8 +588,7 @@ void test2 (void) }
}
- switch (level)
- {
+ switch (level) {
case 1:
level++;
case 2:
@@ -687,10 +599,7 @@ void test2 (void) level++;
}
- switch (level)
- {}
-
-
+ switch (level) {}
}
#if 0
@@ -700,41 +609,32 @@ void test3 (int a, int, ...) }
#endif
-test3()
-{
+test3() {
int a;
int b;
}
-double test4 (int a, int b, double c)
-{
- return a + b + c;
-}
+double test4(int a, int b, double c) { return a + b + c; }
-void test5(void)
-{
+void test5(void) {
int i = 0;
- if (test4)
- {
+ if (test4) {
i++;
}
}
-void test6 (void)
-{
+void test6(void) {
int a[100];
int *p = a;
int i = 0;
- for (i = 0; i < 100; ++i)
- {
+ for (i = 0; i < 100; ++i) {
a[i] = i;
}
}
-void test7(void)
-{
+void test7(void) {
double a[100];
double b[100];
@@ -743,9 +643,9 @@ void test7(void) double *pointer;
- double* pointerb;
+ double *pointerb;
- char* pointerc;
+ char *pointerc;
pointerb = b;
@@ -753,51 +653,43 @@ void test7(void) 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;
- for (i = 0; i < 50; i++)
- {
+ for (i = 0; i < 50; i++) {
*(a + i) = i;
}
-
}
-void test8 (void)
-{
- union uni uni2;
-}
+void test8(void) { union uni uni2; }
-void test9 (void)
-{
+void test9(void) {
/*im a comment*/
- //im also a comment
+ // im also a comment
}
-void test10 (void)
-{
+void test10(void) {
struct {
unsigned int r1 : 1;
unsigned int r2 : 2;
@@ -817,26 +709,19 @@ void test10 (void) } reg3;
}
-void test11 (void)
-{
- /*empty*/
+void test11(void) { /*empty*/
}
-double test12(double a)
-{
- return a * 2;
-}
+double test12(double a) { return a * 2; }
-int test13(void)
-{
+int test13(void) {
static int a;
int b;
return (a * b);
}
-void test14 (void)
-{
+void test14(void) {
int arr[3][2] = {{2, 3}, {4, 5}, {6, 7}};
int arr2[4][4] = {0};
@@ -851,21 +736,19 @@ void test14 (void) #endif
}
-void test15(void)
-{
- enum colour {red = 3, blue, yellow, green = 5};
+void test15(void) {
+ 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 test16(int a, int b) {
short int sum;
short unsigned int sumus;
sum = a + b;
@@ -874,41 +757,33 @@ short int test16(int a, int b) return sum;
}
-void test17(void)
-{
+void test17(void) {
int a = 100;
int b = 1000;
long int longa;
- a = sizeof (b = 2000U);
+ a = sizeof(b = 2000U);
}
-void test18(void)
-{
+void test18(void) {
int a;
int b;
int c;
unsigned char d;
- if (c && (a = b))
- {
+ if (c && (a = b)) {
/*yada /*yada*/
}
- if ((c = a) || a)
- {
+ if ((c = a) || a) {
/*yada*/
}
- if (c && (a || c))
- {
-
+ if (c && (a || c)) {
}
d = c && (a = c);
-
}
-void test19(void)
-{
+void test19(void) {
const int a = 100;
unsigned char flag = 1;
@@ -917,29 +792,27 @@ void test19(void) unsigned char flag3;
- //char *str = "loco\0";
+ // char *str = "loco\0";
const double pi = 3.54;
- if ((flag) && pi)
- {}
-
- if (flag || flag2 && flag3)
- {}
+ if ((flag) && pi) {
+ }
- if (a == 0 && flag)
- {}
+ if (flag || flag2 && flag3) {
+ }
- if (flag || (a == 0))
- {}
+ if (a == 0 && flag) {
+ }
- if (!flag || flag2)
- {}
+ if (flag || (a == 0)) {
+ }
+ if (!flag || flag2) {
+ }
}
-void test20(void)
-{
+void test20(void) {
signed int a;
unsigned int b;
signed char c;
@@ -956,8 +829,7 @@ void test20(void) f = f << 4U;
}
-void test21(void)
-{
+void test21(void) {
unsigned int a;
a = a >> 44U;
a = a >> shift;
@@ -965,8 +837,7 @@ void test21(void) a << 45U;
}
-void test22(void)
-{
+void test22(void) {
unsigned int a;
int b;
t_int c;
@@ -977,15 +848,13 @@ void test22(void) b = -d;
}
-void test23 (void)
-{
+void test23(void) {
int a, b, c;
a = b, c = a;
}
-void test24(void)
-{
+void test24(void) {
int a;
int b;
int c;
@@ -996,117 +865,100 @@ void test24(void) --a;
}
-void test25(void)
-{
+void test25(void) {
int a;
int b;
int c;
- if (a - b)
- {
+ if (a - b) {
/*i dont care.*/
}
}
-void test26 (void)
-{
+void test26(void) {
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);
}
-void test27(void)
-{
+void test27(void) {
double a;
- for (a = 0.0; a < 10.0; ++a)
- {}
+ for (a = 0.0; a < 10.0; ++a) {
+ }
}
-void test28(void)
-{
+void test28(void) {
int i;
int j;
int k;
int flag = 0;
int counter = 0;
- for (i = 0; i < 10; i++)
- {
+ for (i = 0; i < 10; i++) {
i = i + 3;
}
- for (j = 0; j < 20; ++j)
- {
+ for (j = 0; j < 20; ++j) {
j++;
}
- for (k = 0; k < 10; ++k)
- {
+ for (k = 0; k < 10; ++k) {
k = i + j;
--j;
i = j - k;
}
- for (i = 0; flag == 1; i++)
- {
- if (i > 10)
- {
+ for (i = 0; flag == 1; i++) {
+ if (i > 10) {
flag = 1;
}
}
- for (i = 0; flag == 1, counter++; i++)
- {
- if (i > 10)
- {
+ for (i = 0; flag == 1, counter++; i++) {
+ if (i > 10) {
flag = 1;
}
}
- for (k = 0, i = 0; i < 10, k < 10; ++i, 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++)
- {
+ for (i = 0, k = 0; i < 10, k < 10; ++i, k++) {
k = i + j;
--j;
i = j - k;
}
}
-int test29(int a)
-{
+int test29(int a) {
goto loco;
loco:
return a;
}
-void test30(void)
-{
+void test30(void) {
int a;
int b;
int c;
- for (a = 0; a < 10; ++a)
- {
+ for (a = 0; a < 10; ++a) {
a++;
if (a == 5)
@@ -1115,15 +967,13 @@ void test30(void) break;
}
- for (a = 0; a < 10; a++)
- {
+ for (a = 0; a < 10; a++) {
a++;
if (a == 6)
break;
}
- while (a < 10)
- {
+ while (a < 10) {
if (b == 1)
break;
if (c == 1)
@@ -1139,29 +989,24 @@ void test30(void) break;
} while (a < 10);
- for (a = 0; a < 100; a++)
- {
- for (b = 0; b < 100; b++)
- {
+ for (a = 0; a < 100; a++) {
+ for (b = 0; b < 100; b++) {
c++;
if (a == 1)
break;
}
- for (c = 0; c < 100; c++)
- {
+ for (c = 0; c < 100; c++) {
b++;
if (a == 10)
break;
}
}
- for (a = 0; a < 100; a++)
- {
+ for (a = 0; a < 100; a++) {
if (a == 1)
break;
- while (a < 10)
- {
+ while (a < 10) {
b++;
if (c == 10)
break;
@@ -1169,8 +1014,7 @@ void test30(void) }
}
-int test31(void)
-{
+int test31(void) {
int a;
if (a == 1)
@@ -1181,12 +1025,10 @@ int test31(void) return 1;
}
-void test32(void)
-{
+void test32(void) {
int a;
- switch (a == 1)
- {
+ switch (a == 1) {
case 1:
a++;
case 0:
@@ -1194,29 +1036,27 @@ void test32(void) }
}
-void test33(void)
-{
+void test33(void) {
short int a;
long int b;
b = (int)a;
}
-void test34(void)
-{
+void test34(void) {
int i, a;
i >= 3;
- for (;; i++)
- {
+ for (;; i++) {
a++;
}
; /*yadayada*/
- ;/*:P*/
+ ; /*:P*/
- ; int b;
+ ;
+ int b;
int ut_int = 0;
@@ -1230,6 +1070,5 @@ void malloc (void) }
#endif
-
/**********************************************************************************************************************/
/*the last line's been intentionally left blank.*/
|