diff options
author | Thierry Strudel <tstrudel@google.com> | 2018-11-13 22:40:35 -0800 |
---|---|---|
committer | Thierry Strudel <tstrudel@google.com> | 2018-11-13 22:40:35 -0800 |
commit | c82edb1fc60dc81bd319d9b8d0bee9f8963a6960 (patch) | |
tree | e01d330f8be4adb772fc3e6d448e334fb0085b3a /test | |
parent | 0ad6e3f7ea755e6c7599560946848b429b83198e (diff) | |
parent | cd727d4195b5dec9242c3ed3f48b1ef1214c86e5 (diff) | |
download | fff-master.tar.gz |
Merge remote-tracking branch 'origin/upstream-master'HEADmaster-kernel-build-2021mastermain
Change-Id: Ie5edd0f8aff0a645707387b8bd42b0d695280ef3
Diffstat (limited to 'test')
-rw-r--r-- | test/Makefile | 81 | ||||
-rw-r--r-- | test/c_test_framework.h | 15 | ||||
-rw-r--r-- | test/fff_test_c.c | 115 | ||||
-rw-r--r-- | test/fff_test_cpp.cpp | 48 | ||||
-rw-r--r-- | test/fff_test_global_c.c | 80 | ||||
-rw-r--r-- | test/fff_test_global_cpp.cpp | 24 | ||||
-rw-r--r-- | test/global_fakes.c | 17 | ||||
-rw-r--r-- | test/global_fakes.h | 33 | ||||
-rw-r--r-- | test/test_cases.include | 436 |
9 files changed, 849 insertions, 0 deletions
diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..3368be0 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,81 @@ + +BUILD_DIR = ../build + +FFF_TEST_CPP_OBJS += \ +$(BUILD_DIR)/fff_test_cpp.o \ +$(BUILD_DIR)/gtest-all.o \ +$(BUILD_DIR)/gtest-main.o + +FFF_TEST_GLOBAL_CPP_OBJS += \ +$(BUILD_DIR)/fff_test_global_cpp.o \ +$(BUILD_DIR)/global_fakes.o \ +$(BUILD_DIR)/gtest-all.o \ +$(BUILD_DIR)/gtest-main.o + +FFF_TEST_C_OBJS = $(BUILD_DIR)/fff_test_c.o + +FFF_TEST_GLOBAL_C_OBJS += \ +$(BUILD_DIR)/global_fakes.o \ +$(BUILD_DIR)/fff_test_global_c.o + +FFF_TEST_CPP_TARGET = $(BUILD_DIR)/fff_test_cpp +FFF_TEST_C_TARGET = $(BUILD_DIR)/fff_test_c +FFF_TEST_GLOBAL_C_TARGET = $(BUILD_DIR)/fff_test_glob_c +FFF_TEST_GLOBAL_CPP_TARGET = $(BUILD_DIR)/fff_test_glob_cpp + +LIBS := -lpthread +# All Target +all: $(FFF_TEST_CPP_TARGET) $(FFF_TEST_C_TARGET) $(FFF_TEST_GLOBAL_C_TARGET) $(FFF_TEST_GLOBAL_CPP_TARGET) + + +# Each subdirectory must supply rules for building sources it contributes +$(BUILD_DIR)/%.o: %.cpp + @echo 'Building file: $<' + @echo 'Invoking: GCC C++ Compiler' + g++ -I../ -O0 -g3 -Wall -DGTEST_USE_OWN_TR1_TUPLE=1 -c -o "$@" "$<" + @echo 'Finished building: $<' + @echo ' ' + +$(BUILD_DIR)/%.o: %.c + @echo 'Building file: $<' + @echo 'Invoking: GCC C Compiler' + gcc -I../ -O0 -g3 -Wall -std=c99 -c -o "$@" "$<" + @echo 'Finished building: $<' + @echo ' ' + + +# Link targets +$(FFF_TEST_CPP_TARGET): $(FFF_TEST_CPP_OBJS) + @echo 'Building target: $@' + @echo 'Invoking: GCC C++ Linker' + g++ -o "$(FFF_TEST_CPP_TARGET)" $(FFF_TEST_CPP_OBJS) $(LIBS) + @echo 'Finished building target: $@' + @echo ' ' + +$(FFF_TEST_C_TARGET): $(FFF_TEST_C_OBJS) + @echo 'Building target: $@' + @echo 'Invoking: GCC C Linker' + gcc -o "$(FFF_TEST_C_TARGET)" $(FFF_TEST_C_OBJS) $(LIBS) + @echo 'Finished building target: $@' + @echo ' ' + +$(FFF_TEST_GLOBAL_C_TARGET): $(FFF_TEST_GLOBAL_C_OBJS) + @echo 'Building target: $@' + @echo 'Invoking: GCC C++ Linker' + gcc -o "$(FFF_TEST_GLOBAL_C_TARGET)" $(FFF_TEST_GLOBAL_C_OBJS) $(LIBS) $(WRAP_LDFLAGS) + @echo 'Finished building target: $@' + @echo ' ' + +$(FFF_TEST_GLOBAL_CPP_TARGET): $(FFF_TEST_GLOBAL_CPP_OBJS) + @echo 'Building target: $@' + @echo 'Invoking: GCC C++ Linker' + g++ -o "$(FFF_TEST_GLOBAL_CPP_TARGET)" $(FFF_TEST_GLOBAL_CPP_OBJS) $(LIBS) + @echo 'Finished building target: $@' + @echo ' ' + +# Other Targets +clean: + -$(RM) $(FFF_TEST_CPP_OBJS) $(FFF_TEST_GLOBAL_C_OBJS) $(FFF_TEST_C_OBJS) \ + $(FFF_TEST_CPP_TARGET) $(FFF_TEST_C_TARGET) $(FFF_TEST_GLOBAL_CPP_TARGET) $(FFF_TEST_GLOBAL_C_TARGET) + -@echo ' ' + diff --git a/test/c_test_framework.h b/test/c_test_framework.h new file mode 100644 index 0000000..297a33a --- /dev/null +++ b/test/c_test_framework.h @@ -0,0 +1,15 @@ +#ifndef C_TEST_FRAMEWORK_H_ +#define C_TEST_FRAMEWORK_H_ + +#include <assert.h> +#include <stdio.h> +#include <string.h> + +/* Test Framework :-) */ +void setup(); +#define TEST_F(SUITE, NAME) void NAME() +#define RUN_TEST(SUITE, TESTNAME) do { printf(" Running %s.%s: \n", #SUITE, #TESTNAME); setup(); TESTNAME(); printf(" SUCCESS\n"); } while (0) +#define ASSERT_EQ(A, B) assert((A) == (B)) +#define ASSERT_TRUE(A) assert((A)) + +#endif /* C_TEST_FRAMEWORK_H_ */ diff --git a/test/fff_test_c.c b/test/fff_test_c.c new file mode 100644 index 0000000..6763439 --- /dev/null +++ b/test/fff_test_c.c @@ -0,0 +1,115 @@ + +// Want to keep the argument history for 13 calls +#define OVERRIDE_ARG_HIST_LEN 13u +#define FFF_ARG_HISTORY_LEN OVERRIDE_ARG_HIST_LEN +// Want to keep the call sequence history for 17 function calls +#define OVERRIDE_CALL_HIST_LEN 17u +#define FFF_CALL_HISTORY_LEN OVERRIDE_CALL_HIST_LEN + +#include "../fff.h" +#include "c_test_framework.h" + +#include <assert.h> +#include <stdio.h> +#include <string.h> + + + +enum MYBOOL { FALSE = 899, TRUE }; +struct MyStruct { + int x; + int y; +}; + + +FAKE_VOID_FUNC(voidfunc1, int); +FAKE_VOID_FUNC(voidfunc2, char, char); +FAKE_VOID_FUNC(voidfunc1outparam, char *); +FAKE_VALUE_FUNC(long, longfunc0); +FAKE_VALUE_FUNC(enum MYBOOL, enumfunc0); +FAKE_VALUE_FUNC(struct MyStruct, structfunc0); +FAKE_VOID_FUNC_VARARG(voidfunc3var, char *, int, ...); +FAKE_VALUE_FUNC_VARARG(int, valuefunc3var, char *, int, ...); +FAKE_VALUE_FUNC(int, strlcpy3, char* const, const char* const, const size_t); +FAKE_VOID_FUNC(voidfunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); +FAKE_VALUE_FUNC(int, valuefunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); + +void setup() +{ + RESET_FAKE(voidfunc1); + RESET_FAKE(voidfunc2); + RESET_FAKE(voidfunc1outparam); + RESET_FAKE(longfunc0); + RESET_FAKE(enumfunc0); + RESET_FAKE(structfunc0); + RESET_FAKE(voidfunc3var); + RESET_FAKE(valuefunc3var); + RESET_FAKE(strlcpy3); + FFF_RESET_HISTORY(); +} + + +#include "test_cases.include" + +TEST_F(FFFTestSuite, default_constants_can_be_overridden) +{ + unsigned sizeCallHistory = (sizeof fff.call_history) / (sizeof fff.call_history[0]); + ASSERT_EQ(OVERRIDE_CALL_HIST_LEN, sizeCallHistory); + ASSERT_EQ(OVERRIDE_ARG_HIST_LEN, voidfunc2_fake.arg_history_len); +} + +DEFINE_FFF_GLOBALS; +int main() +{ + setbuf(stdout, NULL); + fprintf(stdout, "-------------\n"); + fprintf(stdout, "Running Tests\n"); + fprintf(stdout, "-------------\n\n"); + fflush(0); + + /* Run tests */ + RUN_TEST(FFFTestSuite, when_void_func_never_called_then_callcount_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_called_once_then_callcount_is_one); + RUN_TEST(FFFTestSuite, when_void_func_called_once_and_reset_then_callcount_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_then_last_arg_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_twice_then_last_arg_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_and_reset_then_captured_arg_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_then_last_args_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_twice_then_last_args_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_and_reset_then_captured_arg_is_zero); + RUN_TEST(FFFTestSuite, when_fake_func_called_then_const_arguments_captured); + + RUN_TEST(FFFTestSuite, when_fake_func_created_default_history_is_fifty_calls); + RUN_TEST(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history); + RUN_TEST(FFFTestSuite, argument_history_is_reset_when_RESET_FAKE_called); + RUN_TEST(FFFTestSuite, when_fake_func_called_max_times_then_no_argument_histories_dropped); + RUN_TEST(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped); + + RUN_TEST(FFFTestSuite, value_func_will_return_zero_by_default); + RUN_TEST(FFFTestSuite, value_func_will_return_value_given); + RUN_TEST(FFFTestSuite, value_func_will_return_zero_after_reset); + RUN_TEST(FFFTestSuite, register_call_macro_registers_one_call); + RUN_TEST(FFFTestSuite, register_call_macro_registers_two_calls); + RUN_TEST(FFFTestSuite, reset_call_history_resets_call_history); + RUN_TEST(FFFTestSuite, call_history_will_not_write_past_array_bounds); + RUN_TEST(FFFTestSuite, calling_fake_registers_one_call); + + RUN_TEST(FFFTestSuite, return_value_sequences_not_exhausted); + RUN_TEST(FFFTestSuite, return_value_sequences_exhausted); + RUN_TEST(FFFTestSuite, default_constants_can_be_overridden); + + RUN_TEST(FFFTestSuite, can_register_custom_fake); + RUN_TEST(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value); + + RUN_TEST(FFFTestSuite, use_void_vararg_fake_with_different_number_of_arguments); + RUN_TEST(FFFTestSuite, use_value_vararg_fake_with_different_number_of_arguments); + + RUN_TEST(FFFTestSuite, can_capture_upto_20_arguments_correctly); + RUN_TEST(FFFTestSuite, value_func_can_capture_upto_20_arguments_correctly); + + printf("\n-------------\n"); + printf("Complete\n"); + printf("-------------\n\n"); + + return 0; +} diff --git a/test/fff_test_cpp.cpp b/test/fff_test_cpp.cpp new file mode 100644 index 0000000..4a51b11 --- /dev/null +++ b/test/fff_test_cpp.cpp @@ -0,0 +1,48 @@ +/* + * fff_test.cpp + * + * Created on: Dec 20, 2010 + * Author: mlong + */ + +// Want to keep the argument history for 13 calls +#define OVERRIDE_ARG_HIST_LEN 13u +#define FFF_ARG_HISTORY_LEN OVERRIDE_ARG_HIST_LEN +// Want to keep the call sequence history for 17 function calls +#define OVERRIDE_CALL_HIST_LEN 17u +#define FFF_CALL_HISTORY_LEN OVERRIDE_CALL_HIST_LEN + +#include "../fff.h" +#include <gtest/gtest.h> + +DEFINE_FFF_GLOBALS + +FAKE_VOID_FUNC(voidfunc1, int); +FAKE_VOID_FUNC(voidfunc2, char, char); +FAKE_VOID_FUNC(voidfunc1outparam, char *); +FAKE_VALUE_FUNC(long, longfunc0); +FAKE_VOID_FUNC(voidfunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); +FAKE_VALUE_FUNC(int, valuefunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); + +class FFFTestSuite: public testing::Test +{ +public: + void SetUp() + { + RESET_FAKE(voidfunc1); + RESET_FAKE(voidfunc2); + RESET_FAKE(longfunc0); + RESET_FAKE(voidfunc1outparam); + FFF_RESET_HISTORY(); + } +}; + +#include "test_cases.include" + +TEST_F(FFFTestSuite, default_constants_can_be_overridden) +{ + unsigned sizeCallHistory = (sizeof fff.call_history) / (sizeof fff.call_history[0]); + ASSERT_EQ(OVERRIDE_CALL_HIST_LEN, sizeCallHistory); + ASSERT_EQ(OVERRIDE_ARG_HIST_LEN, voidfunc2_fake.arg_history_len); +} + diff --git a/test/fff_test_global_c.c b/test/fff_test_global_c.c new file mode 100644 index 0000000..fb8ee57 --- /dev/null +++ b/test/fff_test_global_c.c @@ -0,0 +1,80 @@ + +#include "global_fakes.h" +#include "c_test_framework.h" + + + +DEFINE_FFF_GLOBALS; + +void setup() +{ + RESET_FAKE(voidfunc1); + RESET_FAKE(voidfunc2); + RESET_FAKE(voidfunc1outparam); + RESET_FAKE(longfunc0); + RESET_FAKE(enumfunc0); + RESET_FAKE(structfunc0); + RESET_FAKE(voidfunc3var); + RESET_FAKE(valuefunc3var); + RESET_FAKE(strlcpy3); + + FFF_RESET_HISTORY(); +} + + +#include "test_cases.include" + + +int main() +{ + setbuf(stdout, NULL); + fprintf(stdout, "-------------\n"); + fprintf(stdout, "Running Tests\n"); + fprintf(stdout, "-------------\n\n"); + fflush(0); + + /* Run tests */ + RUN_TEST(FFFTestSuite, when_void_func_never_called_then_callcount_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_called_once_then_callcount_is_one); + RUN_TEST(FFFTestSuite, when_void_func_called_once_and_reset_then_callcount_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_then_last_arg_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_twice_then_last_arg_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_1_integer_arg_called_and_reset_then_captured_arg_is_zero); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_then_last_args_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_twice_then_last_args_captured); + RUN_TEST(FFFTestSuite, when_void_func_with_2_char_args_called_and_reset_then_captured_arg_is_zero); + RUN_TEST(FFFTestSuite, when_fake_func_called_then_const_arguments_captured); + + RUN_TEST(FFFTestSuite, when_fake_func_created_default_history_is_fifty_calls); + RUN_TEST(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history); + RUN_TEST(FFFTestSuite, argument_history_is_reset_when_RESET_FAKE_called); + RUN_TEST(FFFTestSuite, when_fake_func_called_max_times_then_no_argument_histories_dropped); + RUN_TEST(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped); + + RUN_TEST(FFFTestSuite, value_func_will_return_zero_by_default); + RUN_TEST(FFFTestSuite, value_func_will_return_value_given); + RUN_TEST(FFFTestSuite, value_func_will_return_zero_after_reset); + RUN_TEST(FFFTestSuite, register_call_macro_registers_one_call); + RUN_TEST(FFFTestSuite, register_call_macro_registers_two_calls); + RUN_TEST(FFFTestSuite, reset_call_history_resets_call_history); + RUN_TEST(FFFTestSuite, call_history_will_not_write_past_array_bounds); + RUN_TEST(FFFTestSuite, calling_fake_registers_one_call); + + RUN_TEST(FFFTestSuite, return_value_sequences_not_exhausted); + RUN_TEST(FFFTestSuite, return_value_sequences_exhausted); + + RUN_TEST(FFFTestSuite, can_register_custom_fake); + RUN_TEST(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value); + + RUN_TEST(FFFTestSuite, use_void_vararg_fake_with_different_number_of_arguments); + RUN_TEST(FFFTestSuite, use_value_vararg_fake_with_different_number_of_arguments); + + RUN_TEST(FFFTestSuite, can_capture_upto_20_arguments_correctly); + RUN_TEST(FFFTestSuite, value_func_can_capture_upto_20_arguments_correctly); + + printf("\n-------------\n"); + printf("Complete\n"); + printf("-------------\n\n"); + + return 0; +} diff --git a/test/fff_test_global_cpp.cpp b/test/fff_test_global_cpp.cpp new file mode 100644 index 0000000..b4f3275 --- /dev/null +++ b/test/fff_test_global_cpp.cpp @@ -0,0 +1,24 @@ + +extern "C"{ + #include "global_fakes.h" +} +#include <gtest/gtest.h> + +DEFINE_FFF_GLOBALS; + +class FFFTestSuite: public testing::Test +{ +public: + void SetUp() + { + RESET_FAKE(voidfunc1); + RESET_FAKE(voidfunc2); + RESET_FAKE(longfunc0); + RESET_FAKE(voidfunc1outparam); + FFF_RESET_HISTORY(); + } +}; + +#include "test_cases.include" + + diff --git a/test/global_fakes.c b/test/global_fakes.c new file mode 100644 index 0000000..d418761 --- /dev/null +++ b/test/global_fakes.c @@ -0,0 +1,17 @@ +#include "global_fakes.h" +#include <string.h> // for memcpy + +DEFINE_FAKE_VOID_FUNC(voidfunc1, int); +DEFINE_FAKE_VOID_FUNC(voidfunc2, char, char); +DEFINE_FAKE_VOID_FUNC(voidfunc1outparam, char *); + +DEFINE_FAKE_VALUE_FUNC(long, longfunc0); +DEFINE_FAKE_VALUE_FUNC(enum MYBOOL, enumfunc0); +DEFINE_FAKE_VALUE_FUNC(struct MyStruct, structfunc0); +DEFINE_FAKE_VOID_FUNC_VARARG(voidfunc3var, const char *, int, ...); +DEFINE_FAKE_VALUE_FUNC_VARARG(int, valuefunc3var, const char *, int, ...); +#ifndef __cplusplus +DEFINE_FAKE_VALUE_FUNC(int, strlcpy3, char* const, const char* const, const size_t); +#endif /* __cplusplus */ +DEFINE_FAKE_VOID_FUNC(voidfunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); +DEFINE_FAKE_VALUE_FUNC(int, valuefunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); diff --git a/test/global_fakes.h b/test/global_fakes.h new file mode 100644 index 0000000..6c26f07 --- /dev/null +++ b/test/global_fakes.h @@ -0,0 +1,33 @@ + +#ifndef GLOBAL_FAKES_H_ +#define GLOBAL_FAKES_H_ + +#include "../fff.h" +#include "string.h" + + +//// Imaginary production code header file /// +enum MYBOOL { FALSE = 899, TRUE }; +struct MyStruct { + int x; + int y; +}; +enum MYBOOL enumfunc(); +struct MyStruct structfunc(); +//// End Imaginary production code header file /// + +DECLARE_FAKE_VOID_FUNC(voidfunc1, int); +DECLARE_FAKE_VOID_FUNC(voidfunc2, char, char); +DECLARE_FAKE_VOID_FUNC(voidfunc1outparam, char *); +DECLARE_FAKE_VALUE_FUNC(long, longfunc0); +DECLARE_FAKE_VALUE_FUNC(enum MYBOOL, enumfunc0); +DECLARE_FAKE_VALUE_FUNC(struct MyStruct, structfunc0); +DECLARE_FAKE_VOID_FUNC_VARARG(voidfunc3var, const char *, int, ...); +DECLARE_FAKE_VALUE_FUNC_VARARG(int, valuefunc3var, const char *, int, ...); +DECLARE_FAKE_VOID_FUNC(voidfunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); +DECLARE_FAKE_VALUE_FUNC(int, valuefunc20, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int); + +#ifndef __cplusplus +DECLARE_FAKE_VALUE_FUNC(int, strlcpy3, char* const, const char* const, const size_t); +#endif /* __cplusplus */ +#endif /* GLOBAL_FAKES_H_ */ diff --git a/test/test_cases.include b/test/test_cases.include new file mode 100644 index 0000000..51484c1 --- /dev/null +++ b/test/test_cases.include @@ -0,0 +1,436 @@ + + +TEST_F(FFFTestSuite, when_void_func_never_called_then_callcount_is_zero) +{ + ASSERT_EQ(voidfunc1_fake.call_count, 0u); +} + +TEST_F(FFFTestSuite, when_void_func_called_once_then_callcount_is_one) +{ + voidfunc1(66); + ASSERT_EQ(voidfunc1_fake.call_count, 1u); +} + +TEST_F(FFFTestSuite, when_void_func_called_once_and_reset_then_callcount_is_zero) +{ + voidfunc1(66); + RESET_FAKE(voidfunc1); + ASSERT_EQ(voidfunc1_fake.call_count, 0u); +} + +// Single Argument +TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_then_last_arg_captured) +{ + voidfunc1(77); + ASSERT_EQ(voidfunc1_fake.arg0_val, 77); +} + +TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_twice_then_last_arg_captured) +{ + voidfunc1(77); + voidfunc1(12); + ASSERT_EQ(voidfunc1_fake.arg0_val, 12); +} + +TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_and_reset_then_captured_arg_is_zero) +{ + voidfunc1(11); + RESET_FAKE(voidfunc1); + ASSERT_EQ(voidfunc1_fake.arg0_val, 0); +} + +// Two Arguments +TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_then_last_args_captured) +{ + voidfunc2('a', 'b'); + ASSERT_EQ(voidfunc2_fake.arg0_val, 'a'); + ASSERT_EQ(voidfunc2_fake.arg1_val, 'b'); +} + +TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_twice_then_last_args_captured) +{ + voidfunc2('a', 'b'); + voidfunc2('c', 'd'); + ASSERT_EQ(voidfunc2_fake.arg0_val, 'c'); + ASSERT_EQ(voidfunc2_fake.arg1_val, 'd'); +} + +TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_and_reset_then_captured_arg_is_zero) +{ + voidfunc2('e', 'f'); + RESET_FAKE(voidfunc2); + ASSERT_EQ(voidfunc2_fake.arg0_val, 0); + ASSERT_EQ(voidfunc2_fake.arg1_val, 0); +} + +#ifndef __cplusplus +TEST_F(FFFTestSuite, when_fake_func_called_then_const_arguments_captured) +{ + char dst[80]; + strlcpy3(dst, __FUNCTION__, sizeof(__FUNCTION__)); +} +#endif /* __cplusplus */ + +// Argument history +TEST_F(FFFTestSuite, when_fake_func_created_default_history_is_fifty_calls) +{ + ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg0_history) / (sizeof voidfunc2_fake.arg0_history[0])); + ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg1_history) / (sizeof voidfunc2_fake.arg1_history[0])); +} + +TEST_F(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history) +{ + voidfunc2('g', 'h'); + ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]); + ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]); +} + +TEST_F(FFFTestSuite, argument_history_is_reset_when_RESET_FAKE_called) +{ + //given + voidfunc2('g', 'h'); + ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]); + ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]); + //when + RESET_FAKE(voidfunc2); + //then + ASSERT_EQ('\0', voidfunc2_fake.arg0_history[0]); + ASSERT_EQ('\0', voidfunc2_fake.arg1_history[0]); +} + +TEST_F(FFFTestSuite, when_fake_func_called_max_times_then_no_argument_histories_dropped) +{ + unsigned int i; + for (i = 0; i < FFF_ARG_HISTORY_LEN; i++) + { + voidfunc2('1' + i, '2' + i); + } + ASSERT_EQ(0u, voidfunc2_fake.arg_histories_dropped); +} + +TEST_F(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped) +{ + unsigned int i; + for (i = 0; i < FFF_ARG_HISTORY_LEN; i++) + { + voidfunc2('1' + i, '2' + i); + } + voidfunc2('1', '2'); + ASSERT_EQ(1u, voidfunc2_fake.arg_histories_dropped); + // or in other words.. + ASSERT_TRUE(voidfunc2_fake.call_count > voidfunc2_fake.arg_history_len); +} + +// Return values +TEST_F(FFFTestSuite, value_func_will_return_zero_by_default) +{ + ASSERT_EQ(0l, longfunc0()); +} + +TEST_F(FFFTestSuite, value_func_will_return_value_given) +{ + longfunc0_fake.return_val = 99l; + ASSERT_EQ(99l, longfunc0()); +} + +TEST_F(FFFTestSuite, value_func_will_return_zero_after_reset) +{ + longfunc0_fake.return_val = 99l; + RESET_FAKE(longfunc0); + ASSERT_EQ(0l, longfunc0()); +} + +TEST_F(FFFTestSuite, register_call_macro_registers_one_call) +{ + REGISTER_CALL(longfunc0); + ASSERT_EQ(fff.call_history[0], (void *)longfunc0); +} + +TEST_F(FFFTestSuite, register_call_macro_registers_two_calls) +{ + REGISTER_CALL(longfunc0); + REGISTER_CALL(voidfunc2); + + ASSERT_EQ(fff.call_history[0], (void *)longfunc0); + ASSERT_EQ(fff.call_history[1], (void *)voidfunc2); +} + +TEST_F(FFFTestSuite, reset_call_history_resets_call_history) +{ + REGISTER_CALL(longfunc0); + REGISTER_CALL(voidfunc1); + FFF_RESET_HISTORY(); + REGISTER_CALL(voidfunc2); + + ASSERT_EQ(1u, fff.call_history_idx); + ASSERT_EQ(fff.call_history[0], (void *)voidfunc2); + ASSERT_EQ(fff.call_history[1], (void *)0); +} + +TEST_F(FFFTestSuite, call_history_will_not_write_past_array_bounds) +{ + for (unsigned int i = 0; i < FFF_CALL_HISTORY_LEN + 1; i++) + { + REGISTER_CALL(longfunc0); + } + ASSERT_EQ(FFF_CALL_HISTORY_LEN, fff.call_history_idx); +} + +TEST_F(FFFTestSuite, calling_fake_registers_one_call) +{ + longfunc0(); + ASSERT_EQ(fff.call_history_idx, 1u); + ASSERT_EQ(fff.call_history[0], (void *)longfunc0); +} + +TEST_F(FFFTestSuite, return_value_sequences_not_exhausted) +{ + long myReturnVals[3] = { 3, 7, 9 }; + SET_RETURN_SEQ(longfunc0, myReturnVals, 3); + ASSERT_EQ(myReturnVals[0], longfunc0()); + ASSERT_EQ(myReturnVals[1], longfunc0()); + ASSERT_EQ(myReturnVals[2], longfunc0()); +} + + +TEST_F(FFFTestSuite, return_value_sequences_exhausted) +{ + long myReturnVals[3] = { 3, 7, 9 }; + SET_RETURN_SEQ(longfunc0, myReturnVals, 3); + ASSERT_EQ(myReturnVals[0], longfunc0()); + ASSERT_EQ(myReturnVals[1], longfunc0()); + ASSERT_EQ(myReturnVals[2], longfunc0()); + ASSERT_EQ(myReturnVals[2], longfunc0()); + ASSERT_EQ(myReturnVals[2], longfunc0()); +} + +TEST_F(FFFTestSuite, return_value_sequences_reset) +{ + long myReturnVals[3] = { 3, 7, 9 }; + SET_RETURN_SEQ(longfunc0, myReturnVals, 3); + ASSERT_EQ(myReturnVals[0], longfunc0()); + ASSERT_EQ(myReturnVals[1], longfunc0()); + RESET_FAKE(longfunc0); + ASSERT_EQ(0, longfunc0()); +} + +static int my_custom_fake_called = 0; +void my_custom_fake(char a, char b) +{ + my_custom_fake_called++; +} + +TEST_F(FFFTestSuite, can_register_custom_fake) +{ + voidfunc2_fake.custom_fake = my_custom_fake; + voidfunc2('a', 'b'); + ASSERT_EQ(1, my_custom_fake_called); +} + +void voidfunc1outparam_custom_fake1(char *a) +{ + *a = 'x'; +} + +void voidfunc1outparam_custom_fake2(char *a) +{ + *a = 'y'; +} + +void voidfunc1outparam_custom_fake3(char *a) +{ + *a = 'z'; +} + +TEST_F(FFFTestSuite, custom_fake_sequence_not_exausthed) +{ + void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1, + voidfunc1outparam_custom_fake2, + voidfunc1outparam_custom_fake3}; + char a = 'a'; + + SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3); + + voidfunc1outparam(&a); + ASSERT_EQ('x', a); + voidfunc1outparam(&a); + ASSERT_EQ('y', a); + voidfunc1outparam(&a); + ASSERT_EQ('z', a); +} + +TEST_F(FFFTestSuite, return_value_sequence_saved_in_history) +{ + long myReturnVals[3] = { 3, 7, 9 }; + SET_RETURN_SEQ(longfunc0, myReturnVals, 3); + longfunc0(); + longfunc0(); + longfunc0(); + ASSERT_EQ(myReturnVals[0], longfunc0_fake.return_val_history[0]); + ASSERT_EQ(myReturnVals[1], longfunc0_fake.return_val_history[1]); + ASSERT_EQ(myReturnVals[2], longfunc0_fake.return_val_history[2]); +} + +TEST_F(FFFTestSuite, return_value_saved_in_history) +{ + long i; + + for (i = 0; i < FFF_ARG_HISTORY_LEN; i++) + { + longfunc0_fake.return_val = i + 1; + longfunc0(); + } + + for (i = 0; i < FFF_ARG_HISTORY_LEN; i++) + { + ASSERT_EQ(longfunc0_fake.return_val_history[i], i + 1); + } +} +long custom_longfunc1() +{ + return 42; +} + +long custom_longfunc2() +{ + return 15; +} + +long custom_longfunc3() +{ + return 7; +} + +TEST_F(FFFTestSuite, custom_fake_seq_return_values_saved_in_history) +{ + long (*custom_fakes[])(void) = {custom_longfunc1, + custom_longfunc2, + custom_longfunc3}; + SET_CUSTOM_FAKE_SEQ(longfunc0, custom_fakes, 3); + + longfunc0(); + longfunc0(); + longfunc0(); + + ASSERT_EQ(42, longfunc0_fake.return_val_history[0]); + ASSERT_EQ(15, longfunc0_fake.return_val_history[1]); + ASSERT_EQ(7, longfunc0_fake.return_val_history[2]); +} + +TEST_F(FFFTestSuite, custom_fake_sequence_exhausted) +{ + void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1, + voidfunc1outparam_custom_fake2, + voidfunc1outparam_custom_fake3}; + char a = 'a'; + + SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3); + + voidfunc1outparam(&a); + ASSERT_EQ('x', a); + voidfunc1outparam(&a); + ASSERT_EQ('y', a); + voidfunc1outparam(&a); + ASSERT_EQ('z', a); + a = 'a'; + voidfunc1outparam(&a); + ASSERT_EQ('z', a); + a = 'b'; + voidfunc1outparam(&a); + ASSERT_EQ('z', a); +} +//DECLARE_FAKE_VALUE_FUNC0(long, longfunc0); +#define MEANING_OF_LIFE 42 +long my_custom_value_fake(void) +{ + return MEANING_OF_LIFE; +} +TEST_F(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value) +{ + longfunc0_fake.custom_fake = my_custom_value_fake; + long retval = longfunc0(); + ASSERT_EQ(MEANING_OF_LIFE, retval); +} + +#ifndef __cplusplus +TEST_F(FFFTestSuite, use_void_vararg_fake_with_different_number_of_arguments) +{ + voidfunc3var("0 parameters", 0); + voidfunc3var("1 parameter", 1, 10); + voidfunc3var("2 parameters", 2, 10, 20); + voidfunc3var("3 parameters", 3, 10, 20, 30); + + ASSERT_EQ(voidfunc3var_fake.call_count, 4); + char msg[] = "3 parameters"; + ASSERT_EQ(strcmp(voidfunc3var_fake.arg0_val, msg), 0); + ASSERT_EQ(3, voidfunc3var_fake.arg1_val); +} + +TEST_F(FFFTestSuite, use_value_vararg_fake_with_different_number_of_arguments) +{ + valuefunc3var("0 parameters", 0); + valuefunc3var("1 parameter", 1, 10); + valuefunc3var("2 parameters", 2, 10, 20); + valuefunc3var("3 parameters", 3, 10, 20, 30); + + ASSERT_EQ(valuefunc3var_fake.call_count, 4); + char msg[] = "3 parameters"; + ASSERT_EQ(strcmp(valuefunc3var_fake.arg0_val, msg), 0); + ASSERT_EQ(3, valuefunc3var_fake.arg1_val); +} +#endif /* __cplusplus */ + +TEST_F(FFFTestSuite, can_capture_upto_20_arguments_correctly) +{ + voidfunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19); + ASSERT_EQ(0, voidfunc20_fake.arg0_val); + ASSERT_EQ(1, voidfunc20_fake.arg1_val); + ASSERT_EQ(2, voidfunc20_fake.arg2_val); + ASSERT_EQ(3, voidfunc20_fake.arg3_val); + ASSERT_EQ(4, voidfunc20_fake.arg4_val); + ASSERT_EQ(5, voidfunc20_fake.arg5_val); + ASSERT_EQ(6, voidfunc20_fake.arg6_val); + ASSERT_EQ(7, voidfunc20_fake.arg7_val); + ASSERT_EQ(8, voidfunc20_fake.arg8_val); + ASSERT_EQ(9, voidfunc20_fake.arg9_val); + ASSERT_EQ(10, voidfunc20_fake.arg10_val); + ASSERT_EQ(11, voidfunc20_fake.arg11_val); + ASSERT_EQ(12, voidfunc20_fake.arg12_val); + ASSERT_EQ(13, voidfunc20_fake.arg13_val); + ASSERT_EQ(14, voidfunc20_fake.arg14_val); + ASSERT_EQ(15, voidfunc20_fake.arg15_val); + ASSERT_EQ(16, voidfunc20_fake.arg16_val); + ASSERT_EQ(17, voidfunc20_fake.arg17_val); + ASSERT_EQ(18, voidfunc20_fake.arg18_val); + ASSERT_EQ(19, voidfunc20_fake.arg19_val); +} + +TEST_F(FFFTestSuite, value_func_can_capture_upto_20_arguments_correctly) +{ + valuefunc20_fake.return_val = 42; + + int return_val = valuefunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19); + + ASSERT_EQ(42, return_val); + ASSERT_EQ(0, valuefunc20_fake.arg0_val); + ASSERT_EQ(1, valuefunc20_fake.arg1_val); + ASSERT_EQ(2, valuefunc20_fake.arg2_val); + ASSERT_EQ(3, valuefunc20_fake.arg3_val); + ASSERT_EQ(4, valuefunc20_fake.arg4_val); + ASSERT_EQ(5, valuefunc20_fake.arg5_val); + ASSERT_EQ(6, valuefunc20_fake.arg6_val); + ASSERT_EQ(7, valuefunc20_fake.arg7_val); + ASSERT_EQ(8, valuefunc20_fake.arg8_val); + ASSERT_EQ(9, valuefunc20_fake.arg9_val); + ASSERT_EQ(10, valuefunc20_fake.arg10_val); + ASSERT_EQ(11, valuefunc20_fake.arg11_val); + ASSERT_EQ(12, valuefunc20_fake.arg12_val); + ASSERT_EQ(13, valuefunc20_fake.arg13_val); + ASSERT_EQ(14, valuefunc20_fake.arg14_val); + ASSERT_EQ(15, valuefunc20_fake.arg15_val); + ASSERT_EQ(16, valuefunc20_fake.arg16_val); + ASSERT_EQ(17, valuefunc20_fake.arg17_val); + ASSERT_EQ(18, valuefunc20_fake.arg18_val); + ASSERT_EQ(19, valuefunc20_fake.arg19_val); +} + |