Debian Codegraph @

src/vendor/azure-uamqp-c/deps/umock-c/src/umockcallrecorder.c

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #include <stddef.h>
5 #include <string.h>
6 #include "umock_c/umockcallrecorder.h"
7 #include "umock_c/umockcall.h"
8 #include "umock_c/umocktypes.h"
9 #include "umock_c/umockalloc.h"
10 #include "umock_c/umock_log.h"
11
12 typedef struct UMOCK_EXPECTED_CALL_TAG
13 {
14 UMOCKCALL_HANDLE umockcall;
15 unsigned int is_matched : 1;
16 } UMOCK_EXPECTED_CALL;
17
18 typedef struct UMOCKCALLRECORDER_TAG
19 {
20 size_t expected_call_count;
21 UMOCK_EXPECTED_CALL* expected_calls;
22 size_t actual_call_count;
23 UMOCKCALL_HANDLE* actual_calls;
24 char* expected_calls_string;
25 char* actual_calls_string;
26 } UMOCKCALLRECORDER;
27
28 UMOCKCALLRECORDER_HANDLE umockcallrecorder_create(void)
29 {
30 UMOCKCALLRECORDER_HANDLE result;
31
32 /* Codes_SRS_UMOCKCALLRECORDER_01_001: [ umockcallrecorder_create shall create a new instance of a call recorder and return a non-NULL handle to it on success. ]*/
33 result = (UMOCKCALLRECORDER_HANDLE)umockalloc_malloc(sizeof(UMOCKCALLRECORDER));
34 /* Codes_SRS_UMOCKCALLRECORDER_01_002: [ If allocating memory for the call recorder fails, umockcallrecorder_create shall return NULL. ]*/
35 if (result != NULL)
36 {
37 result->expected_call_count = 0;
38 result->expected_calls = NULL;
39 result->expected_calls_string = NULL;
40 result->actual_call_count = 0;
41 result->actual_calls = NULL;
42 result->actual_calls_string = NULL;
43 }
44
45 return result;
46 }
47
48 void umockcallrecorder_destroy(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
49 {
50 /* Codes_SRS_UMOCKCALLRECORDER_01_004: [ If umock_call_recorder is NULL, umockcallrecorder_destroy shall do nothing. ]*/
51 if (umock_call_recorder != NULL)
52 {
53 /* Codes_SRS_UMOCKCALLRECORDER_01_003: [ umockcallrecorder_destroy shall free the resources associated with a the call recorder identified by the umock_call_recorder argument. ]*/
54 (void)umockcallrecorder_reset_all_calls(umock_call_recorder);
55 umockalloc_free(umock_call_recorder->actual_calls_string);
56 umockalloc_free(umock_call_recorder->expected_calls_string);
57 umockalloc_free(umock_call_recorder);
58 }
59 }
60
61 int umockcallrecorder_reset_all_calls(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
62 {
63 int result;
64
65 if (umock_call_recorder == NULL)
66 {
67 /* Codes_SRS_UMOCKCALLRECORDER_01_007: [ If umock_call_recorder is NULL, umockcallrecorder_reset_all_calls shall fail and return a non-zero value. ]*/
68 UMOCK_LOG("umockcallrecorder: Reset all calls failed: NULL umock_call_recorder.");
69 result = __LINE__;
70 }
71 else
72 {
73 /* Codes_SRS_UMOCKCALLRECORDER_01_005: [ umockcallrecorder_reset_all_calls shall free all the expected and actual calls for the call recorder identified by umock_call_recorder. ]*/
74 if (umock_call_recorder->expected_calls != NULL)
75 {
76 size_t i;
77 for (i = 0; i < umock_call_recorder->expected_call_count; i++)
78 {
79 umockcall_destroy(umock_call_recorder->expected_calls[i].umockcall);
80 }
81
82 umockalloc_free(umock_call_recorder->expected_calls);
83 umock_call_recorder->expected_calls = NULL;
84 }
85 umock_call_recorder->expected_call_count = 0;
86
87 if (umock_call_recorder->actual_calls != NULL)
88 {
89 size_t i;
90 for (i = 0; i < umock_call_recorder->actual_call_count; i++)
91 {
92 umockcall_destroy(umock_call_recorder->actual_calls[i]);
93 }
94
95 umockalloc_free(umock_call_recorder->actual_calls);
96 umock_call_recorder->actual_calls = NULL;
97 }
98 umock_call_recorder->actual_call_count = 0;
99
100 /* Codes_SRS_UMOCKCALLRECORDER_01_006: [ On success umockcallrecorder_reset_all_calls shall return 0. ]*/
101 result = 0;
102 }
103
104 return result;
105 }
106
107 int umockcallrecorder_add_expected_call(UMOCKCALLRECORDER_HANDLE umock_call_recorder, UMOCKCALL_HANDLE mock_call)
108 {
109 int result;
110
111 if ((umock_call_recorder == NULL) ||
112 (mock_call == NULL))
113 {
114 /* Codes_SRS_UMOCKCALLRECORDER_01_012: [ If any of the arguments is NULL, umockcallrecorder_add_expected_call shall fail and return a non-zero value. ]*/
115 UMOCK_LOG("umockcallrecorder: Bad arguments in add expected call: umock_call_recorder = %p, mock_call = %p.",
116 umock_call_recorder, mock_call);
117 result = __LINE__;
118 }
119 else
120 {
121 UMOCK_EXPECTED_CALL* new_expected_calls = (UMOCK_EXPECTED_CALL*)umockalloc_realloc(umock_call_recorder->expected_calls, sizeof(UMOCK_EXPECTED_CALL) * (umock_call_recorder->expected_call_count + 1));
122 if (new_expected_calls == NULL)
123 {
124 /* Codes_SRS_UMOCKCALLRECORDER_01_013: [ If allocating memory for the expected calls fails, umockcallrecorder_add_expected_call shall fail and return a non-zero value. ] */
125 UMOCK_LOG("umockcallrecorder: Cannot allocate memory in add expected call.");
126 result = __LINE__;
127 }
128 else
129 {
130 /* Codes_SRS_UMOCKCALLRECORDER_01_008: [ umockcallrecorder_add_expected_call shall add the mock_call call to the expected call list maintained by the call recorder identified by umock_call_recorder. ]*/
131 umock_call_recorder->expected_calls = new_expected_calls;
132 umock_call_recorder->expected_calls[umock_call_recorder->expected_call_count].umockcall = mock_call;
133 umock_call_recorder->expected_calls[umock_call_recorder->expected_call_count++].is_matched = 0;
134
135 /* Codes_SRS_UMOCKCALLRECORDER_01_009: [ On success umockcallrecorder_add_expected_call shall return 0. ]*/
136 result = 0;
137 }
138 }
139
140 return result;
141 }
142
143 int umockcallrecorder_add_actual_call(UMOCKCALLRECORDER_HANDLE umock_call_recorder, UMOCKCALL_HANDLE mock_call, UMOCKCALL_HANDLE* matched_call)
144 {
145 int result;
146
147 if ((umock_call_recorder == NULL) ||
148 (mock_call == NULL) ||
149 (matched_call == NULL))
150 {
151 /* Codes_SRS_UMOCKCALLRECORDER_01_019: [ If any of the arguments is NULL, umockcallrecorder_add_actual_call shall fail and return a non-zero value. ]*/
152 UMOCK_LOG("umockcallrecorder: Bad arguments in add actual call: umock_call_recorder = %p, mock_call = %p, matched_call = %p.",
153 umock_call_recorder, mock_call, matched_call);
154 result = __LINE__;
155 }
156 else
157 {
158 size_t i;
159 unsigned int is_error = 0;
160
161 *matched_call = NULL;
162
163 /* Codes_SRS_UMOCKCALLRECORDER_01_014: [ umockcallrecorder_add_actual_call shall check whether the call mock_call matches any of the expected calls maintained by umock_call_recorder. ]*/
164 /* Codes_SRS_UMOCK_C_LIB_01_115: [ umock_c shall compare calls in order. ]*/
165 for (i = 0; i < umock_call_recorder->expected_call_count; i++)
166 {
167 int ignore_all_calls = umockcall_get_ignore_all_calls(umock_call_recorder->expected_calls[i].umockcall);
168 if (ignore_all_calls < 0)
169 {
170 /* Codes_SRS_UMOCKCALLRECORDER_01_058: [ If getting ignore_all_calls by calling umockcall_get_ignore_all_calls fails, umockcallrecorder_add_actual_call shall fail and return a non-zero value. ]*/
171 UMOCK_LOG("umockcallrecorder: Cannot get the ignore_all_calls flag.");
172 is_error = 1;
173 break;
174 }
175 else
176 {
177 if ((umock_call_recorder->expected_calls[i].is_matched == 0) ||
178 /* Codes_SRS_UMOCKCALLRECORDER_01_057: [ If any expected call has ignore_all_calls set and the actual call is equal to it when comparing the 2 calls, then the call shall be considered matched and not added to the actual calls list. ]*/
179 (ignore_all_calls > 0))
180 {
181 /* Codes_SRS_UMOCKCALLRECORDER_01_017: [ Comparing the calls shall be done by calling umockcall_are_equal. ]*/
182 int are_equal_result = umockcall_are_equal(umock_call_recorder->expected_calls[i].umockcall, mock_call);
183 if (are_equal_result == 1)
184 {
185 /* Codes_SRS_UMOCKCALLRECORDER_01_016: [ If the call matches one of the expected calls, a handle to the matched call shall be filled into the matched_call argument. ]*/
186 *matched_call = umock_call_recorder->expected_calls[i].umockcall;
187 break;
188 }
189 /* Codes_SRS_UMOCKCALLRECORDER_01_021: [ If umockcall_are_equal fails, umockcallrecorder_add_actual_call shall fail and return a non-zero value. ]*/
190 else if (are_equal_result != 0)
191 {
192 is_error = 1;
193 break;
194 }
195 else
196 {
197 if (ignore_all_calls == 0)
198 {
199 i = umock_call_recorder->expected_call_count;
200 break;
201 }
202 }
203 }
204 }
205 }
206
207 if ((umock_call_recorder->actual_call_count == 0) && (i < umock_call_recorder->expected_call_count))
208 {
209 umock_call_recorder->expected_calls[i].is_matched = 1;
210 }
211 else
212 {
213 i = umock_call_recorder->expected_call_count;
214 }
215
216 if (is_error)
217 {
218 UMOCK_LOG("umockcallrecorder: Error in finding a matched call.");
219 result = __LINE__;
220 }
221 else
222 {
223 if (i == umock_call_recorder->expected_call_count)
224 {
225 /* Codes_SRS_UMOCKCALLRECORDER_01_015: [ If the call does not match any of the expected calls, then umockcallrecorder_add_actual_call shall add the mock_call call to the actual call list maintained by umock_call_recorder. ]*/
226 /* an unexpected call */
227 UMOCKCALL_HANDLE* new_actual_calls = (UMOCKCALL_HANDLE*)umockalloc_realloc(umock_call_recorder->actual_calls, sizeof(UMOCKCALL_HANDLE) * (umock_call_recorder->actual_call_count + 1));
228 if (new_actual_calls == NULL)
229 {
230 /* Codes_SRS_UMOCKCALLRECORDER_01_020: [ If allocating memory for the actual calls fails, umockcallrecorder_add_actual_call shall fail and return a non-zero value. ]*/
231 UMOCK_LOG("umockcallrecorder: Cannot allocate memory for actual calls.");
232 result = __LINE__;
233 }
234 else
235 {
236 umock_call_recorder->actual_calls = new_actual_calls;
237 umock_call_recorder->actual_calls[umock_call_recorder->actual_call_count++] = mock_call;
238
239 /* Codes_SRS_UMOCKCALLRECORDER_01_018: [ When no error is encountered, umockcallrecorder_add_actual_call shall return 0. ]*/
240 result = 0;
241 }
242 }
243 else
244 {
245 umockcall_destroy(mock_call);
246
247 /* Codes_SRS_UMOCKCALLRECORDER_01_018: [ When no error is encountered, umockcallrecorder_add_actual_call shall return 0. ]*/
248 result = 0;
249 }
250 }
251 }
252
253 return result;
254 }
255
256 const char* umockcallrecorder_get_expected_calls(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
257 {
258 const char* result;
259
260 if (umock_call_recorder == NULL)
261 {
262 /* Codes_SRS_UMOCKCALLRECORDER_01_029: [ If the umock_call_recorder is NULL, umockcallrecorder_get_expected_calls shall fail and return NULL. ]*/
263 UMOCK_LOG("umockcallrecorder: NULL umock_call_recorder in get expected calls.");
264 result = NULL;
265 }
266 else
267 {
268 size_t i;
269 char* new_expected_calls_string;
270 size_t current_length = 0;
271
272 for (i = 0; i < umock_call_recorder->expected_call_count; i++)
273 {
274 /* Codes_SRS_UMOCKCALLRECORDER_01_055: [ Getting the ignore_all_calls property shall be done by calling umockcall_get_ignore_all_calls. ]*/
275 int ignore_all_calls = umockcall_get_ignore_all_calls(umock_call_recorder->expected_calls[i].umockcall);
276 if (ignore_all_calls < 0)
277 {
278 /* Codes_SRS_UMOCKCALLRECORDER_01_056: [ If umockcall_get_ignore_all_calls returns a negative value then umockcallrecorder_get_expected_calls shall fail and return NULL. ]*/
279 UMOCK_LOG("umockcallrecorder: Cannot get the ignore_all_calls flag.");
280 break;
281 }
282 else
283 {
284 if ((umock_call_recorder->expected_calls[i].is_matched == 0) &&
285 /* Codes_SRS_UMOCKCALLRECORDER_01_054: [ Calls that have the ignore_all_calls property set shall not be reported in the expected call list. ]*/
286 (ignore_all_calls == 0))
287 {
288 /* Codes_SRS_UMOCKCALLRECORDER_01_028: [ The string for each call shall be obtained by calling umockcall_stringify. ]*/
289 char* stringified_call = umockcall_stringify(umock_call_recorder->expected_calls[i].umockcall);
290 if (stringified_call == NULL)
291 {
292 /* Codes_SRS_UMOCKCALLRECORDER_01_030: [ If umockcall_stringify fails, umockcallrecorder_get_expected_calls shall fail and return NULL. ]*/
293 break;
294 }
295 else
296 {
297 size_t stringified_call_length = strlen(stringified_call);
298 new_expected_calls_string = (char*)umockalloc_realloc(umock_call_recorder->expected_calls_string, current_length + stringified_call_length + 1);
299 if (new_expected_calls_string == NULL)
300 {
301 umockalloc_free(stringified_call);
302
303 /* Codes_SRS_UMOCKCALLRECORDER_01_031: [ If allocating memory for the resulting string fails, umockcallrecorder_get_expected_calls shall fail and return NULL. ]*/
304 break;
305 }
306 else
307 {
308 umock_call_recorder->expected_calls_string = new_expected_calls_string;
309 (void)memcpy(umock_call_recorder->expected_calls_string + current_length, stringified_call, stringified_call_length + 1);
310 current_length += stringified_call_length;
311 }
312
313 umockalloc_free(stringified_call);
314 }
315 }
316 }
317 }
318
319 if (i < umock_call_recorder->expected_call_count)
320 {
321 result = NULL;
322 }
323 else
324 {
325 if (current_length == 0)
326 {
327 new_expected_calls_string = (char*)umockalloc_realloc(umock_call_recorder->expected_calls_string, 1);
328 if (new_expected_calls_string == NULL)
329 {
330 /* Codes_SRS_UMOCKCALLRECORDER_01_031: [ If allocating memory for the resulting string fails, umockcallrecorder_get_expected_calls shall fail and return NULL. ]*/
331 UMOCK_LOG("umockcallrecorder: Cannot allocate memory for expected calls.");
332 result = NULL;
333 }
334 else
335 {
336 umock_call_recorder->expected_calls_string = new_expected_calls_string;
337 umock_call_recorder->expected_calls_string[0] = '\0';
338
339 /* Codes_SRS_UMOCKCALLRECORDER_01_027: [ umockcallrecorder_get_expected_calls shall return a pointer to the string representation of all the expected calls. ]*/
340 result = umock_call_recorder->expected_calls_string;
341 }
342 }
343 else
344 {
345 /* Codes_SRS_UMOCKCALLRECORDER_01_027: [ umockcallrecorder_get_expected_calls shall return a pointer to the string representation of all the expected calls. ]*/
346 result = umock_call_recorder->expected_calls_string;
347 }
348 }
349 }
350
351 return result;
352 }
353
354 const char* umockcallrecorder_get_actual_calls(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
355 {
356 const char* result;
357
358 if (umock_call_recorder == NULL)
359 {
360 /* Codes_SRS_UMOCKCALLRECORDER_01_024: [ If the umock_call_recorder is NULL, umockcallrecorder_get_actual_calls shall fail and return NULL. ]*/
361 UMOCK_LOG("umockcallrecorder: NULL umock_call_recorder in get actual calls.");
362 result = NULL;
363 }
364 else
365 {
366 size_t i;
367 char* new_actual_calls_string;
368
369 if (umock_call_recorder->actual_call_count == 0)
370 {
371 new_actual_calls_string = (char*)umockalloc_realloc(umock_call_recorder->actual_calls_string, 1);
372 if (new_actual_calls_string == NULL)
373 {
374 /* Codes_SRS_UMOCKCALLRECORDER_01_026: [ If allocating memory for the resulting string fails, umockcallrecorder_get_actual_calls shall fail and return NULL. ]*/
375 UMOCK_LOG("umockcallrecorder: Cannot allocate memory for actual calls.");
376 result = NULL;
377 }
378 else
379 {
380 umock_call_recorder->actual_calls_string = new_actual_calls_string;
381 umock_call_recorder->actual_calls_string[0] = '\0';
382
383 /* Codes_SRS_UMOCKCALLRECORDER_01_022: [ umockcallrecorder_get_actual_calls shall return a pointer to the string representation of all the actual calls. ]*/
384 result = umock_call_recorder->actual_calls_string;
385 }
386 }
387 else
388 {
389 size_t current_length = 0;
390
391 for (i = 0; i < umock_call_recorder->actual_call_count; i++)
392 {
393 /* Codes_SRS_UMOCKCALLRECORDER_01_023: [ The string for each call shall be obtained by calling umockcall_stringify. ]*/
394 char* stringified_call = umockcall_stringify(umock_call_recorder->actual_calls[i]);
395 if (stringified_call == NULL)
396 {
397 /* Codes_SRS_UMOCKCALLRECORDER_01_025: [ If umockcall_stringify fails, umockcallrecorder_get_actual_calls shall fail and return NULL. ]*/
398 break;
399 }
400 else
401 {
402 size_t stringified_call_length = strlen(stringified_call);
403 new_actual_calls_string = (char*)umockalloc_realloc(umock_call_recorder->actual_calls_string, current_length + stringified_call_length + 1);
404 if (new_actual_calls_string == NULL)
405 {
406 umockalloc_free(stringified_call);
407
408 /* Codes_SRS_UMOCKCALLRECORDER_01_026: [ If allocating memory for the resulting string fails, umockcallrecorder_get_actual_calls shall fail and return NULL. ]*/
409 break;
410 }
411 else
412 {
413 umock_call_recorder->actual_calls_string = new_actual_calls_string;
414 (void)memcpy(umock_call_recorder->actual_calls_string + current_length, stringified_call, stringified_call_length + 1);
415 current_length += stringified_call_length;
416 }
417
418 umockalloc_free(stringified_call);
419 }
420 }
421
422 if (i < umock_call_recorder->actual_call_count)
423 {
424 result = NULL;
425 }
426 else
427 {
428 /* Codes_SRS_UMOCKCALLRECORDER_01_022: [ umockcallrecorder_get_actual_calls shall return a pointer to the string representation of all the actual calls. ]*/
429 result = umock_call_recorder->actual_calls_string;
430 }
431 }
432 }
433
434 return result;
435 }
436
437 UMOCKCALL_HANDLE umockcallrecorder_get_last_expected_call(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
438 {
439 UMOCKCALL_HANDLE result;
440
441 if (umock_call_recorder == NULL)
442 {
443 /* Codes_SRS_UMOCKCALLRECORDER_01_033: [ If umock_call_recorder is NULL, umockcallrecorder_get_last_expected_call shall fail and return NULL. ]*/
444 UMOCK_LOG("umockcallrecorder: NULL umock_call_recorder in get last expected calls.");
445 result = NULL;
446 }
447 else
448 {
449 if (umock_call_recorder->expected_call_count == 0)
450 {
451 /* Codes_SRS_UMOCKCALLRECORDER_01_034: [ If no expected call has been recorded for umock_call_recorder then umockcallrecorder_get_last_expected_call shall fail and return NULL. ]*/
452 UMOCK_LOG("umockcallrecorder: No expected calls recorded.");
453 result = NULL;
454 }
455 else
456 {
457 /* Codes_SRS_UMOCKCALLRECORDER_01_032: [ umockcallrecorder_get_last_expected_call shall return the last expected call for the umock_call_recorder call recorder. ]*/
458 result = umock_call_recorder->expected_calls[umock_call_recorder->expected_call_count - 1].umockcall;
459 }
460 }
461
462 return result;
463 }
464
465 /* Codes_SRS_UMOCKCALLRECORDER_01_035: [ umockcallrecorder_clone shall clone a call recorder and return a handle to the newly cloned call recorder. ]*/
466 UMOCKCALLRECORDER_HANDLE umockcallrecorder_clone(UMOCKCALLRECORDER_HANDLE umock_call_recorder)
467 {
468 UMOCKCALLRECORDER_HANDLE result;
469
470 if (umock_call_recorder == NULL)
471 {
472 /* Codes_SRS_UMOCKCALLRECORDER_01_036: [ If the umock_call_recorder argument is NULL, umockcallrecorder_clone shall fail and return NULL. ]*/
473 UMOCK_LOG("umockcallrecorder_clone: NULL umock_call_recorder.");
474 result = NULL;
475 }
476 else
477 {
478 /* Codes_SRS_UMOCKCALLRECORDER_01_037: [ If allocating memory for the new umock call recorder instance fails, umockcallrecorder_clone shall fail and return NULL. ]*/
479 result = umockcallrecorder_create();
480 if (result != NULL)
481 {
482 size_t i;
483
484 result->expected_calls = (UMOCK_EXPECTED_CALL*)umockalloc_malloc(sizeof(UMOCK_EXPECTED_CALL) * umock_call_recorder->expected_call_count);
485 if (result->expected_calls == NULL)
486 {
487 /* Codes_SRS_UMOCKCALLRECORDER_01_052: [ If allocating memory for the expected calls fails, umockcallrecorder_clone shall fail and return NULL. ]*/
488 umockcallrecorder_destroy(result);
489 result = NULL;
490 UMOCK_LOG("umockcallrecorder: clone call recorder failed - cannot allocate expected_calls.");
491 }
492 else
493 {
494 for (i = 0; i < umock_call_recorder->expected_call_count; i++)
495 {
496 result->expected_calls[i].umockcall = NULL;
497 }
498
499 /* Codes_SRS_UMOCKCALLRECORDER_01_038: [ umockcallrecorder_clone shall clone all the expected calls. ]*/
500 for (i = 0; i < umock_call_recorder->expected_call_count; i++)
501 {
502 result->expected_calls[i].is_matched = umock_call_recorder->expected_calls[i].is_matched;
503
504 /* Codes_SRS_UMOCKCALLRECORDER_01_039: [ Each expected call shall be cloned by calling umockcall_clone. ]*/
505 result->expected_calls[i].umockcall = umockcall_clone(umock_call_recorder->expected_calls[i].umockcall);
506 if (result->expected_calls[i].umockcall == NULL)
507 {
508 break;
509 }
510 }
511
512 if (i < umock_call_recorder->expected_call_count)
513 {
514 size_t j;
515
516 /* Codes_SRS_UMOCKCALLRECORDER_01_040: [ If cloning an expected call fails, umockcallrecorder_clone shall fail and return NULL. ]*/
517 for (j = 0; j < i; j++)
518 {
519 umockcall_destroy(result->expected_calls[j].umockcall);
520 result->expected_calls[j].umockcall = NULL;
521 }
522
523 umockcallrecorder_destroy(result);
524 result = NULL;
525 UMOCK_LOG("umockcallrecorder: clone call recorder failed - cannot clone all expected calls.");
526 }
527 else
528 {
529 result->expected_call_count = umock_call_recorder->expected_call_count;
530
531 result->actual_calls = (UMOCKCALL_HANDLE*)umockalloc_malloc(sizeof(UMOCKCALL_HANDLE) * umock_call_recorder->actual_call_count);
532 if (result->actual_calls == NULL)
533 {
534 /* Codes_SRS_UMOCKCALLRECORDER_01_053: [ If allocating memory for the actual calls fails, umockcallrecorder_clone shall fail and return NULL. ]*/
535 umockcallrecorder_destroy(result);
536 result = NULL;
537 UMOCK_LOG("umockcallrecorder: clone call recorder failed - cannot allocate expected_calls.");
538 }
539 else
540 {
541 for (i = 0; i < umock_call_recorder->actual_call_count; i++)
542 {
543 result->actual_calls[i] = NULL;
544 }
545
546 /* Codes_SRS_UMOCKCALLRECORDER_01_041: [ umockcallrecorder_clone shall clone all the actual calls. ]*/
547 for (i = 0; i < umock_call_recorder->actual_call_count; i++)
548 {
549 /* Codes_SRS_UMOCKCALLRECORDER_01_042: [ Each actual call shall be cloned by calling umockcall_clone. ]*/
550 result->actual_calls[i] = umockcall_clone(umock_call_recorder->actual_calls[i]);
551 if (result->actual_calls[i] == NULL)
552 {
553 break;
554 }
555 }
556
557 if (i < umock_call_recorder->actual_call_count)
558 {
559 size_t j;
560
561 /* Codes_SRS_UMOCKCALLRECORDER_01_043: [ If cloning an actual call fails, umockcallrecorder_clone shall fail and return NULL. ]*/
562 for (j = 0; j < i; j++)
563 {
564 umockcall_destroy(result->actual_calls[j]);
565 result->actual_calls[j] = NULL;
566 }
567
568 umockcallrecorder_destroy(result);
569 result = NULL;
570 UMOCK_LOG("umockcallrecorder: clone call recorder failed - cannot clone all actual calls.");
571 }
572 else
573 {
574 result->actual_call_count = umock_call_recorder->actual_call_count;
575 }
576 }
577 }
578 }
579 }
580 }
581
582 return result;
583 }
584
585 int umockcallrecorder_get_expected_call_count(UMOCKCALLRECORDER_HANDLE umock_call_recorder, size_t* expected_call_count)
586 {
587 int result;
588
589 if ((umock_call_recorder == NULL) ||
590 (expected_call_count == NULL))
591 {
592 /* Codes_SRS_UMOCKCALLRECORDER_01_046: [ If any of the arguments is NULL, umockcallrecorder_get_expected_call_count shall return a non-zero value. ]*/
593 result = __LINE__;
594 UMOCK_LOG("umockcallrecorder_get_expected_call_count: Invalid arguments, umock_call_recorder = %p, expected_call_count = %p",
595 umock_call_recorder, expected_call_count);
596 }
597 else
598 {
599 /* Codes_SRS_UMOCKCALLRECORDER_01_044: [ umockcallrecorder_get_expected_call_count shall return in the expected_call_count argument the number of expected calls associated with the call recorder. ]*/
600 *expected_call_count = umock_call_recorder->expected_call_count;
601 /* Codes_SRS_UMOCKCALLRECORDER_01_045: [ On success umockcallrecorder_get_expected_call_count shall return 0. ]*/
602 result = 0;
603 }
604
605 return result;
606 }
607
608 int umockcallrecorder_fail_call(UMOCKCALLRECORDER_HANDLE umock_call_recorder, size_t index)
609 {
610 int result;
611
612 /* Codes_SRS_UMOCKCALLRECORDER_01_049: [ If umock_call_recorder is NULL, umockcallrecorder_fail_call shall return a non-zero value. ]*/
613 if ((umock_call_recorder == NULL) ||
614 /* Codes_SRS_UMOCKCALLRECORDER_01_050: [ If index is invalid, umockcallrecorder_fail_call shall return a non-zero value. ]*/
615 (index >= umock_call_recorder->expected_call_count))
616 {
617 result = __LINE__;
618 UMOCK_LOG("umockcallrecorder_fail_call: NULL Invalid arguments, umock_call_recorder = %p, index = %zu",
619 umock_call_recorder, index);
620 }
621 else
622 {
623 /* Codes_SRS_UMOCKCALLRECORDER_01_047: [ umockcallrecorder_fail_call shall mark an expected call as to be failed by calling umockcall_set_fail_call with a 1 value for fail_call. ]*/
624 if (umockcall_set_fail_call(umock_call_recorder->expected_calls[index].umockcall, 1) != 0)
625 {
626 /* Codes_SRS_UMOCKCALLRECORDER_01_051: [ If umockcall_set_fail_call fails, umockcallrecorder_fail_call shall return a non-zero value. ]*/
627 result = __LINE__;
628 UMOCK_LOG("umockcallrecorder_fail_call: umockcall_set_fail_call failed.");
629 }
630 else
631 {
632 /* Codes_SRS_UMOCKCALLRECORDER_01_048: [ On success, umockcallrecorder_fail_call shall return 0. ]*/
633 result = 0;
634 }
635 }
636
637 return result;
638 }
639
640 int umockcallrecorder_can_call_fail(UMOCKCALLRECORDER_HANDLE umock_call_recorder, size_t index, int* can_call_fail)
641 {
642 int result;
643
644 /* Codes_SRS_UMOCKCALLRECORDER_31_056: [ If umock_call_recorder or call_can_fail is NULL, umockcallrecorder_can_call_fail shall return a non-zero value. ]*/
645 if ((umock_call_recorder == NULL) ||
646 (can_call_fail == NULL) ||
647 /* Codes_SRS_UMOCKCALLRECORDER_31_057: [ If index is greater or equal to the current expected calls count, umockcallrecorder_can_call_fail shall return a non-zero value. ]*/
648 (index >= umock_call_recorder->expected_call_count))
649 {
650 result = __LINE__;
651 UMOCK_LOG("umockcallrecorder_can_call_fail: NULL Invalid arguments, umock_call_recorder = %p, index = %zu",
652 umock_call_recorder, index);
653 }
654 else
655 {
656 /* Codes_SRS_UMOCKCALLRECORDER_31_061: [ umockcallrecorder_can_call_fail shall determine whether given call can fail or not by calling umockcall_get_call_can_fail. ]*/
657 int can_call_fail_result = umockcall_get_call_can_fail(umock_call_recorder->expected_calls[index].umockcall);
658 if (can_call_fail_result == -1)
659 {
660 /* Codes_SRS_UMOCKCALLRECORDER_31_058: [ If umockcall_get_call_can_fail returns -1, umockcallrecorder_can_call_fail shall return an error to the caller ]*/
661 result = __LINE__;
662 UMOCK_LOG("umockcallrecorder_fail_call: umockcall_set_fail_call failed.");
663 }
664 else
665 {
666 /* Codes_SRS_UMOCKCALLRECORDER_31_059: [ umockcallrecorder_can_call_fail shall return in the can_call_fail argument whether the call can fail or not. ]*/
667 *can_call_fail = can_call_fail_result;
668 /* Codes_SRS_UMOCKCALLRECORDER_31_060: [ On success umockcallrecorder_can_call_fail shall return 0. ]*/
669 result = 0;
670 }
671 }
672
673 return result;
674 }
675