commit 5def7f1fd3bdf760740c7ad596e18c334192fa05 Author: Mike Long Date: Sun Dec 12 20:11:35 2010 +0100 Initial commit diff --git a/README b/README new file mode 100644 index 0000000..e69de29 diff --git a/src/.cproject b/src/.cproject new file mode 100644 index 0000000..5ed7a59 --- /dev/null +++ b/src/.cproject @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/.project b/src/.project new file mode 100644 index 0000000..590162a --- /dev/null +++ b/src/.project @@ -0,0 +1,79 @@ + + + src + + + + + + org.eclipse.cdt.managedbuilder.core.genmakebuilder + clean,full,incremental, + + + ?name? + + + + org.eclipse.cdt.make.core.append_environment + true + + + org.eclipse.cdt.make.core.autoBuildTarget + all + + + org.eclipse.cdt.make.core.buildArguments + + + + org.eclipse.cdt.make.core.buildCommand + make + + + org.eclipse.cdt.make.core.cleanBuildTarget + clean + + + org.eclipse.cdt.make.core.contents + org.eclipse.cdt.make.core.activeConfigSettings + + + org.eclipse.cdt.make.core.enableAutoBuild + false + + + org.eclipse.cdt.make.core.enableCleanBuild + true + + + org.eclipse.cdt.make.core.enableFullBuild + true + + + org.eclipse.cdt.make.core.fullBuildTarget + all + + + org.eclipse.cdt.make.core.stopOnError + true + + + org.eclipse.cdt.make.core.useDefaultBuildCmd + true + + + + + org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder + full,incremental, + + + + + + org.eclipse.cdt.core.cnature + org.eclipse.cdt.core.ccnature + org.eclipse.cdt.managedbuilder.core.managedBuildNature + org.eclipse.cdt.managedbuilder.core.ScannerConfigNature + + diff --git a/src/cmock.c b/src/cmock.c new file mode 100644 index 0000000..c22b900 --- /dev/null +++ b/src/cmock.c @@ -0,0 +1,114 @@ +/* + * cmock.c + * + * Created on: Dec 9, 2010 + * Author: mlong + */ + +#include "embedded.h" +#include "cmock.h" +#include +#include + + +FAKE_VOID_FUNC0(DISPLAY_init); +FAKE_VOID_FUNC0(DISPLAY_clear); +FAKE_VOID_FUNC1(DISPLAY_output_message, const char*); +FAKE_VALUE_FUNC0(int, DISPLAY_get_line_capacity); +FAKE_VALUE_FUNC0(int, DISPLAY_get_line_insert_index); + +void setup() +{ + // Register resets + RESET_FAKE(DISPLAY_init); + RESET_FAKE(DISPLAY_clear); + RESET_FAKE(DISPLAY_output_message); + RESET_FAKE(DISPLAY_get_line_capacity); + RESET_FAKE(DISPLAY_get_line_insert_index); + + // non default init + DISPLAY_get_line_capacity_return_val = 10; +} + +#define TEST_F(IGNORE, NAME) void NAME() +TEST_F(GreeterTests, init_initialises_display) +{ + UI_init(); + assert(1 == DISPLAY_init_call_count); +} + +TEST_F(GreeterTests, given_name_when_greet_called_outputs_name) +{ + // given + char name[] = "mike"; + // when + UI_greet(name); + // then + assert(1 == DISPLAY_output_message_call_count); + assert(name == DISPLAY_output_message_arg0_val); +} + + +TEST_F(GreeterTests, given_name_and_3_times_when_greetmultiple_called_outputs_name_3_times) +{ + // given + char name[] = "mike"; + // when + UI_greet_multiple_times(name, 3); + // then + assert(3 == DISPLAY_output_message_call_count); + assert(name == DISPLAY_output_message_arg0_val); +} + +TEST_F(GreeterTests, given_non_full_screen_will_not_reset_display) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 10; + DISPLAY_get_line_insert_index_return_val = 0; + // when + UI_greet(name); + // then + assert(0 == DISPLAY_clear_call_count); + assert(1 == DISPLAY_output_message_call_count); +} + +// Order assumption +TEST_F(GreeterTests, given_full_screen_single_will_reset_display_then_output) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 1; + DISPLAY_get_line_insert_index_return_val = 1; + // when + UI_greet(name); + // then + assert(1 == DISPLAY_clear_call_count); + assert(1 == DISPLAY_output_message_call_count); +} + +// Order assumption +TEST_F(GreeterTests, given_full_screen_multiple_will_reset_display_then_output) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 4; + DISPLAY_get_line_insert_index_return_val = 4; + // when + UI_greet_multiple_times(name, 1); + // then + assert(1 == DISPLAY_clear_call_count); + assert(1 == DISPLAY_output_message_call_count); +} + +#define RUN_TEST(TESTNAME) printf("Running %s\n", #TESTNAME); setup(); TESTNAME(); +int main() +{ + RUN_TEST(init_initialises_display); + RUN_TEST(given_name_when_greet_called_outputs_name); + RUN_TEST(given_name_when_greet_called_outputs_name); + RUN_TEST(given_name_and_3_times_when_greetmultiple_called_outputs_name_3_times); + RUN_TEST(given_full_screen_single_will_reset_display_then_output); + RUN_TEST(given_full_screen_multiple_will_reset_display_then_output); + return 0; +} diff --git a/src/cmock.h b/src/cmock.h new file mode 100644 index 0000000..d567ecc --- /dev/null +++ b/src/cmock.h @@ -0,0 +1,520 @@ +#ifndef FAKE_FUNCTIONS +#define FAKE_FUNCTIONS + + +/* Defining a void function with 0 parameters*/ +#define FAKE_VOID_FUNC0(FUNCNAME) \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(){ \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 1 parameters*/ +#define FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 2 parameters*/ +#define FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 3 parameters*/ +#define FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 4 parameters*/ +#define FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 5 parameters*/ +#define FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 6 parameters*/ +#define FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 7 parameters*/ +#define FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 8 parameters*/ +#define FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a void function with 9 parameters*/ +#define FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static ARG8_TYPE FUNCNAME##_arg8_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7ARG8_TYPE arg8){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_arg8_val = arg8; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_arg8_val = (ARG8_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 0 parameters*/ +#define FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(){ \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 1 parameters*/ +#define FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 2 parameters*/ +#define FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 3 parameters*/ +#define FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 4 parameters*/ +#define FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 5 parameters*/ +#define FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 6 parameters*/ +#define FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 7 parameters*/ +#define FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 8 parameters*/ +#define FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function returning a value with 9 parameters*/ +#define FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static ARG8_TYPE FUNCNAME##_arg8_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7ARG8_TYPE arg8){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_arg8_val = arg8; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_arg8_val = (ARG8_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ + + +/* Defining a function to reset a fake function */ +#define RESET_FAKE(FUNCNAME) { \ + FUNCNAME##_reset(); \ +} \ + +#endif // FAKE_FUNCTIONS diff --git a/src/cppmock.cpp b/src/cppmock.cpp new file mode 100644 index 0000000..cf8f7ef --- /dev/null +++ b/src/cppmock.cpp @@ -0,0 +1,106 @@ +//============================================================================ +// Name : cmock.cpp +// Author : Mike Long +// Version : +// Copyright : Don't steal +// Description : Hello World in C++, Ansi-style +//============================================================================ + +#include "cppmock.hpp" + +extern "C"{ +#include "embedded.h" +} + +#include + +FAKE_VOID_FUNC0(DISPLAY_init); +FAKE_VOID_FUNC0(DISPLAY_clear); +FAKE_VOID_FUNC1(DISPLAY_output_message, const char*); +FAKE_VALUE_FUNC0(int, DISPLAY_get_line_capacity); +FAKE_VALUE_FUNC0(int, DISPLAY_get_line_insert_index); + + +class GreeterTests : public testing::Test +{ +public: + + void SetUp() + { + // Register resets + RESET_FAKES(); + // non default init + DISPLAY_get_line_capacity_return_val = 10; + } +}; + +TEST_F(GreeterTests, init_initialises_display) +{ + UI_init(); + ASSERT_EQ(1, DISPLAY_init_call_count); +} + +TEST_F(GreeterTests, given_name_when_greet_called_outputs_name) +{ + // given + char name[] = "mike"; + // when + UI_greet(name); + // then + ASSERT_EQ(1, DISPLAY_output_message_call_count); + ASSERT_EQ(name, DISPLAY_output_message_arg0_val); +} + + +TEST_F(GreeterTests, given_name_and_3_times_when_greetmultiple_called_outputs_name_3_times) +{ + // given + char name[] = "mike"; + // when + UI_greet_multiple_times(name, 3); + // then + ASSERT_EQ(3, DISPLAY_output_message_call_count); + ASSERT_EQ(name, DISPLAY_output_message_arg0_val); +} + +TEST_F(GreeterTests, given_non_full_screen_will_not_reset_display) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 10; + DISPLAY_get_line_insert_index_return_val = 0; + // when + UI_greet(name); + // then + ASSERT_EQ(0, DISPLAY_clear_call_count); + ASSERT_EQ(1, DISPLAY_output_message_call_count); +} + +// Order assumption +TEST_F(GreeterTests, given_full_screen_single_will_reset_display_then_output) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 1; + DISPLAY_get_line_insert_index_return_val = 1; + // when + UI_greet(name); + // then + ASSERT_EQ(1, DISPLAY_clear_call_count); + ASSERT_EQ(1, DISPLAY_output_message_call_count); +} + +// Order assumption +TEST_F(GreeterTests, given_full_screen_multiple_will_reset_display_then_output) +{ + char name[] = "mike"; + // given + DISPLAY_get_line_capacity_return_val = 4; + DISPLAY_get_line_insert_index_return_val = 4; + // when + UI_greet_multiple_times(name, 1); + // then + ASSERT_EQ(1, DISPLAY_clear_call_count); + ASSERT_EQ(1, DISPLAY_output_message_call_count); +} + diff --git a/src/cppmock.hpp b/src/cppmock.hpp new file mode 100644 index 0000000..3d04750 --- /dev/null +++ b/src/cppmock.hpp @@ -0,0 +1,604 @@ +#ifndef FAKE_FUNCTIONS +#define FAKE_FUNCTIONS + +#include +typedef void (*void_fptr)(); +std::vector reset_functions; +void RESET_FAKES() +{ + std::vector::iterator it = reset_functions.begin(); + for( ; it != reset_functions.end(); ++it) + { + void_fptr ptr = *it; + ptr(); + } + +} +#define STATIC_INIT(FUNCNAME) \ +class StaticInitializer_##FUNCNAME \ +{ \ +public: \ + StaticInitializer_##FUNCNAME() \ + { \ + reset_functions.push_back(FUNCNAME##_reset); \ + } \ +}; \ +static StaticInitializer_##FUNCNAME staticInitializer_##FUNCNAME; \ + + +/* Defining a void function with 0 parameters*/ +#define FAKE_VOID_FUNC0(FUNCNAME) \ +extern "C"{ \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(){ \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 1 parameters*/ +#define FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 2 parameters*/ +#define FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 3 parameters*/ +#define FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 4 parameters*/ +#define FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 5 parameters*/ +#define FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 6 parameters*/ +#define FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 7 parameters*/ +#define FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 8 parameters*/ +#define FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a void function with 9 parameters*/ +#define FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static ARG8_TYPE FUNCNAME##_arg8_val; \ + static int FUNCNAME##_call_count = 0; \ + void FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7ARG8_TYPE arg8){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_arg8_val = arg8; \ + FUNCNAME##_call_count++; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_arg8_val = (ARG8_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 0 parameters*/ +#define FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ +extern "C"{ \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(){ \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 1 parameters*/ +#define FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 2 parameters*/ +#define FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 3 parameters*/ +#define FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 4 parameters*/ +#define FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 5 parameters*/ +#define FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 6 parameters*/ +#define FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 7 parameters*/ +#define FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 8 parameters*/ +#define FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function returning a value with 9 parameters*/ +#define FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ +extern "C"{ \ + static ARG0_TYPE FUNCNAME##_arg0_val; \ + static ARG1_TYPE FUNCNAME##_arg1_val; \ + static ARG2_TYPE FUNCNAME##_arg2_val; \ + static ARG3_TYPE FUNCNAME##_arg3_val; \ + static ARG4_TYPE FUNCNAME##_arg4_val; \ + static ARG5_TYPE FUNCNAME##_arg5_val; \ + static ARG6_TYPE FUNCNAME##_arg6_val; \ + static ARG7_TYPE FUNCNAME##_arg7_val; \ + static ARG8_TYPE FUNCNAME##_arg8_val; \ + static RETURN_TYPE FUNCNAME##_return_val; \ + static int FUNCNAME##_call_count = 0; \ + RETURN_TYPE FUNCNAME(ARG0_TYPE arg0ARG1_TYPE arg1ARG2_TYPE arg2ARG3_TYPE arg3ARG4_TYPE arg4ARG5_TYPE arg5ARG6_TYPE arg6ARG7_TYPE arg7ARG8_TYPE arg8){ \ + FUNCNAME##_arg0_val = arg0; \ + FUNCNAME##_arg1_val = arg1; \ + FUNCNAME##_arg2_val = arg2; \ + FUNCNAME##_arg3_val = arg3; \ + FUNCNAME##_arg4_val = arg4; \ + FUNCNAME##_arg5_val = arg5; \ + FUNCNAME##_arg6_val = arg6; \ + FUNCNAME##_arg7_val = arg7; \ + FUNCNAME##_arg8_val = arg8; \ + FUNCNAME##_call_count++; \ + return FUNCNAME##_return_val; \ + } \ + void FUNCNAME##_reset(){ \ + FUNCNAME##_arg0_val = (ARG0_TYPE) 0; \ + FUNCNAME##_arg1_val = (ARG1_TYPE) 0; \ + FUNCNAME##_arg2_val = (ARG2_TYPE) 0; \ + FUNCNAME##_arg3_val = (ARG3_TYPE) 0; \ + FUNCNAME##_arg4_val = (ARG4_TYPE) 0; \ + FUNCNAME##_arg5_val = (ARG5_TYPE) 0; \ + FUNCNAME##_arg6_val = (ARG6_TYPE) 0; \ + FUNCNAME##_arg7_val = (ARG7_TYPE) 0; \ + FUNCNAME##_arg8_val = (ARG8_TYPE) 0; \ + FUNCNAME##_call_count = 0; \ + } \ +} \ +STATIC_INIT(FUNCNAME) \ + + +/* Defining a function to reset a fake function */ +#define RESET_FAKE(FUNCNAME) { \ + FUNCNAME##_reset(); \ +} \ + +#endif // FAKE_FUNCTIONS diff --git a/src/embedded.c b/src/embedded.c new file mode 100644 index 0000000..a83acd2 --- /dev/null +++ b/src/embedded.c @@ -0,0 +1,34 @@ + + + +void DISPLAY_init(); +void DISPLAY_clear(); +int DISPLAY_get_line_capacity(); +int DISPLAY_get_line_insert_index(); +void DISPLAY_output_message(char * message); + +void UI_init() +{ + DISPLAY_init(); +} + +void UI_greet(char * name) +{ + if(DISPLAY_get_line_capacity() == DISPLAY_get_line_insert_index()) + { + DISPLAY_clear(); + } + DISPLAY_output_message(name); +} + +void UI_greet_multiple_times(char * name, int times) +{ + int i; + for(i = 0; i < times; i++) + { + UI_greet(name); + } +} + + + diff --git a/src/embedded.h b/src/embedded.h new file mode 100644 index 0000000..0ba9abd --- /dev/null +++ b/src/embedded.h @@ -0,0 +1,10 @@ + +#ifndef EMBEDDED_CODE +#define EMBEDDED_CODE + +void UI_init(); +void UI_greet(char * name); +void UI_greet_multiple_times(char * name, int times); + + +#endif /* EMBEDDED_CODE */ diff --git a/src/fakegen.rb b/src/fakegen.rb new file mode 100644 index 0000000..272827c --- /dev/null +++ b/src/fakegen.rb @@ -0,0 +1,155 @@ + +# fakegen.rb +# A simple code generator to create some C macros for defining test fake functions + + +$cpp_output = true + +def output_macro(args, is_value_function) + + macro_name_preamble = is_value_function ? "FAKE_VALUE_FUNC" : "FAKE_VOID_FUNC"; + macro_name = "#{macro_name_preamble}#{args}" + return_type = is_value_function ? "RETURN_TYPE" : "" + + output_macro_header(macro_name, args, return_type) + + extern_c { # define argument capture variables + output_variables(args, is_value_function) + output_function_signature(args, is_value_function) + + puts "{ \\" + output_function_body(args, is_value_function) + puts " } \\" + output_reset_function(args) + } + puts "STATIC_INIT(FUNCNAME) \\" + puts "" +end + +def output_reset_code + puts <<-REGISTRATION +#include +typedef void (*void_fptr)(); +std::vector reset_functions; +void RESET_FAKES() +{ + std::vector::iterator it = reset_functions.begin(); + for( ; it != reset_functions.end(); ++it) + { + void_fptr ptr = *it; + ptr(); + } + +} + REGISTRATION +end + +def output_static_initializer + puts <<-MY_STATIC_INITIALIZER +#define STATIC_INIT(FUNCNAME) \\ +class StaticInitializer_##FUNCNAME \\ +{ \\ +public: \\ + StaticInitializer_##FUNCNAME() \\ + { \\ + reset_functions.push_back(FUNCNAME##_reset); \\ + } \\ +}; \\ +static StaticInitializer_##FUNCNAME staticInitializer_##FUNCNAME; \\ + + MY_STATIC_INITIALIZER +end + +def output_macro_header(macro_name, args, return_type) + puts "" + + output_macro_name(macro_name, args, return_type) + +end + +def output_macro_name(macro_name, args, return_type) + parameter_list = return_type + if return_type == "" + puts "/* Defining a void function with #{args} parameters*/" + else + puts "/* Defining a function returning a value with #{args} parameters*/" + parameter_list += ", " + end + parameter_list += "FUNCNAME" + print "#define #{macro_name}(" + parameter_list + + args.times { |i| print ", ARG#{i}_TYPE" } + + puts ") \\" +end + +def output_variables(args, is_value_function) + args.times { |i| puts " static ARG#{i}_TYPE FUNCNAME##_arg#{i}_val; \\" } + puts " static RETURN_TYPE FUNCNAME##_return_val; \\" unless not is_value_function + puts " static int FUNCNAME##_call_count = 0; \\" +end + +def output_function_signature(args, is_value_function) + if is_value_function + print " RETURN_TYPE FUNCNAME(" + else + print " void FUNCNAME(" + end + + args.times { |i| print "ARG#{i}_TYPE arg#{i}" } + + print ")" +end + +def output_function_body(args, is_value_function) + # capture arguments + args.times { |i| puts " FUNCNAME##_arg#{i}_val = arg#{i}; \\" } + # update call count + puts " FUNCNAME##_call_count++; \\" + # return something if value function + puts " return FUNCNAME##_return_val; \\" unless not is_value_function +end + +def output_reset_function(args) + puts " void FUNCNAME##_reset(){ \\" + args.times { |i| + puts " FUNCNAME##_arg#{i}_val = (ARG#{i}_TYPE) 0; \\" + } + puts " FUNCNAME##_call_count = 0; \\" + puts " } \\" +end + +def define_reset_fake + puts "" + puts "/* Defining a function to reset a fake function */" + puts "#define RESET_FAKE(FUNCNAME) { \\" + puts " FUNCNAME##_reset(); \\" + puts "} \\" +end + +def include_guard + puts "#ifndef FAKE_FUNCTIONS" + puts "#define FAKE_FUNCTIONS" + puts "" + + yield + + puts "" + puts "#endif // FAKE_FUNCTIONS" +end + +def extern_c + + puts "extern \"C\"{ \\" unless !$cpp_output + yield + puts "} \\" unless !$cpp_output +end + +# lets generate!! +include_guard { + output_reset_code if $cpp_output + output_static_initializer if $cpp_output + 10.times {|arg_count| output_macro(arg_count, false)} + 10.times {|arg_count| output_macro(arg_count, true)} + define_reset_fake +}