Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/optionhandler_ut/optionhandler_ut.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 #ifdef __cplusplus
5 #include <cstdlib>
6 #else
7 #include <stdlib.h>
8 #endif
9
10 static void* my_gballoc_malloc(size_t size)
11 {
12 return malloc(size);
13 }
14
15 static void my_gballoc_free(void* s)
16 {
17 free(s);
18 }
19
20 #ifdef __cplusplus
21 #include <cstddef>
22 #else
23 #include <stddef.h>
24 #endif
25
26 #include "azure_macro_utils/macro_utils.h"
27 #include "testrunnerswitcher.h"
28 #include "umock_c/umock_c.h"
29 #include "umock_c/umocktypes_charptr.h"
30 #include "umock_c/umock_c_negative_tests.h"
31
32 #define ENABLE_MOCKS
33 #define GBALLOC_H
34 #include "azure_c_shared_utility/vector.h"
35 #include "../src/vector.c"
36 #undef GBALLOC_H
37 #include "azure_c_shared_utility/gballoc.h"
38 #include "umock_c/umock_c_prod.h"
39 #include "azure_c_shared_utility/crt_abstractions.h"
40 #include "azure_c_shared_utility/vector.h"
41
42 MOCKABLE_FUNCTION(, void*, aCloneOption, const char*, name, const void*, value);
43 MOCKABLE_FUNCTION(, void, aDestroyOption, const char*, name, const void*, value);
44 MOCKABLE_FUNCTION(, int, aSetOption, void*, handle, const char*, name, const void*, value);
45
46 #undef ENABLE_MOCKS
47
48 #include "azure_c_shared_utility/optionhandler.h"
49
50 static TEST_MUTEX_HANDLE g_testByTest;
51
52 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
53
54 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
55 {
56 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
57 }
58
59 TEST_DEFINE_ENUM_TYPE(OPTIONHANDLER_RESULT, OPTIONHANDLER_RESULT_VALUES);
60 IMPLEMENT_UMOCK_C_ENUM_TYPE(OPTIONHANDLER_RESULT, OPTIONHANDLER_RESULT_VALUES);
61
62 static int my_mallocAndStrcpy_s(char** destination, const char* source)
63 {
64
65 size_t l = strlen(source);
66 char* temp = (char*)my_gballoc_malloc(l + 1);
67 (void)memcpy(temp, source, l+1);
68 *destination=temp;
69 return 0;
70 }
71
72 static void* my_aCloneOption(const char* name, const void* value)
73 {
74 (void)name, (void)value;
75 return my_gballoc_malloc(2);
76 }
77
78 static void my_aDestroyOption(const char* name, const void* value)
79 {
80 (void)(name);
81 my_gballoc_free((void*)value);
82 }
83
84
85 BEGIN_TEST_SUITE(optionhandler_unittests)
86
87 TEST_SUITE_INITIALIZE(a)
88 {
89 g_testByTest = TEST_MUTEX_CREATE();
90 ASSERT_IS_NOT_NULL(g_testByTest);
91
92 (void)umock_c_init(on_umock_c_error);
93
94 (void)umocktypes_charptr_register_types();
95
96 REGISTER_UMOCK_ALIAS_TYPE(const VECTOR_HANDLE, void*);
97 REGISTER_UMOCK_ALIAS_TYPE(VECTOR_HANDLE, void*);
98
99 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
100 REGISTER_GLOBAL_MOCK_FAIL_RETURN(gballoc_malloc, NULL);
101 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
102
103 REGISTER_GLOBAL_INTERFACE_HOOKS(vector);
104 REGISTER_GLOBAL_MOCK_FAIL_RETURN(VECTOR_create, NULL);
105 REGISTER_GLOBAL_MOCK_FAIL_RETURN(VECTOR_push_back, MU_FAILURE);
106
107 REGISTER_GLOBAL_MOCK_HOOK(mallocAndStrcpy_s, my_mallocAndStrcpy_s);
108 REGISTER_GLOBAL_MOCK_FAIL_RETURN(mallocAndStrcpy_s, MU_FAILURE);
109
110 REGISTER_GLOBAL_MOCK_HOOK(aCloneOption, my_aCloneOption);
111 REGISTER_GLOBAL_MOCK_FAIL_RETURN(aCloneOption, NULL);
112
113 REGISTER_GLOBAL_MOCK_FAIL_RETURN(aSetOption, MU_FAILURE);
114
115 REGISTER_GLOBAL_MOCK_HOOK(aDestroyOption, my_aDestroyOption);
116 }
117
118 TEST_SUITE_CLEANUP(TestClassCleanup)
119 {
120 umock_c_deinit();
121
122 TEST_MUTEX_DESTROY(g_testByTest);
123 }
124
125 TEST_FUNCTION_INITIALIZE(initialize)
126 {
127 umock_c_reset_all_calls();
128 }
129
130 TEST_FUNCTION_CLEANUP(cleans)
131 {
132 }
133
134 /* OptionHandler_Create */
135
136 /*Tests_SRS_OPTIONHANDLER_02_001: [ OptionHandler_Create shall fail and retun NULL if any parameters are NULL. ]*/
137 TEST_FUNCTION(OptionHandler_Create_fails_with_NULL_cloneOption_parameter)
138 {
139 ///arrange
140
141 ///act
142 OPTIONHANDLER_HANDLE h = OptionHandler_Create(NULL, aDestroyOption, aSetOption);
143
144 ///assert
145 ASSERT_IS_NULL(h);
146
147 ///cleanup
148 }
149
150 /*Tests_SRS_OPTIONHANDLER_02_001: [ OptionHandler_Create shall fail and retun NULL if any parameters are NULL. ]*/
151 TEST_FUNCTION(OptionHandler_Create_fails_with_NULL_destroyOption_parameter)
152 {
153 ///arrange
154
155 ///act
156 OPTIONHANDLER_HANDLE h = OptionHandler_Create(aCloneOption, NULL, aSetOption);
157
158 ///assert
159 ASSERT_IS_NULL(h);
160
161 ///cleanup
162 }
163
164 /*Tests_SRS_OPTIONHANDLER_02_001: [ OptionHandler_Create shall fail and retun NULL if any parameters are NULL. ]*/
165 TEST_FUNCTION(OptionHandler_Create_fails_with_NULL_setOption_parameter)
166 {
167 ///arrange
168
169 ///act
170 OPTIONHANDLER_HANDLE h = OptionHandler_Create(aCloneOption, aDestroyOption, NULL);
171
172 ///assert
173 ASSERT_IS_NULL(h);
174
175 ///cleanup
176 }
177
178 /*the following function, called "inert" - allegedly half happy and half unhappy is hared between the positive and negative test cases*/
179 static void OptionHandler_Create_inert_path(void)
180 {
181 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)) /*this is creating the handle*/
182 .IgnoreArgument_size();
183
184 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG)) /*this is creating the vector that stores the options*/
185 .IgnoreArgument_elementSize();
186 }
187
188 /*Tests_SRS_OPTIONHANDLER_02_002: [ OptionHandler_Create shall create an empty VECTOR that will hold pairs of const char* and void*. ]*/
189 /*Tests_SRS_OPTIONHANDLER_02_003: [ If all the operations succeed then OptionHandler_Create shall succeed and return a non-NULL handle. ]*/
190 TEST_FUNCTION(OptionHandler_Create_happy_path)
191 {
192 ///arrange
193 OPTIONHANDLER_HANDLE h;
194 OptionHandler_Create_inert_path(); /*in this case, it is happy*/
195
196 ///act
197 h = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
198
199 ///assert
200
201 ASSERT_IS_NOT_NULL(h);
202 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
203
204 ///cleanup
205 OptionHandler_Destroy(h);
206 }
207
208 /*Tests_SRS_OPTIONHANDLER_02_004: [ Otherwise, OptionHandler_Create shall fail and return NULL. ]*/
209 TEST_FUNCTION(OptionHandler_Create_unhappy_paths)
210 {
211 ///arrange
212 size_t i;
213 int negativeTestsInitResult = umock_c_negative_tests_init();
214 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
215
216 OptionHandler_Create_inert_path(); /*in this case, it is unhappy*/
217
218 umock_c_negative_tests_snapshot();
219
220 for (i = 0; i < umock_c_negative_tests_call_count(); i++)
221 {
222 char temp_str[128];
223 OPTIONHANDLER_HANDLE h;
224
225 umock_c_negative_tests_reset();
226 umock_c_negative_tests_fail_call(i);
227
228 ///act
229 (void)sprintf(temp_str, "On failed call %lu", (unsigned long)i);
230
231 ///act
232 h = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
233
234 ///assert
235 ASSERT_IS_NULL(h, temp_str);
236 }
237
238 ///cleanup
239 umock_c_negative_tests_deinit();
240 }
241
242 /* OptionHandler_Clone */
243
244 /* Tests_SRS_OPTIONHANDLER_01_010: [ If handler is NULL, OptionHandler_Clone shall fail and return NULL. ]*/
245 TEST_FUNCTION(OptionHandler_Clone_with_NULL_handler_fails)
246 {
247 ///arrange
248 OPTIONHANDLER_HANDLE result;
249
250 ///act
251 result = OptionHandler_Clone(NULL);
252
253 ///assert
254 ASSERT_IS_NULL(result);
255 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
256 }
257
258 /* Tests_SRS_OPTIONHANDLER_01_001: [ OptionHandler_Clone shall clone an existing option handler instance. ]*/
259 /* Tests_SRS_OPTIONHANDLER_01_002: [ On success it shall return a non-NULL handle. ]*/
260 /* Tests_SRS_OPTIONHANDLER_01_003: [ OptionHandler_Clone shall allocate memory for the new option handler instance. ]*/
261 /* Tests_SRS_OPTIONHANDLER_01_005: [ OptionHandler_Clone shall iterate through all the options stored by the option handler to be cloned by using VECTOR's iteration mechanism. ]*/
262 TEST_FUNCTION(OptionHandler_Clone_clones_an_instance_with_no_options)
263 {
264 ///arrange
265 OPTIONHANDLER_HANDLE source;
266 OPTIONHANDLER_HANDLE result;
267
268 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
269 umock_c_reset_all_calls();
270
271 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
272 .IgnoreArgument_size();
273 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
274 .IgnoreArgument_elementSize();
275 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
276 .IgnoreArgument_handle();
277
278 ///act
279 result = OptionHandler_Clone(source);
280
281 ///assert
282 ASSERT_IS_NOT_NULL(result);
283 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
284
285 ///cleanup
286 OptionHandler_Destroy(source);
287 OptionHandler_Destroy(result);
288 }
289
290 /* Tests_SRS_OPTIONHANDLER_01_001: [ OptionHandler_Clone shall clone an existing option handler instance. ]*/
291 /* Tests_SRS_OPTIONHANDLER_01_002: [ On success it shall return a non-NULL handle. ]*/
292 /* Tests_SRS_OPTIONHANDLER_01_003: [ OptionHandler_Clone shall allocate memory for the new option handler instance. ]*/
293 /* Tests_SRS_OPTIONHANDLER_01_005: [ OptionHandler_Clone shall iterate through all the options stored by the option handler to be cloned by using VECTOR's iteration mechanism. ]*/
294 /* Tests_SRS_OPTIONHANDLER_01_006: [ For each option the option name shall be cloned by calling mallocAndStrcpy_s. ]*/
295 /* Tests_SRS_OPTIONHANDLER_01_007: [ For each option the value shall be cloned by using the cloning function associated with the source option handler handler. ]*/
296 TEST_FUNCTION(OptionHandler_Clone_clones_an_instance_with_one_option)
297 {
298 ///arrange
299 OPTIONHANDLER_HANDLE source;
300 OPTIONHANDLER_HANDLE result;
301
302 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
303 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
304 umock_c_reset_all_calls();
305
306 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
307 .IgnoreArgument_size();
308 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
309 .IgnoreArgument_elementSize();
310 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
311 .IgnoreArgument_handle();
312 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
313 .IgnoreArgument_handle();
314 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
315 .IgnoreArgument_destination();
316 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
317 .IgnoreArgument_value();
318 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
319 .IgnoreArgument_handle()
320 .IgnoreArgument_elements();
321
322 ///act
323 result = OptionHandler_Clone(source);
324
325 ///assert
326 ASSERT_IS_NOT_NULL(result);
327 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
328
329 ///cleanup
330 OptionHandler_Destroy(source);
331 OptionHandler_Destroy(result);
332 }
333
334 /* Tests_SRS_OPTIONHANDLER_01_001: [ OptionHandler_Clone shall clone an existing option handler instance. ]*/
335 /* Tests_SRS_OPTIONHANDLER_01_002: [ On success it shall return a non-NULL handle. ]*/
336 /* Tests_SRS_OPTIONHANDLER_01_003: [ OptionHandler_Clone shall allocate memory for the new option handler instance. ]*/
337 /* Tests_SRS_OPTIONHANDLER_01_005: [ OptionHandler_Clone shall iterate through all the options stored by the option handler to be cloned by using VECTOR's iteration mechanism. ]*/
338 /* Tests_SRS_OPTIONHANDLER_01_006: [ For each option the option name shall be cloned by calling mallocAndStrcpy_s. ]*/
339 /* Tests_SRS_OPTIONHANDLER_01_007: [ For each option the value shall be cloned by using the cloning function associated with the source option handler handler. ]*/
340 TEST_FUNCTION(OptionHandler_Clone_clones_an_instance_with_2_options)
341 {
342 ///arrange
343 OPTIONHANDLER_HANDLE source;
344 OPTIONHANDLER_HANDLE result;
345
346 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
347 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
348 (void)OptionHandler_AddOption(source, "option_2", "y");
349 umock_c_reset_all_calls();
350
351 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
352 .IgnoreArgument_size();
353 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
354 .IgnoreArgument_elementSize();
355 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
356 .IgnoreArgument_handle();
357
358 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
359 .IgnoreArgument_handle();
360 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
361 .IgnoreArgument_destination();
362 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
363 .IgnoreArgument_value();
364 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
365 .IgnoreArgument_handle()
366 .IgnoreArgument_elements();
367
368 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
369 .IgnoreArgument_handle();
370 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "option_2"))
371 .IgnoreArgument_destination();
372 STRICT_EXPECTED_CALL(aCloneOption("option_2", IGNORED_PTR_ARG))
373 .IgnoreArgument_value();
374 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
375 .IgnoreArgument_handle()
376 .IgnoreArgument_elements();
377
378 ///act
379 result = OptionHandler_Clone(source);
380
381 ///assert
382 ASSERT_IS_NOT_NULL(result);
383 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
384
385 ///cleanup
386 OptionHandler_Destroy(source);
387 OptionHandler_Destroy(result);
388 }
389
390 /* Tests_SRS_OPTIONHANDLER_01_004: [ If allocating memory fails, OptionHandler_Clone shall return NULL. ]*/
391 TEST_FUNCTION(when_allocating_memory_for_the_cloned_option_handler_fails_OptionHandler_Clone_fails)
392 {
393 ///arrange
394 OPTIONHANDLER_HANDLE source;
395 OPTIONHANDLER_HANDLE result;
396
397 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
398 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
399 (void)OptionHandler_AddOption(source, "option_2", "y");
400 umock_c_reset_all_calls();
401
402 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
403 .IgnoreArgument_size()
404 .SetReturn(NULL);
405
406 ///act
407 result = OptionHandler_Clone(source);
408
409 ///assert
410 ASSERT_IS_NULL(result);
411 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
412
413 ///cleanup
414 OptionHandler_Destroy(source);
415 }
416
417 /* Tests_SRS_OPTIONHANDLER_01_004: [ If allocating memory fails, OptionHandler_Clone shall return NULL. ]*/
418 TEST_FUNCTION(when_creating_the_vector_fails_OptionHandler_Clone_fails)
419 {
420 ///arrange
421 OPTIONHANDLER_HANDLE source;
422 OPTIONHANDLER_HANDLE result;
423
424 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
425 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
426 (void)OptionHandler_AddOption(source, "option_2", "y");
427 umock_c_reset_all_calls();
428
429 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
430 .IgnoreArgument_size();
431 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
432 .IgnoreArgument_elementSize()
433 .SetReturn(NULL);
434 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
435
436 ///act
437 result = OptionHandler_Clone(source);
438
439 ///assert
440 ASSERT_IS_NULL(result);
441 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
442
443 ///cleanup
444 OptionHandler_Destroy(source);
445 }
446
447 /* Tests_SRS_OPTIONHANDLER_01_008: [ If cloning one of the option names fails, OptionHandler_Clone shall return NULL. ]*/
448 TEST_FUNCTION(when_cloning_the_first_option_name_fails_OptionHandler_Clone_fails)
449 {
450 ///arrange
451 OPTIONHANDLER_HANDLE source;
452 OPTIONHANDLER_HANDLE result;
453
454 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
455 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
456 (void)OptionHandler_AddOption(source, "option_2", "y");
457 umock_c_reset_all_calls();
458
459 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
460 .IgnoreArgument_size();
461 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
462 .IgnoreArgument_elementSize();
463 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
464 .IgnoreArgument_handle();
465
466 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
467 .IgnoreArgument_handle();
468 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
469 .IgnoreArgument_destination()
470 .SetReturn(1);
471
472 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
473 .IgnoreArgument_handle();
474 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
475 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
476
477 ///act
478 result = OptionHandler_Clone(source);
479
480 ///assert
481 ASSERT_IS_NULL(result);
482 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
483
484 ///cleanup
485 OptionHandler_Destroy(source);
486 }
487
488 /* Tests_SRS_OPTIONHANDLER_01_009: [ If cloning one of the option values fails, OptionHandler_Clone shall return NULL. ]*/
489 TEST_FUNCTION(when_cloning_the_first_option_value_fails_OptionHandler_Clone_fails)
490 {
491 ///arrange
492 OPTIONHANDLER_HANDLE source;
493 OPTIONHANDLER_HANDLE result;
494
495 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
496 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
497 (void)OptionHandler_AddOption(source, "option_2", "y");
498 umock_c_reset_all_calls();
499
500 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
501 .IgnoreArgument_size();
502 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
503 .IgnoreArgument_elementSize();
504 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
505 .IgnoreArgument_handle();
506
507 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
508 .IgnoreArgument_handle();
509 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
510 .IgnoreArgument_destination();
511 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
512 .IgnoreArgument_value()
513 .SetReturn(NULL);
514
515 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
516 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
517 .IgnoreArgument_handle();
518 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
519 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
520
521 ///act
522 result = OptionHandler_Clone(source);
523
524 ///assert
525 ASSERT_IS_NULL(result);
526 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
527
528 ///cleanup
529 OptionHandler_Destroy(source);
530 }
531
532 /* Tests_SRS_OPTIONHANDLER_01_011: [ When adding one of the newly cloned options to the option handler storage vector fails, OptionHandler_Clone shall return NULL. ]*/
533 TEST_FUNCTION(when_adding_the_first_cloned_option_fails_OptionHandler_Clone_fails)
534 {
535 ///arrange
536 OPTIONHANDLER_HANDLE source;
537 OPTIONHANDLER_HANDLE result;
538
539 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
540 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
541 (void)OptionHandler_AddOption(source, "option_2", "y");
542 umock_c_reset_all_calls();
543
544 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
545 .IgnoreArgument_size();
546 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
547 .IgnoreArgument_elementSize();
548 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
549 .IgnoreArgument_handle();
550
551 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
552 .IgnoreArgument_handle();
553 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
554 .IgnoreArgument_destination();
555 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
556 .IgnoreArgument_value();
557 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
558 .IgnoreArgument_handle()
559 .IgnoreArgument_elements()
560 .SetReturn(1);
561
562 EXPECTED_CALL(aDestroyOption("TrustedCerts", IGNORED_PTR_ARG));
563 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
564 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
565 .IgnoreArgument_handle();
566 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
567 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
568
569 ///act
570 result = OptionHandler_Clone(source);
571
572 ///assert
573 ASSERT_IS_NULL(result);
574 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
575
576 ///cleanup
577 OptionHandler_Destroy(source);
578 }
579
580 /* Tests_SRS_OPTIONHANDLER_01_008: [ If cloning one of the option names fails, OptionHandler_Clone shall return NULL. ]*/
581 TEST_FUNCTION(when_cloning_the_2nd_option_name_fails_OptionHandler_Clone_fails)
582 {
583 ///arrange
584 OPTIONHANDLER_HANDLE source;
585 OPTIONHANDLER_HANDLE result;
586
587 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
588 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
589 (void)OptionHandler_AddOption(source, "option_2", "y");
590 umock_c_reset_all_calls();
591
592 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
593 .IgnoreArgument_size();
594 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
595 .IgnoreArgument_elementSize();
596 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
597 .IgnoreArgument_handle();
598
599 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
600 .IgnoreArgument_handle();
601 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
602 .IgnoreArgument_destination();
603 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
604 .IgnoreArgument_value();
605 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
606 .IgnoreArgument_handle()
607 .IgnoreArgument_elements();
608
609 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
610 .IgnoreArgument_handle();
611 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "option_2"))
612 .IgnoreArgument_destination()
613 .SetReturn(1);
614
615 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
616 .IgnoreArgument_handle();
617 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
618 .IgnoreArgument_handle();
619 EXPECTED_CALL(aDestroyOption("TrustedCerts", IGNORED_PTR_ARG));
620 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
621 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
622 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
623
624 ///act
625 result = OptionHandler_Clone(source);
626
627 ///assert
628 ASSERT_IS_NULL(result);
629 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
630
631 ///cleanup
632 OptionHandler_Destroy(source);
633 }
634
635 /* Tests_SRS_OPTIONHANDLER_01_009: [ If cloning one of the option values fails, OptionHandler_Clone shall return NULL. ]*/
636 TEST_FUNCTION(when_cloning_the_2nd_option_value_fails_OptionHandler_Clone_fails)
637 {
638 ///arrange
639 OPTIONHANDLER_HANDLE source;
640 OPTIONHANDLER_HANDLE result;
641
642 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
643 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
644 (void)OptionHandler_AddOption(source, "option_2", "y");
645 umock_c_reset_all_calls();
646
647 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
648 .IgnoreArgument_size();
649 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
650 .IgnoreArgument_elementSize();
651 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
652 .IgnoreArgument_handle();
653
654 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
655 .IgnoreArgument_handle();
656 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
657 .IgnoreArgument_destination();
658 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
659 .IgnoreArgument_value();
660 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
661 .IgnoreArgument_handle()
662 .IgnoreArgument_elements();
663
664 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
665 .IgnoreArgument_handle();
666 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "option_2"))
667 .IgnoreArgument_destination();
668 STRICT_EXPECTED_CALL(aCloneOption("option_2", IGNORED_PTR_ARG))
669 .IgnoreArgument_value()
670 .SetReturn(NULL);
671
672 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
673 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
674 .IgnoreArgument_handle();
675 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
676 .IgnoreArgument_handle();
677 EXPECTED_CALL(aDestroyOption("TrustedCerts", IGNORED_PTR_ARG));
678 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
679 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
680 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
681
682 ///act
683 result = OptionHandler_Clone(source);
684
685 ///assert
686 ASSERT_IS_NULL(result);
687 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
688
689 ///cleanup
690 OptionHandler_Destroy(source);
691 }
692
693 /* Tests_SRS_OPTIONHANDLER_01_011: [ When adding one of the newly cloned options to the option handler storage vector fails, OptionHandler_Clone shall return NULL. ]*/
694 TEST_FUNCTION(when_adding_the_2nd_cloned_option_fails_OptionHandler_Clone_fails)
695 {
696 ///arrange
697 OPTIONHANDLER_HANDLE source;
698 OPTIONHANDLER_HANDLE result;
699
700 source = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
701 (void)OptionHandler_AddOption(source, "TrustedCerts", "xxx");
702 (void)OptionHandler_AddOption(source, "option_2", "y");
703 umock_c_reset_all_calls();
704
705 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
706 .IgnoreArgument_size();
707 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
708 .IgnoreArgument_elementSize();
709 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
710 .IgnoreArgument_handle();
711
712 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
713 .IgnoreArgument_handle();
714 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "TrustedCerts"))
715 .IgnoreArgument_destination();
716 STRICT_EXPECTED_CALL(aCloneOption("TrustedCerts", IGNORED_PTR_ARG))
717 .IgnoreArgument_value();
718 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
719 .IgnoreArgument_handle()
720 .IgnoreArgument_elements();
721
722 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
723 .IgnoreArgument_handle();
724 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "option_2"))
725 .IgnoreArgument_destination();
726 STRICT_EXPECTED_CALL(aCloneOption("option_2", IGNORED_PTR_ARG))
727 .IgnoreArgument_value();
728 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
729 .IgnoreArgument_handle()
730 .IgnoreArgument_elements()
731 .SetReturn(1);
732
733 EXPECTED_CALL(aDestroyOption("option_2", IGNORED_PTR_ARG));
734 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
735 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
736 .IgnoreArgument_handle();
737 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
738 .IgnoreArgument_handle();
739 EXPECTED_CALL(aDestroyOption("TrustedCerts", IGNORED_PTR_ARG));
740 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
741 EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG));
742 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
743
744 ///act
745 result = OptionHandler_Clone(source);
746
747 ///assert
748 ASSERT_IS_NULL(result);
749 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
750
751 ///cleanup
752 OptionHandler_Destroy(source);
753 }
754
755 /* OptionHandler_AddOption */
756
757 /*Tests_SRS_OPTIONHANDLER_02_005: [ OptionHandler_AddOption shall fail and return OPTIONHANDLER_INVALIDARG if any parameter is NULL. ]*/
758 TEST_FUNCTION(OptionHandler_AddOption_with_NULL_handle_fails)
759 {
760 ///arrange
761
762 ///act
763 OPTIONHANDLER_RESULT result = OptionHandler_AddOption(NULL, "name", "some value");
764
765 ///assert
766 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_INVALIDARG, result);
767
768 ///cleanup
769 }
770
771 /*Tests_SRS_OPTIONHANDLER_02_005: [ OptionHandler_AddOption shall fail and return OPTIONHANDLER_INVALIDARG if any parameter is NULL. ]*/
772 TEST_FUNCTION(OptionHandler_AddOption_with_NULL_name_fails)
773 {
774 ///arrange
775 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
776
777 ///act
778 OPTIONHANDLER_RESULT result = OptionHandler_AddOption(handle, NULL, "some value");
779
780 ///assert
781 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_INVALIDARG, result);
782
783 ///cleanup
784 OptionHandler_Destroy(handle);
785 }
786
787 /*Tests_SRS_OPTIONHANDLER_02_005: [ OptionHandler_AddOption shall fail and return OPTIONHANDLER_INVALIDARG if any parameter is NULL. ]*/
788 TEST_FUNCTION(OptionHandler_AddOption_with_NULL_value_fails)
789 {
790 ///arrange
791 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
792
793 ///act
794 OPTIONHANDLER_RESULT result = OptionHandler_AddOption(handle, "name", NULL);
795
796 ///assert
797 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_INVALIDARG, result);
798
799 ///cleanup
800 OptionHandler_Destroy(handle);
801 }
802
803 void OptionHandler_AddOption_inert_path(void* value)
804 {
805 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "name"))
806 .IgnoreArgument_destination();
807 STRICT_EXPECTED_CALL(aCloneOption("name", value))
808 .IgnoreAllArguments();
809 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
810 .IgnoreArgument_handle()
811 .IgnoreArgument_elements();
812 }
813
814 /*Tests_SRS_OPTIONHANDLER_02_006: [ OptionHandler_AddOption shall call pfCloneOption passing name and value. ]*/
815 /*Tests_SRS_OPTIONHANDLER_02_007: [ OptionHandler_AddOption shall use VECTOR APIs to save the name and the newly created clone of value. ]*/
816 /*Tests_SRS_OPTIONHANDLER_02_008: [ If all the operations succed then OptionHandler_AddOption shall succeed and return OPTIONHANDLER_OK. ]*/
817 TEST_FUNCTION(OptionHandler_AddOption_happy_path)
818 {
819 ///arrange
820 OPTIONHANDLER_RESULT result;
821 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
822
823 void* value = "value";
824 OptionHandler_AddOption_inert_path(value);
825
826 ///act
827 result = OptionHandler_AddOption(handle, "name", value);
828
829 ///assert
830 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_OK, result);
831
832 ///cleanup
833 OptionHandler_Destroy(handle);
834 }
835
836 /*Tests_SRS_OPTIONHANDLER_02_009: [ Otherwise, OptionHandler_AddOption shall succeed and return OPTIONHANDLER_ERROR. ]*/
837 /*Tests_SRS_OPTIONHANDLER_02_008: [ If all the operations succed then OptionHandler_AddOption shall succeed and return OPTIONHANDLER_OK. ]*/
838 TEST_FUNCTION(OptionHandler_AddOption_unhappy_path)
839 {
840 ///arrange
841 void* value = "value";
842 size_t i;
843 OPTIONHANDLER_HANDLE handle;
844 int negativeTestsInitResult = umock_c_negative_tests_init();
845 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
846
847 handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
848 umock_c_reset_all_calls();
849
850 OptionHandler_AddOption_inert_path(value);
851
852 umock_c_negative_tests_snapshot();
853
854 for (i = 0; i < umock_c_negative_tests_call_count(); i++)
855 {
856 char temp_str[128];
857 OPTIONHANDLER_RESULT result;
858
859 umock_c_negative_tests_reset();
860 umock_c_negative_tests_fail_call(i);
861
862 ///act
863 (void)sprintf(temp_str, "On failed call %lu", (unsigned long)i);
864
865 ///act
866 result = OptionHandler_AddOption(handle, "name", value);
867
868 ///assert
869 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_ERROR, result, temp_str);
870 }
871
872 ///cleanup
873 OptionHandler_Destroy(handle);
874 umock_c_negative_tests_deinit();
875 }
876
877 /* OptionHandler_FeedOptions */
878
879 /*Tests_SRS_OPTIONHANDLER_02_010: [ OptionHandler_FeedOptions shall fail and return OPTIONHANDLER_INVALIDARG if any argument is NULL. ]*/
880 TEST_FUNCTION(OptionHandler_FeedOptions_with_NULL_handle_fails)
881 {
882 ///arrange
883
884 ///act
885 OPTIONHANDLER_RESULT result = OptionHandler_FeedOptions(NULL, "something non NULL");
886
887 ///assert
888 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_INVALIDARG, result);
889
890 ///cleanup
891 }
892
893 /*Tests_SRS_OPTIONHANDLER_02_010: [ OptionHandler_FeedOptions shall fail and return OPTIONHANDLER_INVALIDARG if any argument is NULL. ]*/
894 TEST_FUNCTION(OptionHandler_FeedOptions_with_NULL_destinationhandle_fails)
895 {
896 ///arrange
897 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
898
899 ///act
900 OPTIONHANDLER_RESULT result = OptionHandler_FeedOptions(handle, NULL);
901
902 ///assert
903 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_INVALIDARG, result);
904
905 ///cleanup
906 OptionHandler_Destroy(handle);
907 }
908
909 /*Tests_SRS_OPTIONHANDLER_02_011: [ Otherwise, OptionHandler_FeedOptions shall use VECTOR's iteration mechanisms to retrieve pairs of name, value (const char* and void*). ]*/
910 /*Tests_SRS_OPTIONHANDLER_02_012: [ OptionHandler_FeedOptions shall call for every pair of name,value setOption passing destinationHandle, name and value. ]*/
911 /*Tests_SRS_OPTIONHANDLER_02_013: [ If all the operations succeed then OptionHandler_FeedOptions shall succeed and return OPTIONHANDLER_OK. ]*/
912 TEST_FUNCTION(OptionHandler_FeedOptions_with_0_saved_options_feeds_0_succeeds)
913 {
914 ///arrange
915 OPTIONHANDLER_RESULT result;
916 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
917 umock_c_reset_all_calls();
918
919 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*will return 0, so nothing else happens*/
920 .IgnoreArgument_handle();
921
922 ///act
923 result = OptionHandler_FeedOptions(handle, (void*)42);
924
925 ///assert
926 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_OK, result);
927 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
928
929 ///cleanup
930 OptionHandler_Destroy(handle);
931 }
932
933 static void OptionHandler_FeedOptions_with_1_saved_options_feeds_1_inert_path(void)
934 {
935 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*will return 0, so nothing else happens*/
936 .IgnoreArgument_handle();
937 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
938 .IgnoreArgument_handle();
939 STRICT_EXPECTED_CALL(aSetOption((void*)42, "a", IGNORED_PTR_ARG))
940 .IgnoreArgument_value();
941 }
942
943 /*Tests_SRS_OPTIONHANDLER_02_011: [ Otherwise, OptionHandler_FeedOptions shall use VECTOR's iteration mechanisms to retrieve pairs of name, value (const char* and void*). ]*/
944 /*Tests_SRS_OPTIONHANDLER_02_012: [ OptionHandler_FeedOptions shall call for every pair of name,value setOption passing destinationHandle, name and value. ]*/
945 /*Tests_SRS_OPTIONHANDLER_02_013: [ If all the operations succeed then OptionHandler_FeedOptions shall succeed and return OPTIONHANDLER_OK. ]*/
946 TEST_FUNCTION(OptionHandler_FeedOptions_with_1_saved_options_feeds_1_happypath)
947 {
948 ///arrange
949 OPTIONHANDLER_RESULT result;
950 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
951 (void)OptionHandler_AddOption(handle, "a", "b");
952 umock_c_reset_all_calls();
953
954 OptionHandler_FeedOptions_with_1_saved_options_feeds_1_inert_path();
955
956 ///act
957 result = OptionHandler_FeedOptions(handle, (void*)42);
958
959 ///assert
960 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_OK, result);
961 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
962
963 ///cleanup
964 OptionHandler_Destroy(handle);
965 }
966
967 /*Tests_SRS_OPTIONHANDLER_02_014: [ Otherwise, OptionHandler_FeedOptions shall fail and return OPTIONHANDLER_ERROR. ]*/
968 TEST_FUNCTION(OptionHandler_FeedOptions_with_1_saved_options_feeds_1_unhappypaths)
969 {
970 ///arrange
971 size_t i;
972 size_t calls_that_cannot_fail[] =
973 {
974 0,
975 1,
976 };
977 OPTIONHANDLER_HANDLE handle;
978
979 int negativeTestsInitResult = umock_c_negative_tests_init();
980 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
981
982 handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
983 (void)OptionHandler_AddOption(handle, "a", "b");
984 umock_c_reset_all_calls();
985
986 OptionHandler_FeedOptions_with_1_saved_options_feeds_1_inert_path();
987
988 umock_c_negative_tests_snapshot();
989
990 for (i = 0; i < umock_c_negative_tests_call_count(); i++)
991 {
992 char temp_str[128];
993 size_t j;
994 OPTIONHANDLER_RESULT result;
995
996 for (j = 0;j < sizeof(calls_that_cannot_fail) / sizeof(calls_that_cannot_fail[0]);j++)
997 {
998 if (calls_that_cannot_fail[j] == i)
999 {
1000 break;
1001 }
1002 }
1003
1004 if (j != sizeof(calls_that_cannot_fail) / sizeof(calls_that_cannot_fail[0]))
1005 {
1006 continue; //just go to the next call that might be failed.
1007 }
1008
1009 umock_c_negative_tests_reset();
1010 umock_c_negative_tests_fail_call(i);
1011
1012 ///act
1013 (void)sprintf(temp_str, "On failed call %lu", (unsigned long)i);
1014
1015 ///act
1016 result = OptionHandler_FeedOptions(handle, (void*)42);
1017
1018 ///assert
1019 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_ERROR, result, temp_str);
1020
1021 }
1022
1023 ///cleanup
1024 OptionHandler_Destroy(handle);
1025 umock_c_negative_tests_deinit();
1026 }
1027
1028 static void OptionHandler_FeedOptions_with_2_saved_options_feeds_2_inert_path(void)
1029 {
1030 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*will return 0, so nothing else happens*/
1031 .IgnoreArgument_handle();
1032 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
1033 .IgnoreArgument_handle();
1034 STRICT_EXPECTED_CALL(aSetOption((void*)42, "a", IGNORED_PTR_ARG))
1035 .IgnoreArgument_value();
1036
1037 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
1038 .IgnoreArgument_handle();
1039 STRICT_EXPECTED_CALL(aSetOption((void*)42, "c", IGNORED_PTR_ARG))
1040 .IgnoreArgument_value();
1041 }
1042
1043 /*Tests_SRS_OPTIONHANDLER_02_011: [ Otherwise, OptionHandler_FeedOptions shall use VECTOR's iteration mechanisms to retrieve pairs of name, value (const char* and void*). ]*/
1044 /*Tests_SRS_OPTIONHANDLER_02_012: [ OptionHandler_FeedOptions shall call for every pair of name,value setOption passing destinationHandle, name and value. ]*/
1045 /*Tests_SRS_OPTIONHANDLER_02_013: [ If all the operations succeed then OptionHandler_FeedOptions shall succeed and return OPTIONHANDLER_OK. ]*/
1046 TEST_FUNCTION(OptionHandler_FeedOptions_with_2_saved_options_feeds_2_happypath)
1047 {
1048 ///arrange
1049 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
1050 OPTIONHANDLER_RESULT result;
1051
1052 (void)OptionHandler_AddOption(handle, "a", "b");
1053 (void)OptionHandler_AddOption(handle, "c", "b2");
1054 umock_c_reset_all_calls();
1055
1056 OptionHandler_FeedOptions_with_2_saved_options_feeds_2_inert_path();
1057
1058 ///act
1059 result = OptionHandler_FeedOptions(handle, (void*)42);
1060
1061 ///assert
1062 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_OK, result);
1063 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1064
1065 ///cleanup
1066 OptionHandler_Destroy(handle);
1067 }
1068
1069 /*Tests_SRS_OPTIONHANDLER_02_014: [ Otherwise, OptionHandler_FeedOptions shall fail and return OPTIONHANDLER_ERROR. ]*/
1070 TEST_FUNCTION(OptionHandler_FeedOptions_with_2_saved_options_feeds_2_unhappypaths)
1071 {
1072 ///arrange
1073 OPTIONHANDLER_HANDLE handle;
1074 size_t calls_that_cannot_fail[] =
1075 {
1076 0,
1077 1,
1078 3,
1079 };
1080 size_t i;
1081 int negativeTestsInitResult = umock_c_negative_tests_init();
1082 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
1083
1084 handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
1085 (void)OptionHandler_AddOption(handle, "a", "b");
1086 (void)OptionHandler_AddOption(handle, "c", "b2");
1087 umock_c_reset_all_calls();
1088
1089 OptionHandler_FeedOptions_with_2_saved_options_feeds_2_inert_path();
1090
1091 umock_c_negative_tests_snapshot();
1092
1093 for (i = 0; i < umock_c_negative_tests_call_count(); i++)
1094 {
1095 char temp_str[128];
1096 size_t j;
1097 OPTIONHANDLER_RESULT result;
1098
1099 for (j = 0;j < sizeof(calls_that_cannot_fail) / sizeof(calls_that_cannot_fail[0]);j++)
1100 {
1101 if (calls_that_cannot_fail[j] == i)
1102 {
1103 break;
1104 }
1105 }
1106
1107 if (j != sizeof(calls_that_cannot_fail) / sizeof(calls_that_cannot_fail[0]))
1108 {
1109 continue; //just go to the next call that might be failed.
1110 }
1111
1112 umock_c_negative_tests_reset();
1113 umock_c_negative_tests_fail_call(i);
1114
1115 ///act
1116 (void)sprintf(temp_str, "On failed call %lu", (unsigned long)i);
1117
1118 ///act
1119 result = OptionHandler_FeedOptions(handle, (void*)42);
1120
1121 ///assert
1122 ASSERT_ARE_EQUAL(OPTIONHANDLER_RESULT, OPTIONHANDLER_ERROR, result, temp_str);
1123 }
1124
1125 ///cleanup
1126 OptionHandler_Destroy(handle);
1127 umock_c_negative_tests_deinit();
1128 }
1129
1130 /* OptionHandler_Destroy */
1131
1132 /*Tests_SRS_OPTIONHANDLER_02_015: [ OptionHandler_Destroy shall do nothing if parameter handle is NULL. ]*/
1133 TEST_FUNCTION(OptionHandler_Destroy_with_NULL_does_nothing)
1134 {
1135 ///arrange
1136
1137 ///act
1138 OptionHandler_Destroy(NULL);
1139
1140 ///assert
1141 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1142
1143 ///cleanup
1144 }
1145
1146 /*Tests_SRS_OPTIONHANDLER_02_016: [ Otherwise, OptionHandler_Destroy shall free all used resources. ]*/
1147 TEST_FUNCTION(OptionHandler_Destroy_with_non_NULL_handle_succeeds)
1148 {
1149 ///arrange
1150 OPTIONHANDLER_HANDLE handle = OptionHandler_Create(aCloneOption, aDestroyOption, aSetOption);
1151 (void)OptionHandler_AddOption(handle, "a", "b");
1152 (void)OptionHandler_AddOption(handle, "c", "b2");
1153 umock_c_reset_all_calls();
1154
1155 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
1156 .IgnoreArgument_handle();
1157 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
1158 .IgnoreArgument_handle();
1159 STRICT_EXPECTED_CALL(aDestroyOption("a", IGNORED_PTR_ARG))
1160 .IgnoreArgument_value();
1161 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
1162 .IgnoreArgument_ptr();
1163
1164 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
1165 .IgnoreArgument_handle();
1166 STRICT_EXPECTED_CALL(aDestroyOption("c", IGNORED_PTR_ARG))
1167 .IgnoreArgument_value();
1168 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
1169 .IgnoreArgument_ptr();
1170
1171 STRICT_EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG))
1172 .IgnoreArgument_handle();
1173
1174 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
1175 .IgnoreArgument_ptr();
1176
1177 ///act
1178 OptionHandler_Destroy(handle);
1179
1180 ///assert
1181 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1182
1183 ///cleanup
1184 }
1185
1186 END_TEST_SUITE(optionhandler_unittests)
1187
1188