From fe69e56a0be97a9c4326670aa1ba07f99efecfb2 Mon Sep 17 00:00:00 2001 From: "jh9216.park" Date: Wed, 17 Feb 2021 01:58:36 -0500 Subject: [PATCH] Refactor capi-appfw-application - Use app-core for C++ Requires: - https://review.tizen.org/gerrit/#/c/platform/core/appfw/app-core/+/247812/ - https://review.tizen.org/gerrit/#/c/platform/core/api/app-common/+/253882/ Change-Id: I55abe8e29cb188eb2821eca701563402aa8ed3bf Signed-off-by: jh9216.park --- CMakeLists.txt | 101 +- appcore_ui_app_ambient/CMakeLists.txt | 92 +- .../appcore-ui-app-ambient.pc.in | 0 appcore_ui_app_ambient/include/ui_app_ambient.h | 4 +- .../src/common_private.hh | 18 +- .../src/log_private.hh | 28 +- appcore_ui_app_ambient/src/ui_app_ambient.c | 399 -- appcore_ui_app_ambient/src/ui_app_ambient.cc | 343 ++ cmake/Modules/ApplyPkgConfig.cmake | 35 + doc/appfw_app_control_doc.h | 6 +- include/app_internal.h | 30 - mock/alarm_fake.h | 31 - mock/fff.h | 6493 -------------------- mock/mock.cc | 34 - packaging/capi-appfw-application.spec | 28 +- src/CMakeLists.txt | 87 +- src/app_device.c | 77 - src/app_device.cc | 56 + src/app_main.c | 295 - src/app_main.cc | 266 + src/app_main_legacy.c | 185 - src/app_main_legacy.cc | 210 + src/app_resource.c | 75 - src/app_resource.cc | 56 + src/common_private.hh | 26 + src/log_private.hh | 37 + tests/CMakeLists.txt | 1 + tests/ui-app-ambient_unittests/CMakeLists.txt | 35 + tests/ui-app-ambient_unittests/main.cc | 28 + tests/ui-app-ambient_unittests/mock/aul_mock.cc | 34 + tests/ui-app-ambient_unittests/mock/aul_mock.hh | 38 + tests/ui-app-ambient_unittests/mock/mock_hook.hh | 42 + tests/ui-app-ambient_unittests/mock/module_mock.hh | 25 + .../ui-app-ambient_unittests/mock/test_fixture.cc | 9 +- .../ui-app-ambient_unittests/mock/test_fixture.hh | 53 + .../ui_app_ambient_unittest.cc | 101 + unittest/CMakeLists.txt | 37 - unittest/ui_app_ambient_unittest.cpp | 150 - 38 files changed, 1551 insertions(+), 8014 deletions(-) mode change 100755 => 100644 appcore_ui_app_ambient/CMakeLists.txt mode change 100755 => 100644 appcore_ui_app_ambient/appcore-ui-app-ambient.pc.in rename unittest/main.cpp => appcore_ui_app_ambient/src/common_private.hh (68%) rename mock/aul_fake.h => appcore_ui_app_ambient/src/log_private.hh (55%) delete mode 100644 appcore_ui_app_ambient/src/ui_app_ambient.c create mode 100644 appcore_ui_app_ambient/src/ui_app_ambient.cc create mode 100644 cmake/Modules/ApplyPkgConfig.cmake delete mode 100644 mock/alarm_fake.h delete mode 100644 mock/fff.h delete mode 100644 mock/mock.cc delete mode 100644 src/app_device.c create mode 100644 src/app_device.cc delete mode 100755 src/app_main.c create mode 100644 src/app_main.cc delete mode 100755 src/app_main_legacy.c create mode 100644 src/app_main_legacy.cc delete mode 100644 src/app_resource.c create mode 100644 src/app_resource.cc create mode 100644 src/common_private.hh create mode 100644 src/log_private.hh create mode 100644 tests/CMakeLists.txt create mode 100644 tests/ui-app-ambient_unittests/CMakeLists.txt create mode 100644 tests/ui-app-ambient_unittests/main.cc create mode 100644 tests/ui-app-ambient_unittests/mock/aul_mock.cc create mode 100644 tests/ui-app-ambient_unittests/mock/aul_mock.hh create mode 100644 tests/ui-app-ambient_unittests/mock/mock_hook.hh create mode 100644 tests/ui-app-ambient_unittests/mock/module_mock.hh rename mock/mock.h => tests/ui-app-ambient_unittests/mock/test_fixture.cc (76%) create mode 100644 tests/ui-app-ambient_unittests/mock/test_fixture.hh create mode 100644 tests/ui-app-ambient_unittests/ui_app_ambient_unittest.cc delete mode 100644 unittest/CMakeLists.txt delete mode 100644 unittest/ui_app_ambient_unittest.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 5216a6d..1b308a8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,47 +1,62 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) -SET(INC_DIR include) +PROJECT(capi-appfw-application) + +SET(CMAKE_INSTALL_PREFIX /usr) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(PC_NAME "capi-appfw-application") +SET(PC_REQUIRED "capi-base-common capi-appfw-app-control capi-appfw-app-common libtzplatform-config") +SET(PC_LDFLAGS "-lcapi-appfw-application") + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-zdefs") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_C_FLAGS_RELEASE "-O2") + +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_C_FLAGS} -fPIC") +SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_CXX_FLAGS_RELEASE "-O2") + +SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} + "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") + +SET(TARGET_APPLICATION "capi-appfw-application") +SET(TARGET_APPCORE_UI_APP_AMBIENT "appcore-ui-app-ambient") + +ENABLE_TESTING() +SET(TARGET_UI_APP_AMBIENT_UNITTESTS "ui-app-ambient_unittests") +ADD_TEST(NAME ${TARGET_UI_APP_AMBIENT_UNITTESTS} + COMMAND ${TARGET_UI_APP_AMBIENT_UNITTESTS} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests/ui-app-ambient_unittests) + +INCLUDE(FindPkgConfig) +INCLUDE(ApplyPkgConfig) + +PKG_CHECK_MODULES(ALARM_SERVICE_DEPS REQUIRED alarm-service) +PKG_CHECK_MODULES(APP_CORE_EFL_CPP_DEPS REQUIRED app-core-efl-cpp) +PKG_CHECK_MODULES(AUL_DEPS REQUIRED aul) +PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle) +PKG_CHECK_MODULES(CAPI_APPFW_APP_COMMON_DEPS REQUIRED capi-appfw-app-common) +PKG_CHECK_MODULES(CAPI_APPFW_APP_CONTROL_DEPS REQUIRED capi-appfw-app-control) +PKG_CHECK_MODULES(CAPI_BASE_COMMON_DEPS REQUIRED capi-base-common) +PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog) +PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0) +PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock) +PKG_CHECK_MODULES(LIBTZPLATFORM_CONFIG_DEPS REQUIRED libtzplatform-config) + +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/${TARGET_APPLICATION}.pc.in + ${CMAKE_SOURCE_DIR}/${TARGET_APPLICATION}.pc @ONLY) +INSTALL(FILES ${CMAKE_SOURCE_DIR}/${TARGET_APPLICATION}.pc + DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) + +INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ + DESTINATION include/appfw + FILES_MATCHING + PATTERN "*_private.h" EXCLUDE + PATTERN "include/*.h*") ADD_SUBDIRECTORY(src) ADD_SUBDIRECTORY(appcore_ui_app_ambient) -IF(BUILD_GCOV) - ADD_SUBDIRECTORY(unittest) -ENDIF(BUILD_GCOV) - -INSTALL( - DIRECTORY ${INC_DIR}/ DESTINATION include/appfw - FILES_MATCHING - PATTERN "*_private.h" EXCLUDE - PATTERN "${INC_DIR}/*.h*" - ) - -IF(UNIX) - -ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution) -ADD_CUSTOM_COMMAND( - DEPENDS clean - COMMENT "distribution clean" - COMMAND find - ARGS . - -not -name config.cmake -and \( - -name tester.c -or - -name Testing -or - -name CMakeFiles -or - -name cmake.depends -or - -name cmake.check_depends -or - -name CMakeCache.txt -or - -name cmake.check_cache -or - -name *.cmake -or - -name Makefile -or - -name core -or - -name core.* -or - -name gmon.out -or - -name install_manifest.txt -or - -name *.pc -or - -name *~ \) - | grep -v TC | xargs rm -rf - TARGET distclean - VERBATIM -) - -ENDIF(UNIX) +ADD_SUBDIRECTORY(tests) diff --git a/appcore_ui_app_ambient/CMakeLists.txt b/appcore_ui_app_ambient/CMakeLists.txt old mode 100755 new mode 100644 index cf71e8d..cbd9038 --- a/appcore_ui_app_ambient/CMakeLists.txt +++ b/appcore_ui_app_ambient/CMakeLists.txt @@ -1,57 +1,35 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -PROJECT(appcore-ui-app-ambient C) - -SET(PREFIX ${CMAKE_INSTALL_PREFIX}) -SET(EXEC_PREFIX "\${prefix}") -SET(LIBDIR "\${prefix}/lib") -SET(INCLUDEDIR "\${prefix}/include") - -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) - -ADD_DEFINITIONS("-DPREFIX=\"${PREFIX}\"") - -################################################################# -# Build appcore-ui-app-ambient Library -# ------------------------------ -SET(fw_name "appcore-ui-app-ambient") - -SET(MAJORVER 0) -SET(FULLVER 0.0.1) -SET(PC_NAME ${fw_name}) - - -SET(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/ui_app_ambient.c) - -INCLUDE(FindPkgConfig) -pkg_check_modules(${fw_name} REQUIRED - aul - alarm-service - bundle - capi-appfw-app-common - dlog - ) - -FOREACH(flag ${${fw_name}_CFLAGS}) - SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag} -Werror") -ENDFOREACH(flag) - -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC ") -SET(CMAKE_C_FLAGS_DEBUG "-O0 -g -Wall -Werror") - -ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) -SET_TARGET_PROPERTIES(${fw_name} PROPERTIES SOVERSION ${MAJORVER}) -SET_TARGET_PROPERTIES(${fw_name} PROPERTIES VERSION ${FULLVER}) - -TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS} "-ldl -Wl,--as-needed") - -SET(PC_LDFLAGS -l${fw_name}) - -CONFIGURE_FILE(${fw_name}.pc.in ${fw_name}.pc @ONLY) - -INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR} COMPONENT RuntimeLibraries) -INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) - -INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION include/${fw_name}/ - FILES_MATCHING - PATTERN "*.h" - ) \ No newline at end of file +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src + APPCORE_UI_APP_AMBIENT_SRCS) + +ADD_LIBRARY(${TARGET_APPCORE_UI_APP_AMBIENT} SHARED + ${APPCORE_UI_APP_AMBIENT_SRCS}) +SET_TARGET_PROPERTIES(${TARGET_APPCORE_UI_APP_AMBIENT} + PROPERTIES SOVERSION ${MAJORVER}) +SET_TARGET_PROPERTIES(${TARGET_APPCORE_UI_APP_AMBIENT} + PROPERTIES VERSION ${FULLVER}) + +TARGET_INCLUDE_DIRECTORIES(${TARGET_APPCORE_UI_APP_AMBIENT} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/include) + +APPLY_PKG_CONFIG(${TARGET_APPCORE_UI_APP_AMBIENT} PUBLIC + ALARM_SERVICE_DEPS + AUL_DEPS + BUNDLE_DEPS + CAPI_APPFW_APP_COMMON_DEPS + DLOG_DEPS +) + +SET(PC_LDFLAGS "-l${TARGET_APPCORE_UI_APP_AMBIENT}") +CONFIGURE_FILE(${TARGET_APPCORE_UI_APP_AMBIENT}.pc.in + ${TARGET_APPCORE_UI_APP_AMBIENT}.pc @ONLY) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_APPCORE_UI_APP_AMBIENT}.pc + DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) + +INSTALL(TARGETS ${TARGET_APPCORE_UI_APP_AMBIENT} + DESTINATION ${LIB_INSTALL_DIR} + COMPONENT RuntimeLibraries) +INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ + DESTINATION include/appcore-ui-app-ambient/ + FILES_MATCHING + PATTERN "*.h") diff --git a/appcore_ui_app_ambient/appcore-ui-app-ambient.pc.in b/appcore_ui_app_ambient/appcore-ui-app-ambient.pc.in old mode 100755 new mode 100644 diff --git a/appcore_ui_app_ambient/include/ui_app_ambient.h b/appcore_ui_app_ambient/include/ui_app_ambient.h index 70f44a9..0496a4f 100644 --- a/appcore_ui_app_ambient/include/ui_app_ambient.h +++ b/appcore_ui_app_ambient/include/ui_app_ambient.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 - 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -137,4 +137,4 @@ int ui_app_ambient_notify_event(ui_app_ambient_event_e event, bundle *extra); } #endif -#endif /* __UI_APP_AMBIENT__ */ \ No newline at end of file +#endif /* __UI_APP_AMBIENT__ */ diff --git a/unittest/main.cpp b/appcore_ui_app_ambient/src/common_private.hh similarity index 68% rename from unittest/main.cpp rename to appcore_ui_app_ambient/src/common_private.hh index 0142e55..eaf9a66 100644 --- a/unittest/main.cpp +++ b/appcore_ui_app_ambient/src/common_private.hh @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -13,14 +13,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include -#include -#include -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); +#ifndef COMMON_PRIVATE_HH_ +#define COMMON_PRIVATE_HH_ - return RUN_ALL_TESTS(); -} +#undef EXPORT +#define EXPORT __attribute__ ((visibility("default"))) +#undef API +#define API extern "C" EXPORT + +#endif // COMMON_PRIVATE_HH_ diff --git a/mock/aul_fake.h b/appcore_ui_app_ambient/src/log_private.hh similarity index 55% rename from mock/aul_fake.h rename to appcore_ui_app_ambient/src/log_private.hh index a74febc..82ef370 100644 --- a/mock/aul_fake.h +++ b/appcore_ui_app_ambient/src/log_private.hh @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,16 +14,24 @@ * limitations under the License. */ -#ifndef MOCK_AUL_H_ -#define MOCK_AUL_H_ +#ifndef LOG_PRIVATE_HH_ +#define LOG_PRIVATE_HH_ -#include -#include +#include -#include "mock.h" +#undef LOG_TAG +#define LOG_TAG "UI_APP_AMBIENT" -DECLARE_FAKE_VALUE_FUNC(int, aul_app_get_appid_bypid, int, char*, int); -DECLARE_FAKE_VALUE_FUNC(int, aul_app_com_create, const char*, aul_app_com_permission_h, app_com_cb, void *, aul_app_com_connection_h*); -DECLARE_FAKE_VALUE_FUNC(int, aul_app_com_send, const char*, bundle*); +#undef _E +#define _E LOGE -#endif //MOCK_AUL_H_ +#undef _W +#define _W LOGW + +#undef _I +#define _I LOGI + +#undef _D +#define _D LOGD + +#endif // LOG_PRIVATE_HH_ diff --git a/appcore_ui_app_ambient/src/ui_app_ambient.c b/appcore_ui_app_ambient/src/ui_app_ambient.c deleted file mode 100644 index 2046d7c..0000000 --- a/appcore_ui_app_ambient/src/ui_app_ambient.c +++ /dev/null @@ -1,399 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "ui_app_ambient.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "CAPI_UI_APP_AMBIENT" - -#define APPID_BUFFER_MAX 512 - -#define SECOND 1 -#define ONE_MINUTE_IN_SEC 60 - -#define MILLION 1000000 /* for calculating micro seconds */ - -typedef struct -{ - int alarm_id; - int period_type; - ui_app_ambient_update_frame_cb frame_updated; - ui_app_ambient_changed_cb ambient_changed; - void *user_data; -} ambient_lifecycle_s; - -static ambient_lifecycle_s ambient_lifecycle = { - .alarm_id = 0, - .period_type = UI_APP_AMBIENT_UPDATE_NONE, - .frame_updated = NULL, - .ambient_changed = NULL, - .user_data = NULL -}; - -static struct ambient_tick_type_info { - int interval; - int minute_base; - int hour_base; -} ambient_tick_type_infos[] = { - {0, 0, 0}, - {ONE_MINUTE_IN_SEC, 1, 0}, - {ONE_MINUTE_IN_SEC * 5, 5, 0}, - {ONE_MINUTE_IN_SEC * 15, 15, 0}, - {ONE_MINUTE_IN_SEC * 30, 30, 0} -}; - -static aul_app_com_connection_h __conn; -static bool __initialized = false; -static bool __is_ambient_mode = false; - -static void __alarm_init(void) -{ - int r = 0; - int pid = getpid(); - char appid[APPID_BUFFER_MAX] = {0,}; - - r = aul_app_get_appid_bypid(pid, appid, APPID_BUFFER_MAX); - if (r != AUL_R_OK) { - LOGE("fail to get the appid from the pid : %d", pid); - return; - } - - r = alarmmgr_init(appid); - if (r != ALARMMGR_RESULT_SUCCESS) { - LOGE("fail to alarmmgr_init : error_code : %d", r); - } -} - -static int __alarm_cb(alarm_id_t id, void *data) -{ - LOGD("Ambient Tick callback"); - - if (id == ambient_lifecycle.alarm_id) - ambient_lifecycle.frame_updated(data); - - return 0; -} - -static alarm_entry_t* __get_ambient_tick_alarm(ui_app_ambient_update_period_e period) -{ - struct timespec current_time; - struct tm cur_tm; - struct tm next_tm; - int offset = 0; - int remain_min; - int minute_base; - int ret; - time_t next; - alarm_entry_t *alarm_info = NULL; - alarm_date_t date = {0}; - - alarm_info = alarmmgr_create_alarm(); - if (!alarm_info) - return NULL; - - clock_gettime(CLOCK_REALTIME, ¤t_time); - - tzset(); - localtime_r(¤t_time.tv_sec, &cur_tm); - - switch(period) { - case UI_APP_AMBIENT_UPDATE_MINUTE: - offset = ONE_MINUTE_IN_SEC - cur_tm.tm_sec; - break; - case UI_APP_AMBIENT_UPDATE_FIVE_MINUTES: - case UI_APP_AMBIENT_UPDATE_FIFTEEN_MINUTES: - case UI_APP_AMBIENT_UPDATE_THIRTY_MINUTES: - /* To make a gap minutes */ - minute_base = ambient_tick_type_infos[period].minute_base; - remain_min = minute_base - 1 - (cur_tm.tm_min % minute_base); - offset = (remain_min * ONE_MINUTE_IN_SEC) + - (ONE_MINUTE_IN_SEC - cur_tm.tm_sec); - break; - default: - break; - } - - next = current_time.tv_sec + offset; - localtime_r(&next, &next_tm); - - date.year = next_tm.tm_year + 1900; - date.month = next_tm.tm_mon + 1; - date.day = next_tm.tm_mday; - date.hour = next_tm.tm_hour; - date.min = next_tm.tm_min; - date.sec = next_tm.tm_sec; - - alarmmgr_set_type(alarm_info, ALARM_TYPE_VOLATILE); - - ret = alarmmgr_set_time(alarm_info, date); - if (ret != ALARMMGR_RESULT_SUCCESS) { - LOGE("Failed to alarmmgr_set_time : %d", ret); - alarmmgr_free_alarm(alarm_info); - return NULL; - } - - ret = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_REPEAT, - ambient_tick_type_infos[period].interval); - if (ret != ALARMMGR_RESULT_SUCCESS) { - LOGE("Failed to alarmmgr_set_time : %d", ret); - alarmmgr_free_alarm(alarm_info); - return NULL; - } - - LOGD("Next alarm tick [%d:%d:%d]", date.hour, date.min, date.sec); - return alarm_info; -} - -static int __set_ambient_tick_cb() -{ - int r; - alarm_entry_t *alarm_info = NULL; - - if (ambient_lifecycle.period_type == UI_APP_AMBIENT_UPDATE_NONE && - ambient_lifecycle.alarm_id == 0) { - LOGI("DEFAULT period is set [FIFTEEN_MINUTES]"); - ambient_lifecycle.period_type = UI_APP_AMBIENT_UPDATE_FIFTEEN_MINUTES; - } - - alarm_info = __get_ambient_tick_alarm(ambient_lifecycle.period_type); - if (!alarm_info) - return -1; - - __alarm_init(); - - r = alarmmgr_add_alarm_withcb_with_localtime(alarm_info, __alarm_cb, - ambient_lifecycle.user_data, &ambient_lifecycle.alarm_id); - if (r < 0) - LOGE("fail to alarmmgr_add_alarm : error_code : %d", r); - - ambient_lifecycle.frame_updated(ambient_lifecycle.user_data); - - alarmmgr_free_alarm(alarm_info); - return r; -} - -int __on_change_signal(const char *endpoint, aul_app_com_result_e e, - bundle *envelope, void *user_data) -{ - LOGE("__on_change_signal"); - - bundle *b = NULL; - char *extra; - char *mode; - ui_app_ambient_state_e state; - - bundle_get_str(envelope, "__AMBIENT_MODE__", &mode); - bundle_get_str(envelope, "__AMBIENT_EXTRA__", &extra); - b = bundle_decode((bundle_raw *)extra, strlen(extra)); - - state = (ui_app_ambient_state_e)atoi(mode); - - if (ambient_lifecycle.ambient_changed) - ambient_lifecycle.ambient_changed(state, b, user_data); - - if (state == UI_APP_AMBIENT_STATE_ENTER && !__is_ambient_mode) { - int ret = __set_ambient_tick_cb(); - if (ret != 0) - LOGE("Failed to set ambient tick cb : %d", ret); - else - __is_ambient_mode = true; - } else if (state == UI_APP_AMBIENT_STATE_LEAVE && __is_ambient_mode) { - if (ambient_lifecycle.alarm_id) { - alarmmgr_remove_alarm(ambient_lifecycle.alarm_id); - ambient_lifecycle.alarm_id = 0; - } - - __is_ambient_mode = false; - } - - if (b) - bundle_free(b); - - return 0; -} - -static int __set_ambient_changed_cb() -{ - int r; - - if (__conn) { - LOGD("Already set ambient changed cb"); - return 0; - } - - LOGD("Set ambient changed cb"); - - r = aul_app_com_create("ui.ambientchange", NULL, __on_change_signal, - ambient_lifecycle.user_data, &__conn); - if (r != AUL_R_OK) { - LOGE("Failed to listen 'ui.ambientchange' signal"); - } - - return r; -} - -int ui_app_ambient_set_lifecycle(ui_app_ambient_lifecycle_callback_s *lifecycle, - void *user_data) -{ - int ret = -1; - - if (!lifecycle) { - LOGE("Invalid parameter"); - return ret; - } - - if (__initialized) { - LOGW("Lifecycle is already set"); - return 0; - } - - ambient_lifecycle.frame_updated = lifecycle->frame_updated; - ambient_lifecycle.ambient_changed = lifecycle->ambient_changed; - ambient_lifecycle.user_data = user_data; - - ret = __set_ambient_changed_cb(); - if (ret != 0) { - LOGE("Failed to set ambient changed cb : %d", ret); - ui_app_ambient_unset_lifecycle(); - return ret; - } - - __initialized = true; - return 0; -} - -void ui_app_ambient_unset_lifecycle() -{ - if (__conn) { - if (aul_app_com_leave(__conn) < 0) - LOGE("failed to leave app com disable"); - - __conn = NULL; - } - - if (ambient_lifecycle.alarm_id) { - alarmmgr_remove_alarm(ambient_lifecycle.alarm_id); - ambient_lifecycle.alarm_id = 0; - } - - if (ambient_lifecycle.ambient_changed) - ambient_lifecycle.ambient_changed = NULL; - - if (ambient_lifecycle.frame_updated) - ambient_lifecycle.frame_updated = NULL; - - if (ambient_lifecycle.user_data) - ambient_lifecycle.user_data = NULL; - - __initialized = false; -} - -int ui_app_ambient_set_update_period(ui_app_ambient_update_period_e period) -{ - int ret = 0; - LOGD("set update period : %d", period); - ambient_lifecycle.period_type = period; - - if (__is_ambient_mode) { - if (ambient_lifecycle.alarm_id) { - alarmmgr_remove_alarm(ambient_lifecycle.alarm_id); - ambient_lifecycle.alarm_id = 0; - } - - if (ambient_lifecycle.period_type != UI_APP_AMBIENT_UPDATE_NONE) - ret = __set_ambient_tick_cb(); - } - - return ret; -} - -int ui_app_ambient_get_update_period(ui_app_ambient_update_period_e *period) -{ - if (!period) { - LOGE("Invalid parameter"); - return -1; - } - - *period = ambient_lifecycle.period_type; - return 0; -} - -int ui_app_ambient_notify_event(ui_app_ambient_event_e event, bundle *extra) -{ - char buf[32]; - char appid_buf[APPID_BUFFER_MAX] = {0, }; - int ret; - bundle *envelope; - - if (extra == NULL) { - LOGE("extra data is null"); - envelope = bundle_create(); - } else { - envelope = bundle_dup(extra); - } - - if (envelope == NULL) { - LOGE("out of memory"); - return -1; - } - - snprintf(buf, sizeof(buf), "%d", event); - ret = bundle_add_str(envelope, "__APP_AMBIENT_EVENT__", buf); - if (ret != BUNDLE_ERROR_NONE) { - LOGE("bundle_add_str returns false"); - bundle_free(envelope); - return -1; - } - - if (aul_app_get_appid_bypid( - getpid(), appid_buf, sizeof(appid_buf)) != AUL_R_OK) { - LOGE("Failed to get appid (%d)", getpid()); - bundle_free(envelope); - return -1; - } - - ret = bundle_add_str(envelope, "__APP_AMBIENT_SENDER__", appid_buf); - if (ret != BUNDLE_ERROR_NONE) { - LOGE("bundle_add_str returns false"); - bundle_free(envelope); - return -1; - } - - ret = aul_app_com_send("aod.ambientevent", envelope); - if (ret != AUL_R_OK) { - LOGE("Failed aul_app_com_send"); - bundle_free(envelope); - return -1; - } - LOGI("Send AOD Event(%d) done", event); - - bundle_free(envelope); - return 0; -} \ No newline at end of file diff --git a/appcore_ui_app_ambient/src/ui_app_ambient.cc b/appcore_ui_app_ambient/src/ui_app_ambient.cc new file mode 100644 index 0000000..2f13c24 --- /dev/null +++ b/appcore_ui_app_ambient/src/ui_app_ambient.cc @@ -0,0 +1,343 @@ +/* + * Copyright (c) 2020 - 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "common_private.hh" +#include "log_private.hh" +#include "ui_app_ambient.h" + +namespace { + +constexpr const int SECOND = 1; +constexpr const int ONE_MINUTE_IN_SEC = 60; +constexpr const int MILLION = 1000000; // for calculating micro seconds + +struct AmbientTickTypeInfo { + int interval_; + int minute_base_; + int hour_base_; +}; + +AmbientTickTypeInfo ambient_tick_type_infos[] = { + { 0, 0 , 0}, + { ONE_MINUTE_IN_SEC, 1, 0 }, + { ONE_MINUTE_IN_SEC * 5, 5, 0 }, + { ONE_MINUTE_IN_SEC * 15, 15, 0 }, + { ONE_MINUTE_IN_SEC * 30, 30, 0 } +}; + +class UIAppAmbient { + public: + ~UIAppAmbient() {} + + int SetLifecycleCallback(ui_app_ambient_lifecycle_callback_s* callback, + void* user_data) { + if (initialized_) + return 0; + + callback_ = *callback; + user_data_ = user_data; + + int ret = aul_app_com_create("ui.ambientchange", nullptr, OnAppComCb, this, + &conn_); + if (ret != AUL_R_OK) { + _E("aul_app_com_create() is failed. error(%d)", ret); + return ret; + } + + initialized_ = true; + return 0; + } + + void UnsetLifecycleCallback() { + if (conn_) { + aul_app_com_leave(conn_); + conn_ = nullptr; + } + + if (alarm_id_) { + alarmmgr_remove_alarm(alarm_id_); + alarm_id_ = 0; + } + + callback_.ambient_changed = nullptr; + callback_.frame_updated = nullptr; + user_data_ = nullptr; + initialized_ = false; + } + + int SetUpdatePeriod(int period_type) { + period_type_ = period_type; + if (IsAmbientMode()) { + if (alarm_id_) { + alarmmgr_remove_alarm(alarm_id_); + alarm_id_ = 0; + } + + if (period_type != UI_APP_AMBIENT_UPDATE_NONE) + return SetAmbientTick(); + } + + return 0; + } + + int GetUpdatePeriod() { + return period_type_; + } + + int SendAmbientEvent(ui_app_ambient_event_e event, bundle* extra) { + int ret = SetAppId(); + if (ret != 0) + return ret; + + tizen_base::Bundle envelope(extra ? extra : bundle_create(), false, true); + envelope.Add("__APP_AMBIENT_EVENT__", std::to_string(event).c_str()); + envelope.Add("__APP_AMBIENT_SENDER__", app_id_.c_str()); + ret = aul_app_com_send("aod.ambientevent", envelope.GetHandle()); + if (ret != AUL_R_OK) { + _E("aul_app_com_send() is failed. error(%d)", ret); + return -1; + } + + _I("Send AOD Event(%d) done", event); + return 0; + } + + private: + static int OnAppComCb(const char* endpoint, aul_app_com_result_e result, + bundle* envelope, void* user_data) { + _E("OnAppComMessageReceived"); + const char* mode = bundle_get_val(envelope, "__AMBIENT_MODE__"); + if (mode == nullptr) + return -1; + + ui_app_ambient_state_e state = static_cast( + std::stoi(mode)); + + const char* extra = bundle_get_val(envelope, "__AMBIENT_EXTRA__"); + if (extra == nullptr) + return -1; + + tizen_base::Bundle b(extra); + + auto* handle = static_cast(user_data); + auto callback = handle->callback_; + if (callback.ambient_changed) + callback.ambient_changed(state, b.GetHandle(), handle->user_data_); + + if (state == UI_APP_AMBIENT_STATE_ENTER && !handle->IsAmbientMode()) { + int ret = handle->SetAmbientTick(); + if (ret != 0) + _E("Failed to set alarm"); + } else if (state == UI_APP_AMBIENT_STATE_LEAVE && handle->IsAmbientMode()) { + handle->UnsetAmbientTick(); + } + + return 0; + } + + static int AlarmCb(alarm_id_t id, void* user_data) { + _D("OnAmbientTick"); + auto* handle = static_cast(user_data); + if (handle->alarm_id_ == id) { + auto callback = handle->callback_; + callback.frame_updated(handle->user_data_); + } + + return 0; + } + + int SetAppId() { + if (app_id_.empty()) { + char appid[256] = { 0, }; + int ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid)); + if (ret != AUL_R_OK) { + _E("aul_app_get_appid_bypid() is failed. error(%d)", ret); + return ret; + } + + app_id_ = std::string(appid); + } + return 0; + } + + alarm_entry_t* GetAmbientTickAlarm(int period_type) { + alarm_entry_t* alarm_info = alarmmgr_create_alarm(); + if (alarm_info == nullptr) + return nullptr; + + std::unique_ptr ptr( + alarm_info, alarmmgr_free_alarm); + + struct timespec current_time; + clock_gettime(CLOCK_REALTIME, ¤t_time); + tzset(); + struct tm current_tm; + localtime_r(¤t_time.tv_sec, ¤t_tm); + + int offset = 0; + if (period_type == UI_APP_AMBIENT_UPDATE_FIVE_MINUTES || + period_type == UI_APP_AMBIENT_UPDATE_FIFTEEN_MINUTES || + period_type == UI_APP_AMBIENT_UPDATE_THIRTY_MINUTES) { + int minute_base = ambient_tick_type_infos[period_type].minute_base_; + int remain_min = minute_base - 1 - (current_tm.tm_min % minute_base); + offset = (remain_min * ONE_MINUTE_IN_SEC) + + (ONE_MINUTE_IN_SEC - current_tm.tm_sec); + } else if (period_type == UI_APP_AMBIENT_UPDATE_MINUTE) { + offset = ONE_MINUTE_IN_SEC - current_tm.tm_sec; + } + + struct tm next_tm; + time_t next = current_time.tv_sec + offset; + localtime_r(&next, &next_tm); + + alarm_date_t date = { 0, }; + date.year = next_tm.tm_year + 1900; + date.month = next_tm.tm_mon + 1; + date.day = next_tm.tm_mday; + date.hour = next_tm.tm_hour; + date.min = next_tm.tm_min; + date.sec = next_tm.tm_sec; + + alarmmgr_set_type(alarm_info, ALARM_TYPE_VOLATILE); + + int ret = alarmmgr_set_time(alarm_info, date); + if (ret != ALARMMGR_RESULT_SUCCESS) { + _E("alarmmgr_set_time() is failed. error(%d)", ret); + return nullptr; + } + + ret = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_REPEAT, + ambient_tick_type_infos[period_type].interval_); + if (ret != ALARMMGR_RESULT_SUCCESS) { + _E("alarmmgr_set_repeat_mode() is failed. error(%d)", ret); + return nullptr; + } + + LOGD("Next alarm tick [%d:%d:%d]", date.hour, date.min, date.sec); + return ptr.release(); + } + + int SetAmbientTick() { + if (period_type_ == UI_APP_AMBIENT_UPDATE_NONE && alarm_id_ == 0) { + _I("Default period is set [FIFTEEN_MINUTES]"); + period_type_ = UI_APP_AMBIENT_UPDATE_FIFTEEN_MINUTES; + } + + int ret = SetAppId(); + if (ret != 0) + return ret; + + ret = alarmmgr_init(app_id_.c_str()); + if (ret != ALARMMGR_RESULT_SUCCESS) + _E("alarmmgr_init() is failed. error(%d)", ret); + + alarm_entry_t* alarm_info = GetAmbientTickAlarm(period_type_); + if (alarm_info == nullptr) + return -1; + + ret = alarmmgr_add_alarm_withcb_with_localtime(alarm_info, AlarmCb, + this, &alarm_id_); + if (ret < 0) { + _E("alarmmgr_add_alarm_withcb_with_localtime() is failed. error(%d)", + ret); + } + + callback_.frame_updated(user_data_); + alarmmgr_free_alarm(alarm_info); + ambient_mode_ = true; + return 0; + } + + void UnsetAmbientTick() { + if (alarm_id_) { + alarmmgr_remove_alarm(alarm_id_); + alarm_id_ = 0; + } + + ambient_mode_ = false; + } + + bool IsAmbientMode() { + return ambient_mode_; + } + + private: + bool initialized_ = false; + std::string app_id_; + aul_app_com_connection_h conn_ = nullptr; + ui_app_ambient_lifecycle_callback_s callback_ = { 0, }; + void* user_data_ = nullptr; + bool ambient_mode_ = false; + int period_type_ = UI_APP_AMBIENT_UPDATE_NONE; + int alarm_id_ = 0; +}; + +UIAppAmbient context; + +} // namespace + +API int ui_app_ambient_set_lifecycle( + ui_app_ambient_lifecycle_callback_s* lifecycle, void* user_data) { + if (lifecycle == nullptr || + lifecycle->ambient_changed == nullptr || + lifecycle->frame_updated == nullptr) { + _E("Invalid parameter"); + return -1; + } + + return context.SetLifecycleCallback(lifecycle, user_data); +} + +API void ui_app_ambient_unset_lifecycle(void) { + context.UnsetLifecycleCallback(); +} + +API int ui_app_ambient_set_update_period( + ui_app_ambient_update_period_e period) { + _D("Period: %d", period); + return context.SetUpdatePeriod(period); +} + +API int ui_app_ambient_get_update_period( + ui_app_ambient_update_period_e* period) { + if (period == nullptr) { + _E("Invalid parameter"); + return -1; + } + + *period = static_cast( + context.GetUpdatePeriod()); + return 0; +} + +API int ui_app_ambient_notify_event(ui_app_ambient_event_e event, + bundle* extra) { + return context.SendAmbientEvent(event, extra); +} diff --git a/cmake/Modules/ApplyPkgConfig.cmake b/cmake/Modules/ApplyPkgConfig.cmake new file mode 100644 index 0000000..9b84be3 --- /dev/null +++ b/cmake/Modules/ApplyPkgConfig.cmake @@ -0,0 +1,35 @@ +# Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# +# This function applies external (out of source tree) dependencies +# to given target. Arguments are: +# TARGET - valid cmake target +# PRIVACY - dependency can be inherited by dependent targets or not: +# PUBLIC - this should be used by default, cause compile/link flags passing +# PRIVATE - do not passes any settings to dependent targets, +# may be usefull for static libraries from the inside of the project +# Argument ARGV2 and following are supposed to be names of checked pkg config +# packages. This function will use variables created by check_pkg_modules(). +# - ${DEP_NAME}_LIBRARIES +# - ${DEP_NAME}_INCLUDE_DIRS +# - ${DEP_NAME}_CFLAGS +# +FUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) + MATH(EXPR DEST_INDEX "${ARGC}-1") + FOREACH(I RANGE 2 ${DEST_INDEX}) + IF(NOT ${ARGV${I}}_FOUND) + MESSAGE(FATAL_ERROR "Not found dependency - ${ARGV${I}}_FOUND") + ENDIF(NOT ${ARGV${I}}_FOUND) + TARGET_LINK_LIBRARIES(${TARGET} ${PRIVACY} "${${ARGV${I}}_LIBRARIES}") + TARGET_INCLUDE_DIRECTORIES(${TARGET} ${PRIVACY} SYSTEM "${${ARGV${I}}_INCLUDE_DIRS}") + STRING(REPLACE ";" " " CFLAGS_STR "${${ARGV${I}}_CFLAGS}") + SET(CFLAGS_LIST ${CFLAGS_STR}) + SEPARATE_ARGUMENTS(CFLAGS_LIST) + FOREACH(OPTION ${CFLAGS_LIST}) + TARGET_COMPILE_OPTIONS(${TARGET} ${PRIVACY} ${OPTION}) + ENDFOREACH(OPTION) + SET_TARGET_PROPERTIES(${TARGET} PROPERTIES SKIP_BUILD_RPATH true) + ENDFOREACH(I RANGE 2 ${DEST_INDEX}) +ENDFUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) diff --git a/doc/appfw_app_control_doc.h b/doc/appfw_app_control_doc.h index c8c9d00..8e6b012 100755 --- a/doc/appfw_app_control_doc.h +++ b/doc/appfw_app_control_doc.h @@ -1,14 +1,14 @@ /* - * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2011 - 2021 Samsung Electronics Co., Ltd All Rights Reserved * - * Licensed under the Apache License, Version 2.0 (the License); + * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, + * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. diff --git a/include/app_internal.h b/include/app_internal.h index 3a71441..559951a 100644 --- a/include/app_internal.h +++ b/include/app_internal.h @@ -217,36 +217,6 @@ void app_exit(void); */ void app_efl_exit(void); -/** - * @brief Initialize the application main loop. - * - * @details After calling this function, the application main loop doesn't run. - * @since_tizen 3.0 - * @param[in] argc The argument count - * @param[in] argv The argument vector - * @param[in] callback The set of callback functions to handle application lifecycle events - * @param[in] user_data The user data to be passed to the callback functions - * @param[out] handle The appcore_context handle to be newly created on success - * - * @return 0 on success, otherwise a negative error value - * @retval #APP_ERROR_NONE Successful - * @retval #APP_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #APP_ERROR_INVALID_CONTEXT The application is illegally launched, not launched by the launch system - * @retval #APP_ERROR_ALREADY_RUNNING The main loop already starts - * @sett ui_app_fini() - */ -int ui_app_init(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data, appcore_context_h *handle); - -/** - * @brief Finalize the application main loop. - * - * @since_tizen 3.0 - * @param[in] handle The handle of appcore context - * - * @see ui_app_init() - */ -void ui_app_fini(appcore_context_h handle); - #ifdef __cplusplus } #endif diff --git a/mock/alarm_fake.h b/mock/alarm_fake.h deleted file mode 100644 index fa011c7..0000000 --- a/mock/alarm_fake.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef MOCK_ALAMR_H_ -#define MOCK_ALAMR_H_ - -#include - -#include "mock.h" - -DECLARE_FAKE_VALUE_FUNC(alarm_entry_t*, alarmmgr_create_alarm); -DECLARE_FAKE_VALUE_FUNC(int, alarmmgr_free_alarm, alarm_entry_t*); -DECLARE_FAKE_VALUE_FUNC(int, alarmmgr_init, const char*); -DECLARE_FAKE_VALUE_FUNC(int, alarmmgr_set_time, alarm_entry_t*, alarm_date_t); -DECLARE_FAKE_VALUE_FUNC(int, alarmmgr_set_repeat_mode, alarm_entry_t*, alarm_repeat_mode_t, int); -DECLARE_FAKE_VALUE_FUNC(int, alarmmgr_add_alarm_with_localtime, alarm_entry_t*, const char*, alarm_id_t*); - -#endif //MOCK_ALAMR_H_ diff --git a/mock/fff.h b/mock/fff.h deleted file mode 100644 index 6289a58..0000000 --- a/mock/fff.h +++ /dev/null @@ -1,6493 +0,0 @@ -/* -LICENSE - -The MIT License (MIT) - -Copyright (c) 2010 Michael Long - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ -#ifndef FAKE_FUNCTIONS -#define FAKE_FUNCTIONS - -#include -#include /* For memset and memcpy */ - -#define FFF_MAX_ARGS (20u) -#ifndef FFF_ARG_HISTORY_LEN - #define FFF_ARG_HISTORY_LEN (50u) -#endif -#ifndef FFF_CALL_HISTORY_LEN - #define FFF_CALL_HISTORY_LEN (50u) -#endif -/* -- INTERNAL HELPER MACROS -- */ -#define SET_RETURN_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \ - FUNCNAME##_fake.return_val_seq = ARRAY_POINTER; \ - FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN; -#define SET_CUSTOM_FAKE_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \ - FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER; \ - FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN; - -/* Defining a function to reset a fake function */ -#define RESET_FAKE(FUNCNAME) { \ - FUNCNAME##_reset(); \ -} \ - - -#define DECLARE_ARG(type, n, FUNCNAME) \ - type arg##n##_val; \ - type arg##n##_history[FFF_ARG_HISTORY_LEN]; - -#define DECLARE_ALL_FUNC_COMMON \ - unsigned int call_count; \ - unsigned int arg_history_len; \ - unsigned int arg_histories_dropped; \ - -#define DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - RETURN_TYPE return_val_history[FFF_ARG_HISTORY_LEN]; - -#define SAVE_ARG(FUNCNAME, n) \ - memcpy((void*)&FUNCNAME##_fake.arg##n##_val, (void*)&arg##n, sizeof(arg##n)); - -#define ROOM_FOR_MORE_HISTORY(FUNCNAME) \ - FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN - -#define SAVE_RET_HISTORY(FUNCNAME, RETVAL) \ - if ((FUNCNAME##_fake.call_count - 1) < FFF_ARG_HISTORY_LEN) \ - memcpy((void *)&FUNCNAME##_fake.return_val_history[FUNCNAME##_fake.call_count - 1], (const void *) &RETVAL, sizeof(RETVAL)); \ - -#define SAVE_ARG_HISTORY(FUNCNAME, ARGN) \ - memcpy((void*)&FUNCNAME##_fake.arg##ARGN##_history[FUNCNAME##_fake.call_count], (void*)&arg##ARGN, sizeof(arg##ARGN)); - -#define HISTORY_DROPPED(FUNCNAME) \ - FUNCNAME##_fake.arg_histories_dropped++ - -#define DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - RETURN_TYPE return_val; \ - int return_val_seq_len; \ - int return_val_seq_idx; \ - RETURN_TYPE * return_val_seq; \ - -#define DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - int custom_fake_seq_len; \ - int custom_fake_seq_idx; \ - -#define INCREMENT_CALL_COUNT(FUNCNAME) \ - FUNCNAME##_fake.call_count++ - -#define RETURN_FAKE_RESULT(FUNCNAME) \ - if (FUNCNAME##_fake.return_val_seq_len){ /* then its a sequence */ \ - if(FUNCNAME##_fake.return_val_seq_idx < FUNCNAME##_fake.return_val_seq_len) { \ - SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx]) \ - return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx++]; \ - } \ - SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]) \ - return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]; /* return last element */ \ - } \ - SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val) \ - return FUNCNAME##_fake.return_val; \ - -#ifdef __cplusplus - #define FFF_EXTERN_C extern "C"{ - #define FFF_END_EXTERN_C } -#else /* ansi c */ - #define FFF_EXTERN_C - #define FFF_END_EXTERN_C -#endif /* cpp/ansi c */ - -#define DEFINE_RESET_FUNCTION(FUNCNAME) \ - void FUNCNAME##_reset(void){ \ - memset(&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake)); \ - FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN; \ - } -/* -- END INTERNAL HELPER MACROS -- */ - -typedef void (*fff_function_t)(void); -typedef struct { - fff_function_t call_history[FFF_CALL_HISTORY_LEN]; - unsigned int call_history_idx; -} fff_globals_t; - -FFF_EXTERN_C -extern fff_globals_t fff; -FFF_END_EXTERN_C - -#define DEFINE_FFF_GLOBALS \ - FFF_EXTERN_C \ - fff_globals_t fff; \ - FFF_END_EXTERN_C - -#define FFF_RESET_HISTORY() \ - fff.call_history_idx = 0; \ - memset(fff.call_history, 0, sizeof(fff.call_history)); - -#define REGISTER_CALL(function) \ - if(fff.call_history_idx < FFF_CALL_HISTORY_LEN) \ - fff.call_history[fff.call_history_idx++] = (fff_function_t)function; - -#define DECLARE_FAKE_VOID_FUNC0(FUNCNAME) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(void); \ - void(**custom_fake_seq)(void); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(void); \ - -#define DEFINE_FAKE_VOID_FUNC0(FUNCNAME) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(void){ \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC0(FUNCNAME) \ - DECLARE_FAKE_VOID_FUNC0(FUNCNAME) \ - DEFINE_FAKE_VOID_FUNC0(FUNCNAME) \ - - -#define DECLARE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0); \ - void(**custom_fake_seq)(ARG0_TYPE arg0); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0); \ - -#define DEFINE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0){ \ - SAVE_ARG(FUNCNAME, 0); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ - DECLARE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ - DEFINE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - -#define DEFINE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - DECLARE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - DEFINE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - -#define DEFINE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - DECLARE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - DEFINE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - -#define DEFINE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - DECLARE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - DEFINE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - -#define DEFINE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - DECLARE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - DEFINE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - -#define DEFINE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - DECLARE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - DEFINE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - -#define DEFINE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - DECLARE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - DEFINE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - -#define DEFINE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - DECLARE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - DEFINE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - -#define DEFINE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - DECLARE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - DEFINE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - -#define DEFINE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - DECLARE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - DEFINE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - -#define DEFINE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - DECLARE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - DEFINE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - -#define DEFINE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - DECLARE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - DEFINE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - -#define DEFINE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - DECLARE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - DEFINE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - -#define DEFINE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - DECLARE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - DEFINE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - -#define DEFINE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - DECLARE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - DEFINE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - -#define DEFINE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - DECLARE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - DEFINE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - -#define DEFINE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - DECLARE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - DEFINE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - -#define DEFINE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - DECLARE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - DEFINE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - -#define DEFINE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - DECLARE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - DEFINE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ARG(ARG19_TYPE, 19, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - -#define DEFINE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - SAVE_ARG(FUNCNAME, 19); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - SAVE_ARG_HISTORY(FUNCNAME, 19); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - } \ - else{ \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - DECLARE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - DEFINE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(void); \ - RETURN_TYPE(**custom_fake_seq)(void); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(void); \ - -#define DEFINE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(void){ \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ - DECLARE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ - DEFINE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \ - - -#define DECLARE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0); \ - -#define DEFINE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0){ \ - SAVE_ARG(FUNCNAME, 0); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ - DECLARE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ - DEFINE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \ - -#define DEFINE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - DECLARE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - DEFINE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \ - -#define DEFINE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - DECLARE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - DEFINE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \ - -#define DEFINE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - DECLARE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - DEFINE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \ - -#define DEFINE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - DECLARE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - DEFINE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \ - -#define DEFINE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - DECLARE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - DEFINE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \ - -#define DEFINE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - DECLARE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - DEFINE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \ - -#define DEFINE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - DECLARE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - DEFINE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \ - -#define 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) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#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) \ - DECLARE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \ - 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) \ - - -#define DECLARE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \ - -#define DEFINE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - DECLARE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - DEFINE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \ - -#define DEFINE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - DECLARE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - DEFINE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \ - -#define DEFINE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - DECLARE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - DEFINE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \ - -#define DEFINE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - DECLARE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - DEFINE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \ - -#define DEFINE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - DECLARE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - DEFINE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \ - -#define DEFINE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - DECLARE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - DEFINE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \ - -#define DEFINE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - DECLARE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - DEFINE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \ - -#define DEFINE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - DECLARE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - DEFINE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \ - -#define DEFINE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - DECLARE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - DEFINE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \ - -#define DEFINE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - DECLARE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - DEFINE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \ - - -#define DECLARE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ARG(ARG19_TYPE, 19, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \ - -#define DEFINE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - SAVE_ARG(FUNCNAME, 19); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - SAVE_ARG_HISTORY(FUNCNAME, 19); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - else{ \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - } \ - } \ - if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - DECLARE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - DEFINE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \ - - -#define DECLARE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ...); \ - -#define DEFINE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg0); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg0); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg0); \ - FUNCNAME##_fake.custom_fake(arg0, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \ - -#define DEFINE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg1); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg1); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg1); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \ - -#define DEFINE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg2); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg2); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg2); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \ - -#define DEFINE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg3); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg3); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg3); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \ - -#define DEFINE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg4); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg4); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg4); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \ - -#define DEFINE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg5); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg5); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg5); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \ - -#define DEFINE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg6); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg6); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg6); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \ - -#define DEFINE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg7); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg7); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg7); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \ - -#define DEFINE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg8); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg8); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg8); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \ - -#define DEFINE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg9); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg9); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg9); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \ - -#define DEFINE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg10); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg10); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg10); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \ - -#define DEFINE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg11); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg11); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg11); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \ - -#define DEFINE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg12); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg12); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg12); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \ - -#define DEFINE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg13); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg13); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg13); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \ - -#define DEFINE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg14); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg14); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg14); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \ - -#define DEFINE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg15); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg15); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg15); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \ - -#define DEFINE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg16); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg16); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg16); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \ - -#define DEFINE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg17); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg17); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg17); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - - -#define DECLARE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \ - void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \ - -#define DEFINE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg18); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - va_end(ap); \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg18); \ - FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - va_end(ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - va_list ap; \ - va_start(ap, arg18); \ - FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - va_end(ap); \ - } \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - DECLARE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - DEFINE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg0); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg0); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg0); \ - ret = FUNCNAME##_fake.custom_fake(arg0, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg1); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg1); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg1); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg2); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg2); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg2); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg3); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg3); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg3); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg4); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg4); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg4); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg5); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg5); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg5); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg6); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg6); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg6); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg7); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg7); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg7); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg8); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg8); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg8); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg9); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg9); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg9); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg10); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg10); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg10); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg11); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg11); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg11); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg12); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg12); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg12); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg13); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg13); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg13); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg14); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg14); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg14); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg15); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg15); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg15); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg16); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg16); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg16); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg17); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg17); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg17); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \ - - -#define DECLARE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - typedef struct FUNCNAME##_Fake { \ - DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \ - DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \ - DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \ - DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \ - DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \ - DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \ - DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \ - DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \ - DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \ - DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \ - DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \ - DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \ - DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \ - DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \ - DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \ - DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \ - DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \ - DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \ - DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \ - DECLARE_ALL_FUNC_COMMON \ - DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \ - DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \ - DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \ - RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \ - RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \ - } FUNCNAME##_Fake; \ - extern FUNCNAME##_Fake FUNCNAME##_fake; \ - void FUNCNAME##_reset(void); \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \ - -#define DEFINE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - FUNCNAME##_Fake FUNCNAME##_fake; \ - RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \ - SAVE_ARG(FUNCNAME, 0); \ - SAVE_ARG(FUNCNAME, 1); \ - SAVE_ARG(FUNCNAME, 2); \ - SAVE_ARG(FUNCNAME, 3); \ - SAVE_ARG(FUNCNAME, 4); \ - SAVE_ARG(FUNCNAME, 5); \ - SAVE_ARG(FUNCNAME, 6); \ - SAVE_ARG(FUNCNAME, 7); \ - SAVE_ARG(FUNCNAME, 8); \ - SAVE_ARG(FUNCNAME, 9); \ - SAVE_ARG(FUNCNAME, 10); \ - SAVE_ARG(FUNCNAME, 11); \ - SAVE_ARG(FUNCNAME, 12); \ - SAVE_ARG(FUNCNAME, 13); \ - SAVE_ARG(FUNCNAME, 14); \ - SAVE_ARG(FUNCNAME, 15); \ - SAVE_ARG(FUNCNAME, 16); \ - SAVE_ARG(FUNCNAME, 17); \ - SAVE_ARG(FUNCNAME, 18); \ - if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \ - SAVE_ARG_HISTORY(FUNCNAME, 0); \ - SAVE_ARG_HISTORY(FUNCNAME, 1); \ - SAVE_ARG_HISTORY(FUNCNAME, 2); \ - SAVE_ARG_HISTORY(FUNCNAME, 3); \ - SAVE_ARG_HISTORY(FUNCNAME, 4); \ - SAVE_ARG_HISTORY(FUNCNAME, 5); \ - SAVE_ARG_HISTORY(FUNCNAME, 6); \ - SAVE_ARG_HISTORY(FUNCNAME, 7); \ - SAVE_ARG_HISTORY(FUNCNAME, 8); \ - SAVE_ARG_HISTORY(FUNCNAME, 9); \ - SAVE_ARG_HISTORY(FUNCNAME, 10); \ - SAVE_ARG_HISTORY(FUNCNAME, 11); \ - SAVE_ARG_HISTORY(FUNCNAME, 12); \ - SAVE_ARG_HISTORY(FUNCNAME, 13); \ - SAVE_ARG_HISTORY(FUNCNAME, 14); \ - SAVE_ARG_HISTORY(FUNCNAME, 15); \ - SAVE_ARG_HISTORY(FUNCNAME, 16); \ - SAVE_ARG_HISTORY(FUNCNAME, 17); \ - SAVE_ARG_HISTORY(FUNCNAME, 18); \ - } \ - else{ \ - HISTORY_DROPPED(FUNCNAME); \ - } \ - INCREMENT_CALL_COUNT(FUNCNAME); \ - REGISTER_CALL(FUNCNAME); \ - if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \ - if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \ - va_list ap; \ - va_start(ap, arg18); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - } \ - else{ \ - va_list ap; \ - va_start(ap, arg18); \ - RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - va_end(ap); \ - return ret; \ - return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - } \ - } \ - if(FUNCNAME##_fake.custom_fake){ \ - RETURN_TYPE ret; \ - va_list ap; \ - va_start(ap, arg18); \ - ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \ - va_end(ap); \ - SAVE_RET_HISTORY(FUNCNAME, ret); \ - return ret; \ - } \ - RETURN_FAKE_RESULT(FUNCNAME) \ - } \ - DEFINE_RESET_FUNCTION(FUNCNAME) \ - -#define FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - DECLARE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - DEFINE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \ - -/* MSVC expand macro fix */ -#define EXPAND(x) x - -#define PP_NARG_MINUS2(...) EXPAND(PP_NARG_MINUS2_(__VA_ARGS__, PP_RSEQ_N_MINUS2())) - -#define PP_NARG_MINUS2_(...) EXPAND(PP_ARG_MINUS2_N(__VA_ARGS__)) - -#define PP_ARG_MINUS2_N(returnVal, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, N, ...) N - -#define PP_RSEQ_N_MINUS2() 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 - -#define PP_NARG_MINUS1(...) EXPAND(PP_NARG_MINUS1_(__VA_ARGS__, PP_RSEQ_N_MINUS1())) - -#define PP_NARG_MINUS1_(...) EXPAND(PP_ARG_MINUS1_N(__VA_ARGS__)) - -#define PP_ARG_MINUS1_N( _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, N, ...) N - -#define PP_RSEQ_N_MINUS1() 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 - - - -/* DECLARE AND DEFINE FAKE FUNCTIONS - PLACE IN TEST FILES */ - -#define FAKE_VALUE_FUNC(...) EXPAND(FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define FUNC_VALUE_(N,...) EXPAND(FUNC_VALUE_N(N,__VA_ARGS__)) - -#define FUNC_VALUE_N(N,...) EXPAND(FAKE_VALUE_FUNC ## N(__VA_ARGS__)) - - -#define FAKE_VOID_FUNC(...) EXPAND(FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define FUNC_VOID_(N,...) EXPAND(FUNC_VOID_N(N,__VA_ARGS__)) - -#define FUNC_VOID_N(N,...) EXPAND(FAKE_VOID_FUNC ## N(__VA_ARGS__)) - - -#define FAKE_VALUE_FUNC_VARARG(...) EXPAND(FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define FUNC_VALUE_VARARG_(N,...) EXPAND(FUNC_VALUE_VARARG_N(N,__VA_ARGS__)) - -#define FUNC_VALUE_VARARG_N(N,...) EXPAND(FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__)) - - -#define FAKE_VOID_FUNC_VARARG(...) EXPAND(FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define FUNC_VOID_VARARG_(N,...) EXPAND(FUNC_VOID_VARARG_N(N,__VA_ARGS__)) - -#define FUNC_VOID_VARARG_N(N,...) EXPAND(FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__)) - - - -/* DECLARE FAKE FUNCTIONS - PLACE IN HEADER FILES */ - -#define DECLARE_FAKE_VALUE_FUNC(...) EXPAND(DECLARE_FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define DECLARE_FUNC_VALUE_(N,...) EXPAND(DECLARE_FUNC_VALUE_N(N,__VA_ARGS__)) - -#define DECLARE_FUNC_VALUE_N(N,...) EXPAND(DECLARE_FAKE_VALUE_FUNC ## N(__VA_ARGS__)) - - -#define DECLARE_FAKE_VOID_FUNC(...) EXPAND(DECLARE_FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define DECLARE_FUNC_VOID_(N,...) EXPAND(DECLARE_FUNC_VOID_N(N,__VA_ARGS__)) - -#define DECLARE_FUNC_VOID_N(N,...) EXPAND(DECLARE_FAKE_VOID_FUNC ## N(__VA_ARGS__)) - - -#define DECLARE_FAKE_VALUE_FUNC_VARARG(...) EXPAND(DECLARE_FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define DECLARE_FUNC_VALUE_VARARG_(N,...) EXPAND(DECLARE_FUNC_VALUE_VARARG_N(N,__VA_ARGS__)) - -#define DECLARE_FUNC_VALUE_VARARG_N(N,...) EXPAND(DECLARE_FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__)) - - -#define DECLARE_FAKE_VOID_FUNC_VARARG(...) EXPAND(DECLARE_FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define DECLARE_FUNC_VOID_VARARG_(N,...) EXPAND(DECLARE_FUNC_VOID_VARARG_N(N,__VA_ARGS__)) - -#define DECLARE_FUNC_VOID_VARARG_N(N,...) EXPAND(DECLARE_FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__)) - - - -/* DEFINE FAKE FUNCTIONS - PLACE IN SOURCE FILES */ - -#define DEFINE_FAKE_VALUE_FUNC(...) EXPAND(DEFINE_FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define DEFINE_FUNC_VALUE_(N,...) EXPAND(DEFINE_FUNC_VALUE_N(N,__VA_ARGS__)) - -#define DEFINE_FUNC_VALUE_N(N,...) EXPAND(DEFINE_FAKE_VALUE_FUNC ## N(__VA_ARGS__)) - - -#define DEFINE_FAKE_VOID_FUNC(...) EXPAND(DEFINE_FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define DEFINE_FUNC_VOID_(N,...) EXPAND(DEFINE_FUNC_VOID_N(N,__VA_ARGS__)) - -#define DEFINE_FUNC_VOID_N(N,...) EXPAND(DEFINE_FAKE_VOID_FUNC ## N(__VA_ARGS__)) - - -#define DEFINE_FAKE_VALUE_FUNC_VARARG(...) EXPAND(DEFINE_FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__)) - -#define DEFINE_FUNC_VALUE_VARARG_(N,...) EXPAND(DEFINE_FUNC_VALUE_VARARG_N(N,__VA_ARGS__)) - -#define DEFINE_FUNC_VALUE_VARARG_N(N,...) EXPAND(DEFINE_FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__)) - - -#define DEFINE_FAKE_VOID_FUNC_VARARG(...) EXPAND(DEFINE_FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__)) - -#define DEFINE_FUNC_VOID_VARARG_(N,...) EXPAND(DEFINE_FUNC_VOID_VARARG_N(N,__VA_ARGS__)) - -#define DEFINE_FUNC_VOID_VARARG_N(N,...) EXPAND(DEFINE_FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__)) - - - - -#endif /* FAKE_FUNCTIONS */ diff --git a/mock/mock.cc b/mock/mock.cc deleted file mode 100644 index 2990ed6..0000000 --- a/mock/mock.cc +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "aul_fake.h" -#include "alarm_fake.h" -#include "mock.h" - -DEFINE_FFF_GLOBALS; - -/* aul.h */ -DEFINE_FAKE_VALUE_FUNC(int, aul_app_get_appid_bypid, int, char*, int); -DEFINE_FAKE_VALUE_FUNC(int, aul_app_com_create, const char*, aul_app_com_permission_h, app_com_cb, void *, aul_app_com_connection_h*); -DEFINE_FAKE_VALUE_FUNC(int, aul_app_com_send, const char*, bundle*); - -/* alarm.h */ -DEFINE_FAKE_VALUE_FUNC(alarm_entry_t*, alarmmgr_create_alarm); -DEFINE_FAKE_VALUE_FUNC(int, alarmmgr_free_alarm, alarm_entry_t*); -DEFINE_FAKE_VALUE_FUNC(int, alarmmgr_init, const char*); -DEFINE_FAKE_VALUE_FUNC(int, alarmmgr_set_time, alarm_entry_t*, alarm_date_t); -DEFINE_FAKE_VALUE_FUNC(int, alarmmgr_set_repeat_mode, alarm_entry_t*, alarm_repeat_mode_t, int); -DEFINE_FAKE_VALUE_FUNC(int, alarmmgr_add_alarm_with_localtime, alarm_entry_t*, const char*, alarm_id_t*); \ No newline at end of file diff --git a/packaging/capi-appfw-application.spec b/packaging/capi-appfw-application.spec index 66d3f06..9b32df0 100644 --- a/packaging/capi-appfw-application.spec +++ b/packaging/capi-appfw-application.spec @@ -7,27 +7,23 @@ License: Apache-2.0 Source0: %{name}-%{version}.tar.gz Source1001: capi-appfw-application.manifest Source1002: appcore-ui-app-ambient.manifest + BuildRequires: cmake -BuildRequires: pkgconfig(dlog) -BuildRequires: pkgconfig(bundle) -BuildRequires: pkgconfig(appcore-common) -BuildRequires: pkgconfig(appcore-efl) -BuildRequires: pkgconfig(aul) BuildRequires: pkgconfig(alarm-service) -BuildRequires: pkgconfig(appsvc) -BuildRequires: pkgconfig(elementary) -BuildRequires: pkgconfig(capi-base-common) -BuildRequires: pkgconfig(capi-appfw-app-control) +BuildRequires: pkgconfig(app-core-efl-cpp) +BuildRequires: pkgconfig(aul) +BuildRequires: pkgconfig(bundle) BuildRequires: pkgconfig(capi-appfw-app-common) -BuildRequires: pkgconfig(sqlite3) +BuildRequires: pkgconfig(capi-appfw-app-control) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(elementary) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(gmock) BuildRequires: pkgconfig(libtzplatform-config) BuildRequires: pkgconfig(vconf-internal-keys) -BuildRequires: pkgconfig(eventsystem) -BuildRequires: pkgconfig(pkgmgr-info) -BuildRequires: pkgconfig(glib-2.0) %if 0%{?gcov:1} -BuildRequires: pkgconfig(gmock) BuildRequires: lcov BuildRequires: zip %endif @@ -87,7 +83,8 @@ find . -name '*.gcno' -exec cp '{}' gcov-obj ';' %endif %check -(cd unittest && ctest -V --output-on-failure) +export LD_LIBRARY_PATH="../../appcore_ui_app_ambient" +ctest --verbose %{?_smp_mflags} %if 0%{?gcov:1} lcov -c --ignore-errors graph --no-external -q -d . -o appcore_ui_app_ambient.info genhtml appcore_ui_app_ambient.info -o appcore_ui_app_ambient.out @@ -146,6 +143,7 @@ Header & package configuration of appcore-ui-app-ambient %manifest appcore-ui-app-ambient.manifest %license LICENSE %{_libdir}/libappcore-ui-app-ambient.so.* +%{_bindir}/ui-app-ambient_unittests %files -n appcore-ui-app-ambient-devel %{_includedir}/appcore-ui-app-ambient/*.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 5373be6..14c50a5 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,66 +1,25 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -SET(fw_name "capi-appfw-application") - -PROJECT(${fw_name}) - -SET(CMAKE_INSTALL_PREFIX /usr) -SET(PREFIX ${CMAKE_INSTALL_PREFIX}) - -SET(INC_DIR ${CMAKE_SOURCE_DIR}/include) -INCLUDE_DIRECTORIES(${INC_DIR}) - -SET(requires "dlog bundle appcore-common appcore-efl aul capi-base-common capi-appfw-app-common capi-appfw-app-control libtzplatform-config pkgmgr-info glib-2.0") -SET(pc_requires "capi-base-common vconf-internal-keys capi-appfw-app-control capi-appfw-app-common libtzplatform-config") - -INCLUDE(FindPkgConfig) -pkg_check_modules(${fw_name} REQUIRED ${requires}) -FOREACH(flag ${${fw_name}_CFLAGS}) - SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag} -Werror") -ENDFOREACH(flag) - -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC ") -SET(CMAKE_C_FLAGS_DEBUG "-O0 -g -Wall -Werror") - -IF("${ARCH}" STREQUAL "arm") - ADD_DEFINITIONS("-DTARGET") -ENDIF("${ARCH}" STREQUAL "arm") - -ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") -ADD_DEFINITIONS("-DSLP_DEBUG") - -SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}") - -ADD_LIBRARY(${fw_name} SHARED - app_device.c - app_main.c - app_main_legacy.c - app_resource.c - ) - -TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS} capi-appfw-app-common capi-appfw-app-control) - -SET_TARGET_PROPERTIES(${fw_name} - PROPERTIES - VERSION ${FULLVER} - SOVERSION ${MAJORVER} - CLEAN_DIRECT_OUTPUT 1 +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APPLICATION_SRCS) + +ADD_LIBRARY(${TARGET_APPLICATION} SHARED ${APPLICATION_SRCS}) + +SET_TARGET_PROPERTIES(${TARGET_APPLICATION} PROPERTIES SOVERSION ${MAJORVER}) +SET_TARGET_PROPERTIES(${TARGET_APPLICATION} PROPERTIES VERSION ${FULLVER}) + +TARGET_INCLUDE_DIRECTORIES(${TARGET_APPLICATION} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/../ + ${CMAKE_CURRENT_SOURCE_DIR}/../include/) + +APPLY_PKG_CONFIG(${TARGET_APPLICATION} PUBLIC + APP_CORE_EFL_CPP_DEPS + AUL_DEPS + BUNDLE_DEPS + CAPI_APPFW_APP_COMMON_DEPS + CAPI_APPFW_APP_CONTROL_DEPS + CAPI_BASE_COMMON_DEPS + DLOG_DEPS + GLIB_DEPS + LIBTZPLATFORM_CONFIG_DEPS ) -INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR}) -INSTALL( - DIRECTORY ${INC_DIR}/ DESTINATION include/appfw - FILES_MATCHING - PATTERN "*_private.h" EXCLUDE - PATTERN "${INC_DIR}/*.h" - ) - -SET(PC_NAME ${fw_name}) -SET(PC_REQUIRED ${pc_requires}) -SET(PC_LDFLAGS -l${fw_name}) - -CONFIGURE_FILE( - ${CMAKE_SOURCE_DIR}/${fw_name}.pc.in - ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc - @ONLY -) -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) +INSTALL(TARGETS ${TARGET_APPLICATION} DESTINATION ${LIB_INSTALL_DIR}) diff --git a/src/app_device.c b/src/app_device.c deleted file mode 100644 index 07fafb9..0000000 --- a/src/app_device.c +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the License); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "CAPI_APPFW_APPLICATION" - -/* LCOV_EXCL_START */ -static app_device_orientation_e __convert_appcore_rm(int rm) -{ - app_device_orientation_e dev_orientation; - - switch (rm) { - case APPCORE_BASE_RM_PORTRAIT_NORMAL: - dev_orientation = APP_DEVICE_ORIENTATION_0; - break; - case APPCORE_BASE_RM_PORTRAIT_REVERSE: - dev_orientation = APP_DEVICE_ORIENTATION_180; - break; - case APPCORE_BASE_RM_LANDSCAPE_NORMAL: - dev_orientation = APP_DEVICE_ORIENTATION_270; - break; - case APPCORE_BASE_RM_LANDSCAPE_REVERSE: - dev_orientation = APP_DEVICE_ORIENTATION_90; - break; - default: - dev_orientation = APP_DEVICE_ORIENTATION_0; - break; - } - - return dev_orientation; -} -/* LCOV_EXCL_STOP */ - -app_device_orientation_e app_get_device_orientation(void) -{ - enum appcore_base_rm rm; - app_device_orientation_e dev_orientation = APP_DEVICE_ORIENTATION_0; - - if (appcore_base_get_rotation_state(&rm) == 0) - dev_orientation = __convert_appcore_rm(rm); - - return dev_orientation; -} - diff --git a/src/app_device.cc b/src/app_device.cc new file mode 100644 index 0000000..0a4f322 --- /dev/null +++ b/src/app_device.cc @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2011 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "app_internal.h" +#include "common_private.hh" + +using namespace tizen_cpp; + +namespace { + +/* LCOV_EXCL_START */ +app_device_orientation_e AppCoreRmConvert(int rm) { + switch (rm) { + case AppCoreBase::ROTATION_PORTRAIT_NORMAL: + return APP_DEVICE_ORIENTATION_0; + case AppCoreBase::ROTATION_PORTRAIT_REVERSE: + return APP_DEVICE_ORIENTATION_180; + case AppCoreBase::ROTATION_LANDSCAPE_NORMAL: + return APP_DEVICE_ORIENTATION_270; + case AppCoreBase::ROTATION_LANDSCAPE_REVERSE: + return APP_DEVICE_ORIENTATION_90; + default: + return APP_DEVICE_ORIENTATION_0; + } +} +/* LCOV_EXCL_STOP */ + +} // namespace + +API app_device_orientation_e app_get_device_orientation(void) { + app_device_orientation_e dev_orientation = APP_DEVICE_ORIENTATION_0; + + try { + AppCoreBase::RotationState s = AppCoreBase::GetRotationState(); + dev_orientation = AppCoreRmConvert(s); + } catch (const std::runtime_error& e) { + return APP_DEVICE_ORIENTATION_0; + } + + return dev_orientation; +} diff --git a/src/app_main.c b/src/app_main.c deleted file mode 100755 index 5dcefe1..0000000 --- a/src/app_main.c +++ /dev/null @@ -1,295 +0,0 @@ -/* - * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the License); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include - -#include "app_extension.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "CAPI_APPFW_APPLICATION" - -#define UI_APP_EVENT_MAX 7 - -typedef enum { - APP_STATE_NOT_RUNNING, /* The application has been launched or was running but was terminated */ - APP_STATE_CREATING, /* The application is initializing the resources on app_create_cb callback */ - APP_STATE_RUNNING, /* The application is running in the foreground and background */ -} app_state_e; - -struct app_event_handler { - app_event_type_e type; - app_event_cb cb; - void *data; - void *raw; -}; - -struct app_event_info { - app_event_type_e type; - void *value; -}; - -struct ui_app_context { - ui_app_lifecycle_callback_s callback; - void *data; -}; - -static struct ui_app_context __context; -static app_state_e __app_state = APP_STATE_NOT_RUNNING; - -static int __app_event_converter[APPCORE_BASE_EVENT_MAX] = { - [APP_EVENT_LOW_MEMORY] = APPCORE_BASE_EVENT_LOW_MEMORY, - [APP_EVENT_LOW_BATTERY] = APPCORE_BASE_EVENT_LOW_BATTERY, - [APP_EVENT_LANGUAGE_CHANGED] = APPCORE_BASE_EVENT_LANG_CHANGE, - [APP_EVENT_DEVICE_ORIENTATION_CHANGED] = APPCORE_BASE_EVENT_DEVICE_ORIENTATION_CHANGED, - [APP_EVENT_REGION_FORMAT_CHANGED] = APPCORE_BASE_EVENT_REGION_CHANGE, - [APP_EVENT_SUSPENDED_STATE_CHANGED] = APPCORE_BASE_EVENT_SUSPENDED_STATE_CHANGE, - [APP_EVENT_UPDATE_REQUESTED] = APPCORE_BASE_EVENT_UPDATE_REQUESTED, -}; - -static int __ui_app_create(void *data) -{ - LOGW("ui_app_create()"); - appcore_efl_base_on_create(); - if (__context.callback.create == NULL || - __context.callback.create(__context.data) == false) - return app_error(APP_ERROR_INVALID_CONTEXT, __FUNCTION__, "app_create_cb() returns false"); - - return APP_ERROR_NONE; -} - -static int __ui_app_terminate(void *data) -{ - LOGW("ui_app_terminate()"); - appcore_efl_base_on_terminate(); - - if (__context.callback.terminate) - __context.callback.terminate(__context.data); - - return APP_ERROR_NONE; -} - -static int __ui_app_control(bundle *b, void *data) -{ - app_control_h app_control = NULL; - - LOGW("ui_app_control()"); - appcore_efl_base_on_control(b); - - if (b) { - if (app_control_create_event(b, &app_control) != APP_ERROR_NONE) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "Failed to create an app_control handle"); - } else { - if (app_control_create(&app_control) != APP_ERROR_NONE) - return app_error(APP_ERROR_OUT_OF_MEMORY, __FUNCTION__, "Failed to create an app_control handle"); - } - - if (__context.callback.app_control) - __context.callback.app_control(app_control, __context.data); - - app_control_destroy(app_control); - - return APP_ERROR_NONE; -} - -static int __ui_app_pause(void *data) -{ - LOGW("ui_app_pause()"); - appcore_efl_base_on_pause(); - if (__context.callback.pause) - __context.callback.pause(__context.data); - return APP_ERROR_NONE; -} - -static int __ui_app_resume(void *data) -{ - LOGW("ui_app_resume"); - appcore_efl_base_on_resume(); - if (__context.callback.resume) - __context.callback.resume(__context.data); - return APP_ERROR_NONE; -} - -static int __app_init(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data, appcore_efl_base_ops ops) -{ - int ret; - - if (argc < 1 || argv == NULL || callback == NULL) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); - - if (callback->create == NULL) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "app_create_cb() callback must be registered"); - - if (__app_state != APP_STATE_NOT_RUNNING) - return app_error(APP_ERROR_ALREADY_RUNNING, __FUNCTION__, NULL); - - __context.callback = *callback; - __context.data = user_data; - __app_state = APP_STATE_CREATING; - - ret = appcore_efl_base_init(ops, argc, argv, NULL, - APPCORE_EFL_BASE_HINT_WINDOW_GROUP_CONTROL | - APPCORE_EFL_BASE_HINT_WINDOW_STACK_CONTROL | - APPCORE_EFL_BASE_HINT_BG_LAUNCH_CONTROL | - APPCORE_EFL_BASE_HINT_HW_ACC_CONTROL | - APPCORE_EFL_BASE_HINT_WINDOW_AUTO_CONTROL | - APPCORE_EFL_BASE_HINT_LEGACY_CONTROL | - APPCORE_EFL_BASE_HINT_WINDOW_ID_CONTROL); - - if (ret < 0) { - __app_state = APP_STATE_NOT_RUNNING; - return app_error(APP_ERROR_INVALID_CONTEXT, __FUNCTION__, NULL); - } - - return APP_ERROR_NONE; -} - -static void __app_fini(void) -{ - appcore_efl_base_fini(); - __app_state = APP_STATE_NOT_RUNNING; - -} - -int ui_app_init(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data, appcore_context_h *handle) -{ - appcore_efl_base_ops ops = appcore_efl_base_get_default_ops(); - - LOGW("ui_app_init()"); - /* override methods */ - ops.ui_base.base.create = __ui_app_create; - ops.ui_base.base.control = __ui_app_control; - ops.ui_base.base.terminate = __ui_app_terminate; - ops.ui_base.pause = __ui_app_pause; - ops.ui_base.resume = __ui_app_resume; - ops.ui_base.base.run = NULL; - ops.ui_base.base.exit = NULL; - - return __app_init(argc, argv, callback, user_data, ops); -} - -void ui_app_fini(appcore_context_h handle) -{ - LOGW("ui_app_fini()"); - __app_fini(); -} - -int ui_app_main(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data) -{ - int ret; - appcore_efl_base_ops ops = appcore_efl_base_get_default_ops(); - - LOGW("ui_app_main()"); - /* override methods */ - ops.ui_base.base.create = __ui_app_create; - ops.ui_base.base.control = __ui_app_control; - ops.ui_base.base.terminate = __ui_app_terminate; - ops.ui_base.pause = __ui_app_pause; - ops.ui_base.resume = __ui_app_resume; - - ret = __app_init(argc, argv, callback, user_data, ops); - if (ret != APP_ERROR_NONE) - return ret; - - __app_fini(); - - return APP_ERROR_NONE; -} - -void ui_app_exit(void) -{ - LOGW("ui_app_exit()"); - appcore_efl_base_exit(); -} - -int __event_cb(void *event, void *data) -{ - app_event_handler_h handler = data; - - struct app_event_info app_event; - - app_event.type = handler->type; - app_event.value = event; - - if (handler->cb) - handler->cb(&app_event, handler->data); - - return 0; -} - -int ui_app_add_event_handler(app_event_handler_h *event_handler, app_event_type_e event_type, app_event_cb callback, void *user_data) -{ - app_event_handler_h handler; - - if (event_handler == NULL || callback == NULL) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "null parameter"); - - if (event_type < APP_EVENT_LOW_MEMORY || event_type > APP_EVENT_UPDATE_REQUESTED) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "invalid event type"); - - handler = calloc(1, sizeof(struct app_event_handler)); - if (!handler) - return app_error(APP_ERROR_OUT_OF_MEMORY, __FUNCTION__, "failed to create handler"); - - handler->type = event_type; - handler->cb = callback; - handler->data = user_data; - handler->raw = appcore_base_add_event(__app_event_converter[event_type], __event_cb, handler); - - *event_handler = handler; - - return APP_ERROR_NONE; -} - -int ui_app_remove_event_handler(app_event_handler_h event_handler) -{ - int ret; - app_event_type_e type; - - if (event_handler == NULL) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "handler is null"); - - type = event_handler->type; - if (type < APP_EVENT_LOW_MEMORY || type > APP_EVENT_UPDATE_REQUESTED) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "invalid handler"); - - - ret = appcore_base_remove_event(event_handler->raw); - if (ret < 0) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, "invalid raw handler"); - - free(event_handler); - - return APP_ERROR_NONE; -} - diff --git a/src/app_main.cc b/src/app_main.cc new file mode 100644 index 0000000..771d0ea --- /dev/null +++ b/src/app_main.cc @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2011 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "app_internal.h" +#include "common_private.hh" +#include "log_private.hh" + +namespace { + +using namespace tizen_cpp; + +class UiAppContext : public AppCoreEflBase { + public: + enum AppState { + APP_STATE_NOT_RUNNING, + APP_STATE_CREATING, + APP_STATE_RUNNING, + }; + + UiAppContext(ui_app_lifecycle_callback_s callback, void* data, + unsigned int hint) + : AppCoreEflBase(hint), callback_(callback), data_(data) { + SetAppState(APP_STATE_CREATING); + } + + void Run(int argc, char** argv) override { + SetAppState(APP_STATE_RUNNING); + AppCoreEflBase::Run(argc, argv); + SetAppState(APP_STATE_NOT_RUNNING); + } + + int OnCreate() override { + LOGW("ui_app_create()"); + if (callback_.create == nullptr || callback_.create(data_) == false) + return app_error(APP_ERROR_INVALID_CONTEXT, __FUNCTION__, + "app_create_cb() returns false"); + AppCoreEflBase::OnCreate(); + + return APP_ERROR_NONE; + } + + int OnControl(tizen_base::Bundle b) override { + app_control_h app_control = nullptr; + + LOGW("ui_app_control()"); + AppCoreEflBase::OnControl(b); + + if (b.GetHandle()) { + int ret = app_control_create_event(b.GetHandle(), &app_control); + if (ret != APP_ERROR_NONE) { + _E("Failed to create an app_control handle"); + return APP_ERROR_INVALID_PARAMETER; + } + } else { + if (app_control_create(&app_control) != APP_ERROR_NONE) { + _E("Failed to create an app_control handle"); + return APP_ERROR_OUT_OF_MEMORY; + } + } + + if (callback_.app_control) + callback_.app_control(app_control, data_); + + app_control_destroy(app_control); + return APP_ERROR_NONE; + } + + int OnTerminate() override { + LOGW("ui_app_terminate()"); + AppCoreEflBase::OnTerminate(); + + if (callback_.terminate) + callback_.terminate(data_); + + return APP_ERROR_NONE; + } + + int OnPause() override { + LOGW("ui_app_pause()"); + AppCoreEflBase::OnPause(); + if (callback_.pause) + callback_.pause(data_); + return APP_ERROR_NONE; + } + + int OnResume() override { + LOGW("ui_app_resume"); + AppCoreEflBase::OnResume(); + if (callback_.resume) + callback_.resume(data_); + return APP_ERROR_NONE; + } + + AppState GetAppState() const { + return state_; + } + + void SetAppState(AppState state) { + state_ = state; + } + + private: + ui_app_lifecycle_callback_s callback_; + void* data_; + AppState state_ = APP_STATE_NOT_RUNNING; +}; + +constexpr int UI_APP_EVENT_MAX = 7; +constexpr IAppCore::IEvent::Type __app_event_converter[UI_APP_EVENT_MAX] = { + [APP_EVENT_LOW_MEMORY] = + IAppCore::IEvent::Type::LOW_MEMORY, + [APP_EVENT_LOW_BATTERY] = + IAppCore::IEvent::Type::LOW_BATTERY, + [APP_EVENT_LANGUAGE_CHANGED] = + IAppCore::IEvent::Type::LANG_CHANGE, + [APP_EVENT_DEVICE_ORIENTATION_CHANGED] = + IAppCore::IEvent::Type::DEVICE_ORIENTATION_CHANGED, + [APP_EVENT_REGION_FORMAT_CHANGED] = + IAppCore::IEvent::Type::REGION_CHANGE, + [APP_EVENT_SUSPENDED_STATE_CHANGED] = + IAppCore::IEvent::Type::SUSPENDED_STATE_CHANGE, + [APP_EVENT_UPDATE_REQUESTED] = + IAppCore::IEvent::Type::UPDATE_REQUESTED, +}; + +std::unique_ptr __context; +std::list> __pending_app_events; + +} // namespace + +API int ui_app_main(int argc, char** argv, + ui_app_lifecycle_callback_s* callback, void* user_data) { + if (argc < 1 || argv == nullptr || callback == nullptr) { + _E("Invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + if (callback->create == nullptr) { + _E("app_create_cb() callback MUST be registerted"); + return APP_ERROR_INVALID_PARAMETER; + } + + if (__context.get() != nullptr && + __context->GetAppState() != UiAppContext::APP_STATE_NOT_RUNNING) { + _E("Already running"); + return APP_ERROR_ALREADY_RUNNING; + } + + unsigned int hint = AppCoreEflBase::HINT_WINDOW_GROUP_CONTROL | + AppCoreEflBase::HINT_WINDOW_STACK_CONTROL | + AppCoreEflBase::HINT_BG_LAUNCH_CONTROL | + AppCoreEflBase::HINT_HW_ACC_CONTROL | + AppCoreEflBase::HINT_WINDOW_AUTO_CONTROL | + AppCoreEflBase::HINT_LEGACY_CONTROL | + AppCoreEflBase::HINT_WINDOW_ID_CONTROL; + + LOGW("ui_app_main()"); + try { + __context = std::make_unique(*callback, user_data, hint); + for (auto i : __pending_app_events) + __context->AddEvent(i); + + __context->Run(argc, argv); + } catch (std::runtime_error& e) { + __context->SetAppState(UiAppContext::APP_STATE_NOT_RUNNING); + } + + return APP_ERROR_NONE; +} + +API void ui_app_exit(void) { + LOGW("ui_app_exit()"); + if (__context.get() && + __context->GetAppState() == UiAppContext::APP_STATE_RUNNING) + __context->Exit(); +} + +API int ui_app_add_event_handler(app_event_handler_h* event_handler, + app_event_type_e event_type, app_event_cb callback, void* user_data) { + if (event_handler == nullptr || callback == nullptr) { + _E("Invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + if (event_type < APP_EVENT_LOW_MEMORY || + event_type > APP_EVENT_UPDATE_REQUESTED) { + _E("Invalid event type"); + return APP_ERROR_INVALID_PARAMETER; + } + + auto* ae = new (std::nothrow) AppEvent(__app_event_converter[event_type], + callback, user_data); + if (ae == nullptr) { + _E("Out of memory"); + return APP_ERROR_OUT_OF_MEMORY; + } + + auto* h = new (std::nothrow) std::shared_ptr(ae); + if (h == nullptr) { + _E("Out of memory"); + delete ae; + return APP_ERROR_OUT_OF_MEMORY; + } + + if (__context.get() && + __context->GetAppState() == UiAppContext::APP_STATE_RUNNING) { + __context->AddEvent(*h); + } else { + __pending_app_events.push_back(*h); + } + + *event_handler = reinterpret_cast(h); + return APP_ERROR_NONE; +} + +API int ui_app_remove_event_handler(app_event_handler_h event_handler) { + if (event_handler == nullptr) { + _E("Invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + auto* eb = reinterpret_cast*>(event_handler); + auto type = (*eb)->GetType(); + if (type < IAppCore::IEvent::Type::LOW_MEMORY || + type > IAppCore::IEvent::Type::UPDATE_REQUESTED) { + _E("invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + if (__context.get() && + __context->GetAppState() == UiAppContext::APP_STATE_RUNNING) { + if (!__context->RemoveEvent(*eb)) { + _E("Invalid handle"); + return APP_ERROR_INVALID_PARAMETER; + } + } else { + __pending_app_events.remove(*eb); + } + + delete eb; + return APP_ERROR_NONE; +} diff --git a/src/app_main_legacy.c b/src/app_main_legacy.c deleted file mode 100755 index 32cb232..0000000 --- a/src/app_main_legacy.c +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the License); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include - -#include -#include -#include - -#include -#include "app_extension.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "CAPI_APPFW_APPLICATION" - -typedef struct { - app_event_callback_s *callback; - void *data; -} app_context_s; - -static bool __on_create(void *data) -{ - app_context_s *context = data; - - if (context->callback->create) - return context->callback->create(context->data); - - return false; -} - -static void __on_terminate(void *data) -{ - app_context_s *context = data; - - if (context->callback->terminate) - context->callback->terminate(context->data); -} - -/* LCOV_EXCL_START */ -static void __on_pause(void *data) -{ - app_context_s *context = data; - - if (context->callback->pause) - context->callback->pause(context->data); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void __on_resume(void *data) -{ - app_context_s *context = data; - - if (context->callback->resume) - context->callback->resume(context->data); - -} -/* LCOV_EXCL_STOP */ - -static void __on_app_control(app_control_h app_control, void *data) -{ - app_context_s *context = data; - - if (context->callback->app_control) - context->callback->app_control(app_control, context->data); -} - -static void __on_low_memory(app_event_info_h event_info, void *data) -{ - app_context_s *context = data; - - if (context->callback->low_memory) - context->callback->low_memory(context->data); -} - -static void __on_low_battery(app_event_info_h event_info, void *data) -{ - app_context_s *context = data; - - if (context->callback->low_battery) - context->callback->low_battery(context->data); -} - -/* LCOV_EXCL_START */ -static void __on_rotation_event(app_event_info_h event_info, void *data) -{ - app_context_s *context = data; - - if (context->callback->device_orientation) { - app_device_orientation_e ori; - app_event_get_device_orientation(event_info, &ori); - context->callback->device_orientation(ori, context->data); - } - -} -/* LCOV_EXCL_STOP */ - -static void __on_lang_changed(app_event_info_h event_info, void *data) -{ - app_context_s *context = data; - - if (context->callback->language_changed) - context->callback->language_changed(context->data); -} - -static void __on_region_changed(app_event_info_h event_info, void *data) -{ - app_context_s *context = data; - - if (context->callback->region_format_changed) - context->callback->region_format_changed(context->data); -} - -int app_main(int argc, char **argv, app_event_callback_s *callback, void *data) -{ - ui_app_lifecycle_callback_s cb = { - .create = __on_create, - .terminate = __on_terminate, - .pause = __on_pause, - .resume = __on_resume, - .app_control = __on_app_control - }; - - app_context_s app_context = { - .callback = callback, - .data = data - }; - - app_event_handler_h handler; - - if (!callback) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); - - if (callback->low_memory) - ui_app_add_event_handler(&handler, APP_EVENT_LOW_MEMORY, __on_low_memory, &app_context); - if (callback->low_battery) - ui_app_add_event_handler(&handler, APP_EVENT_LOW_BATTERY, __on_low_battery, &app_context); - if (callback->language_changed) - ui_app_add_event_handler(&handler, APP_EVENT_LANGUAGE_CHANGED, __on_lang_changed, &app_context); - if (callback->device_orientation) - ui_app_add_event_handler(&handler, APP_EVENT_DEVICE_ORIENTATION_CHANGED, __on_rotation_event, &app_context); - if (callback->region_format_changed) - ui_app_add_event_handler(&handler, APP_EVENT_REGION_FORMAT_CHANGED, __on_region_changed, &app_context); - - return ui_app_main(argc, argv, &cb, &app_context); -} - -int app_efl_main(int *argc, char ***argv, app_event_callback_s *callback, void *user_data) -{ - if (argc == NULL || argv == NULL) - return app_error(APP_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL); - - return app_main(*argc, *argv, callback, user_data); -} - -void app_exit(void) -{ - ui_app_exit(); -} - -void app_efl_exit(void) -{ - ui_app_exit(); -} - - - diff --git a/src/app_main_legacy.cc b/src/app_main_legacy.cc new file mode 100644 index 0000000..5cc2158 --- /dev/null +++ b/src/app_main_legacy.cc @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2011 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "app.h" +#include "app_extension.h" +#include "app_internal.h" +#include "common_private.hh" +#include "log_private.hh" + +namespace { + +class AppMain { + public: + AppMain(app_event_callback_s* cb, void* data) + : cb_(cb), data_(data) { + } + + int Run(int argc, char** argv) { + RegisterSystemEvents(); + + ui_app_lifecycle_callback_s callback = { + .create = OnCreate, + .terminate = OnTerminate, + .pause = OnPause, + .resume = OnResume, + .app_control = OnAppControl + }; + int ret = ui_app_main(argc, argv, &callback, this); + + DeregisterSystemEvents(); + return ret; + } + + private: + void RegisterSystemEvents() { + if (cb_->low_memory) { + ui_app_add_event_handler(&low_memory_, + APP_EVENT_LOW_MEMORY, OnLowMemory, this); + } + + if (cb_->low_battery) { + ui_app_add_event_handler(&low_battery_, + APP_EVENT_LOW_BATTERY, OnLowBattery, this); + } + + if (cb_->language_changed) { + ui_app_add_event_handler(&language_changed_, + APP_EVENT_LANGUAGE_CHANGED, OnLanguageChanged, this); + } + + if (cb_->device_orientation) { + ui_app_add_event_handler(&device_orientation_changed_, + APP_EVENT_DEVICE_ORIENTATION_CHANGED, OnDeviceOrientationChanged, + this); + } + + if (cb_->region_format_changed) { + ui_app_add_event_handler(®ion_format_changed_, + APP_EVENT_REGION_FORMAT_CHANGED, OnRegionFormatChanged, this); + } + } + + void DeregisterSystemEvents() { + if (region_format_changed_) { + ui_app_remove_event_handler(region_format_changed_); + region_format_changed_ = nullptr; + } + + if (device_orientation_changed_) { + ui_app_remove_event_handler(device_orientation_changed_); + device_orientation_changed_ = nullptr; + } + + if (language_changed_) { + ui_app_remove_event_handler(language_changed_); + language_changed_ = nullptr; + } + + if (low_battery_) { + ui_app_remove_event_handler(low_battery_); + low_battery_ = nullptr; + } + + if (low_memory_) { + ui_app_remove_event_handler(low_memory_); + low_memory_ = nullptr; + } + } + + static bool OnCreate(void* data) { + auto* context = static_cast(data); + if (context->cb_->create) + return context->cb_->create(context->data_); + + return false; + } + + static void OnTerminate(void* data) { + auto* context = static_cast(data); + if (context->cb_->terminate) + context->cb_->terminate(context->cb_); + } + + static void OnPause(void* data) { + auto* context = static_cast(data); + if (context->cb_->pause) + context->cb_->pause(context->data_); + } + + static void OnResume(void* data) { + auto* context = static_cast(data); + if (context->cb_->resume) + context->cb_->resume(context->data_); + } + + static void OnAppControl(app_control_h app_control, void* data) { + auto* context = static_cast(data); + if (context->cb_->app_control) + context->cb_->app_control(app_control, context->data_); + } + + static void OnLowMemory(app_event_info_h event_info, void* data) { + auto* context = static_cast(data); + if (context->cb_->low_memory) + context->cb_->low_memory(context->data_); + } + + static void OnLowBattery(app_event_info_h event_info, void* data) { + auto* context = static_cast(data); + if (context->cb_->low_battery) + context->cb_->low_battery(context->data_); + } + + static void OnDeviceOrientationChanged(app_event_info_h event_info, + void* data) { + auto* context = static_cast(data); + if (context->cb_->device_orientation) { + app_device_orientation_e value; + app_event_get_device_orientation(event_info, &value); + context->cb_->device_orientation(value, context->data_); + } + } + + static void OnLanguageChanged(app_event_info_h event_info, void* data) { + auto* context = static_cast(data); + if (context->cb_->language_changed) + context->cb_->language_changed(context->data_); + } + + static void OnRegionFormatChanged(app_event_info_h event_info, void* data) { + auto* context = static_cast(data); + if (context->cb_->region_format_changed) + context->cb_->region_format_changed(context->data_); + } + + private: + app_event_callback_s* cb_; + void* data_; + app_event_handler_h low_memory_ = nullptr; + app_event_handler_h low_battery_ = nullptr; + app_event_handler_h language_changed_ = nullptr; + app_event_handler_h device_orientation_changed_ = nullptr; + app_event_handler_h region_format_changed_ = nullptr; +}; + +} // namespace + +API int app_main(int argc, char** argv, app_event_callback_s* callback, + void* data) { + if (callback == nullptr) { + _E("Invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + AppMain app(callback, data); + return app.Run(argc, argv); +} + +API int app_efl_main(int* argc, char*** argv, app_event_callback_s* callback, + void* user_data) { + if (argc == nullptr || argv == nullptr) { + _E("Invalid parameter"); + return APP_ERROR_INVALID_PARAMETER; + } + + return app_main(*argc, *argv, callback, user_data); +} + +API void app_exit(void) { + ui_app_exit(); +} + +API void app_efl_exit(void) { + app_exit(); +} diff --git a/src/app_resource.c b/src/app_resource.c deleted file mode 100644 index 5ab9a16..0000000 --- a/src/app_resource.c +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the License); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include "app_extension.h" - -static void __set_preinit_window_name(const char *win_name, void *win) -{ - const Evas *e; - Ecore_Evas *ee; - - if (!win_name || !win) - return; - - e = evas_object_evas_get((const Evas_Object *)win); - if (e) { - ee = ecore_evas_ecore_evas_get(e); - if (ee) - ecore_evas_name_class_set(ee, win_name, win_name); - } -} - -void *app_get_preinitialized_window(const char *win_name) -{ - void *win; - - win = elm_win_precreated_object_get(); - if (win == NULL) - return NULL; - - __set_preinit_window_name(win_name, win); - elm_win_precreated_object_set(NULL); - - return win; -} - -void *app_get_preinitialized_background(void) -{ - void *background; - - background = elm_bg_precreated_object_get(); - if (background == NULL) - return NULL; - - elm_bg_precreated_object_set(NULL); - - return background; -} - -void *app_get_preinitialized_conformant(void) -{ - void *conformant; - - conformant = elm_conformant_precreated_object_get(); - if (conformant == NULL) - return NULL; - - elm_conformant_precreated_object_set(NULL); - - return conformant; -} - diff --git a/src/app_resource.cc b/src/app_resource.cc new file mode 100644 index 0000000..4b6d5f4 --- /dev/null +++ b/src/app_resource.cc @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2011 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "app_extension.h" +#include "common_private.hh" + +API void* app_get_preinitialized_window(const char* win_name) { + void* win = elm_win_precreated_object_get(); + if (win == nullptr) + return nullptr; + + if (win_name != nullptr) { + const Evas* e = evas_object_evas_get(static_cast(win)); + if (e != nullptr) { + Ecore_Evas* ee = ecore_evas_ecore_evas_get(e); + if (ee != nullptr) + ecore_evas_name_class_set(ee, win_name, win_name); + } + } + + elm_win_precreated_object_set(nullptr); + return win; +} + +API void* app_get_preinitialized_background(void) { + void* background = elm_bg_precreated_object_get(); + if (background == nullptr) + return nullptr; + + elm_bg_precreated_object_set(nullptr); + return background; +} + +API void* app_get_preinitialized_conformant(void) { + void* conformant = elm_conformant_precreated_object_get(); + if (conformant == nullptr) + return nullptr; + + elm_conformant_precreated_object_set(nullptr); + return conformant; +} diff --git a/src/common_private.hh b/src/common_private.hh new file mode 100644 index 0000000..eaf9a66 --- /dev/null +++ b/src/common_private.hh @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef COMMON_PRIVATE_HH_ +#define COMMON_PRIVATE_HH_ + +#undef EXPORT +#define EXPORT __attribute__ ((visibility("default"))) + +#undef API +#define API extern "C" EXPORT + +#endif // COMMON_PRIVATE_HH_ diff --git a/src/log_private.hh b/src/log_private.hh new file mode 100644 index 0000000..014c904 --- /dev/null +++ b/src/log_private.hh @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LOG_PRIVATE_HH_ +#define LOG_PRIVATE_HH_ + +#include + +#undef LOG_TAG +#define LOG_TAG "CAPI_APPFW_APPLICATION" + +#undef _E +#define _E LOGE + +#undef _W +#define _W LOGW + +#undef _I +#define _I LOGI + +#undef _D +#define _D LOGD + +#endif // LOG_PRIVATE_HH_ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 0000000..9ed63b3 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1 @@ +ADD_SUBDIRECTORY(ui-app-ambient_unittests) diff --git a/tests/ui-app-ambient_unittests/CMakeLists.txt b/tests/ui-app-ambient_unittests/CMakeLists.txt new file mode 100644 index 0000000..417c1be --- /dev/null +++ b/tests/ui-app-ambient_unittests/CMakeLists.txt @@ -0,0 +1,35 @@ +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} UNIT_TEST_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/mock MOCK_SRCS) + +ADD_EXECUTABLE(${TARGET_UI_APP_AMBIENT_UNITTESTS} + ${UNIT_TEST_SRCS} + ${MOCK_SRCS}) + +TARGET_INCLUDE_DIRECTORIES(${TARGET_UI_APP_AMBIENT_UNITTESTS} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/mock/ + ${CMAKE_CURRENT_SOURCE_DIR}/../ + ${CMAKE_CURRENT_SOURCE_DIR}/../../ + ${CMAKE_CURRENT_SOURCE_DIR}/../../appcore_ui_app_ambient/ + ${CMAKE_CURRENT_SOURCE_DIR}/../../appcore_ui_app_ambient/include/ + ${CMAKE_CURRENT_SOURCE_DIR}/../../appcore_ui_app_ambient/src/) + +APPLY_PKG_CONFIG(${TARGET_UI_APP_AMBIENT_UNITTESTS} PUBLIC + ALARM_SERVICE_DEPS + AUL_DEPS + BUNDLE_DEPS + CAPI_APPFW_APP_COMMON_DEPS + DLOG_DEPS + GLIB_DEPS + GMOCK_DEPS +) + +TARGET_LINK_LIBRARIES(${TARGET_UI_APP_AMBIENT_UNITTESTS} PUBLIC + ${TARGET_APPCORE_UI_APP_AMBIENT}) + +SET_TARGET_PROPERTIES(${TARGET_UI_APP_AMBIENT_UNITTESTS} + PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_UI_APP_AMBIENT_UNITTESTS} + PROPERTIES LINK_FLAGS "-pie") + +INSTALL(TARGETS ${TARGET_UI_APP_AMBIENT_UNITTESTS} DESTINATION bin) diff --git a/tests/ui-app-ambient_unittests/main.cc b/tests/ui-app-ambient_unittests/main.cc new file mode 100644 index 0000000..420cb6a --- /dev/null +++ b/tests/ui-app-ambient_unittests/main.cc @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2020 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +int main(int argc, char** argv) { + try { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); + } catch (std::exception const &e) { + std::cout << "test_main caught exception: " << e.what() << std::endl; + return -1; + } +} diff --git a/tests/ui-app-ambient_unittests/mock/aul_mock.cc b/tests/ui-app-ambient_unittests/mock/aul_mock.cc new file mode 100644 index 0000000..abcfb71 --- /dev/null +++ b/tests/ui-app-ambient_unittests/mock/aul_mock.cc @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ui-app-ambient_unittests/mock/aul_mock.hh" +#include "ui-app-ambient_unittests/mock/mock_hook.hh" +#include "ui-app-ambient_unittests/mock/test_fixture.hh" + +extern "C" int aul_app_get_appid_bypid(int pid, char* appid, int size) { + return MOCK_HOOK_P3(AulMock, aul_app_get_appid_bypid, pid, appid, size); +} + +extern "C" int aul_app_com_create(const char* endpoint, + aul_app_com_permission_h permission, app_com_cb callback, void* user_data, + aul_app_com_connection_h* connection) { + return MOCK_HOOK_P5(AulMock, aul_app_com_create, endpoint, permission, + callback, user_data, connection); +} + +extern "C" int aul_app_com_send(const char* endpoint, bundle* envelope) { + return MOCK_HOOK_P2(AulMock, aul_app_com_send, endpoint, envelope); +} diff --git a/tests/ui-app-ambient_unittests/mock/aul_mock.hh b/tests/ui-app-ambient_unittests/mock/aul_mock.hh new file mode 100644 index 0000000..e7bdd73 --- /dev/null +++ b/tests/ui-app-ambient_unittests/mock/aul_mock.hh @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef UI_APP_AMBIENT_UNITTESTS_MOCK_AUL_MOCK_HH_ +#define UI_APP_AMBIENT_UNITTESTS_MOCK_AUL_MOCK_HH_ + +#include +#include + +#include + +#include "ui-app-ambient_unittests/mock/module_mock.hh" + +class AulMock : public virtual ModuleMock { + public: + virtual ~AulMock() {} + + MOCK_METHOD3(aul_app_get_appid_bypid, int (int, char*, int)); + MOCK_METHOD5(aul_app_com_create, + int (const char*, aul_app_com_permission_h, app_com_cb, void*, + aul_app_com_connection_h*)); + MOCK_METHOD2(aul_app_com_send, int (const char*, bundle*)); +}; + +#endif // UI_APP_AMBIENT_UNITTESTS_MOCK_AUL_MOCK_HH_ diff --git a/tests/ui-app-ambient_unittests/mock/mock_hook.hh b/tests/ui-app-ambient_unittests/mock/mock_hook.hh new file mode 100644 index 0000000..9758c2c --- /dev/null +++ b/tests/ui-app-ambient_unittests/mock/mock_hook.hh @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef UI_APP_AMBIENT_UNITTESTS_MOCK_MOCK_HOOK_HH_ +#define UI_APP_AMBIENT_UNITTESTS_MOCK_MOCK_HOOK_HH_ + +#define MOCK_HOOK_P0(MOCK_CLASS, f) \ + TestFixture::GetMock().f() +#define MOCK_HOOK_P1(MOCK_CLASS, f, p1) \ + TestFixture::GetMock().f(p1) +#define MOCK_HOOK_P2(MOCK_CLASS, f, p1, p2) \ + TestFixture::GetMock().f(p1, p2) +#define MOCK_HOOK_P3(MOCK_CLASS, f, p1, p2, p3) \ + TestFixture::GetMock().f(p1, p2, p3) +#define MOCK_HOOK_P4(MOCK_CLASS, f, p1, p2, p3, p4) \ + TestFixture::GetMock().f(p1, p2, p3, p4) +#define MOCK_HOOK_P5(MOCK_CLASS, f, p1, p2, p3, p4, p5) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5) +#define MOCK_HOOK_P6(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6) +#define MOCK_HOOK_P7(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7) +#define MOCK_HOOK_P8(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7, p8) +#define MOCK_HOOK_P10(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) \ + TestFixture::GetMock().f( \ + p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + +#endif // UI_APP_AMBIENT_UNITTESTS_MOCK_MOCK_HOOK_HH_ diff --git a/tests/ui-app-ambient_unittests/mock/module_mock.hh b/tests/ui-app-ambient_unittests/mock/module_mock.hh new file mode 100644 index 0000000..496325f --- /dev/null +++ b/tests/ui-app-ambient_unittests/mock/module_mock.hh @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef UI_APP_AMBIENT_UNITTESTS_MOCK_MODULE_MOCK_HH_ +#define UI_APP_AMBIENT_UNITTESTS_MOCK_MODULE_MOCK_HH_ + +class ModuleMock { + public: + virtual ~ModuleMock() {} +}; + +#endif // UI_APP_AMBIENT_UNITTESTS_MOCK_MODULE_MOCK_HH_ diff --git a/mock/mock.h b/tests/ui-app-ambient_unittests/mock/test_fixture.cc similarity index 76% rename from mock/mock.h rename to tests/ui-app-ambient_unittests/mock/test_fixture.cc index 6f4949f..a5eac53 100644 --- a/mock/mock.h +++ b/tests/ui-app-ambient_unittests/mock/test_fixture.cc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,9 +14,8 @@ * limitations under the License. */ -#ifndef MOCK_MOCK_H__ -#define MOCK_MOCK_H__ +#include -#include "fff.h" +#include "ui-app-ambient_unittests/mock/test_fixture.hh" -#endif // MOCK_MOCK_H__ +std::unique_ptr TestFixture::mock_; diff --git a/tests/ui-app-ambient_unittests/mock/test_fixture.hh b/tests/ui-app-ambient_unittests/mock/test_fixture.hh new file mode 100644 index 0000000..291afec --- /dev/null +++ b/tests/ui-app-ambient_unittests/mock/test_fixture.hh @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef UI_APP_AMBIENT_UNITTESTS_MOCK_TEST_FIXTURE_HH_ +#define UI_APP_AMBIENT_UNITTESTS_MOCK_TEST_FIXTURE_HH_ + +#include + +#include +#include +#include +#include + +#include "ui-app-ambient_unittests/mock/module_mock.hh" + +class TestFixture : public ::testing::Test { + public: + explicit TestFixture(std::unique_ptr&& mock) { + mock_ = std::move(mock); + } + virtual ~TestFixture() { + mock_.reset(); + } + + virtual void SetUp() {} + virtual void TearDown() {} + + template + static T& GetMock() { + auto ptr = dynamic_cast(mock_.get()); + if (!ptr) + throw std::invalid_argument("The test does not provide mock of \"" + + std::string(typeid(T).name()) + "\""); + return *ptr; + } + + static std::unique_ptr mock_; +}; + +#endif // UI_APP_AMBIENT_UNITTESTS_MOCK_TEST_FIXTURE_HH_ diff --git a/tests/ui-app-ambient_unittests/ui_app_ambient_unittest.cc b/tests/ui-app-ambient_unittests/ui_app_ambient_unittest.cc new file mode 100644 index 0000000..23249fb --- /dev/null +++ b/tests/ui-app-ambient_unittests/ui_app_ambient_unittest.cc @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2020 - 2021 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "ui-app-ambient_unittests/mock/aul_mock.hh" +#include "ui-app-ambient_unittests/mock/test_fixture.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::Invoke; + +namespace { + +int fake_aul_app_get_appid_bypid(int pid, char* appid, int size) { + return 0; +} + +int fake_aul_app_com_create(const char* endpoint, + aul_app_com_permission_h permission, app_com_cb callback, void* user_data, + aul_app_com_connection_h* connection) { + return 0; +} + +int fake_aul_app_com_send(const char* endpoint, bundle* envelope) { + return 0; +} + +} // namespace + +class Mocks : public ::testing::NiceMock {}; + +class UIAppAmbientTest : public TestFixture { + public: + UIAppAmbientTest() : TestFixture(std::make_unique()) {} + virtual ~UIAppAmbientTest() {} + + void SetUp() override {} + void TearDown() override {} +}; + +TEST_F(UIAppAmbientTest, ui_app_ambient_set_lifecycle_P) { + ui_app_ambient_lifecycle_callback_s callback; + callback.frame_updated = [](void* user_data) {}; + callback.ambient_changed = + [](ui_app_ambient_state_e state, bundle* data, void* user_data) { + printf("state: %d\n", state); + }; + + EXPECT_CALL(GetMock(), aul_app_com_create(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_app_com_create)); + + int ret = ui_app_ambient_set_lifecycle(&callback, nullptr); + EXPECT_EQ(ret, 0); + ui_app_ambient_unset_lifecycle(); +} + +TEST_F(UIAppAmbientTest, ui_app_ambient_set_update_period_P) { + int ret = ui_app_ambient_set_update_period(UI_APP_AMBIENT_UPDATE_MINUTE); + EXPECT_EQ(ret, 0); +} + +TEST_F(UIAppAmbientTest, ui_app_ambient_get_update_period_P) { + ui_app_ambient_update_period_e period; + int ret = ui_app_ambient_get_update_period(&period); + EXPECT_EQ(ret, 0); +} + +TEST_F(UIAppAmbientTest, ui_app_ambient_get_update_period_N) { + int ret = ui_app_ambient_get_update_period(nullptr); + EXPECT_NE(ret, 0); +} + +TEST_F(UIAppAmbientTest, ui_app_ambient_notify_P) { + EXPECT_CALL(GetMock(), aul_app_get_appid_bypid(_, _, _)). + WillOnce(Invoke(fake_aul_app_get_appid_bypid)); + EXPECT_CALL(GetMock(), aul_app_com_send(_, _)). + WillOnce(Invoke(fake_aul_app_com_send)); + + int ret = ui_app_ambient_notify_event(UI_APP_AMBIENT_EVENT_READY, nullptr); + EXPECT_EQ(ret, 0); +} diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt deleted file mode 100644 index 1c4afb2..0000000 --- a/unittest/CMakeLists.txt +++ /dev/null @@ -1,37 +0,0 @@ -SET(GTEST_TEST "gtest-ui-app-ambient") - -ENABLE_TESTING() - -INCLUDE(FindPkgConfig) -LINK_DIRECTORIES(${CMAKE_BINARY_DIR}) -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/appcore_ui_app_ambient/include) -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/mock) - -PKG_CHECK_MODULES(gtest_pkgs REQUIRED - glib-2.0 - gmock - dlog - aul - alarm-service - bundle - capi-appfw-app-common - ) - -FOREACH(flag ${gtest_pkgs_CFLAGS}) - SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") -ENDFOREACH(flag) - -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fpie") -SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -fpie") - -FILE(GLOB GTEST_TEST_SRCS *.cpp) -AUX_SOURCE_DIRECTORY(${CMAKE_SOURCE_DIR}/unittest GTEST_TEST_SRCS) -AUX_SOURCE_DIRECTORY(${CMAKE_SOURCE_DIR}/mock GTEST_TEST_SRCS) -AUX_SOURCE_DIRECTORY(${CMAKE_SOURCE_DIR}/appcore_ui_app_ambient/src -UI_APP_AMBIENT_SRCS) - -ADD_EXECUTABLE(${GTEST_TEST} ${GTEST_TEST_SRCS} ${UI_APP_AMBIENT_SRCS}) -TARGET_LINK_LIBRARIES(${GTEST_TEST} ${gtest_pkgs_LDFLAGS}) - -ADD_TEST(${GTEST_TEST} ${GTEST_TEST}) -INSTALL(TARGETS ${GTEST_TEST} DESTINATION /usr/bin) \ No newline at end of file diff --git a/unittest/ui_app_ambient_unittest.cpp b/unittest/ui_app_ambient_unittest.cpp deleted file mode 100644 index 89083ae..0000000 --- a/unittest/ui_app_ambient_unittest.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include -#include -#include -#include - -#include "aul_fake.h" -#include "alarm_fake.h" -#include "ui_app_ambient.h" - -class UIAppAmbientTest : public ::testing::Test { - protected: - void SetUp() override { - - } - void TearDown() override { - - } - -}; - -static int __aul_app_get_appid_bypid_fake(int pid, char* appidid, int size) -{ - return 0; -} - -static int __aul_app_com_create_fake( - const char *endpoint, - aul_app_com_permission_h permission, - app_com_cb callback, - void *user_data, - aul_app_com_connection_h *connection) -{ - return 0; -} - -static int __aul_app_com_send_fake(const char *endpoint, bundle *envelope) -{ - return 0; -} - -static alarm_entry_t* __alarmmgr_create_alarm_fake(void) -{ - alarm_entry_t *base_info = (alarm_entry_t *)malloc(sizeof(alarm_entry_t)); - return base_info; -} - -static int __alarmmgr_free_alarm_fake(alarm_entry_t *alarm) -{ - free(alarm); - return 0; -} - -static int __alarmmgr_init_fake(const char *appid) -{ - return 0; -} - -static int __alarmmgr_set_time_fake(alarm_entry_t *info, alarm_date_t date) -{ - return 0; -} - -static int __alarmmgr_set_repeat_mode_fake(alarm_entry_t *info, alarm_repeat_mode_t mode, int value) -{ - return 0; -} - -static int __alarmmgr_add_alarm_with_localtime_fake(alarm_entry_t *info, const char *dest, int *alarm_id) -{ - return 0; -} - -static void __frame_cb(void *user_data) -{ -} - -static void __changed_cb(ui_app_ambient_state_e state, bundle *data, void *user_data) -{ - printf("state : %d", state); -} - -TEST_F(UIAppAmbientTest, ui_app_ambient_set_lifecycle_p) -{ - int ret; - ui_app_ambient_lifecycle_callback_s callback; - callback.frame_updated = __frame_cb; - callback.ambient_changed = __changed_cb; - - aul_app_get_appid_bypid_fake.custom_fake = __aul_app_get_appid_bypid_fake; - aul_app_com_create_fake.custom_fake = __aul_app_com_create_fake; - alarmmgr_create_alarm_fake.custom_fake = __alarmmgr_create_alarm_fake; - alarmmgr_free_alarm_fake.custom_fake = __alarmmgr_free_alarm_fake; - alarmmgr_init_fake.custom_fake = __alarmmgr_init_fake; - alarmmgr_set_time_fake.custom_fake = __alarmmgr_set_time_fake; - alarmmgr_set_repeat_mode_fake.custom_fake = __alarmmgr_set_repeat_mode_fake; - alarmmgr_add_alarm_with_localtime_fake.custom_fake = __alarmmgr_add_alarm_with_localtime_fake; - - ret = ui_app_ambient_set_lifecycle(&callback, NULL); - EXPECT_EQ(0, ret); - - ui_app_ambient_unset_lifecycle(); -} - -TEST_F(UIAppAmbientTest, ui_app_ambient_set_update_period_p) -{ - int ret; - ret = ui_app_ambient_set_update_period(UI_APP_AMBIENT_UPDATE_MINUTE); - EXPECT_EQ(0, ret); -} - -TEST_F(UIAppAmbientTest, ui_app_ambient_get_update_period_p) -{ - int ret; - ui_app_ambient_update_period_e period; - - ret = ui_app_ambient_get_update_period(&period); - EXPECT_EQ(0, ret); -} - -TEST_F(UIAppAmbientTest, ui_app_ambient_get_update_period_n) -{ - int ret; - - ret = ui_app_ambient_get_update_period(NULL); - EXPECT_NE(0, ret); -} - -TEST_F(UIAppAmbientTest, ui_app_ambient_notify_p) -{ - int ret; - aul_app_com_send_fake.custom_fake = __aul_app_com_send_fake; - - ret = ui_app_ambient_notify_event(UI_APP_AMBIENT_EVENT_READY, NULL); - EXPECT_EQ(0, ret); -} \ No newline at end of file -- 2.7.4