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 <jh9216.park@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5216a6d..1b308a8 100644 (file)
--- 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 (executable)
new mode 100644 (file)
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 (executable)
new mode 100644 (file)

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 (file)
--- 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 (file)
--- 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 <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <unistd.h>
 
-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 (file)
--- 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 <aul.h>
-#include <aul_app_com.h>
+#include <dlog.h>
 
-#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 (file)
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 <stdio.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <stdlib.h>
-
-#include <dlog.h>
-#include <aul.h>
-#include <aul_app_com.h>
-#include <app_common_internal.h>
-#include <alarm.h>
-
-#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, &current_time);
-
-       tzset();
-       localtime_r(&current_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 (file)
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 <alarm.h>
+#include <app_common_internal.h>
+#include <aul.h>
+#include <aul_app_com.h>
+#include <bundle_cpp.h>
+#include <bundle_internal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <memory>
+#include <string>
+
+#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<ui_app_ambient_state_e>(
+        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<UIAppAmbient*>(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<UIAppAmbient*>(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<alarm_entry_t, decltype(alarmmgr_free_alarm)*> ptr(
+        alarm_info, alarmmgr_free_alarm);
+
+    struct timespec current_time;
+    clock_gettime(CLOCK_REALTIME, &current_time);
+    tzset();
+    struct tm current_tm;
+    localtime_r(&current_time.tv_sec, &current_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<ui_app_ambient_update_period_e>(
+      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 (file)
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 (executable)
--- 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 (file)
--- 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 (file)
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 <alarm.h>
-
-#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 (file)
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 <stdarg.h>
-#include <string.h> /* 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 (file)
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 (file)
--- 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 (file)
--- 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 (file)
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 <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#include <bundle.h>
-#include <appcore_base.h>
-#include <aul.h>
-#include <dlog.h>
-#include <vconf.h>
-
-#include <app_internal.h>
-
-#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 (file)
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 <app_core_efl_base.hh>
+
+#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 (executable)
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 <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#include <bundle.h>
-#include <appcore_efl_base.h>
-#include <dlog.h>
-
-#include <app_internal.h>
-#include <app_control_internal.h>
-#include <app_common_internal.h>
-#include <tizen_error.h>
-
-#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 (file)
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 <app_common_internal.h>
+#include <app_control_internal.h>
+#include <dlog.h>
+#include <tizen_error.h>
+
+#include <app_core_efl_base.hh>
+#include <app_event_internal.hh>
+
+#include <list>
+#include <memory>
+
+#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<UiAppContext> __context;
+std::list<std::shared_ptr<AppEvent>> __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<UiAppContext>(*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<AppEvent>(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<app_event_handler_h>(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<std::shared_ptr<AppEvent>*>(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 (executable)
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 <stdio.h>
-#include <stdlib.h>
-#include <dlog.h>
-
-#include <app_common_internal.h>
-#include <app_internal.h>
-#include <tizen_error.h>
-
-#include <app.h>
-#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 (file)
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 <app_common_internal.h>
+
+#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(&region_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<AppMain*>(data);
+    if (context->cb_->create)
+      return context->cb_->create(context->data_);
+
+    return false;
+  }
+
+  static void OnTerminate(void* data) {
+    auto* context = static_cast<AppMain*>(data);
+    if (context->cb_->terminate)
+      context->cb_->terminate(context->cb_);
+  }
+
+  static void OnPause(void* data) {
+    auto* context = static_cast<AppMain*>(data);
+    if (context->cb_->pause)
+      context->cb_->pause(context->data_);
+  }
+
+  static void OnResume(void* data) {
+    auto* context = static_cast<AppMain*>(data);
+    if (context->cb_->resume)
+      context->cb_->resume(context->data_);
+  }
+
+  static void OnAppControl(app_control_h app_control, void* data) {
+    auto* context = static_cast<AppMain*>(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<AppMain*>(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<AppMain*>(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<AppMain*>(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<AppMain*>(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<AppMain*>(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 (file)
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 <Elementary.h>
-#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 (file)
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 <Elementary.h>
+
+#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<Evas_Object*>(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 (file)
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 (file)
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 <dlog.h>
+
+#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 (file)
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 (file)
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 (file)
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 <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+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 (file)
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 (file)
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 <aul.h>
+#include <aul_app_com.h>
+
+#include <gmock/gmock.h>
+
+#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 (file)
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<MOCK_CLASS>().f()
+#define MOCK_HOOK_P1(MOCK_CLASS, f, p1)                                        \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1)
+#define MOCK_HOOK_P2(MOCK_CLASS, f, p1, p2)                                    \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2)
+#define MOCK_HOOK_P3(MOCK_CLASS, f, p1, p2, p3)                                \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3)
+#define MOCK_HOOK_P4(MOCK_CLASS, f, p1, p2, p3, p4)                            \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4)
+#define MOCK_HOOK_P5(MOCK_CLASS, f, p1, p2, p3, p4, p5)                        \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5)
+#define MOCK_HOOK_P6(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6)                    \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5, p6)
+#define MOCK_HOOK_P7(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7)                \
+    TestFixture::GetMock<MOCK_CLASS>().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<MOCK_CLASS>().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<MOCK_CLASS>().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 (file)
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 (file)
--- 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 <memory>
 
-#include "fff.h"
+#include "ui-app-ambient_unittests/mock/test_fixture.hh"
 
-#endif // MOCK_MOCK_H__
+std::unique_ptr<ModuleMock> 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 (file)
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 <gtest/gtest.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include "ui-app-ambient_unittests/mock/module_mock.hh"
+
+class TestFixture : public ::testing::Test {
+ public:
+  explicit TestFixture(std::unique_ptr<ModuleMock>&& mock) {
+    mock_ = std::move(mock);
+  }
+  virtual ~TestFixture() {
+    mock_.reset();
+  }
+
+  virtual void SetUp() {}
+  virtual void TearDown() {}
+
+  template <typename T>
+  static T& GetMock() {
+    auto ptr = dynamic_cast<T*>(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<ModuleMock> 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 (file)
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 <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <stdio.h>
+#include <ui_app_ambient.h>
+#include <unistd.h>
+
+#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<AulMock> {};
+
+class UIAppAmbientTest : public TestFixture {
+ public:
+  UIAppAmbientTest() : TestFixture(std::make_unique<Mocks>()) {}
+  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<AulMock>(), 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<AulMock>(), aul_app_get_appid_bypid(_, _, _)).
+      WillOnce(Invoke(fake_aul_app_get_appid_bypid));
+  EXPECT_CALL(GetMock<AulMock>(), 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 (file)
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 (file)
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 <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <unistd.h>
-#include <stdio.h>
-
-#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