Xin Zhang / azure-iot-c-sdk-f767zi

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   samplemqtt

uamqp/deps/umock-c/inc/umock_c_internal.h@0:f7f1f0d76dd6, 2018-08-23 (annotated)

Committer:
XinZhangMS
Date:
Thu Aug 23 06:52:14 2018 +0000
Revision:
0:f7f1f0d76dd6
azure-c-sdk for mbed os supporting NUCLEO_F767ZI

Who changed what in which revision?

UserRevisionLine numberNew contents of line
XinZhangMS 0:f7f1f0d76dd6 1 // Copyright (c) Microsoft. All rights reserved.
XinZhangMS 0:f7f1f0d76dd6 2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
XinZhangMS 0:f7f1f0d76dd6 3
XinZhangMS 0:f7f1f0d76dd6 4 #ifndef UMOCK_C_INTERNAL_H
XinZhangMS 0:f7f1f0d76dd6 5 #define UMOCK_C_INTERNAL_H
XinZhangMS 0:f7f1f0d76dd6 6
XinZhangMS 0:f7f1f0d76dd6 7 #ifdef __cplusplus
XinZhangMS 0:f7f1f0d76dd6 8 #include <cstdlib>
XinZhangMS 0:f7f1f0d76dd6 9 extern "C" {
XinZhangMS 0:f7f1f0d76dd6 10 #else
XinZhangMS 0:f7f1f0d76dd6 11 #include <stdlib.h>
XinZhangMS 0:f7f1f0d76dd6 12 #endif
XinZhangMS 0:f7f1f0d76dd6 13
XinZhangMS 0:f7f1f0d76dd6 14 #include <stdio.h>
XinZhangMS 0:f7f1f0d76dd6 15
XinZhangMS 0:f7f1f0d76dd6 16 #include "macro_utils.h"
XinZhangMS 0:f7f1f0d76dd6 17 #include "umocktypes.h"
XinZhangMS 0:f7f1f0d76dd6 18 #include "umockcall.h"
XinZhangMS 0:f7f1f0d76dd6 19 #include "umockcallrecorder.h"
XinZhangMS 0:f7f1f0d76dd6 20 #include "umock_c.h"
XinZhangMS 0:f7f1f0d76dd6 21 #include "umock_log.h"
XinZhangMS 0:f7f1f0d76dd6 22 #include "umockalloc.h"
XinZhangMS 0:f7f1f0d76dd6 23 #include "umockcallpairs.h"
XinZhangMS 0:f7f1f0d76dd6 24 #include "umockstring.h"
XinZhangMS 0:f7f1f0d76dd6 25 #include "umockautoignoreargs.h"
XinZhangMS 0:f7f1f0d76dd6 26
XinZhangMS 0:f7f1f0d76dd6 27 extern void umock_c_indicate_error(UMOCK_C_ERROR_CODE error_code);
XinZhangMS 0:f7f1f0d76dd6 28 extern UMOCKCALL_HANDLE umock_c_get_last_expected_call(void);
XinZhangMS 0:f7f1f0d76dd6 29 extern int umock_c_add_expected_call(UMOCKCALL_HANDLE mock_call);
XinZhangMS 0:f7f1f0d76dd6 30 extern int umock_c_add_actual_call(UMOCKCALL_HANDLE mock_call, UMOCKCALL_HANDLE* matched_call);
XinZhangMS 0:f7f1f0d76dd6 31
XinZhangMS 0:f7f1f0d76dd6 32 typedef struct ARG_BUFFER_TAG
XinZhangMS 0:f7f1f0d76dd6 33 {
XinZhangMS 0:f7f1f0d76dd6 34 void* bytes;
XinZhangMS 0:f7f1f0d76dd6 35 size_t length;
XinZhangMS 0:f7f1f0d76dd6 36 } ARG_BUFFER;
XinZhangMS 0:f7f1f0d76dd6 37
XinZhangMS 0:f7f1f0d76dd6 38 typedef int(*TRACK_CREATE_FUNC_TYPE)(PAIRED_HANDLES* paired_handles, const void* handle, const char* handle_type, size_t handle_type_size);
XinZhangMS 0:f7f1f0d76dd6 39 typedef int(*TRACK_DESTROY_FUNC_TYPE)(PAIRED_HANDLES* paired_handles, const void* handle);
XinZhangMS 0:f7f1f0d76dd6 40
XinZhangMS 0:f7f1f0d76dd6 41 #define MOCK_ENABLED 0
XinZhangMS 0:f7f1f0d76dd6 42 #define MOCK_DISABLED 1
XinZhangMS 0:f7f1f0d76dd6 43
XinZhangMS 0:f7f1f0d76dd6 44 #define ARG_IS_IGNORED -1
XinZhangMS 0:f7f1f0d76dd6 45 #define ARG_IS_NOT_IGNORED 0
XinZhangMS 0:f7f1f0d76dd6 46
XinZhangMS 0:f7f1f0d76dd6 47 #define FAIL_RETURN_VALUE_SET -1
XinZhangMS 0:f7f1f0d76dd6 48 #define FAIL_RETURN_VALUE_NOT_SET 0
XinZhangMS 0:f7f1f0d76dd6 49
XinZhangMS 0:f7f1f0d76dd6 50 #define RETURN_VALUE_SET -1
XinZhangMS 0:f7f1f0d76dd6 51 #define RETURN_VALUE_NOT_SET 0
XinZhangMS 0:f7f1f0d76dd6 52
XinZhangMS 0:f7f1f0d76dd6 53 #define COUNT_OF(A) (sizeof(A) / sizeof((A)[0]))
XinZhangMS 0:f7f1f0d76dd6 54
XinZhangMS 0:f7f1f0d76dd6 55 #define GET_USED_ARGUMENT_TYPE(mock_call, arg_name, arg_type) \
XinZhangMS 0:f7f1f0d76dd6 56 mock_call->C2(override_argument_type_,arg_name) != NULL ? mock_call->C2(override_argument_type_,arg_name) : #arg_type
XinZhangMS 0:f7f1f0d76dd6 57
XinZhangMS 0:f7f1f0d76dd6 58 #define COPY_ARG_TO_MOCK_STRUCT(arg_type, arg_name) umocktypes_copy(#arg_type, (void*)&mock_call_data->arg_name, (void*)&arg_name);
XinZhangMS 0:f7f1f0d76dd6 59 #define DECLARE_MOCK_CALL_STRUCT_STACK(arg_type, arg_name) arg_type arg_name;
XinZhangMS 0:f7f1f0d76dd6 60 #define MARK_ARG_AS_NOT_IGNORED(arg_type, arg_name) mock_call_data->C2(is_ignored_, arg_name) = ARG_IS_NOT_IGNORED;
XinZhangMS 0:f7f1f0d76dd6 61 #define CLEAR_VALIDATE_ARG_VALUE(arg_type, arg_name) mock_call_data->C2(validate_arg_value_pointer_, arg_name) = NULL;
XinZhangMS 0:f7f1f0d76dd6 62 #define CLEAR_OVERRIDE_ARGUMENT_TYPE(arg_type, arg_name) mock_call_data->C2(override_argument_type_, arg_name) = NULL;
XinZhangMS 0:f7f1f0d76dd6 63 #define MARK_ARG_AS_IGNORED(arg_type, arg_name) mock_call_data->C2(is_ignored_, arg_name) = ARG_IS_IGNORED;
XinZhangMS 0:f7f1f0d76dd6 64 #define CLEAR_OUT_ARG_BUFFERS(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 65 C2(mock_call_data->out_arg_buffer_,arg_name).bytes = NULL; \
XinZhangMS 0:f7f1f0d76dd6 66 mock_call_data->out_arg_buffers[COUNT_OF(mock_call_data->out_arg_buffers) - DIV2(count)] = &C2(mock_call_data->out_arg_buffer_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 67 #define CLEAR_VALIDATE_ARG_BUFFERS(count, arg_type, arg_name) mock_call_data->validate_arg_buffers[COUNT_OF(mock_call_data->validate_arg_buffers) - DIV2(count)].bytes = NULL;
XinZhangMS 0:f7f1f0d76dd6 68 #define FREE_ARG_VALUE(count, arg_type, arg_name) umocktypes_free(GET_USED_ARGUMENT_TYPE(typed_mock_call_data, arg_name, arg_type), (void*)&typed_mock_call_data->arg_name);
XinZhangMS 0:f7f1f0d76dd6 69 #define FREE_OUT_ARG_BUFFERS(count, arg_type, arg_name) umockalloc_free(typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->bytes);
XinZhangMS 0:f7f1f0d76dd6 70 #define FREE_VALIDATE_ARG_BUFFERS(count, arg_type, arg_name) umockalloc_free(typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].bytes);
XinZhangMS 0:f7f1f0d76dd6 71 #define FREE_OVERRIDE_ARGUMENT_TYPE(count, arg_type, arg_name) umockalloc_free(typed_mock_call_data->C2(override_argument_type_, arg_name));
XinZhangMS 0:f7f1f0d76dd6 72
XinZhangMS 0:f7f1f0d76dd6 73 #define COPY_IGNORE_ARG(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 74 result->C2(is_ignored_, arg_name) = typed_mock_call_data->C2(is_ignored_, arg_name);
XinZhangMS 0:f7f1f0d76dd6 75
XinZhangMS 0:f7f1f0d76dd6 76 #define COPY_VALIDATE_ARG_VALUE(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 77 result->C2(validate_arg_value_pointer_, arg_name) = typed_mock_call_data->C2(validate_arg_value_pointer_, arg_name);
XinZhangMS 0:f7f1f0d76dd6 78
XinZhangMS 0:f7f1f0d76dd6 79 #define COPY_OVERRIDE_ARGUMENT_TYPE(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 80 result->C2(override_argument_type_, arg_name) = (typed_mock_call_data->C2(override_argument_type_, arg_name) == NULL) ? NULL : umockstring_clone(typed_mock_call_data->C2(override_argument_type_, arg_name));
XinZhangMS 0:f7f1f0d76dd6 81
XinZhangMS 0:f7f1f0d76dd6 82 #define COPY_ARG_VALUE(arg_type, arg_name) umocktypes_copy(GET_USED_ARGUMENT_TYPE(typed_mock_call_data, arg_name, arg_type), (void*)&result->arg_name, (void*)&typed_mock_call_data->arg_name);
XinZhangMS 0:f7f1f0d76dd6 83 #define COPY_OUT_ARG_BUFFERS(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 84 result->out_arg_buffers[COUNT_OF(result->out_arg_buffers) - DIV2(count)] = &result->C2(out_arg_buffer_,arg_name); \
XinZhangMS 0:f7f1f0d76dd6 85 result->out_arg_buffers[COUNT_OF(result->out_arg_buffers) - DIV2(count)]->length = typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->length; \
XinZhangMS 0:f7f1f0d76dd6 86 if (typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->bytes != NULL) \
XinZhangMS 0:f7f1f0d76dd6 87 { \
XinZhangMS 0:f7f1f0d76dd6 88 result->out_arg_buffers[COUNT_OF(result->out_arg_buffers) - DIV2(count)]->bytes = umockalloc_malloc(typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->length); \
XinZhangMS 0:f7f1f0d76dd6 89 (void)memcpy(result->out_arg_buffers[COUNT_OF(result->out_arg_buffers) - DIV2(count)]->bytes, typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->bytes, typed_mock_call_data->out_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)]->length); \
XinZhangMS 0:f7f1f0d76dd6 90 } \
XinZhangMS 0:f7f1f0d76dd6 91 else \
XinZhangMS 0:f7f1f0d76dd6 92 { \
XinZhangMS 0:f7f1f0d76dd6 93 result->out_arg_buffers[COUNT_OF(result->out_arg_buffers) - DIV2(count)]->bytes = NULL; \
XinZhangMS 0:f7f1f0d76dd6 94 }
XinZhangMS 0:f7f1f0d76dd6 95
XinZhangMS 0:f7f1f0d76dd6 96 #define COPY_VALIDATE_ARG_BUFFERS(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 97 result->validate_arg_buffers[COUNT_OF(result->validate_arg_buffers) - DIV2(count)].length = typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].length; \
XinZhangMS 0:f7f1f0d76dd6 98 if (typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].bytes != NULL) \
XinZhangMS 0:f7f1f0d76dd6 99 { \
XinZhangMS 0:f7f1f0d76dd6 100 result->validate_arg_buffers[COUNT_OF(result->validate_arg_buffers) - DIV2(count)].bytes = umockalloc_malloc(typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].length); \
XinZhangMS 0:f7f1f0d76dd6 101 (void)memcpy(result->validate_arg_buffers[COUNT_OF(result->validate_arg_buffers) - DIV2(count)].bytes, typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].bytes, typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].length); \
XinZhangMS 0:f7f1f0d76dd6 102 } \
XinZhangMS 0:f7f1f0d76dd6 103 else \
XinZhangMS 0:f7f1f0d76dd6 104 { \
XinZhangMS 0:f7f1f0d76dd6 105 result->validate_arg_buffers[COUNT_OF(result->validate_arg_buffers) - DIV2(count)].bytes = NULL; \
XinZhangMS 0:f7f1f0d76dd6 106 }
XinZhangMS 0:f7f1f0d76dd6 107
XinZhangMS 0:f7f1f0d76dd6 108 #define ONLY_FIRST_ARG(arg0type, arg0name, ...) arg0name
XinZhangMS 0:f7f1f0d76dd6 109 #define FILL_ARG_IN_METADATA(arg_type, arg_name) { TOSTRING(arg_type), TOSTRING(arg_name) },
XinZhangMS 0:f7f1f0d76dd6 110 #define ARG_IN_SIGNATURE(count, arg_type, arg_name) arg_type arg_name IFCOMMA(count)
XinZhangMS 0:f7f1f0d76dd6 111 #define ARG_NAME_ONLY_IN_CALL(count, arg_type, arg_name) arg_name IFCOMMA(count)
XinZhangMS 0:f7f1f0d76dd6 112 #define ONLY_FIRST_ARG_NAME_IN_CALL(count, arg_type, arg_name) count
XinZhangMS 0:f7f1f0d76dd6 113 #define ARG_ASSIGN_IN_ARRAY(arg_type, arg_name) arg_name_local
XinZhangMS 0:f7f1f0d76dd6 114 #define DECLARE_VALIDATE_ARG_VALUE(arg_type, arg_name) void* C2(validate_arg_value_pointer_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 115 #define DECLARE_IGNORE_FLAG_FOR_ARG(arg_type, arg_name) int C2(is_ignored_,arg_name) : 1;
XinZhangMS 0:f7f1f0d76dd6 116 #define DECLARE_OVERRIDE_ARGUMENT_TYPE_FOR_ARG(arg_type, arg_name) char* C2(override_argument_type_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 117 #define DECLARE_OUT_ARG_BUFFER_FOR_ARG(arg_type, arg_name) ARG_BUFFER C2(out_arg_buffer_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 118 #define COPY_IGNORE_ARG_BY_NAME_TO_MODIFIER(name, arg_type, arg_name) C2(mock_call_modifier->IgnoreArgument_,arg_name) = C4(ignore_argument_func_,name,_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 119 #define COPY_VALIDATE_ARG_BY_NAME_TO_MODIFIER(name, arg_type, arg_name) C2(mock_call_modifier->ValidateArgument_,arg_name) = C4(validate_argument_func_,name,_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 120 #define COPY_COPY_OUT_ARGUMENT_BUFFER_BY_NAME_TO_MODIFIER(name, arg_type, arg_name) C2(mock_call_modifier->CopyOutArgumentBuffer_,arg_name) = C4(copy_out_argument_buffer_func_,name,_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 121 #define COPY_VALIDATE_ARGUMENT_VALUE_BY_NAME_TO_MODIFIER(name, arg_type, arg_name) C2(mock_call_modifier->ValidateArgumentValue_,arg_name) = C4(validate_argument_value_func_,name,_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 122 #define COPY_VALIDATE_ARGUMENT_VALUE_AS_TYPE_BY_NAME_TO_MODIFIER(name, arg_type, arg_name) C3(mock_call_modifier->ValidateArgumentValue_,arg_name,_AsType) = C4(validate_argument_value_as_type_func_,name,_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 123 #define COPY_OUT_ARG_VALUE_FROM_MATCHED_CALL(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 124 if (matched_call_data->out_arg_buffers[COUNT_OF(matched_call_data->out_arg_buffers) - DIV2(count)]->bytes != NULL) \
XinZhangMS 0:f7f1f0d76dd6 125 { \
XinZhangMS 0:f7f1f0d76dd6 126 (void)memcpy(*((void**)(&arg_name)), matched_call_data->out_arg_buffers[COUNT_OF(matched_call_data->out_arg_buffers) - DIV2(count)]->bytes, matched_call_data->out_arg_buffers[COUNT_OF(matched_call_data->out_arg_buffers) - DIV2(count)]->length); \
XinZhangMS 0:f7f1f0d76dd6 127 } \
XinZhangMS 0:f7f1f0d76dd6 128
XinZhangMS 0:f7f1f0d76dd6 129 #define STRINGIFY_ARGS_DECLARE_RESULT_VAR(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 130 char* C2(arg_name,_stringified) \
XinZhangMS 0:f7f1f0d76dd6 131 = (C2(typed_mock_call_data->validate_arg_value_pointer_, arg_name) != NULL) ? \
XinZhangMS 0:f7f1f0d76dd6 132 umocktypes_stringify(TOSTRING(arg_type), (void*)C2(typed_mock_call_data->validate_arg_value_pointer_, arg_name)) : \
XinZhangMS 0:f7f1f0d76dd6 133 ((typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->out_arg_buffers) - DIV2(count)].bytes != NULL) ? \
XinZhangMS 0:f7f1f0d76dd6 134 umockc_stringify_buffer(typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].bytes, typed_mock_call_data->validate_arg_buffers[COUNT_OF(typed_mock_call_data->validate_arg_buffers) - DIV2(count)].length) : \
XinZhangMS 0:f7f1f0d76dd6 135 umocktypes_stringify(TOSTRING(arg_type), (void*)&typed_mock_call_data->arg_name));
XinZhangMS 0:f7f1f0d76dd6 136
XinZhangMS 0:f7f1f0d76dd6 137 #define STRINGIFY_ARGS_CHECK_ARG_STRINGIFY_SUCCESS(arg_type, arg_name) if (C2(arg_name,_stringified) == NULL) is_error = 1;
XinZhangMS 0:f7f1f0d76dd6 138 #define STRINGIFY_ARGS_DECLARE_ARG_STRING_LENGTH(arg_type, arg_name) size_t C2(arg_name,_stringified_length) = strlen(C2(arg_name,_stringified));
XinZhangMS 0:f7f1f0d76dd6 139 #define STRINGIFY_ARGS_COUNT_LENGTH(arg_type, arg_name) args_string_length += C2(arg_name,_stringified_length);
XinZhangMS 0:f7f1f0d76dd6 140 #define STRINGIFY_ARGS_FREE_STRINGIFIED_ARG(arg_type, arg_name) umockalloc_free(C2(arg_name,_stringified));
XinZhangMS 0:f7f1f0d76dd6 141 #define STRINGIFY_ARGS_COPY_ARG_STRING(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 142 if (arg_index > 0) \
XinZhangMS 0:f7f1f0d76dd6 143 { \
XinZhangMS 0:f7f1f0d76dd6 144 result[current_pos] = ','; \
XinZhangMS 0:f7f1f0d76dd6 145 current_pos++; \
XinZhangMS 0:f7f1f0d76dd6 146 } \
XinZhangMS 0:f7f1f0d76dd6 147 (void)memcpy(result + current_pos, C2(arg_name,_stringified), C2(arg_name,_stringified_length) + 1); \
XinZhangMS 0:f7f1f0d76dd6 148 current_pos += C2(arg_name, _stringified_length); \
XinZhangMS 0:f7f1f0d76dd6 149 arg_index++;
XinZhangMS 0:f7f1f0d76dd6 150
XinZhangMS 0:f7f1f0d76dd6 151 /* Codes_SRS_UMOCK_C_LIB_01_096: [If the content of the code under test buffer and the buffer supplied to ValidateArgumentBuffer does not match then this should be treated as a mismatch in argument comparison for that argument.]*/
XinZhangMS 0:f7f1f0d76dd6 152 #define ARE_EQUAL_FOR_ARG(count, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 153 if (result && \
XinZhangMS 0:f7f1f0d76dd6 154 (((typed_left->validate_arg_buffers[COUNT_OF(typed_left->validate_arg_buffers) - DIV2(count)].bytes != NULL) && (memcmp(*((void**)&typed_right->arg_name), typed_left->validate_arg_buffers[COUNT_OF(typed_left->validate_arg_buffers) - DIV2(count)].bytes, typed_left->validate_arg_buffers[COUNT_OF(typed_left->validate_arg_buffers) - DIV2(count)].length) != 0)) \
XinZhangMS 0:f7f1f0d76dd6 155 || ((typed_right->validate_arg_buffers[COUNT_OF(typed_right->validate_arg_buffers) - DIV2(count)].bytes != NULL) && (memcmp(*((void**)&typed_left->arg_name), typed_right->validate_arg_buffers[COUNT_OF(typed_right->validate_arg_buffers) - DIV2(count)].bytes, typed_right->validate_arg_buffers[COUNT_OF(typed_right->validate_arg_buffers) - DIV2(count)].length) != 0))) \
XinZhangMS 0:f7f1f0d76dd6 156 ) \
XinZhangMS 0:f7f1f0d76dd6 157 { \
XinZhangMS 0:f7f1f0d76dd6 158 result = 0; \
XinZhangMS 0:f7f1f0d76dd6 159 } \
XinZhangMS 0:f7f1f0d76dd6 160 if ((result == 1) && (C2(typed_left->is_ignored_, arg_name) == ARG_IS_NOT_IGNORED) \
XinZhangMS 0:f7f1f0d76dd6 161 && (C2(typed_right->is_ignored_, arg_name) == ARG_IS_NOT_IGNORED)) \
XinZhangMS 0:f7f1f0d76dd6 162 { \
XinZhangMS 0:f7f1f0d76dd6 163 void* left_value; \
XinZhangMS 0:f7f1f0d76dd6 164 void* right_value; \
XinZhangMS 0:f7f1f0d76dd6 165 if (C2(typed_left->validate_arg_value_pointer_, arg_name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 166 { \
XinZhangMS 0:f7f1f0d76dd6 167 left_value = (void*)C2(typed_left->validate_arg_value_pointer_, arg_name); \
XinZhangMS 0:f7f1f0d76dd6 168 } \
XinZhangMS 0:f7f1f0d76dd6 169 else \
XinZhangMS 0:f7f1f0d76dd6 170 { \
XinZhangMS 0:f7f1f0d76dd6 171 left_value = (void*)&typed_left->arg_name; \
XinZhangMS 0:f7f1f0d76dd6 172 } \
XinZhangMS 0:f7f1f0d76dd6 173 if (C2(typed_right->validate_arg_value_pointer_, arg_name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 174 { \
XinZhangMS 0:f7f1f0d76dd6 175 right_value = (void*)C2(typed_right->validate_arg_value_pointer_, arg_name); \
XinZhangMS 0:f7f1f0d76dd6 176 } \
XinZhangMS 0:f7f1f0d76dd6 177 else \
XinZhangMS 0:f7f1f0d76dd6 178 { \
XinZhangMS 0:f7f1f0d76dd6 179 right_value = (void*)&typed_right->arg_name; \
XinZhangMS 0:f7f1f0d76dd6 180 } \
XinZhangMS 0:f7f1f0d76dd6 181 result = umocktypes_are_equal(GET_USED_ARGUMENT_TYPE(typed_left, arg_name, arg_type), left_value, right_value); \
XinZhangMS 0:f7f1f0d76dd6 182 }
XinZhangMS 0:f7f1f0d76dd6 183
XinZhangMS 0:f7f1f0d76dd6 184 #define DECLARE_MOCK_CALL_MODIFIER(name, ...) \
XinZhangMS 0:f7f1f0d76dd6 185 C2(mock_call_modifier_,name) mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 186 C2(fill_mock_call_modifier_,name)(&mock_call_modifier);
XinZhangMS 0:f7f1f0d76dd6 187
XinZhangMS 0:f7f1f0d76dd6 188 #define DECLARE_IGNORE_ARGUMENT_FUNCTION_PROTOTYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 189 static C2(mock_call_modifier_,name) C4(ignore_argument_func_,name,_,arg_name)(void);
XinZhangMS 0:f7f1f0d76dd6 190
XinZhangMS 0:f7f1f0d76dd6 191 #define DECLARE_VALIDATE_ARGUMENT_FUNCTION_PROTOTYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 192 static C2(mock_call_modifier_,name) C4(validate_argument_func_,name,_,arg_name)(void);
XinZhangMS 0:f7f1f0d76dd6 193
XinZhangMS 0:f7f1f0d76dd6 194 #define DECLARE_COPY_OUT_ARGUMENT_BUFFER_FUNCTION_PROTOTYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 195 static C2(mock_call_modifier_,name) C4(copy_out_argument_buffer_func_,name,_,arg_name)(const void* bytes, size_t length);
XinZhangMS 0:f7f1f0d76dd6 196
XinZhangMS 0:f7f1f0d76dd6 197 #define DECLARE_VALIDATE_ARGUMENT_VALUE_FUNCTION_PROTOTYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 198 static C2(mock_call_modifier_,name) C4(validate_argument_value_func_,name,_,arg_name)(arg_type* arg_value);
XinZhangMS 0:f7f1f0d76dd6 199
XinZhangMS 0:f7f1f0d76dd6 200 #define DECLARE_VALIDATE_ARGUMENT_VALUE_AS_TYPE_FUNCTION_PROTOTYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 201 static C2(mock_call_modifier_,name) C4(validate_argument_value_as_type_func_,name,_,arg_name)(const char* type_name);
XinZhangMS 0:f7f1f0d76dd6 202
XinZhangMS 0:f7f1f0d76dd6 203 #define IGNORE_ARGUMENT_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 204 C4(ignore_argument_func_type_,name,_,arg_name) C2(IgnoreArgument_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 205
XinZhangMS 0:f7f1f0d76dd6 206 #define VALIDATE_ARGUMENT_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 207 C4(validate_argument_func_type_,name,_,arg_name) C2(ValidateArgument_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 208
XinZhangMS 0:f7f1f0d76dd6 209 #define COPY_OUT_ARGUMENT_BUFFER_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 210 C4(copy_out_argument_buffer_func_type_,name,_,arg_name) C2(CopyOutArgumentBuffer_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 211
XinZhangMS 0:f7f1f0d76dd6 212 #define VALIDATE_ARGUMENT_VALUE_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 213 C4(validate_argument_value_func_type_,name,_,arg_name) C2(ValidateArgumentValue_,arg_name);
XinZhangMS 0:f7f1f0d76dd6 214
XinZhangMS 0:f7f1f0d76dd6 215 #define VALIDATE_ARGUMENT_VALUE_AS_TYPE_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 216 C4(validate_argument_value_as_type_func_type_,name,_,arg_name) C3(ValidateArgumentValue_,arg_name,_AsType);
XinZhangMS 0:f7f1f0d76dd6 217
XinZhangMS 0:f7f1f0d76dd6 218 #define ARG_RELATED_FUNCTIONS_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 219 IGNORE_ARGUMENT_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 220 VALIDATE_ARGUMENT_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 221 COPY_OUT_ARGUMENT_BUFFER_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 222 VALIDATE_ARGUMENT_VALUE_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 223 VALIDATE_ARGUMENT_VALUE_AS_TYPE_FUNCTION_IN_MODIFIERS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 224
XinZhangMS 0:f7f1f0d76dd6 225 #define DECLARE_IGNORE_ARGUMENT_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 226 typedef struct C2(_mock_call_modifier_,name) (*C4(ignore_argument_func_type_,name,_,arg_name))(void);
XinZhangMS 0:f7f1f0d76dd6 227
XinZhangMS 0:f7f1f0d76dd6 228 #define DECLARE_VALIDATE_ARGUMENT_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 229 typedef struct C2(_mock_call_modifier_,name) (*C4(validate_argument_func_type_,name,_,arg_name))(void);
XinZhangMS 0:f7f1f0d76dd6 230
XinZhangMS 0:f7f1f0d76dd6 231 #define DECLARE_COPY_OUT_ARGUMENT_BUFFER_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 232 typedef struct C2(_mock_call_modifier_,name) (*C4(copy_out_argument_buffer_func_type_,name,_,arg_name))(const void* bytes, size_t length);
XinZhangMS 0:f7f1f0d76dd6 233
XinZhangMS 0:f7f1f0d76dd6 234 #define DECLARE_VALIDATE_ARGUMENT_VALUE_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 235 typedef struct C2(_mock_call_modifier_,name) (*C4(validate_argument_value_func_type_,name,_,arg_name))(arg_type* arg_value);
XinZhangMS 0:f7f1f0d76dd6 236
XinZhangMS 0:f7f1f0d76dd6 237 #define DECLARE_VALIDATE_ARGUMENT_AS_TYPE_VALUE_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 238 typedef struct C2(_mock_call_modifier_,name) (*C4(validate_argument_value_as_type_func_type_,name,_,arg_name))(const char* type_name);
XinZhangMS 0:f7f1f0d76dd6 239
XinZhangMS 0:f7f1f0d76dd6 240 #define DECLARE_ARG_RELATED_FUNCTIONS(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 241 DECLARE_IGNORE_ARGUMENT_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 242 DECLARE_VALIDATE_ARGUMENT_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 243 DECLARE_COPY_OUT_ARGUMENT_BUFFER_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 244 DECLARE_VALIDATE_ARGUMENT_VALUE_FUNCTION_TYPE(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 245 DECLARE_VALIDATE_ARGUMENT_AS_TYPE_VALUE_FUNCTION_TYPE(name, arg_type, arg_name)
XinZhangMS 0:f7f1f0d76dd6 246
XinZhangMS 0:f7f1f0d76dd6 247 #define IGNORE_ARGUMENT_FUNCTION_IN_ARRAY(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 248 &C4(ignore_argument_func_,name,_,arg_name),
XinZhangMS 0:f7f1f0d76dd6 249
XinZhangMS 0:f7f1f0d76dd6 250 #define VALIDATE_ARGUMENT_FUNCTION_IN_ARRAY(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 251 &C4(validate_argument_func_,name,_,arg_name),
XinZhangMS 0:f7f1f0d76dd6 252
XinZhangMS 0:f7f1f0d76dd6 253 /* These 2 macros are used to check if a type is "void" or not */
XinZhangMS 0:f7f1f0d76dd6 254 #define TEST_void 0
XinZhangMS 0:f7f1f0d76dd6 255 #define IS_NOT_VOID(x) \
XinZhangMS 0:f7f1f0d76dd6 256 IF(C2(TEST_,x), 1, 0)
XinZhangMS 0:f7f1f0d76dd6 257
XinZhangMS 0:f7f1f0d76dd6 258 /* Codes_SRS_UMOCK_C_LIB_01_076: [The IgnoreAllArguments call modifier shall record that for that specific call all arguments will be ignored for that specific call.] */
XinZhangMS 0:f7f1f0d76dd6 259 #define IMPLEMENT_IGNORE_ALL_ARGUMENTS_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 260 static C2(mock_call_modifier_,name) C2(ignore_all_arguments_func_,name)(void) \
XinZhangMS 0:f7f1f0d76dd6 261 { \
XinZhangMS 0:f7f1f0d76dd6 262 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 263 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 264 IF(COUNT_ARG(__VA_ARGS__), FOR_EACH_2(MARK_ARG_AS_IGNORED, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 265 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 266 } \
XinZhangMS 0:f7f1f0d76dd6 267
XinZhangMS 0:f7f1f0d76dd6 268 /* Codes_SRS_UMOCK_C_LIB_01_077: [The ValidateAllArguments call modifier shall record that for that specific call all arguments will be validated.] */
XinZhangMS 0:f7f1f0d76dd6 269 #define IMPLEMENT_VALIDATE_ALL_ARGUMENTS_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 270 static C2(mock_call_modifier_,name) C2(validate_all_arguments_func_,name)(void) \
XinZhangMS 0:f7f1f0d76dd6 271 { \
XinZhangMS 0:f7f1f0d76dd6 272 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 273 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 274 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 275 { \
XinZhangMS 0:f7f1f0d76dd6 276 UMOCK_LOG("ValidateAllArguments called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 277 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 278 } \
XinZhangMS 0:f7f1f0d76dd6 279 else \
XinZhangMS 0:f7f1f0d76dd6 280 { \
XinZhangMS 0:f7f1f0d76dd6 281 IF(COUNT_ARG(__VA_ARGS__), FOR_EACH_2(MARK_ARG_AS_NOT_IGNORED, __VA_ARGS__), ) \
XinZhangMS 0:f7f1f0d76dd6 282 } \
XinZhangMS 0:f7f1f0d76dd6 283 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 284 } \
XinZhangMS 0:f7f1f0d76dd6 285
XinZhangMS 0:f7f1f0d76dd6 286 /* Codes_SRS_UMOCK_C_LIB_01_078: [The IgnoreArgument_{arg_name} call modifier shall record that the argument identified by arg_name will be ignored for that specific call.] */
XinZhangMS 0:f7f1f0d76dd6 287 #define IMPLEMENT_IGNORE_ARGUMENT_BY_NAME_FUNCTION(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 288 static C2(mock_call_modifier_,name) C4(ignore_argument_func_,name,_,arg_name)(void) \
XinZhangMS 0:f7f1f0d76dd6 289 { \
XinZhangMS 0:f7f1f0d76dd6 290 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 291 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 292 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 293 { \
XinZhangMS 0:f7f1f0d76dd6 294 UMOCK_LOG("IgnoreArgument_%s called without having an expected call.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 295 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 296 } \
XinZhangMS 0:f7f1f0d76dd6 297 else \
XinZhangMS 0:f7f1f0d76dd6 298 { \
XinZhangMS 0:f7f1f0d76dd6 299 C2(mock_call_data->is_ignored_,arg_name) = ARG_IS_IGNORED; \
XinZhangMS 0:f7f1f0d76dd6 300 } \
XinZhangMS 0:f7f1f0d76dd6 301 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 302 } \
XinZhangMS 0:f7f1f0d76dd6 303
XinZhangMS 0:f7f1f0d76dd6 304 /* Codes_SRS_UMOCK_C_LIB_01_079: [The ValidateArgument_{arg_name} call modifier shall record that the argument identified by arg_name will be validated for that specific call.]*/
XinZhangMS 0:f7f1f0d76dd6 305 #define IMPLEMENT_VALIDATE_ARGUMENT_BY_NAME_FUNCTION(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 306 static C2(mock_call_modifier_,name) C4(validate_argument_func_,name,_,arg_name)(void) \
XinZhangMS 0:f7f1f0d76dd6 307 { \
XinZhangMS 0:f7f1f0d76dd6 308 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 309 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 310 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 311 { \
XinZhangMS 0:f7f1f0d76dd6 312 UMOCK_LOG("ValidateArgument_%s called without having an expected call.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 313 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 314 } \
XinZhangMS 0:f7f1f0d76dd6 315 else \
XinZhangMS 0:f7f1f0d76dd6 316 { \
XinZhangMS 0:f7f1f0d76dd6 317 C2(mock_call_data->is_ignored_,arg_name) = ARG_IS_NOT_IGNORED; \
XinZhangMS 0:f7f1f0d76dd6 318 } \
XinZhangMS 0:f7f1f0d76dd6 319 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 320 } \
XinZhangMS 0:f7f1f0d76dd6 321
XinZhangMS 0:f7f1f0d76dd6 322 /* Codes_SRS_UMOCK_C_LIB_01_080: [The IgnoreArgument call modifier shall record that the indexth argument will be ignored for that specific call.]*/
XinZhangMS 0:f7f1f0d76dd6 323 /* Codes_SRS_UMOCK_C_LIB_01_081: [If the index is out of range umock_c shall raise an error with the code UMOCK_C_ARG_INDEX_OUT_OF_RANGE.] */
XinZhangMS 0:f7f1f0d76dd6 324 #define IMPLEMENT_IGNORE_ARGUMENT_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 325 static C2(mock_call_modifier_,name) C2(ignore_argument_func_,name)(size_t arg_index) \
XinZhangMS 0:f7f1f0d76dd6 326 { \
XinZhangMS 0:f7f1f0d76dd6 327 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 328 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 329 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 330 { \
XinZhangMS 0:f7f1f0d76dd6 331 UMOCK_LOG("IgnoreArgument called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 332 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 333 } \
XinZhangMS 0:f7f1f0d76dd6 334 else \
XinZhangMS 0:f7f1f0d76dd6 335 { \
XinZhangMS 0:f7f1f0d76dd6 336 IF(COUNT_ARG(__VA_ARGS__), \
XinZhangMS 0:f7f1f0d76dd6 337 if ((arg_index < 1) || (arg_index > (sizeof(C2(ignore_one_argument_array_,name)) / sizeof(C2(ignore_one_argument_array_,name)[0])))) \
XinZhangMS 0:f7f1f0d76dd6 338 { \
XinZhangMS 0:f7f1f0d76dd6 339 UMOCK_LOG("Bad argument index in call to IgnoreArgument %lu.", arg_index); \
XinZhangMS 0:f7f1f0d76dd6 340 umock_c_indicate_error(UMOCK_C_ARG_INDEX_OUT_OF_RANGE); \
XinZhangMS 0:f7f1f0d76dd6 341 } \
XinZhangMS 0:f7f1f0d76dd6 342 else \
XinZhangMS 0:f7f1f0d76dd6 343 { \
XinZhangMS 0:f7f1f0d76dd6 344 C2(ignore_one_argument_array_,name)[arg_index - 1](); \
XinZhangMS 0:f7f1f0d76dd6 345 }, \
XinZhangMS 0:f7f1f0d76dd6 346 ) \
XinZhangMS 0:f7f1f0d76dd6 347 } \
XinZhangMS 0:f7f1f0d76dd6 348 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 349 } \
XinZhangMS 0:f7f1f0d76dd6 350
XinZhangMS 0:f7f1f0d76dd6 351 /* Codes_SRS_UMOCK_C_LIB_01_082: [The ValidateArgument call modifier shall record that the indexth argument will be validated for that specific call.]*/
XinZhangMS 0:f7f1f0d76dd6 352 /* Codes_SRS_UMOCK_C_LIB_01_083: [If the index is out of range umock_c shall raise an error with the code UMOCK_C_ARG_INDEX_OUT_OF_RANGE.]*/
XinZhangMS 0:f7f1f0d76dd6 353 #define IMPLEMENT_VALIDATE_ARGUMENT_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 354 static C2(mock_call_modifier_,name) C2(validate_argument_func_,name)(size_t arg_index) \
XinZhangMS 0:f7f1f0d76dd6 355 { \
XinZhangMS 0:f7f1f0d76dd6 356 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 357 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 358 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 359 { \
XinZhangMS 0:f7f1f0d76dd6 360 UMOCK_LOG("ValidateArgument called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 361 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 362 } \
XinZhangMS 0:f7f1f0d76dd6 363 else \
XinZhangMS 0:f7f1f0d76dd6 364 { \
XinZhangMS 0:f7f1f0d76dd6 365 IF(COUNT_ARG(__VA_ARGS__), \
XinZhangMS 0:f7f1f0d76dd6 366 if ((arg_index < 1) || (arg_index > (sizeof(C2(validate_one_argument_array_,name)) / sizeof(C2(validate_one_argument_array_,name)[0])))) \
XinZhangMS 0:f7f1f0d76dd6 367 { \
XinZhangMS 0:f7f1f0d76dd6 368 UMOCK_LOG("Bad argument index in call to ValidateArgument %lu.", arg_index); \
XinZhangMS 0:f7f1f0d76dd6 369 umock_c_indicate_error(UMOCK_C_ARG_INDEX_OUT_OF_RANGE); \
XinZhangMS 0:f7f1f0d76dd6 370 } \
XinZhangMS 0:f7f1f0d76dd6 371 else \
XinZhangMS 0:f7f1f0d76dd6 372 { \
XinZhangMS 0:f7f1f0d76dd6 373 C2(validate_one_argument_array_,name)[arg_index - 1](); \
XinZhangMS 0:f7f1f0d76dd6 374 }, \
XinZhangMS 0:f7f1f0d76dd6 375 ) \
XinZhangMS 0:f7f1f0d76dd6 376 } \
XinZhangMS 0:f7f1f0d76dd6 377 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 378 } \
XinZhangMS 0:f7f1f0d76dd6 379
XinZhangMS 0:f7f1f0d76dd6 380 /* Codes_SRS_UMOCK_C_LIB_01_084: [The SetReturn call modifier shall record that when an actual call is matched with the specific expected call, it shall return the result value to the code under test.] */
XinZhangMS 0:f7f1f0d76dd6 381 #define IMPLEMENT_SET_RETURN_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 382 static C2(mock_call_modifier_,name) C2(set_return_func_,name)(return_type return_value) \
XinZhangMS 0:f7f1f0d76dd6 383 { \
XinZhangMS 0:f7f1f0d76dd6 384 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 385 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 386 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 387 { \
XinZhangMS 0:f7f1f0d76dd6 388 UMOCK_LOG("SetReturn called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 389 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 390 } \
XinZhangMS 0:f7f1f0d76dd6 391 else \
XinZhangMS 0:f7f1f0d76dd6 392 { \
XinZhangMS 0:f7f1f0d76dd6 393 mock_call_data->return_value_set = RETURN_VALUE_SET; \
XinZhangMS 0:f7f1f0d76dd6 394 if (umocktypes_copy(#return_type, (void*)&mock_call_data->return_value, (void*)&return_value) != 0) \
XinZhangMS 0:f7f1f0d76dd6 395 { \
XinZhangMS 0:f7f1f0d76dd6 396 UMOCK_LOG("Could not copy return value of type %s.", TOSTRING(return_type)); \
XinZhangMS 0:f7f1f0d76dd6 397 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 398 } \
XinZhangMS 0:f7f1f0d76dd6 399 } \
XinZhangMS 0:f7f1f0d76dd6 400 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 401 }
XinZhangMS 0:f7f1f0d76dd6 402
XinZhangMS 0:f7f1f0d76dd6 403 /* Codes_SRS_UMOCK_C_LIB_01_085: [The SetFailReturn call modifier shall record a fail return value.]*/
XinZhangMS 0:f7f1f0d76dd6 404 #define IMPLEMENT_SET_FAIL_RETURN_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 405 static C2(mock_call_modifier_,name) C2(set_fail_return_func_,name)(return_type return_value) \
XinZhangMS 0:f7f1f0d76dd6 406 { \
XinZhangMS 0:f7f1f0d76dd6 407 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 408 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 409 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 410 { \
XinZhangMS 0:f7f1f0d76dd6 411 UMOCK_LOG("SetFailReturn called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 412 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 413 } \
XinZhangMS 0:f7f1f0d76dd6 414 else \
XinZhangMS 0:f7f1f0d76dd6 415 { \
XinZhangMS 0:f7f1f0d76dd6 416 mock_call_data->fail_return_value_set = FAIL_RETURN_VALUE_SET; \
XinZhangMS 0:f7f1f0d76dd6 417 if (umocktypes_copy(#return_type, (void*)&mock_call_data->fail_return_value, (void*)&return_value) != 0) \
XinZhangMS 0:f7f1f0d76dd6 418 { \
XinZhangMS 0:f7f1f0d76dd6 419 UMOCK_LOG("Could not copy fail return value of type %s.", TOSTRING(return_type)); \
XinZhangMS 0:f7f1f0d76dd6 420 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 421 } \
XinZhangMS 0:f7f1f0d76dd6 422 } \
XinZhangMS 0:f7f1f0d76dd6 423 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 424 }
XinZhangMS 0:f7f1f0d76dd6 425
XinZhangMS 0:f7f1f0d76dd6 426 /* Codes_SRS_UMOCK_C_LIB_01_116: [ The argument targetted by CopyOutArgument shall also be marked as ignored. ] */
XinZhangMS 0:f7f1f0d76dd6 427 /* Codes_SRS_UMOCK_C_LIB_01_088: [The memory shall be copied.]*/
XinZhangMS 0:f7f1f0d76dd6 428 /* Codes_SRS_UMOCK_C_LIB_01_091: [If the index is out of range umock_c shall raise an error with the code UMOCK_C_ARG_INDEX_OUT_OF_RANGE.]*/
XinZhangMS 0:f7f1f0d76dd6 429 /* Codes_SRS_UMOCK_C_LIB_01_117: [ If any memory allocation error occurs, umock_c shall raise an error with the code UMOCK_C_MALLOC_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 430 /* Codes_SRS_UMOCK_C_LIB_01_118: [ If any other error occurs, umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 431 /* Codes_SRS_UMOCK_C_LIB_01_092: [If bytes is NULL or length is 0, umock_c shall raise an error with the code UMOCK_C_INVALID_ARGUMENT_BUFFER.] */
XinZhangMS 0:f7f1f0d76dd6 432 /* Codes_SRS_UMOCK_C_LIB_01_089: [The buffers for previous CopyOutArgumentBuffer calls shall be freed.]*/
XinZhangMS 0:f7f1f0d76dd6 433 /* Codes_SRS_UMOCK_C_LIB_01_133: [ If several calls to CopyOutArgumentBuffer are made, only the last buffer shall be kept. ]*/
XinZhangMS 0:f7f1f0d76dd6 434 #define IMPLEMENT_COPY_OUT_ARGUMENT_BUFFER_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 435 static C2(mock_call_modifier_, name) C2(copy_out_argument_buffer_func_, name)(size_t index, const void* bytes, size_t length) \
XinZhangMS 0:f7f1f0d76dd6 436 { \
XinZhangMS 0:f7f1f0d76dd6 437 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 438 if ((index < 1) || (index > DIV2(COUNT_ARG(__VA_ARGS__)))) \
XinZhangMS 0:f7f1f0d76dd6 439 { \
XinZhangMS 0:f7f1f0d76dd6 440 UMOCK_LOG("Bad argument index in CopyOutArgumentBuffer: %lu.", index); \
XinZhangMS 0:f7f1f0d76dd6 441 umock_c_indicate_error(UMOCK_C_ARG_INDEX_OUT_OF_RANGE); \
XinZhangMS 0:f7f1f0d76dd6 442 } \
XinZhangMS 0:f7f1f0d76dd6 443 else if ((bytes == NULL) || (length == 0)) \
XinZhangMS 0:f7f1f0d76dd6 444 { \
XinZhangMS 0:f7f1f0d76dd6 445 UMOCK_LOG("Bad arguments to CopyOutArgumentBuffer: bytes = %p, length = %lu.", bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 446 umock_c_indicate_error(UMOCK_C_INVALID_ARGUMENT_BUFFER); \
XinZhangMS 0:f7f1f0d76dd6 447 } \
XinZhangMS 0:f7f1f0d76dd6 448 else \
XinZhangMS 0:f7f1f0d76dd6 449 { \
XinZhangMS 0:f7f1f0d76dd6 450 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 451 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 452 { \
XinZhangMS 0:f7f1f0d76dd6 453 UMOCK_LOG("CopyOutArgumentBuffer called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 454 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 455 } \
XinZhangMS 0:f7f1f0d76dd6 456 else \
XinZhangMS 0:f7f1f0d76dd6 457 { \
XinZhangMS 0:f7f1f0d76dd6 458 ARG_BUFFER* arg_buffer = mock_call_data->out_arg_buffers[index - 1]; \
XinZhangMS 0:f7f1f0d76dd6 459 umockalloc_free(arg_buffer->bytes); \
XinZhangMS 0:f7f1f0d76dd6 460 arg_buffer->bytes = umockalloc_malloc(length); \
XinZhangMS 0:f7f1f0d76dd6 461 if (arg_buffer->bytes == NULL) \
XinZhangMS 0:f7f1f0d76dd6 462 { \
XinZhangMS 0:f7f1f0d76dd6 463 UMOCK_LOG("Could not allocate memory for out argument buffers."); \
XinZhangMS 0:f7f1f0d76dd6 464 umock_c_indicate_error(UMOCK_C_MALLOC_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 465 } \
XinZhangMS 0:f7f1f0d76dd6 466 else \
XinZhangMS 0:f7f1f0d76dd6 467 { \
XinZhangMS 0:f7f1f0d76dd6 468 (void)memcpy(arg_buffer->bytes, bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 469 arg_buffer->length = length; \
XinZhangMS 0:f7f1f0d76dd6 470 mock_call_modifier.IgnoreArgument(index); \
XinZhangMS 0:f7f1f0d76dd6 471 } \
XinZhangMS 0:f7f1f0d76dd6 472 } \
XinZhangMS 0:f7f1f0d76dd6 473 } \
XinZhangMS 0:f7f1f0d76dd6 474 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 475 } \
XinZhangMS 0:f7f1f0d76dd6 476
XinZhangMS 0:f7f1f0d76dd6 477 /* Codes_SRS_UMOCK_C_LIB_01_154: [ The CopyOutArgumentBuffer_{arg_name} call modifier shall copy the memory pointed to by bytes and being length bytes so that it is later injected as an out argument when the code under test calls the mock function. ] */
XinZhangMS 0:f7f1f0d76dd6 478 /* Codes_SRS_UMOCK_C_LIB_01_163: [ The buffers for previous CopyOutArgumentBuffer calls shall be freed. ]*/
XinZhangMS 0:f7f1f0d76dd6 479 /* Codes_SRS_UMOCK_C_LIB_01_156: [ If several calls to CopyOutArgumentBuffer are made, only the last buffer shall be kept. ]*/
XinZhangMS 0:f7f1f0d76dd6 480 /* Codes_SRS_UMOCK_C_LIB_01_155: [ The memory shall be copied. ]*/
XinZhangMS 0:f7f1f0d76dd6 481 /* Codes_SRS_UMOCK_C_LIB_01_158: [ If bytes is NULL or length is 0, umock_c shall raise an error with the code UMOCK_C_INVALID_ARGUMENT_BUFFER. ] */
XinZhangMS 0:f7f1f0d76dd6 482 #define IMPLEMENT_COPY_OUT_ARGUMENT_BUFFER_BY_NAME_FUNCTION(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 483 static C2(mock_call_modifier_,name) C4(copy_out_argument_buffer_func_,name,_,arg_name)(const void* bytes, size_t length) \
XinZhangMS 0:f7f1f0d76dd6 484 { \
XinZhangMS 0:f7f1f0d76dd6 485 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 486 if ((bytes == NULL) || (length == 0)) \
XinZhangMS 0:f7f1f0d76dd6 487 { \
XinZhangMS 0:f7f1f0d76dd6 488 UMOCK_LOG("Bad arguments to CopyOutArgumentBuffer: bytes = %p, length = %lu.", bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 489 umock_c_indicate_error(UMOCK_C_INVALID_ARGUMENT_BUFFER); \
XinZhangMS 0:f7f1f0d76dd6 490 } \
XinZhangMS 0:f7f1f0d76dd6 491 else \
XinZhangMS 0:f7f1f0d76dd6 492 { \
XinZhangMS 0:f7f1f0d76dd6 493 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 494 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 495 { \
XinZhangMS 0:f7f1f0d76dd6 496 UMOCK_LOG("CopyOutArgumentBuffer called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 497 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 498 } \
XinZhangMS 0:f7f1f0d76dd6 499 else \
XinZhangMS 0:f7f1f0d76dd6 500 { \
XinZhangMS 0:f7f1f0d76dd6 501 ARG_BUFFER* arg_buffer = &C2(mock_call_data->out_arg_buffer_, arg_name); \
XinZhangMS 0:f7f1f0d76dd6 502 umockalloc_free(arg_buffer->bytes); \
XinZhangMS 0:f7f1f0d76dd6 503 arg_buffer->bytes = umockalloc_malloc(length); \
XinZhangMS 0:f7f1f0d76dd6 504 if (arg_buffer->bytes == NULL) \
XinZhangMS 0:f7f1f0d76dd6 505 { \
XinZhangMS 0:f7f1f0d76dd6 506 UMOCK_LOG("Could not allocate memory for out argument buffers."); \
XinZhangMS 0:f7f1f0d76dd6 507 umock_c_indicate_error(UMOCK_C_MALLOC_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 508 } \
XinZhangMS 0:f7f1f0d76dd6 509 else \
XinZhangMS 0:f7f1f0d76dd6 510 { \
XinZhangMS 0:f7f1f0d76dd6 511 (void)memcpy(arg_buffer->bytes, bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 512 arg_buffer->length = length; \
XinZhangMS 0:f7f1f0d76dd6 513 C2(mock_call_modifier.IgnoreArgument_, arg_name)(); \
XinZhangMS 0:f7f1f0d76dd6 514 } \
XinZhangMS 0:f7f1f0d76dd6 515 } \
XinZhangMS 0:f7f1f0d76dd6 516 } \
XinZhangMS 0:f7f1f0d76dd6 517 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 518 } \
XinZhangMS 0:f7f1f0d76dd6 519
XinZhangMS 0:f7f1f0d76dd6 520 #define IMPLEMENT_COPY_OUT_ARGUMENT_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 521 static C2(mock_call_modifier_,name) C2(copy_out_argument_func_,name)(size_t arg_index, void* value) \
XinZhangMS 0:f7f1f0d76dd6 522 { \
XinZhangMS 0:f7f1f0d76dd6 523 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 524 (void)value; \
XinZhangMS 0:f7f1f0d76dd6 525 (void)arg_index; \
XinZhangMS 0:f7f1f0d76dd6 526 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 527 } \
XinZhangMS 0:f7f1f0d76dd6 528
XinZhangMS 0:f7f1f0d76dd6 529 /* Codes_SRS_UMOCK_C_LIB_01_095: [The ValidateArgumentBuffer call modifier shall copy the memory pointed to by bytes and being length bytes so that it is later compared against a pointer type argument when the code under test calls the mock function.] */
XinZhangMS 0:f7f1f0d76dd6 530 /* Codes_SRS_UMOCK_C_LIB_01_097: [ValidateArgumentBuffer shall implicitly perform an IgnoreArgument on the indexth argument.]*/
XinZhangMS 0:f7f1f0d76dd6 531 /* Codes_SRS_UMOCK_C_LIB_01_099: [If the index is out of range umock_c shall raise an error with the code UMOCK_C_ARG_INDEX_OUT_OF_RANGE.]*/
XinZhangMS 0:f7f1f0d76dd6 532 /* Codes_SRS_UMOCK_C_LIB_01_100: [If bytes is NULL or length is 0, umock_c shall raise an error with the code UMOCK_C_INVALID_ARGUMENT_BUFFER.] */
XinZhangMS 0:f7f1f0d76dd6 533 /* Codes_SRS_UMOCK_C_LIB_01_131: [ The memory pointed by bytes shall be copied. ]*/
XinZhangMS 0:f7f1f0d76dd6 534 /* Codes_SRS_UMOCK_C_LIB_01_132: [ If several calls to ValidateArgumentBuffer are made, only the last buffer shall be kept. ]*/
XinZhangMS 0:f7f1f0d76dd6 535 /* Codes_SRS_UMOCK_C_LIB_01_130: [ The buffers for previous ValidateArgumentBuffer calls shall be freed. ]*/
XinZhangMS 0:f7f1f0d76dd6 536 #define IMPLEMENT_VALIDATE_ARGUMENT_BUFFER_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 537 static C2(mock_call_modifier_,name) C2(validate_argument_buffer_func_,name)(size_t index, const void* bytes, size_t length) \
XinZhangMS 0:f7f1f0d76dd6 538 { \
XinZhangMS 0:f7f1f0d76dd6 539 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 540 if ((index < 1) || (index > DIV2(COUNT_ARG(__VA_ARGS__)))) \
XinZhangMS 0:f7f1f0d76dd6 541 { \
XinZhangMS 0:f7f1f0d76dd6 542 UMOCK_LOG("Bad argument index in ValidateArgumentBuffer: %lu.", index); \
XinZhangMS 0:f7f1f0d76dd6 543 umock_c_indicate_error(UMOCK_C_ARG_INDEX_OUT_OF_RANGE); \
XinZhangMS 0:f7f1f0d76dd6 544 } \
XinZhangMS 0:f7f1f0d76dd6 545 else if ((bytes == NULL) || (length == 0)) \
XinZhangMS 0:f7f1f0d76dd6 546 { \
XinZhangMS 0:f7f1f0d76dd6 547 UMOCK_LOG("Bad arguments to ValidateArgumentBuffer: bytes = %p, length = %lu.", bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 548 umock_c_indicate_error(UMOCK_C_INVALID_ARGUMENT_BUFFER); \
XinZhangMS 0:f7f1f0d76dd6 549 } \
XinZhangMS 0:f7f1f0d76dd6 550 else \
XinZhangMS 0:f7f1f0d76dd6 551 { \
XinZhangMS 0:f7f1f0d76dd6 552 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 553 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 554 { \
XinZhangMS 0:f7f1f0d76dd6 555 UMOCK_LOG("ValidateArgumentBuffer called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 556 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 557 } \
XinZhangMS 0:f7f1f0d76dd6 558 else \
XinZhangMS 0:f7f1f0d76dd6 559 { \
XinZhangMS 0:f7f1f0d76dd6 560 umockalloc_free(mock_call_data->validate_arg_buffers[index - 1].bytes); \
XinZhangMS 0:f7f1f0d76dd6 561 mock_call_data->validate_arg_buffers[index - 1].bytes = umockalloc_malloc(length); \
XinZhangMS 0:f7f1f0d76dd6 562 if (mock_call_data->validate_arg_buffers[index - 1].bytes == NULL) \
XinZhangMS 0:f7f1f0d76dd6 563 { \
XinZhangMS 0:f7f1f0d76dd6 564 UMOCK_LOG("Could not allocate memory for validating argument buffers."); \
XinZhangMS 0:f7f1f0d76dd6 565 umock_c_indicate_error(UMOCK_C_MALLOC_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 566 } \
XinZhangMS 0:f7f1f0d76dd6 567 else \
XinZhangMS 0:f7f1f0d76dd6 568 { \
XinZhangMS 0:f7f1f0d76dd6 569 (void)memcpy(mock_call_data->validate_arg_buffers[index - 1].bytes, bytes, length); \
XinZhangMS 0:f7f1f0d76dd6 570 mock_call_data->validate_arg_buffers[index - 1].length = length; \
XinZhangMS 0:f7f1f0d76dd6 571 mock_call_modifier.IgnoreArgument(index); \
XinZhangMS 0:f7f1f0d76dd6 572 } \
XinZhangMS 0:f7f1f0d76dd6 573 } \
XinZhangMS 0:f7f1f0d76dd6 574 } \
XinZhangMS 0:f7f1f0d76dd6 575 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 576 } \
XinZhangMS 0:f7f1f0d76dd6 577
XinZhangMS 0:f7f1f0d76dd6 578 /* Codes_SRS_UMOCK_C_LIB_01_101: [The IgnoreAllCalls call modifier shall record that all calls matching the expected call shall be ignored. If no matching call occurs no missing call shall be reported.]*/
XinZhangMS 0:f7f1f0d76dd6 579 /* Codes_SRS_UMOCK_C_LIB_01_208: [ If no matching call occurs no missing call shall be reported. ]*/
XinZhangMS 0:f7f1f0d76dd6 580 #define IMPLEMENT_IGNORE_ALL_CALLS_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 581 static C2(mock_call_modifier_,name) C2(ignore_all_calls_func_,name)(void) \
XinZhangMS 0:f7f1f0d76dd6 582 { \
XinZhangMS 0:f7f1f0d76dd6 583 UMOCKCALL_HANDLE last_expected_call = umock_c_get_last_expected_call(); \
XinZhangMS 0:f7f1f0d76dd6 584 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 585 if (last_expected_call == NULL) \
XinZhangMS 0:f7f1f0d76dd6 586 { \
XinZhangMS 0:f7f1f0d76dd6 587 UMOCK_LOG("Cannot get last expected call."); \
XinZhangMS 0:f7f1f0d76dd6 588 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 589 } \
XinZhangMS 0:f7f1f0d76dd6 590 else \
XinZhangMS 0:f7f1f0d76dd6 591 { \
XinZhangMS 0:f7f1f0d76dd6 592 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(last_expected_call); \
XinZhangMS 0:f7f1f0d76dd6 593 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 594 { \
XinZhangMS 0:f7f1f0d76dd6 595 UMOCK_LOG("ValidateArgumentBuffer called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 596 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 597 } \
XinZhangMS 0:f7f1f0d76dd6 598 else \
XinZhangMS 0:f7f1f0d76dd6 599 { \
XinZhangMS 0:f7f1f0d76dd6 600 if (umockcall_set_ignore_all_calls(last_expected_call, 1) != 0) \
XinZhangMS 0:f7f1f0d76dd6 601 { \
XinZhangMS 0:f7f1f0d76dd6 602 UMOCK_LOG("Cannot set the ignore_all_calls value on the last expected call."); \
XinZhangMS 0:f7f1f0d76dd6 603 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 604 } \
XinZhangMS 0:f7f1f0d76dd6 605 } \
XinZhangMS 0:f7f1f0d76dd6 606 } \
XinZhangMS 0:f7f1f0d76dd6 607 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 608 } \
XinZhangMS 0:f7f1f0d76dd6 609
XinZhangMS 0:f7f1f0d76dd6 610 /* Codes_SRS_UMOCK_C_LIB_01_179: [ The CaptureReturn call modifier shall copy the return value that is being returned to the code under test when an actual call is matched with the expected call. ]*/
XinZhangMS 0:f7f1f0d76dd6 611 /* Codes_SRS_UMOCK_C_LIB_01_180: [ If CaptureReturn is called multiple times for the same call, an error shall be indicated with the code UMOCK_C_CAPTURE_RETURN_ALREADY_USED. ]*/
XinZhangMS 0:f7f1f0d76dd6 612 /* Codes_SRS_UMOCK_C_LIB_01_182: [ If captured_return_value is NULL, umock_c shall raise an error with the code UMOCK_C_NULL_ARGUMENT. ]*/
XinZhangMS 0:f7f1f0d76dd6 613 #define IMPLEMENT_CAPTURE_RETURN_FUNCTION(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 614 static C2(mock_call_modifier_,name) C2(capture_return_func_,name)(return_type* captured_return_value) \
XinZhangMS 0:f7f1f0d76dd6 615 { \
XinZhangMS 0:f7f1f0d76dd6 616 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 617 if (captured_return_value == NULL) \
XinZhangMS 0:f7f1f0d76dd6 618 { \
XinZhangMS 0:f7f1f0d76dd6 619 UMOCK_LOG("NULL captured_return_value."); \
XinZhangMS 0:f7f1f0d76dd6 620 umock_c_indicate_error(UMOCK_C_NULL_ARGUMENT); \
XinZhangMS 0:f7f1f0d76dd6 621 } \
XinZhangMS 0:f7f1f0d76dd6 622 else \
XinZhangMS 0:f7f1f0d76dd6 623 { \
XinZhangMS 0:f7f1f0d76dd6 624 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 625 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 626 { \
XinZhangMS 0:f7f1f0d76dd6 627 UMOCK_LOG("CaptureReturn called without having an expected call."); \
XinZhangMS 0:f7f1f0d76dd6 628 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 629 } \
XinZhangMS 0:f7f1f0d76dd6 630 else \
XinZhangMS 0:f7f1f0d76dd6 631 { \
XinZhangMS 0:f7f1f0d76dd6 632 if (mock_call_data->captured_return_value != NULL) \
XinZhangMS 0:f7f1f0d76dd6 633 { \
XinZhangMS 0:f7f1f0d76dd6 634 UMOCK_LOG("CaptureReturn called multiple times."); \
XinZhangMS 0:f7f1f0d76dd6 635 umock_c_indicate_error(UMOCK_C_CAPTURE_RETURN_ALREADY_USED); \
XinZhangMS 0:f7f1f0d76dd6 636 } \
XinZhangMS 0:f7f1f0d76dd6 637 else \
XinZhangMS 0:f7f1f0d76dd6 638 { \
XinZhangMS 0:f7f1f0d76dd6 639 mock_call_data->captured_return_value = captured_return_value; \
XinZhangMS 0:f7f1f0d76dd6 640 } \
XinZhangMS 0:f7f1f0d76dd6 641 } \
XinZhangMS 0:f7f1f0d76dd6 642 } \
XinZhangMS 0:f7f1f0d76dd6 643 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 644 }
XinZhangMS 0:f7f1f0d76dd6 645
XinZhangMS 0:f7f1f0d76dd6 646 /* Codes_SRS_UMOCK_C_LIB_01_183: [ The ValidateArgumentValue_{arg_name} shall validate that the value of an argument matches the value pointed by arg_value. ]*/
XinZhangMS 0:f7f1f0d76dd6 647 /* Codes_SRS_UMOCK_C_LIB_01_184: [ If arg_value is NULL, umock_c shall raise an error with the code UMOCK_C_NULL_ARGUMENT. ]*/
XinZhangMS 0:f7f1f0d76dd6 648 /* Codes_SRS_UMOCK_C_LIB_01_185: [ The ValidateArgumentValue_{arg_name} modifier shall inhibit comparing with any value passed directly as an argument in the expected call. ]*/
XinZhangMS 0:f7f1f0d76dd6 649 /* Codes_SRS_UMOCK_C_LIB_01_186: [ The ValidateArgumentValue_{arg_name} shall implicitly do a ValidateArgument for the arg_name argument, making sure the argument is not ignored. ]*/
XinZhangMS 0:f7f1f0d76dd6 650 #define IMPLEMENT_VALIDATE_ARGUMENT_VALUE_BY_NAME_FUNCTION(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 651 static C2(mock_call_modifier_,name) C4(validate_argument_value_func_,name,_,arg_name)(arg_type* arg_value) \
XinZhangMS 0:f7f1f0d76dd6 652 { \
XinZhangMS 0:f7f1f0d76dd6 653 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 654 if (arg_value == NULL) \
XinZhangMS 0:f7f1f0d76dd6 655 { \
XinZhangMS 0:f7f1f0d76dd6 656 UMOCK_LOG("NULL argument to ValidateArgumentValue_%s.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 657 umock_c_indicate_error(UMOCK_C_NULL_ARGUMENT); \
XinZhangMS 0:f7f1f0d76dd6 658 } \
XinZhangMS 0:f7f1f0d76dd6 659 else \
XinZhangMS 0:f7f1f0d76dd6 660 { \
XinZhangMS 0:f7f1f0d76dd6 661 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 662 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 663 { \
XinZhangMS 0:f7f1f0d76dd6 664 UMOCK_LOG("ValidateArgumentValue_%s called without having an expected call.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 665 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 666 } \
XinZhangMS 0:f7f1f0d76dd6 667 else \
XinZhangMS 0:f7f1f0d76dd6 668 { \
XinZhangMS 0:f7f1f0d76dd6 669 mock_call_data->C2(is_ignored_, arg_name) = ARG_IS_NOT_IGNORED; \
XinZhangMS 0:f7f1f0d76dd6 670 mock_call_data->C2(validate_arg_value_pointer_, arg_name) = (void*)arg_value; \
XinZhangMS 0:f7f1f0d76dd6 671 } \
XinZhangMS 0:f7f1f0d76dd6 672 } \
XinZhangMS 0:f7f1f0d76dd6 673 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 674 }
XinZhangMS 0:f7f1f0d76dd6 675
XinZhangMS 0:f7f1f0d76dd6 676 /* Codes_SRS_UMOCK_C_LIB_01_199: [ `ValidateArgumentValue_{arg_name}_AsType` shall ensure that validation of the argument `arg_name` is done as if the argument is of type `type_name`. ]*/
XinZhangMS 0:f7f1f0d76dd6 677 /* Codes_SRS_UMOCK_C_LIB_01_200: [ If `type_name` is NULL, umock_c shall raise an error with the code UMOCK_C_NULL_ARGUMENT. ]*/
XinZhangMS 0:f7f1f0d76dd6 678 /* Codes_SRS_UMOCK_C_LIB_01_202: [ If storing the argument value as the new type fails, umock_c shall raise an error with the code UMOCK_C_COPY_ARGUMENT_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 679 #define IMPLEMENT_VALIDATE_ARGUMENT_VALUE_AS_TYPE_BY_NAME_FUNCTION(name, arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 680 static C2(mock_call_modifier_,name) C4(validate_argument_value_as_type_func_,name,_,arg_name)(const char* type_name) \
XinZhangMS 0:f7f1f0d76dd6 681 { \
XinZhangMS 0:f7f1f0d76dd6 682 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 683 if (type_name == NULL) \
XinZhangMS 0:f7f1f0d76dd6 684 { \
XinZhangMS 0:f7f1f0d76dd6 685 UMOCK_LOG("NULL argument to ValidateArgumentValue_%s_AsType.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 686 umock_c_indicate_error(UMOCK_C_NULL_ARGUMENT); \
XinZhangMS 0:f7f1f0d76dd6 687 } \
XinZhangMS 0:f7f1f0d76dd6 688 else \
XinZhangMS 0:f7f1f0d76dd6 689 { \
XinZhangMS 0:f7f1f0d76dd6 690 C2(mock_call_, name)* mock_call_data = (C2(mock_call_, name)*)umockcall_get_call_data(umock_c_get_last_expected_call()); \
XinZhangMS 0:f7f1f0d76dd6 691 if (mock_call_data == NULL) \
XinZhangMS 0:f7f1f0d76dd6 692 { \
XinZhangMS 0:f7f1f0d76dd6 693 UMOCK_LOG("ValidateArgumentValue_%s called without having an expected call.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 694 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 695 } \
XinZhangMS 0:f7f1f0d76dd6 696 else \
XinZhangMS 0:f7f1f0d76dd6 697 { \
XinZhangMS 0:f7f1f0d76dd6 698 char* cloned_type_name = umockstring_clone(type_name); \
XinZhangMS 0:f7f1f0d76dd6 699 if (cloned_type_name == NULL) \
XinZhangMS 0:f7f1f0d76dd6 700 { \
XinZhangMS 0:f7f1f0d76dd6 701 umockalloc_free(cloned_type_name); \
XinZhangMS 0:f7f1f0d76dd6 702 UMOCK_LOG("Cannot allocate memory to copy type_name in ValidateArgumentValue_%s_AsType for type name %s.", TOSTRING(arg_name), type_name); \
XinZhangMS 0:f7f1f0d76dd6 703 umock_c_indicate_error(UMOCK_C_MALLOC_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 704 } \
XinZhangMS 0:f7f1f0d76dd6 705 else \
XinZhangMS 0:f7f1f0d76dd6 706 { \
XinZhangMS 0:f7f1f0d76dd6 707 void* temp = umockalloc_malloc(sizeof(arg_type)); \
XinZhangMS 0:f7f1f0d76dd6 708 if (temp == NULL) \
XinZhangMS 0:f7f1f0d76dd6 709 { \
XinZhangMS 0:f7f1f0d76dd6 710 umockalloc_free(cloned_type_name); \
XinZhangMS 0:f7f1f0d76dd6 711 UMOCK_LOG("Cannot allocate memory for the temporary argument value in ValidateArgumentValue_%s.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 712 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 713 } \
XinZhangMS 0:f7f1f0d76dd6 714 else \
XinZhangMS 0:f7f1f0d76dd6 715 { \
XinZhangMS 0:f7f1f0d76dd6 716 if (umocktypes_copy(GET_USED_ARGUMENT_TYPE(mock_call_data, arg_name, arg_type), (void*)temp, (void*)&mock_call_data->arg_name) != 0) \
XinZhangMS 0:f7f1f0d76dd6 717 { \
XinZhangMS 0:f7f1f0d76dd6 718 umockalloc_free(cloned_type_name); \
XinZhangMS 0:f7f1f0d76dd6 719 UMOCK_LOG("Cannot copy argument in ValidateArgumentValue_%s.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 720 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 721 } \
XinZhangMS 0:f7f1f0d76dd6 722 else \
XinZhangMS 0:f7f1f0d76dd6 723 { \
XinZhangMS 0:f7f1f0d76dd6 724 umocktypes_free(GET_USED_ARGUMENT_TYPE(mock_call_data, arg_name, arg_type), (void*)&mock_call_data->arg_name); \
XinZhangMS 0:f7f1f0d76dd6 725 if (umocktypes_copy(type_name, (void*)&mock_call_data->arg_name, (void*)temp) != 0) \
XinZhangMS 0:f7f1f0d76dd6 726 { \
XinZhangMS 0:f7f1f0d76dd6 727 umockalloc_free(cloned_type_name); \
XinZhangMS 0:f7f1f0d76dd6 728 UMOCK_LOG("Cannot copy argument as new type in ValidateArgumentValue_%s.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 729 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 730 } \
XinZhangMS 0:f7f1f0d76dd6 731 else \
XinZhangMS 0:f7f1f0d76dd6 732 { \
XinZhangMS 0:f7f1f0d76dd6 733 umocktypes_free(GET_USED_ARGUMENT_TYPE(mock_call_data, arg_name, arg_type), (void*)temp); \
XinZhangMS 0:f7f1f0d76dd6 734 umockalloc_free(mock_call_data->C2(override_argument_type_, arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 735 mock_call_data->C2(override_argument_type_, arg_name) = cloned_type_name; \
XinZhangMS 0:f7f1f0d76dd6 736 } \
XinZhangMS 0:f7f1f0d76dd6 737 } \
XinZhangMS 0:f7f1f0d76dd6 738 umockalloc_free(temp); \
XinZhangMS 0:f7f1f0d76dd6 739 } \
XinZhangMS 0:f7f1f0d76dd6 740 } \
XinZhangMS 0:f7f1f0d76dd6 741 } \
XinZhangMS 0:f7f1f0d76dd6 742 } \
XinZhangMS 0:f7f1f0d76dd6 743 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 744 }
XinZhangMS 0:f7f1f0d76dd6 745
XinZhangMS 0:f7f1f0d76dd6 746 #define IMPLEMENT_MOCK_FUNCTION(function_prefix, args_ignored, return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 747 C2(mock_call_modifier_,name) UMOCK_STATIC C2(function_prefix,name)(IF(COUNT_ARG(__VA_ARGS__),,void) FOR_EACH_2_COUNTED(ARG_IN_SIGNATURE, __VA_ARGS__)) \
XinZhangMS 0:f7f1f0d76dd6 748 { \
XinZhangMS 0:f7f1f0d76dd6 749 UMOCKCALL_HANDLE mock_call; \
XinZhangMS 0:f7f1f0d76dd6 750 C2(mock_call_,name)* mock_call_data = (C2(mock_call_,name)*)umockalloc_malloc(sizeof(C2(mock_call_,name))); \
XinZhangMS 0:f7f1f0d76dd6 751 DECLARE_MOCK_CALL_MODIFIER(name) \
XinZhangMS 0:f7f1f0d76dd6 752 FOR_EACH_2(COPY_ARG_TO_MOCK_STRUCT, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 753 IF(args_ignored, FOR_EACH_2(MARK_ARG_AS_IGNORED, __VA_ARGS__), FOR_EACH_2(MARK_ARG_AS_NOT_IGNORED, __VA_ARGS__)) \
XinZhangMS 0:f7f1f0d76dd6 754 FOR_EACH_2_COUNTED(CLEAR_OUT_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 755 FOR_EACH_2_COUNTED(CLEAR_VALIDATE_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 756 FOR_EACH_2(CLEAR_VALIDATE_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 757 FOR_EACH_2(CLEAR_OVERRIDE_ARGUMENT_TYPE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 758 IF(IS_NOT_VOID(return_type), \
XinZhangMS 0:f7f1f0d76dd6 759 mock_call_data->return_value_set = RETURN_VALUE_NOT_SET; \
XinZhangMS 0:f7f1f0d76dd6 760 mock_call_data->captured_return_value = NULL; \
XinZhangMS 0:f7f1f0d76dd6 761 mock_call_data->fail_return_value_set = FAIL_RETURN_VALUE_NOT_SET; \
XinZhangMS 0:f7f1f0d76dd6 762 ,) \
XinZhangMS 0:f7f1f0d76dd6 763 mock_call = umockcall_create(#name, mock_call_data, C2(mock_call_data_copy_func_,name), C2(mock_call_data_free_func_,name), C2(mock_call_data_stringify_,name), C2(mock_call_data_are_equal_,name)); \
XinZhangMS 0:f7f1f0d76dd6 764 if (mock_call == NULL) \
XinZhangMS 0:f7f1f0d76dd6 765 { \
XinZhangMS 0:f7f1f0d76dd6 766 UMOCK_LOG("Failed creating mock call."); \
XinZhangMS 0:f7f1f0d76dd6 767 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 768 } \
XinZhangMS 0:f7f1f0d76dd6 769 else \
XinZhangMS 0:f7f1f0d76dd6 770 { \
XinZhangMS 0:f7f1f0d76dd6 771 (void)umock_c_add_expected_call(mock_call); \
XinZhangMS 0:f7f1f0d76dd6 772 } \
XinZhangMS 0:f7f1f0d76dd6 773 return mock_call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 774 } \
XinZhangMS 0:f7f1f0d76dd6 775
XinZhangMS 0:f7f1f0d76dd6 776 #define IMPLEMENT_STRICT_EXPECTED_MOCK(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 777 IMPLEMENT_MOCK_FUNCTION(umock_c_strict_expected_, 0, return_type, name, __VA_ARGS__)
XinZhangMS 0:f7f1f0d76dd6 778
XinZhangMS 0:f7f1f0d76dd6 779 #define IMPLEMENT_EXPECTED_MOCK(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 780 IMPLEMENT_MOCK_FUNCTION(umock_c_expected_, 1, return_type, name, __VA_ARGS__)
XinZhangMS 0:f7f1f0d76dd6 781
XinZhangMS 0:f7f1f0d76dd6 782 /* Codes_SRS_UMOCK_C_LIB_01_104: [The REGISTER_GLOBAL_MOCK_HOOK shall register a mock hook to be called every time the mocked function is called by production code.]*/
XinZhangMS 0:f7f1f0d76dd6 783 /* Codes_SRS_UMOCK_C_LIB_01_107: [If there are multiple invocations of REGISTER_GLOBAL_MOCK_HOOK, the last one shall take effect over the previous ones.] */
XinZhangMS 0:f7f1f0d76dd6 784 /* Codes_SRS_UMOCK_C_LIB_01_134: [ REGISTER_GLOBAL_MOCK_HOOK called with a NULL hook unregisters a previously registered hook. ]*/
XinZhangMS 0:f7f1f0d76dd6 785 #define IMPLEMENT_REGISTER_GLOBAL_MOCK_HOOK(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 786 UMOCK_STATIC void C2(set_global_mock_hook_,name)(C2(mock_hook_func_type_, name) mock_return_hook) \
XinZhangMS 0:f7f1f0d76dd6 787 { \
XinZhangMS 0:f7f1f0d76dd6 788 C2(mock_hook_,name) = mock_return_hook; \
XinZhangMS 0:f7f1f0d76dd6 789 } \
XinZhangMS 0:f7f1f0d76dd6 790
XinZhangMS 0:f7f1f0d76dd6 791 /* Codes_SRS_UMOCK_C_LIB_01_108: [The REGISTER_GLOBAL_MOCK_RETURN shall register a return value to always be returned by a mock function.]*/
XinZhangMS 0:f7f1f0d76dd6 792 /* Codes_SRS_UMOCK_C_LIB_01_109: [If there are multiple invocations of REGISTER_GLOBAL_MOCK_RETURN, the last one shall take effect over the previous ones.]*/
XinZhangMS 0:f7f1f0d76dd6 793 /* Codes_SRS_UMOCK_C_LIB_01_141: [ If any error occurs during REGISTER_GLOBAL_MOCK_RETURN, umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 794 #define IMPLEMENT_REGISTER_GLOBAL_MOCK_RETURN(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 795 IF(IS_NOT_VOID(return_type), UMOCK_STATIC void C2(set_global_mock_return_, name)(return_type return_value) \
XinZhangMS 0:f7f1f0d76dd6 796 { \
XinZhangMS 0:f7f1f0d76dd6 797 C2(mock_call_default_result_,name) = return_value; \
XinZhangMS 0:f7f1f0d76dd6 798 }, ) \
XinZhangMS 0:f7f1f0d76dd6 799
XinZhangMS 0:f7f1f0d76dd6 800 /* Codes_SRS_UMOCK_C_LIB_01_111: [The REGISTER_GLOBAL_MOCK_FAIL_RETURN shall register a fail return value to be returned by a mock function when marked as failed in the expected calls.]*/
XinZhangMS 0:f7f1f0d76dd6 801 /* Codes_SRS_UMOCK_C_LIB_01_112: [If there are multiple invocations of REGISTER_GLOBAL_FAIL_MOCK_RETURN, the last one shall take effect over the previous ones.]*/
XinZhangMS 0:f7f1f0d76dd6 802 /* Codes_SRS_UMOCK_C_LIB_01_142: [ If any error occurs during REGISTER_GLOBAL_MOCK_FAIL_RETURN, umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 803 #define IMPLEMENT_REGISTER_GLOBAL_MOCK_FAIL_RETURN(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 804 IF(IS_NOT_VOID(return_type), UMOCK_STATIC void C2(set_global_mock_fail_return_, name)(return_type fail_return_value) \
XinZhangMS 0:f7f1f0d76dd6 805 { \
XinZhangMS 0:f7f1f0d76dd6 806 C2(mock_call_fail_result_,name) = fail_return_value; \
XinZhangMS 0:f7f1f0d76dd6 807 }, ) \
XinZhangMS 0:f7f1f0d76dd6 808
XinZhangMS 0:f7f1f0d76dd6 809 /* Codes_SRS_UMOCK_C_LIB_01_113: [The REGISTER_GLOBAL_MOCK_RETURNS shall register both a success and a fail return value associated with a mock function.]*/
XinZhangMS 0:f7f1f0d76dd6 810 /* Codes_SRS_UMOCK_C_LIB_01_114: [If there are multiple invocations of REGISTER_GLOBAL_MOCK_RETURNS, the last one shall take effect over the previous ones.]*/
XinZhangMS 0:f7f1f0d76dd6 811 /* Codes_SRS_UMOCK_C_LIB_01_143: [ If any error occurs during REGISTER_GLOBAL_MOCK_RETURNS, umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 812 #define IMPLEMENT_REGISTER_GLOBAL_MOCK_RETURNS(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 813 IF(IS_NOT_VOID(return_type), UMOCK_STATIC void C2(set_global_mock_returns_, name)(return_type return_value, return_type fail_return_value) \
XinZhangMS 0:f7f1f0d76dd6 814 { \
XinZhangMS 0:f7f1f0d76dd6 815 C2(mock_call_default_result_,name) = return_value; \
XinZhangMS 0:f7f1f0d76dd6 816 C2(mock_call_fail_result_,name) = fail_return_value; \
XinZhangMS 0:f7f1f0d76dd6 817 }, ) \
XinZhangMS 0:f7f1f0d76dd6 818
XinZhangMS 0:f7f1f0d76dd6 819 #define DECLARE_VALIDATE_ONE_ARGUMENT_FUNC_TYPE(name) \
XinZhangMS 0:f7f1f0d76dd6 820 typedef struct C2(_mock_call_modifier_, name) (*C2(validate_one_argument_func_type_, name))(void);
XinZhangMS 0:f7f1f0d76dd6 821
XinZhangMS 0:f7f1f0d76dd6 822 #define COPY_RETURN_VALUE(return_type, name) \
XinZhangMS 0:f7f1f0d76dd6 823 result = C2(mock_call_default_result_, name);
XinZhangMS 0:f7f1f0d76dd6 824
XinZhangMS 0:f7f1f0d76dd6 825 typedef struct MOCK_CALL_ARG_METADATA_TAG
XinZhangMS 0:f7f1f0d76dd6 826 {
XinZhangMS 0:f7f1f0d76dd6 827 const char* type;
XinZhangMS 0:f7f1f0d76dd6 828 const char* name;
XinZhangMS 0:f7f1f0d76dd6 829 } MOCK_CALL_ARG_METADATA;
XinZhangMS 0:f7f1f0d76dd6 830
XinZhangMS 0:f7f1f0d76dd6 831 typedef struct MOCK_CALL_METADATA_TAG
XinZhangMS 0:f7f1f0d76dd6 832 {
XinZhangMS 0:f7f1f0d76dd6 833 const char* return_type;
XinZhangMS 0:f7f1f0d76dd6 834 const char* name;
XinZhangMS 0:f7f1f0d76dd6 835 size_t arg_count;
XinZhangMS 0:f7f1f0d76dd6 836 const MOCK_CALL_ARG_METADATA* args;
XinZhangMS 0:f7f1f0d76dd6 837 } MOCK_CALL_METADATA;
XinZhangMS 0:f7f1f0d76dd6 838
XinZhangMS 0:f7f1f0d76dd6 839 #define UNUSED_ARG(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 840 (void)arg_name;
XinZhangMS 0:f7f1f0d76dd6 841
XinZhangMS 0:f7f1f0d76dd6 842 /* Codes_SRS_UMOCK_C_LIB_01_205: [ If `IGNORED_PTR_ARG` or `IGNORED_NUM_ARG` is used as an argument value with `STRICT_EXPECTED_CALL`, the argument shall be automatically ignored. ]*/
XinZhangMS 0:f7f1f0d76dd6 843 /* Codes_SRS_UMOCK_C_LIB_01_206: [ `IGNORED_PTR_ARG` shall be defined as NULL so that it can be used for pointer type arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 844 /* Codes_SRS_UMOCK_C_LIB_01_207: [ `IGNORED_NUM_ARG` shall be defined to 0 so that it can be used for numeric type arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 845 #define AUTO_IGNORE_ARG(arg_type, arg_name) \
XinZhangMS 0:f7f1f0d76dd6 846 if (umockautoignoreargs_is_call_argument_ignored(call_as_string, arg_index++, &is_ignored) != 0) \
XinZhangMS 0:f7f1f0d76dd6 847 { \
XinZhangMS 0:f7f1f0d76dd6 848 UMOCK_LOG("Failed parsing argument %s value from the call.", TOSTRING(arg_name)); \
XinZhangMS 0:f7f1f0d76dd6 849 } \
XinZhangMS 0:f7f1f0d76dd6 850 else \
XinZhangMS 0:f7f1f0d76dd6 851 { \
XinZhangMS 0:f7f1f0d76dd6 852 if (is_ignored) \
XinZhangMS 0:f7f1f0d76dd6 853 { \
XinZhangMS 0:f7f1f0d76dd6 854 result.C2(IgnoreArgument_, arg_name)(); \
XinZhangMS 0:f7f1f0d76dd6 855 } \
XinZhangMS 0:f7f1f0d76dd6 856 } \
XinZhangMS 0:f7f1f0d76dd6 857
XinZhangMS 0:f7f1f0d76dd6 858 /* Codes_SRS_UMOCK_C_LIB_01_004: [If ENABLE_MOCKS is defined, MOCKABLE_FUNCTION shall generate the declaration of the function and code for the mocked function, thus allowing setting up of expectations in test functions.] */
XinZhangMS 0:f7f1f0d76dd6 859 /* Codes_SRS_UMOCK_C_LIB_01_014: [For each argument the argument value shall be stored for later comparison with actual calls.] */
XinZhangMS 0:f7f1f0d76dd6 860 /* Codes_SRS_UMOCK_C_LIB_01_017: [No arguments shall be saved by default, unless other modifiers state it.]*/
XinZhangMS 0:f7f1f0d76dd6 861 /* Codes_SRS_UMOCK_C_LIB_01_074: [When an expected call is recorded a call modifier interface in the form of a structure containing function pointers shall be returned to the caller.] */
XinZhangMS 0:f7f1f0d76dd6 862 /* Codes_SRS_UMOCK_C_LIB_01_075: [The last modifier in a chain overrides previous modifiers if any collision occurs.]*/
XinZhangMS 0:f7f1f0d76dd6 863 /* Codes_SRS_UMOCK_C_LIB_01_127: [ IgnoreAllArguments shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 864 /* Codes_SRS_UMOCK_C_LIB_01_126: [ ValidateAllArguments shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 865 /* Codes_SRS_UMOCK_C_LIB_01_125: [ IgnoreArgument_{arg_name} shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 866 /* Codes_SRS_UMOCK_C_LIB_01_124: [ ValidateArgument_{arg_name} shall only be available for mock functions that have arguments. **]*/
XinZhangMS 0:f7f1f0d76dd6 867 /* Codes_SRS_UMOCK_C_LIB_01_123: [ IgnoreArgument shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 868 /* Codes_SRS_UMOCK_C_LIB_01_122: [ ValidateArgument shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 869 /* Codes_SRS_UMOCK_C_LIB_01_121: [ SetReturn shall only be available if the return type is not void. ]*/
XinZhangMS 0:f7f1f0d76dd6 870 /* Codes_SRS_UMOCK_C_LIB_01_120: [ SetFailReturn shall only be available if the return type is not void. ]*/
XinZhangMS 0:f7f1f0d76dd6 871 /* Codes_SRS_UMOCK_C_LIB_01_119: [ CopyOutArgumentBuffer shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 872 /* Codes_SRS_UMOCK_C_LIB_01_128: [ CopyOutArgument shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 873 /* Codes_SRS_UMOCK_C_LIB_01_129: [ ValidateArgumentBuffer shall only be available for mock functions that have arguments. ]*/
XinZhangMS 0:f7f1f0d76dd6 874 /* Codes_SRS_UMOCK_C_LIB_01_105: [The hook\92s result shall be returned by the mock to the production code.]*/
XinZhangMS 0:f7f1f0d76dd6 875 /* Codes_SRS_UMOCK_C_LIB_01_106: [The signature for the hook shall be assumed to have exactly the same arguments and return as the mocked function.]*/
XinZhangMS 0:f7f1f0d76dd6 876 /* Codes_SRS_UMOCK_C_LIB_01_135: [ All parameters passed to the mock shall be passed down to the mock hook. ]*/
XinZhangMS 0:f7f1f0d76dd6 877 /* Codes_SRS_UMOCK_C_LIB_01_148: [ If call comparison fails an error shall be indicated by calling the error callback with UMOCK_C_COMPARE_CALL_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 878 /* Codes_SRS_UMOCK_C_LIB_01_136: [ When multiple return values are set for a mock function by using different means (such as SetReturn), the following order shall be in effect: ]*/
XinZhangMS 0:f7f1f0d76dd6 879 /* Codes_SRS_UMOCK_C_LIB_01_137: [ - If a return value has been specified for an expected call then that value shall be returned. ]*/
XinZhangMS 0:f7f1f0d76dd6 880 /* Codes_SRS_UMOCK_C_LIB_01_138: [ - If a global mock hook has been specified then it shall be called and its result returned. ]*/
XinZhangMS 0:f7f1f0d76dd6 881 /* Codes_SRS_UMOCK_C_LIB_01_139: [ - If a global return value has been specified then it shall be returned. ]*/
XinZhangMS 0:f7f1f0d76dd6 882 /* Codes_SRS_UMOCK_C_LIB_01_140: [ - Otherwise the value of a static variable of the same type as the return type shall be returned. ]*/
XinZhangMS 0:f7f1f0d76dd6 883 /* Codes_SRS_UMOCK_C_LIB_01_188: [ The create call shall have a non-void return type. ]*/
XinZhangMS 0:f7f1f0d76dd6 884 #define MOCKABLE_FUNCTION_UMOCK_INTERNAL_WITH_MOCK_NO_CODE(return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 885 typedef return_type (*C2(mock_hook_func_type_, name))(IF(COUNT_ARG(__VA_ARGS__),,void) FOR_EACH_2_COUNTED(ARG_IN_SIGNATURE, __VA_ARGS__)); \
XinZhangMS 0:f7f1f0d76dd6 886 static C2(mock_hook_func_type_,name) C2(mock_hook_,name) = NULL; \
XinZhangMS 0:f7f1f0d76dd6 887 static TRACK_CREATE_FUNC_TYPE C2(track_create_destroy_pair_malloc_,name) = NULL; \
XinZhangMS 0:f7f1f0d76dd6 888 static TRACK_DESTROY_FUNC_TYPE C2(track_create_destroy_pair_free_,name) = NULL; \
XinZhangMS 0:f7f1f0d76dd6 889 static PAIRED_HANDLES C2(paired_handles_,name); \
XinZhangMS 0:f7f1f0d76dd6 890 static PAIRED_HANDLES* C2(used_paired_handles_,name) = NULL; \
XinZhangMS 0:f7f1f0d76dd6 891 static const MOCK_CALL_ARG_METADATA C2(mock_call_args_metadata_,name)[IF(COUNT_ARG(__VA_ARGS__), DIV2(COUNT_ARG(__VA_ARGS__)), 1)] \
XinZhangMS 0:f7f1f0d76dd6 892 = { IF(COUNT_ARG(__VA_ARGS__),,NULL) FOR_EACH_2(FILL_ARG_IN_METADATA, __VA_ARGS__) }; \
XinZhangMS 0:f7f1f0d76dd6 893 static const MOCK_CALL_METADATA C2(mock_call_metadata_,name) = { TOSTRING(return_type), TOSTRING(name), DIV2(COUNT_ARG(__VA_ARGS__)), \
XinZhangMS 0:f7f1f0d76dd6 894 C2(mock_call_args_metadata_,name) }; \
XinZhangMS 0:f7f1f0d76dd6 895 struct C2(_mock_call_modifier_,name); \
XinZhangMS 0:f7f1f0d76dd6 896 IF(IS_NOT_VOID(return_type),typedef struct C2(_mock_call_modifier_,name) (*C2(set_return_func_type_,name))(return_type return_value); \
XinZhangMS 0:f7f1f0d76dd6 897 typedef struct C2(_mock_call_modifier_,name) (*C2(set_fail_return_func_type_,name))(return_type return_value); \
XinZhangMS 0:f7f1f0d76dd6 898 typedef struct C2(_mock_call_modifier_,name) (*C2(capture_return_func_type_,name))(return_type* captured_return_value);,) \
XinZhangMS 0:f7f1f0d76dd6 899 typedef struct C2(_mock_call_modifier_,name) (*C2(ignore_all_calls_func_type_,name))(void); \
XinZhangMS 0:f7f1f0d76dd6 900 IF(COUNT_ARG(__VA_ARGS__),typedef struct C2(_mock_call_modifier_,name) (*C2(ignore_all_arguments_func_type_,name))(void); \
XinZhangMS 0:f7f1f0d76dd6 901 typedef struct C2(_mock_call_modifier_,name) (*C2(validate_all_arguments_func_type_,name))(void); \
XinZhangMS 0:f7f1f0d76dd6 902 typedef struct C2(_mock_call_modifier_,name) (*C2(copy_out_argument_func_type_,name))(size_t arg_index, void* value); \
XinZhangMS 0:f7f1f0d76dd6 903 typedef struct C2(_mock_call_modifier_,name) (*C2(ignore_argument_func_type_,name))(size_t arg_index); \
XinZhangMS 0:f7f1f0d76dd6 904 typedef struct C2(_mock_call_modifier_,name) (*C2(validate_argument_func_type_,name))(size_t arg_index); \
XinZhangMS 0:f7f1f0d76dd6 905 typedef struct C2(_mock_call_modifier_,name) (*C2(validate_argument_buffer_func_type_,name))(size_t index, const void* bytes, size_t length); \
XinZhangMS 0:f7f1f0d76dd6 906 typedef struct C2(_mock_call_modifier_,name) (*C2(copy_out_argument_buffer_func_type_,name))(size_t index, const void* bytes, size_t length); \
XinZhangMS 0:f7f1f0d76dd6 907 FOR_EACH_2_KEEP_1(DECLARE_ARG_RELATED_FUNCTIONS, name, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 908 typedef struct C2(_mock_call_modifier_,name) \
XinZhangMS 0:f7f1f0d76dd6 909 { \
XinZhangMS 0:f7f1f0d76dd6 910 C2(ignore_all_calls_func_type_,name) IgnoreAllCalls; \
XinZhangMS 0:f7f1f0d76dd6 911 IF(IS_NOT_VOID(return_type),C2(set_return_func_type_,name) SetReturn; \
XinZhangMS 0:f7f1f0d76dd6 912 C2(set_fail_return_func_type_,name) SetFailReturn; \
XinZhangMS 0:f7f1f0d76dd6 913 C2(capture_return_func_type_,name) CaptureReturn;,) \
XinZhangMS 0:f7f1f0d76dd6 914 IF(COUNT_ARG(__VA_ARGS__),C2(ignore_all_arguments_func_type_,name) IgnoreAllArguments; \
XinZhangMS 0:f7f1f0d76dd6 915 C2(validate_all_arguments_func_type_,name) ValidateAllArguments; \
XinZhangMS 0:f7f1f0d76dd6 916 C2(copy_out_argument_func_type_,name) CopyOutArgument; \
XinZhangMS 0:f7f1f0d76dd6 917 C2(ignore_argument_func_type_,name) IgnoreArgument; \
XinZhangMS 0:f7f1f0d76dd6 918 C2(validate_argument_func_type_,name) ValidateArgument; \
XinZhangMS 0:f7f1f0d76dd6 919 C2(validate_argument_buffer_func_type_,name) ValidateArgumentBuffer; \
XinZhangMS 0:f7f1f0d76dd6 920 C2(copy_out_argument_buffer_func_type_,name) CopyOutArgumentBuffer; \
XinZhangMS 0:f7f1f0d76dd6 921 FOR_EACH_2_KEEP_1(ARG_RELATED_FUNCTIONS_IN_MODIFIERS, name, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 922 } C2(mock_call_modifier_,name); \
XinZhangMS 0:f7f1f0d76dd6 923 static C2(mock_call_modifier_,name) C2(ignore_all_calls_func_,name)(void); \
XinZhangMS 0:f7f1f0d76dd6 924 IF(IS_NOT_VOID(return_type),static C2(mock_call_modifier_,name) C2(set_return_func_,name)(return_type return_value); \
XinZhangMS 0:f7f1f0d76dd6 925 static C2(mock_call_modifier_,name) C2(set_fail_return_func_,name)(return_type return_value); \
XinZhangMS 0:f7f1f0d76dd6 926 static C2(mock_call_modifier_,name) C2(capture_return_func_,name)(return_type* captured_return_value);,) \
XinZhangMS 0:f7f1f0d76dd6 927 IF(COUNT_ARG(__VA_ARGS__),static C2(mock_call_modifier_,name) C2(ignore_all_arguments_func_,name)(void); \
XinZhangMS 0:f7f1f0d76dd6 928 static C2(mock_call_modifier_,name) C2(validate_all_arguments_func_,name)(void); \
XinZhangMS 0:f7f1f0d76dd6 929 static C2(mock_call_modifier_,name) C2(copy_out_argument_func_,name)(size_t arg_index, void* value); \
XinZhangMS 0:f7f1f0d76dd6 930 static C2(mock_call_modifier_,name) C2(ignore_argument_func_,name)(size_t arg_index); \
XinZhangMS 0:f7f1f0d76dd6 931 static C2(mock_call_modifier_,name) C2(validate_argument_func_,name)(size_t arg_index); \
XinZhangMS 0:f7f1f0d76dd6 932 static C2(mock_call_modifier_,name) C2(validate_argument_buffer_func_,name)(size_t index, const void* bytes, size_t length); \
XinZhangMS 0:f7f1f0d76dd6 933 static C2(mock_call_modifier_,name) C2(copy_out_argument_buffer_func_,name)(size_t index, const void* bytes, size_t length); \
XinZhangMS 0:f7f1f0d76dd6 934 FOR_EACH_2_KEEP_1(DECLARE_IGNORE_ARGUMENT_FUNCTION_PROTOTYPE, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 935 FOR_EACH_2_KEEP_1(DECLARE_VALIDATE_ARGUMENT_FUNCTION_PROTOTYPE, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 936 FOR_EACH_2_KEEP_1(DECLARE_COPY_OUT_ARGUMENT_BUFFER_FUNCTION_PROTOTYPE, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 937 FOR_EACH_2_KEEP_1(DECLARE_VALIDATE_ARGUMENT_VALUE_FUNCTION_PROTOTYPE, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 938 FOR_EACH_2_KEEP_1(DECLARE_VALIDATE_ARGUMENT_VALUE_AS_TYPE_FUNCTION_PROTOTYPE, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 939 typedef struct C2(_mock_call_modifier_,name) (*C2(ignore_one_argument_func_type_,name))(void);,) \
XinZhangMS 0:f7f1f0d76dd6 940 IF(COUNT_ARG(__VA_ARGS__), static const C2(ignore_one_argument_func_type_,name) C2(ignore_one_argument_array_,name)[] = \
XinZhangMS 0:f7f1f0d76dd6 941 {,) \
XinZhangMS 0:f7f1f0d76dd6 942 FOR_EACH_2_KEEP_1(IGNORE_ARGUMENT_FUNCTION_IN_ARRAY, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 943 IF(COUNT_ARG(__VA_ARGS__), }; \
XinZhangMS 0:f7f1f0d76dd6 944 DECLARE_VALIDATE_ONE_ARGUMENT_FUNC_TYPE(name) \
XinZhangMS 0:f7f1f0d76dd6 945 static const C2(validate_one_argument_func_type_,name) C2(validate_one_argument_array_,name)[] = \
XinZhangMS 0:f7f1f0d76dd6 946 {,) \
XinZhangMS 0:f7f1f0d76dd6 947 FOR_EACH_2_KEEP_1(VALIDATE_ARGUMENT_FUNCTION_IN_ARRAY, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 948 IF(COUNT_ARG(__VA_ARGS__),};,) \
XinZhangMS 0:f7f1f0d76dd6 949 static void C2(fill_mock_call_modifier_,name)(C2(mock_call_modifier_,name)* mock_call_modifier) \
XinZhangMS 0:f7f1f0d76dd6 950 { \
XinZhangMS 0:f7f1f0d76dd6 951 IF(IS_NOT_VOID(return_type),mock_call_modifier->SetReturn = C2(set_return_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 952 mock_call_modifier->SetFailReturn = C2(set_fail_return_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 953 mock_call_modifier->CaptureReturn = C2(capture_return_func_,name);,) \
XinZhangMS 0:f7f1f0d76dd6 954 IF(COUNT_ARG(__VA_ARGS__),mock_call_modifier->IgnoreAllArguments = C2(ignore_all_arguments_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 955 mock_call_modifier->ValidateAllArguments = C2(validate_all_arguments_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 956 mock_call_modifier->CopyOutArgument = C2(copy_out_argument_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 957 mock_call_modifier->IgnoreArgument = C2(ignore_argument_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 958 mock_call_modifier->ValidateArgument = C2(validate_argument_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 959 mock_call_modifier->ValidateArgumentBuffer = C2(validate_argument_buffer_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 960 mock_call_modifier->CopyOutArgumentBuffer = C2(copy_out_argument_buffer_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 961 FOR_EACH_2_KEEP_1(COPY_IGNORE_ARG_BY_NAME_TO_MODIFIER, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 962 FOR_EACH_2_KEEP_1(COPY_VALIDATE_ARG_BY_NAME_TO_MODIFIER, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 963 FOR_EACH_2_KEEP_1(COPY_COPY_OUT_ARGUMENT_BUFFER_BY_NAME_TO_MODIFIER, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 964 FOR_EACH_2_KEEP_1(COPY_VALIDATE_ARGUMENT_VALUE_BY_NAME_TO_MODIFIER, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 965 FOR_EACH_2_KEEP_1(COPY_VALIDATE_ARGUMENT_VALUE_AS_TYPE_BY_NAME_TO_MODIFIER, name, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 966 mock_call_modifier->IgnoreAllCalls = C2(ignore_all_calls_func_,name); \
XinZhangMS 0:f7f1f0d76dd6 967 } \
XinZhangMS 0:f7f1f0d76dd6 968 typedef struct C2(_mock_call_,name) \
XinZhangMS 0:f7f1f0d76dd6 969 { \
XinZhangMS 0:f7f1f0d76dd6 970 IF(IS_NOT_VOID(return_type),return_type return_value; \
XinZhangMS 0:f7f1f0d76dd6 971 return_type fail_return_value; \
XinZhangMS 0:f7f1f0d76dd6 972 return_type* captured_return_value;,) \
XinZhangMS 0:f7f1f0d76dd6 973 IF(COUNT_ARG(__VA_ARGS__), FOR_EACH_2(DECLARE_MOCK_CALL_STRUCT_STACK, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 974 FOR_EACH_2(DECLARE_OUT_ARG_BUFFER_FOR_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 975 ARG_BUFFER* out_arg_buffers[IF(COUNT_ARG(__VA_ARGS__), DIV2(COUNT_ARG(__VA_ARGS__)),1)]; \
XinZhangMS 0:f7f1f0d76dd6 976 ARG_BUFFER validate_arg_buffers[IF(COUNT_ARG(__VA_ARGS__), DIV2(COUNT_ARG(__VA_ARGS__)),1)]; \
XinZhangMS 0:f7f1f0d76dd6 977 FOR_EACH_2(DECLARE_VALIDATE_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 978 FOR_EACH_2(DECLARE_IGNORE_FLAG_FOR_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 979 FOR_EACH_2(DECLARE_OVERRIDE_ARGUMENT_TYPE_FOR_ARG, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 980 IF(IS_NOT_VOID(return_type),int fail_return_value_set : 1; \
XinZhangMS 0:f7f1f0d76dd6 981 int return_value_set : 1;,) \
XinZhangMS 0:f7f1f0d76dd6 982 IF(COUNT_ARG(__VA_ARGS__), , IF(IS_NOT_VOID(return_type),, int dummy : 1;)) \
XinZhangMS 0:f7f1f0d76dd6 983 } C2(mock_call_,name); \
XinZhangMS 0:f7f1f0d76dd6 984 typedef C2(mock_call_modifier_,name) (*C3(auto_ignore_args_function_,name,_type))(C2(mock_call_modifier_,name) call_modifier, const char* call_as_string); \
XinZhangMS 0:f7f1f0d76dd6 985 C2(mock_call_modifier_,name) UMOCK_STATIC C2(auto_ignore_args_function_,name)(C2(mock_call_modifier_,name) call_modifier, const char* call_as_string) \
XinZhangMS 0:f7f1f0d76dd6 986 { \
XinZhangMS 0:f7f1f0d76dd6 987 C2(mock_call_modifier_,name) result = call_modifier; \
XinZhangMS 0:f7f1f0d76dd6 988 IF(COUNT_ARG(__VA_ARGS__), \
XinZhangMS 0:f7f1f0d76dd6 989 int is_ignored; \
XinZhangMS 0:f7f1f0d76dd6 990 int arg_index = 1; ,) \
XinZhangMS 0:f7f1f0d76dd6 991 (void)call_as_string; \
XinZhangMS 0:f7f1f0d76dd6 992 FOR_EACH_2(AUTO_IGNORE_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 993 return result; \
XinZhangMS 0:f7f1f0d76dd6 994 } \
XinZhangMS 0:f7f1f0d76dd6 995 C3(auto_ignore_args_function_,name,_type) UMOCK_STATIC C2(get_auto_ignore_args_function_,name)(IF(COUNT_ARG(__VA_ARGS__),,void) FOR_EACH_2_COUNTED(ARG_IN_SIGNATURE, __VA_ARGS__)) \
XinZhangMS 0:f7f1f0d76dd6 996 { \
XinZhangMS 0:f7f1f0d76dd6 997 FOR_EACH_2(UNUSED_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 998 return C2(auto_ignore_args_function_,name); \
XinZhangMS 0:f7f1f0d76dd6 999 } \
XinZhangMS 0:f7f1f0d76dd6 1000 UMOCK_STATIC char* C2(mock_call_data_stringify_,name)(void* mock_call_data) \
XinZhangMS 0:f7f1f0d76dd6 1001 { \
XinZhangMS 0:f7f1f0d76dd6 1002 char* result; \
XinZhangMS 0:f7f1f0d76dd6 1003 IF(COUNT_ARG(__VA_ARGS__), C2(mock_call_,name)* typed_mock_call_data = (C2(mock_call_,name)*)mock_call_data;,) \
XinZhangMS 0:f7f1f0d76dd6 1004 int is_error = 0; \
XinZhangMS 0:f7f1f0d76dd6 1005 size_t args_string_length = 0; \
XinZhangMS 0:f7f1f0d76dd6 1006 FOR_EACH_2_COUNTED(STRINGIFY_ARGS_DECLARE_RESULT_VAR, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1007 IF(COUNT_ARG(__VA_ARGS__),,(void)mock_call_data;) \
XinZhangMS 0:f7f1f0d76dd6 1008 FOR_EACH_2(STRINGIFY_ARGS_CHECK_ARG_STRINGIFY_SUCCESS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1009 (void)mock_call_data; \
XinZhangMS 0:f7f1f0d76dd6 1010 if (is_error != 0) \
XinZhangMS 0:f7f1f0d76dd6 1011 { \
XinZhangMS 0:f7f1f0d76dd6 1012 result = NULL; \
XinZhangMS 0:f7f1f0d76dd6 1013 } \
XinZhangMS 0:f7f1f0d76dd6 1014 else \
XinZhangMS 0:f7f1f0d76dd6 1015 { \
XinZhangMS 0:f7f1f0d76dd6 1016 FOR_EACH_2(STRINGIFY_ARGS_DECLARE_ARG_STRING_LENGTH, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1017 FOR_EACH_2(STRINGIFY_ARGS_COUNT_LENGTH, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1018 IF(COUNT_ARG(__VA_ARGS__), args_string_length += COUNT_ARG(__VA_ARGS__) - 1;,) \
XinZhangMS 0:f7f1f0d76dd6 1019 result = (char*)umockalloc_malloc(args_string_length + 1); \
XinZhangMS 0:f7f1f0d76dd6 1020 if (result != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1021 { \
XinZhangMS 0:f7f1f0d76dd6 1022 if (args_string_length == 0) \
XinZhangMS 0:f7f1f0d76dd6 1023 { \
XinZhangMS 0:f7f1f0d76dd6 1024 result[0] = '\0'; \
XinZhangMS 0:f7f1f0d76dd6 1025 } \
XinZhangMS 0:f7f1f0d76dd6 1026 else \
XinZhangMS 0:f7f1f0d76dd6 1027 { \
XinZhangMS 0:f7f1f0d76dd6 1028 IF(COUNT_ARG(__VA_ARGS__), \
XinZhangMS 0:f7f1f0d76dd6 1029 size_t current_pos = 0; \
XinZhangMS 0:f7f1f0d76dd6 1030 size_t arg_index = 0; \
XinZhangMS 0:f7f1f0d76dd6 1031 FOR_EACH_2(STRINGIFY_ARGS_COPY_ARG_STRING, __VA_ARGS__), ) \
XinZhangMS 0:f7f1f0d76dd6 1032 } \
XinZhangMS 0:f7f1f0d76dd6 1033 } \
XinZhangMS 0:f7f1f0d76dd6 1034 } \
XinZhangMS 0:f7f1f0d76dd6 1035 FOR_EACH_2(STRINGIFY_ARGS_FREE_STRINGIFIED_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1036 return result; \
XinZhangMS 0:f7f1f0d76dd6 1037 } \
XinZhangMS 0:f7f1f0d76dd6 1038 UMOCK_STATIC int C2(mock_call_data_are_equal_,name)(void* left, void* right) \
XinZhangMS 0:f7f1f0d76dd6 1039 { \
XinZhangMS 0:f7f1f0d76dd6 1040 int result; \
XinZhangMS 0:f7f1f0d76dd6 1041 if (left == right) \
XinZhangMS 0:f7f1f0d76dd6 1042 { \
XinZhangMS 0:f7f1f0d76dd6 1043 result = 1; \
XinZhangMS 0:f7f1f0d76dd6 1044 } \
XinZhangMS 0:f7f1f0d76dd6 1045 else if ((left == NULL) || (right == NULL)) \
XinZhangMS 0:f7f1f0d76dd6 1046 { \
XinZhangMS 0:f7f1f0d76dd6 1047 result = 0; \
XinZhangMS 0:f7f1f0d76dd6 1048 } \
XinZhangMS 0:f7f1f0d76dd6 1049 else \
XinZhangMS 0:f7f1f0d76dd6 1050 { \
XinZhangMS 0:f7f1f0d76dd6 1051 result = 1; \
XinZhangMS 0:f7f1f0d76dd6 1052 IF(COUNT_ARG(__VA_ARGS__), \
XinZhangMS 0:f7f1f0d76dd6 1053 { \
XinZhangMS 0:f7f1f0d76dd6 1054 C2(mock_call_,name)* typed_left = (C2(mock_call_,name)*)left; \
XinZhangMS 0:f7f1f0d76dd6 1055 C2(mock_call_,name)* typed_right = (C2(mock_call_,name)*)right; \
XinZhangMS 0:f7f1f0d76dd6 1056 FOR_EACH_2_COUNTED(ARE_EQUAL_FOR_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1057 }, ) \
XinZhangMS 0:f7f1f0d76dd6 1058 } \
XinZhangMS 0:f7f1f0d76dd6 1059 return result; \
XinZhangMS 0:f7f1f0d76dd6 1060 } \
XinZhangMS 0:f7f1f0d76dd6 1061 UMOCK_STATIC void C2(mock_call_data_free_func_,name)(void* mock_call_data) \
XinZhangMS 0:f7f1f0d76dd6 1062 { \
XinZhangMS 0:f7f1f0d76dd6 1063 C2(mock_call_,name)* typed_mock_call_data = (C2(mock_call_,name)*)mock_call_data; \
XinZhangMS 0:f7f1f0d76dd6 1064 FOR_EACH_2_COUNTED(FREE_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1065 FOR_EACH_2_COUNTED(FREE_OUT_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1066 FOR_EACH_2_COUNTED(FREE_VALIDATE_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1067 FOR_EACH_2_COUNTED(FREE_OVERRIDE_ARGUMENT_TYPE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1068 IF(IS_NOT_VOID(return_type),if (typed_mock_call_data->return_value_set == RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1069 { \
XinZhangMS 0:f7f1f0d76dd6 1070 umocktypes_free(TOSTRING(return_type), (void*)&typed_mock_call_data->return_value); \
XinZhangMS 0:f7f1f0d76dd6 1071 } \
XinZhangMS 0:f7f1f0d76dd6 1072 if (typed_mock_call_data->fail_return_value_set == FAIL_RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1073 { \
XinZhangMS 0:f7f1f0d76dd6 1074 umocktypes_free(TOSTRING(return_type), (void*)&typed_mock_call_data->fail_return_value); \
XinZhangMS 0:f7f1f0d76dd6 1075 },) \
XinZhangMS 0:f7f1f0d76dd6 1076 umockalloc_free(typed_mock_call_data); \
XinZhangMS 0:f7f1f0d76dd6 1077 } \
XinZhangMS 0:f7f1f0d76dd6 1078 UMOCK_STATIC void* C2(mock_call_data_copy_func_,name)(void* mock_call_data) \
XinZhangMS 0:f7f1f0d76dd6 1079 { \
XinZhangMS 0:f7f1f0d76dd6 1080 C2(mock_call_,name)* result = (C2(mock_call_,name)*)umockalloc_malloc(sizeof(C2(mock_call_,name))); \
XinZhangMS 0:f7f1f0d76dd6 1081 IF(COUNT_ARG(__VA_ARGS__), C2(mock_call_,name)* typed_mock_call_data = (C2(mock_call_,name)*)mock_call_data;,) \
XinZhangMS 0:f7f1f0d76dd6 1082 IF(IS_NOT_VOID(return_type), C2(mock_call_,name)* typed_mock_call_data_result = (C2(mock_call_,name)*)mock_call_data;,) \
XinZhangMS 0:f7f1f0d76dd6 1083 (void)mock_call_data; \
XinZhangMS 0:f7f1f0d76dd6 1084 FOR_EACH_2(COPY_IGNORE_ARG, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1085 FOR_EACH_2(COPY_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1086 FOR_EACH_2_COUNTED(COPY_OUT_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1087 FOR_EACH_2_COUNTED(COPY_VALIDATE_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1088 FOR_EACH_2(COPY_VALIDATE_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1089 FOR_EACH_2(COPY_OVERRIDE_ARGUMENT_TYPE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1090 IF(IS_NOT_VOID(return_type), \
XinZhangMS 0:f7f1f0d76dd6 1091 result->return_value_set = typed_mock_call_data_result->return_value_set; \
XinZhangMS 0:f7f1f0d76dd6 1092 result->fail_return_value_set = typed_mock_call_data_result->fail_return_value_set; \
XinZhangMS 0:f7f1f0d76dd6 1093 if (typed_mock_call_data_result->return_value_set == RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1094 { \
XinZhangMS 0:f7f1f0d76dd6 1095 umocktypes_copy(TOSTRING(return_type), (void*)&result->return_value, (void*)&typed_mock_call_data_result->return_value); \
XinZhangMS 0:f7f1f0d76dd6 1096 } \
XinZhangMS 0:f7f1f0d76dd6 1097 result->captured_return_value = typed_mock_call_data_result->captured_return_value; \
XinZhangMS 0:f7f1f0d76dd6 1098 if (typed_mock_call_data_result->fail_return_value_set == FAIL_RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1099 { \
XinZhangMS 0:f7f1f0d76dd6 1100 umocktypes_copy(TOSTRING(return_type), (void*)&result->fail_return_value, (void*)&typed_mock_call_data_result->fail_return_value); \
XinZhangMS 0:f7f1f0d76dd6 1101 },) \
XinZhangMS 0:f7f1f0d76dd6 1102 return result; \
XinZhangMS 0:f7f1f0d76dd6 1103 } \
XinZhangMS 0:f7f1f0d76dd6 1104 IF(IS_NOT_VOID(return_type),static return_type C2(mock_call_default_result_,name); \
XinZhangMS 0:f7f1f0d76dd6 1105 static return_type C2(mock_call_fail_result_,name); \
XinZhangMS 0:f7f1f0d76dd6 1106 IMPLEMENT_SET_RETURN_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1107 IMPLEMENT_SET_FAIL_RETURN_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1108 IMPLEMENT_CAPTURE_RETURN_FUNCTION(return_type, name, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 1109 IF(COUNT_ARG(__VA_ARGS__),IMPLEMENT_IGNORE_ALL_ARGUMENTS_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1110 IMPLEMENT_VALIDATE_ALL_ARGUMENTS_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1111 FOR_EACH_2_KEEP_1(IMPLEMENT_IGNORE_ARGUMENT_BY_NAME_FUNCTION, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1112 FOR_EACH_2_KEEP_1(IMPLEMENT_VALIDATE_ARGUMENT_BY_NAME_FUNCTION, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1113 IMPLEMENT_IGNORE_ARGUMENT_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1114 IMPLEMENT_VALIDATE_ARGUMENT_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1115 IMPLEMENT_COPY_OUT_ARGUMENT_BUFFER_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1116 FOR_EACH_2_KEEP_1(IMPLEMENT_COPY_OUT_ARGUMENT_BUFFER_BY_NAME_FUNCTION, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1117 IMPLEMENT_COPY_OUT_ARGUMENT_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1118 IMPLEMENT_VALIDATE_ARGUMENT_BUFFER_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1119 FOR_EACH_2_KEEP_1(IMPLEMENT_VALIDATE_ARGUMENT_VALUE_BY_NAME_FUNCTION, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1120 FOR_EACH_2_KEEP_1(IMPLEMENT_VALIDATE_ARGUMENT_VALUE_AS_TYPE_BY_NAME_FUNCTION, name, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 1121 IMPLEMENT_IGNORE_ALL_CALLS_FUNCTION(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1122 IMPLEMENT_REGISTER_GLOBAL_MOCK_HOOK(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1123 IMPLEMENT_REGISTER_GLOBAL_MOCK_RETURN(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1124 IMPLEMENT_REGISTER_GLOBAL_MOCK_FAIL_RETURN(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1125 IMPLEMENT_REGISTER_GLOBAL_MOCK_RETURNS(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1126 IMPLEMENT_STRICT_EXPECTED_MOCK(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1127 IMPLEMENT_EXPECTED_MOCK(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1128
XinZhangMS 0:f7f1f0d76dd6 1129 /* Codes_SRS_UMOCK_C_LIB_01_193: [ When a destroy_call happens the memory block associated with the argument passed to it shall be freed. ] */
XinZhangMS 0:f7f1f0d76dd6 1130 /* Codes_SRS_UMOCK_C_LIB_01_195: [ If any error occurs during the destroy_call related then umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 1131 /* Codes_SRS_UMOCK_C_LIB_01_194: [ If the first argument passed to destroy_call is not found in the list of tracked handles (returned by create_call) then umock_c shall raise an error with the code UMOCK_C_INVALID_PAIRED_CALLS. ]*/
XinZhangMS 0:f7f1f0d76dd6 1132 #define MOCKABLE_FUNCTION_BODY_WITHOUT_RETURN(modifiers, return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 1133 UMOCK_STATIC return_type modifiers name(IF(COUNT_ARG(__VA_ARGS__),,void) FOR_EACH_2_COUNTED(ARG_IN_SIGNATURE, __VA_ARGS__)) \
XinZhangMS 0:f7f1f0d76dd6 1134 { \
XinZhangMS 0:f7f1f0d76dd6 1135 UMOCKCALL_HANDLE mock_call; \
XinZhangMS 0:f7f1f0d76dd6 1136 UMOCKCALL_HANDLE matched_call; \
XinZhangMS 0:f7f1f0d76dd6 1137 IF(IS_NOT_VOID(return_type), \
XinZhangMS 0:f7f1f0d76dd6 1138 unsigned int result_value_set = 0; \
XinZhangMS 0:f7f1f0d76dd6 1139 unsigned int fail_result_value_set = 0; \
XinZhangMS 0:f7f1f0d76dd6 1140 void* captured_return_value = NULL;,) \
XinZhangMS 0:f7f1f0d76dd6 1141 IF(IS_NOT_VOID(return_type),TRACK_CREATE_FUNC_TYPE track_create_destroy_pair_malloc_local = C2(track_create_destroy_pair_malloc_,name); \
XinZhangMS 0:f7f1f0d76dd6 1142 PAIRED_HANDLES* used_paired_handles_local = C2(used_paired_handles_,name); \
XinZhangMS 0:f7f1f0d76dd6 1143 const char* return_type_string = TOSTRING(return_type);,) \
XinZhangMS 0:f7f1f0d76dd6 1144 IF(IS_NOT_VOID(return_type),return_type result = C2(mock_call_default_result_,name);,) \
XinZhangMS 0:f7f1f0d76dd6 1145 C2(mock_call_,name)* matched_call_data; \
XinZhangMS 0:f7f1f0d76dd6 1146 C2(mock_call_,name)* mock_call_data = (C2(mock_call_,name)*)umockalloc_malloc(sizeof(C2(mock_call_,name))); \
XinZhangMS 0:f7f1f0d76dd6 1147 FOR_EACH_2(COPY_ARG_TO_MOCK_STRUCT, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1148 FOR_EACH_2(MARK_ARG_AS_NOT_IGNORED, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1149 FOR_EACH_2_COUNTED(CLEAR_OUT_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1150 FOR_EACH_2_COUNTED(CLEAR_VALIDATE_ARG_BUFFERS, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1151 FOR_EACH_2(CLEAR_VALIDATE_ARG_VALUE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1152 FOR_EACH_2(CLEAR_OVERRIDE_ARGUMENT_TYPE, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1153 IF(IS_NOT_VOID(return_type),mock_call_data->return_value_set = RETURN_VALUE_NOT_SET; \
XinZhangMS 0:f7f1f0d76dd6 1154 mock_call_data->captured_return_value = NULL; \
XinZhangMS 0:f7f1f0d76dd6 1155 mock_call_data->fail_return_value_set = FAIL_RETURN_VALUE_NOT_SET;,) \
XinZhangMS 0:f7f1f0d76dd6 1156 mock_call = umockcall_create(#name, mock_call_data, C2(mock_call_data_copy_func_,name), C2(mock_call_data_free_func_,name), C2(mock_call_data_stringify_,name), C2(mock_call_data_are_equal_,name)); \
XinZhangMS 0:f7f1f0d76dd6 1157 if (mock_call == NULL) \
XinZhangMS 0:f7f1f0d76dd6 1158 { \
XinZhangMS 0:f7f1f0d76dd6 1159 IF(IS_NOT_VOID(return_type),COPY_RETURN_VALUE(return_type, name),) \
XinZhangMS 0:f7f1f0d76dd6 1160 UMOCK_LOG("Could not create a mock call in the actual call for %s.", TOSTRING(name)); \
XinZhangMS 0:f7f1f0d76dd6 1161 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 1162 } \
XinZhangMS 0:f7f1f0d76dd6 1163 else \
XinZhangMS 0:f7f1f0d76dd6 1164 { \
XinZhangMS 0:f7f1f0d76dd6 1165 if (umock_c_add_actual_call(mock_call, &matched_call) != 0) \
XinZhangMS 0:f7f1f0d76dd6 1166 { \
XinZhangMS 0:f7f1f0d76dd6 1167 umockcall_destroy(mock_call); \
XinZhangMS 0:f7f1f0d76dd6 1168 UMOCK_LOG("Could not add an actual call for %s.", TOSTRING(name)); \
XinZhangMS 0:f7f1f0d76dd6 1169 umock_c_indicate_error(UMOCK_C_COMPARE_CALL_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 1170 } \
XinZhangMS 0:f7f1f0d76dd6 1171 if (matched_call != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1172 { \
XinZhangMS 0:f7f1f0d76dd6 1173 matched_call_data = (C2(mock_call_,name)*)umockcall_get_call_data(matched_call); \
XinZhangMS 0:f7f1f0d76dd6 1174 IF(IS_NOT_VOID(return_type),if (matched_call_data != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1175 { \
XinZhangMS 0:f7f1f0d76dd6 1176 captured_return_value = (void*)matched_call_data->captured_return_value; \
XinZhangMS 0:f7f1f0d76dd6 1177 if (umockcall_get_fail_call(matched_call)) \
XinZhangMS 0:f7f1f0d76dd6 1178 { \
XinZhangMS 0:f7f1f0d76dd6 1179 if (matched_call_data->fail_return_value_set == FAIL_RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1180 { \
XinZhangMS 0:f7f1f0d76dd6 1181 result = matched_call_data->fail_return_value; \
XinZhangMS 0:f7f1f0d76dd6 1182 } \
XinZhangMS 0:f7f1f0d76dd6 1183 else \
XinZhangMS 0:f7f1f0d76dd6 1184 { \
XinZhangMS 0:f7f1f0d76dd6 1185 result = C2(mock_call_fail_result_, name); \
XinZhangMS 0:f7f1f0d76dd6 1186 } \
XinZhangMS 0:f7f1f0d76dd6 1187 result_value_set = 1; \
XinZhangMS 0:f7f1f0d76dd6 1188 fail_result_value_set = 1; \
XinZhangMS 0:f7f1f0d76dd6 1189 } \
XinZhangMS 0:f7f1f0d76dd6 1190 else if (matched_call_data->return_value_set == RETURN_VALUE_SET) \
XinZhangMS 0:f7f1f0d76dd6 1191 { \
XinZhangMS 0:f7f1f0d76dd6 1192 result = matched_call_data->return_value; \
XinZhangMS 0:f7f1f0d76dd6 1193 result_value_set = 1; \
XinZhangMS 0:f7f1f0d76dd6 1194 } \
XinZhangMS 0:f7f1f0d76dd6 1195 else \
XinZhangMS 0:f7f1f0d76dd6 1196 { \
XinZhangMS 0:f7f1f0d76dd6 1197 if (C2(mock_hook_, name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1198 { \
XinZhangMS 0:f7f1f0d76dd6 1199 IF(IS_NOT_VOID(return_type),result =,) C2(mock_hook_, name)(FOR_EACH_2_COUNTED(ARG_NAME_ONLY_IN_CALL, __VA_ARGS__)); \
XinZhangMS 0:f7f1f0d76dd6 1200 IF(IS_NOT_VOID(return_type),result_value_set = 1;,) \
XinZhangMS 0:f7f1f0d76dd6 1201 } \
XinZhangMS 0:f7f1f0d76dd6 1202 } \
XinZhangMS 0:f7f1f0d76dd6 1203 }, \
XinZhangMS 0:f7f1f0d76dd6 1204 if (C2(mock_hook_, name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1205 { \
XinZhangMS 0:f7f1f0d76dd6 1206 C2(mock_hook_, name)(FOR_EACH_2_COUNTED(ARG_NAME_ONLY_IN_CALL, __VA_ARGS__)); \
XinZhangMS 0:f7f1f0d76dd6 1207 } \
XinZhangMS 0:f7f1f0d76dd6 1208 ) \
XinZhangMS 0:f7f1f0d76dd6 1209 IF(COUNT_ARG(__VA_ARGS__), FOR_EACH_2_COUNTED(COPY_OUT_ARG_VALUE_FROM_MATCHED_CALL, __VA_ARGS__),) \
XinZhangMS 0:f7f1f0d76dd6 1210 } \
XinZhangMS 0:f7f1f0d76dd6 1211 else \
XinZhangMS 0:f7f1f0d76dd6 1212 { \
XinZhangMS 0:f7f1f0d76dd6 1213 if (C2(mock_hook_, name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1214 { \
XinZhangMS 0:f7f1f0d76dd6 1215 IF(IS_NOT_VOID(return_type),result =,) C2(mock_hook_, name)(FOR_EACH_2_COUNTED(ARG_NAME_ONLY_IN_CALL, __VA_ARGS__)); \
XinZhangMS 0:f7f1f0d76dd6 1216 IF(IS_NOT_VOID(return_type),result_value_set = 1;,) \
XinZhangMS 0:f7f1f0d76dd6 1217 } \
XinZhangMS 0:f7f1f0d76dd6 1218 } \
XinZhangMS 0:f7f1f0d76dd6 1219 } \
XinZhangMS 0:f7f1f0d76dd6 1220 IF(COUNT_ARG(__VA_ARGS__), if (C2(track_create_destroy_pair_free_, name) != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1221 { \
XinZhangMS 0:f7f1f0d76dd6 1222 if (C2(track_create_destroy_pair_free_, name)(C2(used_paired_handles_, name), (void*)&ONLY_FIRST_ARG(__VA_ARGS__, 1)) != 0) \
XinZhangMS 0:f7f1f0d76dd6 1223 { \
XinZhangMS 0:f7f1f0d76dd6 1224 UMOCK_LOG("Could not track the destroy call for %s.", TOSTRING(name)); \
XinZhangMS 0:f7f1f0d76dd6 1225 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 1226 } \
XinZhangMS 0:f7f1f0d76dd6 1227 },) \
XinZhangMS 0:f7f1f0d76dd6 1228 {
XinZhangMS 0:f7f1f0d76dd6 1229
XinZhangMS 0:f7f1f0d76dd6 1230 /* Codes_SRS_UMOCK_C_LIB_01_188: [ The create call shall have a non-void return type. ]*/
XinZhangMS 0:f7f1f0d76dd6 1231 /* Codes_SRS_UMOCK_C_LIB_01_191: [ At each create_call a memory block shall be allocated so that it can be reported as a leak by any memory checker. ]*/
XinZhangMS 0:f7f1f0d76dd6 1232 /* Codes_SRS_UMOCK_C_LIB_01_192: [ If any error occurs during the create_call related then umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 1233 /* Codes_SRS_UMOCK_C_LIB_01_204: [ Tracking of paired calls shall not be done if the actual call to the `create_call` is using the `SetFailReturn` call modifier. ]*/
XinZhangMS 0:f7f1f0d76dd6 1234 #define MOCKABLE_FUNCTION_UMOCK_INTERNAL_WITH_MOCK(modifiers, return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 1235 MOCKABLE_FUNCTION_UMOCK_INTERNAL_WITH_MOCK_NO_CODE(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1236 MOCKABLE_FUNCTION_BODY_WITHOUT_RETURN(modifiers, return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1237 IF(IS_NOT_VOID(return_type), \
XinZhangMS 0:f7f1f0d76dd6 1238 if (result_value_set == 0) \
XinZhangMS 0:f7f1f0d76dd6 1239 { \
XinZhangMS 0:f7f1f0d76dd6 1240 COPY_RETURN_VALUE(return_type, name) \
XinZhangMS 0:f7f1f0d76dd6 1241 }; \
XinZhangMS 0:f7f1f0d76dd6 1242 if (captured_return_value != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1243 { \
XinZhangMS 0:f7f1f0d76dd6 1244 (void)memcpy(captured_return_value, (void*)&result, sizeof(result)); \
XinZhangMS 0:f7f1f0d76dd6 1245 } \
XinZhangMS 0:f7f1f0d76dd6 1246 if ((track_create_destroy_pair_malloc_local != NULL) && (fail_result_value_set == 0)) \
XinZhangMS 0:f7f1f0d76dd6 1247 { \
XinZhangMS 0:f7f1f0d76dd6 1248 if (track_create_destroy_pair_malloc_local(used_paired_handles_local, (const void*)&result, return_type_string, sizeof(result)) != 0) \
XinZhangMS 0:f7f1f0d76dd6 1249 { \
XinZhangMS 0:f7f1f0d76dd6 1250 UMOCK_LOG("Could not track the create call for %s.", TOSTRING(name)); \
XinZhangMS 0:f7f1f0d76dd6 1251 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 1252 } \
XinZhangMS 0:f7f1f0d76dd6 1253 } \
XinZhangMS 0:f7f1f0d76dd6 1254 return result;,) \
XinZhangMS 0:f7f1f0d76dd6 1255 } \
XinZhangMS 0:f7f1f0d76dd6 1256 } \
XinZhangMS 0:f7f1f0d76dd6 1257
XinZhangMS 0:f7f1f0d76dd6 1258 /* Codes_SRS_UMOCK_C_LIB_01_150: [ MOCK_FUNCTION_WITH_CODE shall define a mock function and allow the user to embed code between this define and a MOCK_FUNCTION_END call. ]*/
XinZhangMS 0:f7f1f0d76dd6 1259 #define MOCK_FUNCTION_WITH_CODE(modifiers, return_type, name, ...) \
XinZhangMS 0:f7f1f0d76dd6 1260 MOCKABLE_FUNCTION_UMOCK_INTERNAL_WITH_MOCK_NO_CODE(return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1261 MOCKABLE_FUNCTION_BODY_WITHOUT_RETURN(modifiers, return_type, name, __VA_ARGS__) \
XinZhangMS 0:f7f1f0d76dd6 1262
XinZhangMS 0:f7f1f0d76dd6 1263 /* Codes_SRS_UMOCK_C_LIB_01_188: [ The create call shall have a non-void return type. ]*/
XinZhangMS 0:f7f1f0d76dd6 1264 /* Codes_SRS_UMOCK_C_LIB_01_191: [ At each create_call a memory block shall be allocated so that it can be reported as a leak by any memory checker. ]*/
XinZhangMS 0:f7f1f0d76dd6 1265 /* Codes_SRS_UMOCK_C_LIB_01_192: [ If any error occurs during the create_call related then umock_c shall raise an error with the code UMOCK_C_ERROR. ]*/
XinZhangMS 0:f7f1f0d76dd6 1266 /* Codes_SRS_UMOCK_C_LIB_01_204: [ Tracking of paired calls shall not be done if the actual call to the `create_call` is using the `SetFailReturn` call modifier. ]*/
XinZhangMS 0:f7f1f0d76dd6 1267 #define MOCK_FUNCTION_END(...) \
XinZhangMS 0:f7f1f0d76dd6 1268 IF(COUNT_ARG(__VA_ARGS__), if (result_value_set == 0) \
XinZhangMS 0:f7f1f0d76dd6 1269 { \
XinZhangMS 0:f7f1f0d76dd6 1270 result = __VA_ARGS__; \
XinZhangMS 0:f7f1f0d76dd6 1271 }; \
XinZhangMS 0:f7f1f0d76dd6 1272 if (captured_return_value != NULL) \
XinZhangMS 0:f7f1f0d76dd6 1273 { \
XinZhangMS 0:f7f1f0d76dd6 1274 (void)memcpy(captured_return_value, (void*)&result, sizeof(result)); \
XinZhangMS 0:f7f1f0d76dd6 1275 } \
XinZhangMS 0:f7f1f0d76dd6 1276 if ((track_create_destroy_pair_malloc_local != NULL) && (fail_result_value_set == 0)) \
XinZhangMS 0:f7f1f0d76dd6 1277 { \
XinZhangMS 0:f7f1f0d76dd6 1278 if (track_create_destroy_pair_malloc_local(used_paired_handles_local, (const void*)&result, return_type_string, sizeof(result)) != 0) \
XinZhangMS 0:f7f1f0d76dd6 1279 { \
XinZhangMS 0:f7f1f0d76dd6 1280 UMOCK_LOG("Could not track the create call for %s.", TOSTRING(name)); \
XinZhangMS 0:f7f1f0d76dd6 1281 umock_c_indicate_error(UMOCK_C_ERROR); \
XinZhangMS 0:f7f1f0d76dd6 1282 } \
XinZhangMS 0:f7f1f0d76dd6 1283 } \
XinZhangMS 0:f7f1f0d76dd6 1284 return result;,) \
XinZhangMS 0:f7f1f0d76dd6 1285 } \
XinZhangMS 0:f7f1f0d76dd6 1286 }
XinZhangMS 0:f7f1f0d76dd6 1287
XinZhangMS 0:f7f1f0d76dd6 1288 /* Codes_SRS_UMOCK_C_LIB_01_187: [ REGISTER_UMOCKC_PAIRED_CREATE_DESTROY_CALLS shall register with umock two calls that are expected to be paired. ]*/
XinZhangMS 0:f7f1f0d76dd6 1289 /* Codes_SRS_UMOCK_C_LIB_01_190: [ If create_call or destroy_call do not obey these rules, at the time of calling REGISTER_UMOCKC_PAIRED_CREATE_DESTROY_CALLS umock_c shall raise an error with the code UMOCK_C_INVALID_PAIRED_CALLS. ]*/
XinZhangMS 0:f7f1f0d76dd6 1290 /* Codes_SRS_UMOCK_C_LIB_01_189: [ The destroy call shall take as argument at least one argument. The type of the first argument shall be of the same type as the return type for the create_call. ]*/
XinZhangMS 0:f7f1f0d76dd6 1291 #define REGISTER_UMOCKC_PAIRED_CREATE_DESTROY_CALLS(create_call, destroy_call) \
XinZhangMS 0:f7f1f0d76dd6 1292 if ((strcmp(C2(mock_call_metadata_,create_call).return_type, "void") == 0) || \
XinZhangMS 0:f7f1f0d76dd6 1293 (C2(mock_call_metadata_,destroy_call).arg_count == 0) || \
XinZhangMS 0:f7f1f0d76dd6 1294 (strcmp(C2(mock_call_metadata_,create_call).return_type, C2(mock_call_metadata_, destroy_call).args[0].type) != 0)) \
XinZhangMS 0:f7f1f0d76dd6 1295 { \
XinZhangMS 0:f7f1f0d76dd6 1296 umock_c_indicate_error(UMOCK_C_INVALID_PAIRED_CALLS); \
XinZhangMS 0:f7f1f0d76dd6 1297 } \
XinZhangMS 0:f7f1f0d76dd6 1298 else \
XinZhangMS 0:f7f1f0d76dd6 1299 { \
XinZhangMS 0:f7f1f0d76dd6 1300 C2(track_create_destroy_pair_malloc_, create_call) = umockcallpairs_track_create_paired_call; \
XinZhangMS 0:f7f1f0d76dd6 1301 C2(track_create_destroy_pair_free_, destroy_call) = umockcallpairs_track_destroy_paired_call; \
XinZhangMS 0:f7f1f0d76dd6 1302 C2(used_paired_handles_, create_call) = &C2(paired_handles_, create_call); \
XinZhangMS 0:f7f1f0d76dd6 1303 C2(used_paired_handles_, destroy_call) = &C2(paired_handles_, create_call); \
XinZhangMS 0:f7f1f0d76dd6 1304 }
XinZhangMS 0:f7f1f0d76dd6 1305
XinZhangMS 0:f7f1f0d76dd6 1306 #ifdef __cplusplus
XinZhangMS 0:f7f1f0d76dd6 1307 }
XinZhangMS 0:f7f1f0d76dd6 1308 #endif
XinZhangMS 0:f7f1f0d76dd6 1309
XinZhangMS 0:f7f1f0d76dd6 1310 #endif /* UMOCK_C_INTERNAL_H */