Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/map_ut/map_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 #include "azure_macro_utils/macro_utils.h"
11 #include "azure_c_shared_utility/optimize_size.h"
12
13 static size_t currentmalloc_call = 0;
14 static size_t whenShallmalloc_fail = 0;
15
16 static size_t currentcalloc_call = 0;
17 static size_t whenShallcalloc_fail = 0;
18
19 static size_t currentrealloc_call = 0;
20 static size_t whenShallrealloc_fail = 0;
21
22 void* my_gballoc_malloc(size_t size)
23 {
24 void* result;
25 currentmalloc_call++;
26 if (whenShallmalloc_fail > 0)
27 {
28 if (currentmalloc_call == whenShallmalloc_fail)
29 {
30 result = NULL;
31 }
32 else
33 {
34 result = malloc(size);
35 }
36 }
37 else
38 {
39 result = malloc(size);
40 }
41 return result;
42 }
43
44 void* my_gballoc_calloc(size_t nmemb, size_t size)
45 {
46 void* result;
47 currentcalloc_call++;
48 if (whenShallcalloc_fail > 0)
49 {
50 if (currentcalloc_call == whenShallcalloc_fail)
51 {
52 result = NULL;
53 }
54 else
55 {
56 result = calloc(nmemb, size);
57 }
58 }
59 else
60 {
61 result = calloc(nmemb, size);
62 }
63 return result;
64 }
65
66 void* my_gballoc_realloc(void* ptr, size_t size)
67 {
68 void* result;
69 currentrealloc_call++;
70 if (whenShallrealloc_fail > 0)
71 {
72 if (currentrealloc_call == whenShallrealloc_fail)
73 {
74 result = NULL;
75 }
76 else
77 {
78 result = realloc(ptr, size);
79 }
80 }
81 else
82 {
83 result = realloc(ptr, size);
84 }
85
86 return result;
87 }
88
89 void my_gballoc_free(void* ptr)
90 {
91 free(ptr);
92 }
93
94 #include "testrunnerswitcher.h"
95 #include "umock_c/umock_c.h"
96 #include "umock_c/umocktypes_charptr.h"
97
98 static TEST_MUTEX_HANDLE g_testByTest;
99
100 #define ENABLE_MOCKS
101
102 #include "azure_c_shared_utility/strings.h"
103
104 STRING_HANDLE my_STRING_construct(const char* psz)
105 {
106 (void)psz;
107 return (STRING_HANDLE)malloc(1);
108 }
109
110 void my_STRING_delete(STRING_HANDLE handle)
111 {
112 free(handle);
113 }
114
115 STRING_HANDLE my_STRING_new_JSON(const char* source)
116 {
117 (void)source;
118 return (STRING_HANDLE)malloc(1);
119 }
120
121 #include "azure_c_shared_utility/gballoc.h"
122
123 #undef ENABLE_MOCKS
124
125 #include "azure_c_shared_utility/map.h"
126
127 TEST_DEFINE_ENUM_TYPE(MAP_RESULT, MAP_RESULT_VALUES)
128 IMPLEMENT_UMOCK_C_ENUM_TYPE(MAP_RESULT, MAP_RESULT_VALUES);
129
130 static int DontAllowCapitalsFilters(const char* mapProperty, const char* mapValue)
131 {
132 int result = 0;
133 const char* iterator = mapProperty;
134 while (iterator != NULL && *iterator != '\0')
135 {
136 if (*iterator >= 'A' && *iterator <= 'Z')
137 {
138 result = MU_FAILURE;
139 break;
140 }
141 iterator++;
142 }
143
144 if (result != 0)
145 {
146 iterator = mapValue;
147 while (iterator != NULL && *iterator != '\0')
148 {
149 if (*iterator >= 'A' && *iterator <= 'Z')
150 {
151 result = MU_FAILURE;
152 break;
153 }
154 iterator++;
155 }
156 }
157
158 return result;
159 }
160
161 /* capacity */
162
163 static const char* TEST_REDKEY = "testRedKey";
164 static const char* TEST_REDVALUE = "testRedValue";
165
166 static const char* TEST_YELLOWKEY = "testYellowKey";
167 static const char* TEST_YELLOWVALUE = "testYellowValue";
168
169 static const char* TEST_BLUEKEY = "testBlueKey";
170 static const char* TEST_BLUEVALUE = "cyan";
171
172 static const char* TEST_GREENKEY = "testgreenkey";
173 static const char* TEST_GREENVALUE = "green";
174
175 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
176
177 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
178 {
179 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
180 }
181
182 BEGIN_TEST_SUITE(map_unittests)
183
184 TEST_SUITE_INITIALIZE(TestClassInitialize)
185 {
186 int result;
187
188 g_testByTest = TEST_MUTEX_CREATE();
189 ASSERT_IS_NOT_NULL(g_testByTest);
190
191 umock_c_init(on_umock_c_error);
192
193 result = umocktypes_charptr_register_types();
194 ASSERT_ARE_EQUAL(int, 0, result);
195
196 REGISTER_UMOCK_ALIAS_TYPE(MAP_HANDLE, void*);
197 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
198
199 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
200 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
201 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
202 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
203 REGISTER_GLOBAL_MOCK_HOOK(STRING_construct, my_STRING_construct);
204 REGISTER_GLOBAL_MOCK_HOOK(STRING_delete, my_STRING_delete);
205 REGISTER_GLOBAL_MOCK_HOOK(STRING_new_JSON, my_STRING_new_JSON);
206 }
207
208 TEST_SUITE_CLEANUP(TestClassCleanup)
209 {
210 umock_c_deinit();
211
212 TEST_MUTEX_DESTROY(g_testByTest);
213 }
214
215 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
216 {
217 if (TEST_MUTEX_ACQUIRE(g_testByTest))
218 {
219 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
220 }
221
222 umock_c_reset_all_calls();
223
224 currentmalloc_call = 0;
225 whenShallmalloc_fail = 0;
226
227 currentcalloc_call = 0;
228 whenShallcalloc_fail = 0;
229
230 currentrealloc_call = 0;
231 whenShallrealloc_fail = 0;
232 }
233
234 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
235 {
236 TEST_MUTEX_RELEASE(g_testByTest);
237 }
238
239 /*Tests_SRS_MAP_02_001: [Map_Create shall create a new, empty map.]*/ /*this tests "create"*/
240 /*Tests_SRS_MAP_02_003: [Otherwise, it shall return a non-NULL handle that can be used in subsequent calls.] */
241 /*Tests_SRS_MAP_02_004: [Map_Destroy shall release all resources associated with the map.] */
242 TEST_FUNCTION(Map_Create_Destroy_succeeds)
243 {
244 MAP_HANDLE handle;
245
246 ///arrange
247 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
248 .IgnoreAllArguments();
249
250 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*keys*/
251 .IgnoreArgument(1);
252 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*values*/
253 .IgnoreArgument(1);
254 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*handleData*/
255 .IgnoreArgument(1);
256
257 ///act
258 handle = Map_Create(NULL);
259 Map_Destroy(handle);
260
261 ///assert
262 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
263
264 ///cleanup
265 }
266
267 /*Tests_SRS_MAP_02_004: [Map_Destroy shall release all resources associated with the map.] */
268 TEST_FUNCTION(Map_Destroy_on_non_empty_map_succeeds_1)
269 {
270 ///arrange
271 MAP_HANDLE handle = Map_Create(NULL);
272 Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
273 umock_c_reset_all_calls();
274
275 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free the red key*/
276 .ValidateArgumentBuffer(1, TEST_REDKEY, strlen(TEST_REDKEY)+1);
277
278 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))/*free the red value*/
279 .ValidateArgumentBuffer(1, TEST_REDVALUE, strlen(TEST_REDVALUE)+1);
280
281 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free keys array*/
282 .IgnoreArgument(1);
283
284 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free values array*/
285 .IgnoreArgument(1);
286
287 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free handle*/
288 .IgnoreArgument(1);
289
290 ///act
291 Map_Destroy(handle);
292
293 ///assert
294 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
295
296 ///cleanup
297 }
298
299 /*Tests_SRS_MAP_02_004: [Map_Destroy shall release all resources associated with the map.] */
300 TEST_FUNCTION(Map_Destroy_on_non_empty_map_succeeds_2)
301 {
302 ///arrange
303 MAP_HANDLE handle = Map_Create(NULL);
304 Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
305 Map_AddOrUpdate(handle, TEST_REDKEY, "a"); /*overwrites to something smaller*/
306 umock_c_reset_all_calls();
307
308 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free the red key*/
309 .ValidateArgumentBuffer(1, TEST_REDKEY, strlen(TEST_REDKEY)+1);
310
311 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))/*free the red value*/
312 .ValidateArgumentBuffer(1, "a", 2);
313
314 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free keys array*/
315 .IgnoreArgument(1);
316
317 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free values array*/
318 .IgnoreArgument(1);
319
320 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*free handle*/
321 .IgnoreArgument(1);
322
323 ///act
324 Map_Destroy(handle);
325
326 ///assert
327 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
328
329 ///cleanup
330 }
331
332 /*Tests_SRS_MAP_02_001: [Map_Create shall create a new, empty map.]*/ /*this tests "empty"*/
333 TEST_FUNCTION(Map_Create_Destroy_succeeds_2)
334 {
335 ///arrange
336 MAP_HANDLE handle = Map_Create(NULL);
337 const char*const* keys;
338 const char*const* values;
339 size_t count;
340 MAP_RESULT result;
341
342 umock_c_reset_all_calls();
343
344 ///act
345 result = Map_GetInternals(handle, &keys, &values, &count);
346
347 ///assert
348 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result);
349 ASSERT_ARE_EQUAL(size_t, 0, count);
350 ASSERT_ARE_EQUAL(void_ptr, NULL, keys);
351 ASSERT_ARE_EQUAL(void_ptr, NULL, values);
352 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
353
354 ///cleanup
355 Map_Destroy(handle);
356 }
357
358 /*Tests_SRS_MAP_02_002: [If during creation there are any error, then Map_Create shall return NULL.]*/
359 TEST_FUNCTION(Map_Create_fails_when_malloc_fails)
360 {
361 ///arrange
362 MAP_HANDLE handle;
363 whenShallcalloc_fail = 1;
364 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
365 .IgnoreAllArguments();
366
367 ///act
368 handle = Map_Create(NULL);
369
370 ///assert
371 ASSERT_IS_NULL(handle);
372 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
373
374 ///cleanup
375 Map_Destroy(handle);
376 }
377
378 /*Tests_SRS_MAP_02_005: [If parameter handle is NULL then Map_Destroy shall take no action.]*/
379 TEST_FUNCTION(Map_Destroy_with_NULL_argument_does_nothing)
380 {
381 ///arrange
382 ///act
383 Map_Destroy(NULL);
384
385 ///assert
386 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
387
388 ///cleanup
389 }
390
391 /*Tests_SRS_MAP_02_006: [If parameter handle is NULL then Map_Add shall return MAP_INVALID_ARG.]*/
392 TEST_FUNCTION(Map_Add_with_NULL_parameter_handle_fails)
393 {
394 ///arrange
395 MAP_HANDLE handle = Map_Create(NULL);
396 MAP_RESULT result;
397
398 umock_c_reset_all_calls();
399
400 ///act
401 result = Map_Add(NULL, TEST_REDKEY, TEST_REDVALUE);
402
403 ///assert
404 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
405 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
406
407 ///cleanup
408 Map_Destroy(handle);
409 }
410
411 /*Tests_SRS_MAP_02_007: [If parameter key is NULL then Map_Add shall return MAP_INVALID_ARG.]*/
412 TEST_FUNCTION(Map_Add_with_NULL_parameter_key_fails)
413 {
414 ///arrange
415 MAP_HANDLE handle = Map_Create(NULL);
416 MAP_RESULT result;
417 umock_c_reset_all_calls();
418
419 ///act
420 result = Map_Add(handle, NULL, TEST_REDVALUE);
421
422 ///assert
423 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
424 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
425
426 ///cleanup
427 Map_Destroy(handle);
428 }
429
430 /*Tests_SRS_MAP_02_008: [If parameter value is NULL then Map_Add shall return MAP_INVALID_ARG.]*/
431 TEST_FUNCTION(Map_Add_with_NULL_parameter_value_fails)
432 {
433 ///arrange
434 MAP_HANDLE handle = Map_Create(NULL);
435 MAP_RESULT result;
436 umock_c_reset_all_calls();
437
438 ///act
439 result = Map_Add(handle, TEST_REDKEY, NULL);
440
441 ///assert
442 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
443 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
444
445 ///cleanup
446 Map_Destroy(handle);
447 }
448
449 /*Tests_SRS_MAP_02_010: [Otherwise, Map_Add shall add the pair <key,value> to the map.] */
450 /*Tests_SRS_MAP_02_012: [Otherwise, Map_Add shall return MAP_OK.] */
451 TEST_FUNCTION(Map_Add_succeeds_1)
452 {
453 ///arrange
454 const char*const* keys;
455 const char*const* values;
456 size_t count;
457 MAP_RESULT result1;
458 MAP_RESULT result2;
459 MAP_HANDLE handle = Map_Create(NULL);
460 umock_c_reset_all_calls();
461
462 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
463
464 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
465
466 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
467
468 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
469
470 ///act
471 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
472 result2 = Map_GetInternals(handle, &keys, &values, &count);
473
474 ///assert
475 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
476 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
477 ASSERT_ARE_EQUAL(size_t, 1, count);
478 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
479 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
480 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
481
482 ///cleanup
483 Map_Destroy(handle);
484 }
485
486 /*Tests_SRS_MAP_02_010: [Otherwise, Map_Add shall add the pair <key,value> to the map.] */
487 /*Tests_SRS_MAP_02_012: [Otherwise, Map_Add shall return MAP_OK.] */
488 /*Tests_SRS_MAP_02_043: [Map_GetInternals shall produce in *keys an pointer to an array of const char* having all the keys stored so far by the map.]*/
489 /*Tests_SRS_MAP_02_044: [Map_GetInternals shall produce in *values a pointer to an array of const char* having all the values stored so far by the map.]*/
490 /*Tests_SRS_MAP_02_045: [Map_GetInternals shall produce in *count the number of stored keys and values.]*/
491 TEST_FUNCTION(Map_Add_succeeds_2)
492 {
493 ///arrange
494 const char*const* keys;
495 const char*const* values;
496 MAP_RESULT result1;
497 MAP_RESULT result2;
498 MAP_RESULT result3;
499 size_t count;
500 MAP_HANDLE handle = Map_Create(NULL);
501 umock_c_reset_all_calls();
502
503 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
504
505 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
506
507 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
508
509 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
510
511 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2*sizeof(const char*))) /*growing keys*/
512 .IgnoreArgument(1);
513
514 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2*sizeof(const char*))) /*growing values*/
515 .IgnoreArgument(1);
516
517 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of blue key*/
518
519 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*copy of blue value*/
520
521 ///act
522 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
523 result2 = Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
524 result3 = Map_GetInternals(handle, &keys, &values, &count);
525
526 ///assert
527 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
528 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
529 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
530 ASSERT_ARE_EQUAL(size_t, 2, count);
531 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
532 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
533 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
534 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
535
536 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
537
538 ///cleanup
539 Map_Destroy(handle);
540 }
541
542 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
543 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_1)
544 {
545 ///arrange
546 const char*const* keys;
547 const char*const* values;
548 size_t count;
549 MAP_RESULT result1;
550 MAP_RESULT result2;
551 MAP_RESULT result3;
552 MAP_HANDLE handle = Map_Create(NULL);
553 umock_c_reset_all_calls();
554
555 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
556
557 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
558
559 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
560
561 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
562
563 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
564 .IgnoreArgument(1);
565
566 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
567 .IgnoreArgument(1);
568
569 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of blue key*/
570
571 whenShallmalloc_fail =currentmalloc_call+ 4;
572 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*copy of blue value*/
573
574 /*below are undo actions*/
575 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo copy of blue key*/
576 .ValidateArgumentBuffer(1, TEST_BLUEKEY, strlen(TEST_BLUEKEY) + 1);
577 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
578 .IgnoreArgument(1);
579 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing values*/
580 .IgnoreArgument(1);
581
582
583 ///act
584 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
585 result2 = Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
586 result3 = Map_GetInternals(handle, &keys, &values, &count);
587
588 ///assert
589 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
590 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
591 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
592 ASSERT_ARE_EQUAL(size_t, 1, count);
593 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
594 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
595
596 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
597
598 ///cleanup
599 Map_Destroy(handle);
600 }
601
602 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
603 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_2)
604 {
605 ///arrange
606 const char*const* keys;
607 const char*const* values;
608 MAP_RESULT result1;
609 MAP_RESULT result2;
610 MAP_RESULT result3;
611 size_t count;
612 MAP_HANDLE handle = Map_Create(NULL);
613 umock_c_reset_all_calls();
614
615 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
616
617 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
618
619 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
620
621 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
622
623 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
624 .IgnoreArgument(1);
625
626 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
627 .IgnoreArgument(1);
628
629 whenShallmalloc_fail = currentmalloc_call + 3;
630 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of blue key*/
631
632 /*below are undo actions*/
633 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
634 .IgnoreArgument(1);
635 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing values*/
636 .IgnoreArgument(1);
637
638
639 ///act
640 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
641 result2 = Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
642 result3 = Map_GetInternals(handle, &keys, &values, &count);
643
644 ///assert
645 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
646 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
647 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
648 ASSERT_ARE_EQUAL(size_t, 1, count);
649 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
650 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
651
652 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
653
654 ///cleanup
655 Map_Destroy(handle);
656 }
657
658 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
659 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_3)
660 {
661 ///arrange
662 const char*const* keys;
663 const char*const* values;
664 MAP_RESULT result1;
665 MAP_RESULT result2;
666 MAP_RESULT result3;
667 size_t count;
668 MAP_HANDLE handle = Map_Create(NULL);
669 umock_c_reset_all_calls();
670
671 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
672
673 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
674
675 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
676
677 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
678
679 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
680 .IgnoreArgument(1);
681
682 whenShallrealloc_fail = currentrealloc_call + 4;
683 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
684 .IgnoreArgument(1);
685
686 /*below are undo actions*/
687 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
688 .IgnoreArgument(1);
689
690 ///act
691 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
692 result2 = Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
693 result3 = Map_GetInternals(handle, &keys, &values, &count);
694
695 ///assert
696 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
697 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
698 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
699 ASSERT_ARE_EQUAL(size_t, 1, count);
700 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
701 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
702
703 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
704
705 ///cleanup
706 Map_Destroy(handle);
707 }
708
709 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
710 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_4)
711 {
712 ///arrange
713 const char*const* keys;
714 const char*const* values;
715 MAP_RESULT result1;
716 MAP_RESULT result2;
717 MAP_RESULT result3;
718 size_t count;
719 MAP_HANDLE handle = Map_Create(NULL);
720 umock_c_reset_all_calls();
721
722 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
723
724 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
725
726 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
727
728 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
729
730 whenShallrealloc_fail = currentrealloc_call + 3;
731 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
732 .IgnoreArgument(1);
733
734 /*below are undo actions*/
735
736 ///act
737 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
738 result2 = Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
739 result3 = Map_GetInternals(handle, &keys, &values, &count);
740
741 ///assert
742 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
743 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
744 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
745 ASSERT_ARE_EQUAL(size_t, 1, count);
746 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
747 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
748
749 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
750
751 ///cleanup
752 Map_Destroy(handle);
753 }
754
755 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
756 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_5)
757 {
758 ///arrange
759 const char*const* keys;
760 const char*const* values;
761 MAP_RESULT result1;
762 MAP_RESULT result3;
763 size_t count;
764 MAP_HANDLE handle = Map_Create(NULL);
765 umock_c_reset_all_calls();
766
767 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
768
769 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
770
771 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
772
773 whenShallmalloc_fail = currentmalloc_call + 2;
774 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
775
776 /*below are undo actions*/
777 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo copy of red key*/
778 .ValidateArgumentBuffer(1, TEST_REDKEY, strlen(TEST_REDKEY) + 1);
779 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
780 .IgnoreArgument(1);
781 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))/*undo growing values*/
782 .IgnoreArgument(1);
783
784 ///act
785 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
786 result3 = Map_GetInternals(handle, &keys, &values, &count);
787
788 ///assert
789 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
790 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
791 ASSERT_ARE_EQUAL(size_t, 0, count);
792
793 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
794
795 ///cleanup
796 Map_Destroy(handle);
797 }
798
799 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
800 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_6)
801 {
802 ///arrange
803 const char*const* keys;
804 const char*const* values;
805 MAP_RESULT result1;
806 MAP_RESULT result3;
807 size_t count;
808 MAP_HANDLE handle = Map_Create(NULL);
809 umock_c_reset_all_calls();
810
811 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
812
813 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
814
815 whenShallmalloc_fail = currentmalloc_call + 1;
816 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
817
818 /*below are undo actions*/
819 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
820 .IgnoreArgument(1);
821 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))/*undo growing values*/
822 .IgnoreArgument(1);
823
824 ///act
825 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
826 result3 = Map_GetInternals(handle, &keys, &values, &count);
827
828 ///assert
829 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
830 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
831 ASSERT_ARE_EQUAL(size_t, 0, count);
832
833 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
834
835 ///cleanup
836 Map_Destroy(handle);
837 }
838
839 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
840 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_7)
841 {
842 ///arrange
843 const char*const* keys;
844 const char*const* values;
845 MAP_RESULT result1;
846 MAP_RESULT result3;
847 size_t count;
848 MAP_HANDLE handle = Map_Create(NULL);
849 umock_c_reset_all_calls();
850
851 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
852
853 whenShallrealloc_fail = currentrealloc_call + 2;
854 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
855
856 /*below are undo actions*/
857 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
858 .IgnoreArgument(1);
859
860 ///act
861 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
862 result3 = Map_GetInternals(handle, &keys, &values, &count);
863
864 ///assert
865 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
866 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
867 ASSERT_ARE_EQUAL(size_t, 0, count);
868
869 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
870
871 ///cleanup
872 Map_Destroy(handle);
873 }
874
875 /*Tests_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
876 TEST_FUNCTION(Map_Add_fails_when_gballoc_fails_8)
877 {
878 ///arrange
879 const char*const* keys;
880 const char*const* values;
881 size_t count;
882 MAP_RESULT result1;
883 MAP_RESULT result3;
884 MAP_HANDLE handle = Map_Create(NULL);
885 umock_c_reset_all_calls();
886
887 whenShallrealloc_fail = currentrealloc_call + 1;
888 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
889
890 /*below are undo actions*/ /*none*/
891
892 ///act
893 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
894 result3 = Map_GetInternals(handle, &keys, &values, &count);
895
896 ///assert
897 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
898 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
899 ASSERT_ARE_EQUAL(size_t, 0, count);
900
901 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
902
903 ///cleanup
904 Map_Destroy(handle);
905 }
906
907 /*Tests_SRS_MAP_02_009: [If the key already exists, then Map_Add shall return MAP_KEYEXISTS.]*/
908 TEST_FUNCTION(Map_Add_with_existing_key_fails_1)
909 {
910 ///arrange
911 const char*const* keys;
912 const char*const* values;
913 MAP_RESULT result1;
914 MAP_RESULT result3;
915 size_t count;
916 MAP_HANDLE handle = Map_Create(NULL);
917 (void)Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
918 umock_c_reset_all_calls();
919
920 /*below are undo actions*/ /*none*/
921
922 ///act
923 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
924 result3 = Map_GetInternals(handle, &keys, &values, &count);
925
926 ///assert
927 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_KEYEXISTS, result1);
928 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
929 ASSERT_ARE_EQUAL(size_t, 1, count);
930 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
931 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
932
933 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
934
935 ///cleanup
936 Map_Destroy(handle);
937 }
938
939 /*Tests_SRS_MAP_02_009: [If the key already exists, then Map_Add shall return MAP_KEYEXISTS.]*/
940 TEST_FUNCTION(Map_Add_with_existing_key_fails_2)
941 {
942 ///arrange
943 const char*const* keys;
944 const char*const* values;
945 size_t count;
946 MAP_RESULT result1;
947 MAP_RESULT result3;
948 MAP_HANDLE handle = Map_Create(NULL);
949 (void)Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
950 (void)Map_Add(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
951 umock_c_reset_all_calls();
952
953 /*below are undo actions*/ /*none*/
954
955 ///act
956 result1 = Map_Add(handle, TEST_BLUEKEY, TEST_YELLOWVALUE);
957 result3 = Map_GetInternals(handle, &keys, &values, &count);
958
959 ///assert
960 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_KEYEXISTS, result1);
961 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
962 ASSERT_ARE_EQUAL(size_t, 2, count);
963 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
964 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
965 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
966 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
967
968 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
969
970 ///cleanup
971 Map_Destroy(handle);
972 }
973
974 /*Tests_SRS_MAP_02_013: [If parameter handle is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.]*/
975 TEST_FUNCTION(Map_AddOrUpdate_with_NULL_parameter_handle_fails)
976 {
977 ///arrange
978
979 ///act
980 MAP_RESULT result1 = Map_AddOrUpdate(NULL, TEST_BLUEKEY, TEST_YELLOWVALUE);
981
982 ///assert
983 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
984 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
985
986 ///cleanup
987 }
988
989 /*Tests_SRS_MAP_02_014: [If parameter key is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.] */
990 TEST_FUNCTION(Map_AddOrUpdate_with_NULL_key_handle_fails)
991 {
992 ///arrange
993 MAP_RESULT result1;
994 MAP_HANDLE handle = Map_Create(NULL);
995 umock_c_reset_all_calls();
996
997 ///act
998 result1 = Map_AddOrUpdate(handle, NULL, TEST_YELLOWVALUE);
999
1000 ///assert
1001 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1002 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1003
1004 ///cleanup
1005 Map_Destroy(handle);
1006 }
1007
1008 /*Tests_SRS_MAP_02_015: [If parameter value is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.]*/
1009 TEST_FUNCTION(Map_AddOrUpdate_with_NULL_value_handle_fails)
1010 {
1011 ///arrange
1012 MAP_RESULT result1;
1013 MAP_HANDLE handle = Map_Create(NULL);
1014 umock_c_reset_all_calls();
1015
1016 ///act
1017 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, NULL);
1018
1019 ///assert
1020 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1021 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1022
1023 ///cleanup
1024 Map_Destroy(handle);
1025 }
1026
1027 /*Tests_SRS_MAP_02_017: [Otherwise, Map_AddOrUpdate shall add the pair <key,value> to the map.]*/
1028 /*Tests_SRS_MAP_02_019: [Otherwise, Map_AddOrUpdate shall return MAP_OK.] */
1029 TEST_FUNCTION(Map_AddOrUpdate_with_1_pair_succeeded)
1030 {
1031 ///arrange
1032 const char*const* keys;
1033 const char*const* values;
1034 MAP_RESULT result1;
1035 MAP_RESULT result2;
1036 size_t count;
1037 MAP_HANDLE handle = Map_Create(NULL);
1038 umock_c_reset_all_calls();
1039
1040 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1041 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1042 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY)+1)); /*copy of red key*/
1043 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1044
1045 ///act
1046 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1047 result2 = Map_GetInternals(handle, &keys, &values, &count);
1048
1049 ///assert
1050 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1051 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
1052 ASSERT_ARE_EQUAL(size_t, 1, count);
1053 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1054 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1055 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1056
1057 ///cleanup
1058 Map_Destroy(handle);
1059 }
1060
1061 /*Tests_SRS_MAP_02_017: [Otherwise, Map_AddOrUpdate shall add the pair <key,value> to the map.]*/
1062 TEST_FUNCTION(Map_AddOrUpdate_with_2_pair_succeeded)
1063 {
1064 ///arrange
1065 const char*const* keys;
1066 const char*const* values;
1067 MAP_RESULT result1;
1068 MAP_RESULT result2;
1069 MAP_RESULT result3;
1070 size_t count;
1071 MAP_HANDLE handle = Map_Create(NULL);
1072 umock_c_reset_all_calls();
1073
1074 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1075 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1076 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1077 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1078
1079 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
1080 .IgnoreArgument(1);
1081 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
1082 .IgnoreArgument(1);
1083 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of red key*/
1084 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*copy of red value*/
1085
1086 ///act
1087 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1088 result2 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1089 result3 = Map_GetInternals(handle, &keys, &values, &count);
1090
1091 ///assert
1092 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1093 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
1094 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1095 ASSERT_ARE_EQUAL(size_t, 2, count);
1096 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1097 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1098 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
1099 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
1100
1101 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1102
1103 ///cleanup
1104 Map_Destroy(handle);
1105 }
1106
1107 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1108 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_1)
1109 {
1110 ///arrange
1111 const char*const* keys;
1112 const char*const* values;
1113 MAP_RESULT result1;
1114 MAP_RESULT result2;
1115 MAP_RESULT result3;
1116 size_t count;
1117 MAP_HANDLE handle = Map_Create(NULL);
1118 umock_c_reset_all_calls();
1119
1120 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1121 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1122 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1123 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1124
1125 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
1126 .IgnoreArgument(1);
1127 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
1128 .IgnoreArgument(1);
1129 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of red key*/
1130
1131 whenShallmalloc_fail = currentmalloc_call + 4;
1132 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*copy of red value*/
1133
1134 /*below are undo actions*/
1135 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo blue key value*/
1136 .ValidateArgumentBuffer(1, TEST_BLUEKEY, strlen(TEST_BLUEKEY) + 1);
1137 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
1138 .IgnoreArgument(1);
1139 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing values*/
1140 .IgnoreArgument(1);
1141
1142 ///act
1143 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1144 result2 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1145 result3 = Map_GetInternals(handle, &keys, &values, &count);
1146
1147 ///assert
1148 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1149 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
1150 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1151 ASSERT_ARE_EQUAL(size_t, 1, count);
1152 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1153 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1154 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1155
1156 ///cleanup
1157 Map_Destroy(handle);
1158 }
1159
1160 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1161 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_2)
1162 {
1163 ///arrange
1164 const char*const* keys;
1165 const char*const* values;
1166 MAP_RESULT result1;
1167 MAP_RESULT result2;
1168 MAP_RESULT result3;
1169 size_t count;
1170 MAP_HANDLE handle = Map_Create(NULL);
1171 umock_c_reset_all_calls();
1172
1173 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1174 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1175 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1176 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1177
1178 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
1179 .IgnoreArgument(1);
1180 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
1181 .IgnoreArgument(1);
1182 whenShallmalloc_fail = currentmalloc_call + 3;
1183 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*copy of red key*/
1184
1185 /*below are undo actions*/
1186 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
1187 .IgnoreArgument(1);
1188 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing values*/
1189 .IgnoreArgument(1);
1190
1191 ///act
1192 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1193 result2 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1194 result3 = Map_GetInternals(handle, &keys, &values, &count);
1195
1196 ///assert
1197 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1198 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
1199 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1200 ASSERT_ARE_EQUAL(size_t, 1, count);
1201 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1202 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1203 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1204
1205 ///cleanup
1206 Map_Destroy(handle);
1207 }
1208
1209 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1210 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_3)
1211 {
1212 ///arrange
1213 const char*const* keys;
1214 const char*const* values;
1215 MAP_RESULT result1;
1216 MAP_RESULT result2;
1217 MAP_RESULT result3;
1218 size_t count;
1219 MAP_HANDLE handle = Map_Create(NULL);
1220 umock_c_reset_all_calls();
1221
1222 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1223 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1224 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1225 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1226
1227 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
1228 .IgnoreArgument(1);
1229 whenShallrealloc_fail = currentrealloc_call + 4;
1230 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing values*/
1231 .IgnoreArgument(1);
1232
1233 /*below are undo actions*/
1234 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*undo growing keys*/
1235 .IgnoreArgument(1);
1236
1237 ///act
1238 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1239 result2 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1240 result3 = Map_GetInternals(handle, &keys, &values, &count);
1241
1242 ///assert
1243 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1244 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
1245 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1246 ASSERT_ARE_EQUAL(size_t, 1, count);
1247 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1248 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1249 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1250
1251 ///cleanup
1252 Map_Destroy(handle);
1253 }
1254
1255 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1256 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_4)
1257 {
1258 ///arrange
1259 const char*const* keys;
1260 const char*const* values;
1261 MAP_RESULT result1;
1262 MAP_RESULT result2;
1263 MAP_RESULT result3;
1264 size_t count;
1265 MAP_HANDLE handle = Map_Create(NULL);
1266 umock_c_reset_all_calls();
1267
1268 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1269 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1270 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1271 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1272
1273 whenShallrealloc_fail = currentrealloc_call + 3;
1274 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * sizeof(const char*))) /*growing keys*/
1275 .IgnoreArgument(1);
1276
1277 /*below are undo actions*/ /*none*/
1278
1279 ///act
1280 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1281 result2 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1282 result3 = Map_GetInternals(handle, &keys, &values, &count);
1283
1284 ///assert
1285 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1286 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result2);
1287 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1288 ASSERT_ARE_EQUAL(size_t, 1, count);
1289 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1290 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1291 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1292
1293 ///cleanup
1294 Map_Destroy(handle);
1295 }
1296
1297 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1298 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_5)
1299 {
1300 ///arrange
1301 const char*const* keys;
1302 const char*const* values;
1303 MAP_RESULT result1;
1304 MAP_RESULT result3;
1305 size_t count;
1306 MAP_HANDLE handle = Map_Create(NULL);
1307 umock_c_reset_all_calls();
1308
1309 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1310 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1311 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1312 whenShallmalloc_fail = currentmalloc_call + 2;
1313 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*copy of red value*/
1314
1315 /*below are undo actions*/
1316 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo red key value*/
1317 .ValidateArgumentBuffer(1, TEST_REDKEY, strlen(TEST_REDKEY) + 1);
1318 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
1319 .IgnoreArgument(1);
1320 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing values*/
1321 .IgnoreArgument(1);
1322
1323 ///act
1324 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1325 result3 = Map_GetInternals(handle, &keys, &values, &count);
1326
1327 ///assert
1328 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1329 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1330 ASSERT_ARE_EQUAL(size_t, 0, count);
1331 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1332
1333 ///cleanup
1334 Map_Destroy(handle);
1335 }
1336
1337 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1338 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_6)
1339 {
1340 ///arrange
1341 const char*const* keys;
1342 const char*const* values;
1343 size_t count;
1344 MAP_RESULT result1;
1345 MAP_RESULT result3;
1346 MAP_HANDLE handle = Map_Create(NULL);
1347 umock_c_reset_all_calls();
1348
1349 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1350 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1351
1352 whenShallmalloc_fail = currentmalloc_call + 1;
1353 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*copy of red key*/
1354
1355 /*below are undo actions*/
1356 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
1357 .IgnoreArgument(1);
1358 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing values*/
1359 .IgnoreArgument(1);
1360
1361 ///act
1362 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1363 result3 = Map_GetInternals(handle, &keys, &values, &count);
1364
1365 ///assert
1366 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1367 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1368 ASSERT_ARE_EQUAL(size_t, 0, count);
1369 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1370
1371 ///cleanup
1372 Map_Destroy(handle);
1373 }
1374
1375 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1376 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_7)
1377 {
1378 ///arrange
1379 const char*const* keys;
1380 const char*const* values;
1381 size_t count;
1382 MAP_RESULT result1;
1383 MAP_RESULT result3;
1384 MAP_HANDLE handle = Map_Create(NULL);
1385 umock_c_reset_all_calls();
1386
1387 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1388 whenShallrealloc_fail = currentrealloc_call + 2;
1389 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing values*/
1390
1391 /*below are undo actions*/
1392 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*undo growing keys*/
1393 .IgnoreArgument(1);
1394
1395 ///act
1396 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1397 result3 = Map_GetInternals(handle, &keys, &values, &count);
1398
1399 ///assert
1400 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1401 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1402 ASSERT_ARE_EQUAL(size_t, 0, count);
1403 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1404
1405 ///cleanup
1406 Map_Destroy(handle);
1407 }
1408
1409 /*Tests_SRS_MAP_02_018: [If there are any failures then Map_AddOrUpdate shall return MAP_ERROR.] */
1410 TEST_FUNCTION(Map_AddOrUpdate_with_2_differnt_pair_fails_when_gballoc_fails_8)
1411 {
1412 ///arrange
1413 const char*const* keys;
1414 const char*const* values;
1415 size_t count;
1416 MAP_RESULT result1;
1417 MAP_RESULT result3;
1418 MAP_HANDLE handle = Map_Create(NULL);
1419 umock_c_reset_all_calls();
1420
1421 whenShallrealloc_fail = currentrealloc_call + 1;
1422 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*))); /*growing keys*/
1423
1424 /*below are undo actions*/
1425
1426 ///act
1427 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1428 result3 = Map_GetInternals(handle, &keys, &values, &count);
1429
1430 ///assert
1431 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1432 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1433 ASSERT_ARE_EQUAL(size_t, 0, count);
1434 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1435
1436 ///cleanup
1437 Map_Destroy(handle);
1438 }
1439
1440 /*Tests_SRS_MAP_02_016: [If the key already exists, then Map_AddOrUpdate shall overwrite the value of the existing key with parameter value.]*/
1441 TEST_FUNCTION(Map_AddOrUpdate_with_2_pair_overwrites_firstValue_succeeds)
1442 {
1443 ///arrange
1444 const char*const* keys;
1445 const char*const* values;
1446 MAP_RESULT result1;
1447 MAP_RESULT result3;
1448 size_t count;
1449 MAP_HANDLE handle = Map_Create(NULL);
1450 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1451 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1452 umock_c_reset_all_calls();
1453
1454 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, strlen(TEST_YELLOWVALUE) + 1)) /*changing redkey value to yellow*/
1455 .ValidateArgumentBuffer(1, TEST_REDVALUE, strlen(TEST_REDVALUE) + 1);
1456
1457 ///act
1458 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_YELLOWVALUE);
1459 result3 = Map_GetInternals(handle, &keys, &values, &count);
1460
1461 ///assert
1462 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1463
1464 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1465 ASSERT_ARE_EQUAL(size_t, 2, count);
1466 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1467 ASSERT_ARE_EQUAL(char_ptr, TEST_YELLOWVALUE, values[0]);
1468 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
1469 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
1470
1471 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1472
1473 ///cleanup
1474 Map_Destroy(handle);
1475 }
1476
1477 /*Tests_SRS_MAP_02_016: [If the key already exists, then Map_AddOrUpdate shall overwrite the value of the existing key with parameter value.]*/
1478 TEST_FUNCTION(Map_AddOrUpdate_with_2_pair_overwrites_firstValue_when_gballoc_fails_it_does_not_change_the_value)
1479 {
1480 ///arrange
1481 const char*const* keys;
1482 const char*const* values;
1483 MAP_RESULT result1;
1484 MAP_RESULT result3;
1485 size_t count;
1486 MAP_HANDLE handle = Map_Create(NULL);
1487 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1488 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1489 umock_c_reset_all_calls();
1490
1491 whenShallrealloc_fail = currentrealloc_call + 1;
1492 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, strlen(TEST_YELLOWVALUE) + 1)) /*changing redkey value to yellow*/
1493 .ValidateArgumentBuffer(1, TEST_REDVALUE, strlen(TEST_REDVALUE) + 1);
1494
1495 ///act
1496 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_YELLOWVALUE);
1497 result3 = Map_GetInternals(handle, &keys, &values, &count);
1498
1499 ///assert
1500 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1501 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1502 ASSERT_ARE_EQUAL(size_t, 2, count);
1503 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1504 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1505 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
1506 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
1507
1508 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1509
1510 ///cleanup
1511 Map_Destroy(handle);
1512 }
1513
1514 /*Tests_SRS_MAP_02_016: [If the key already exists, then Map_AddOrUpdate shall overwrite the value of the existing key with parameter value.]*/
1515 TEST_FUNCTION(Map_AddOrUpdate_with_2_pair_overwrites_secondValue)
1516 {
1517 ///arrange
1518 const char*const* keys;
1519 const char*const* values;
1520 size_t count;
1521 MAP_RESULT result1;
1522 MAP_RESULT result3;
1523 MAP_HANDLE handle = Map_Create(NULL);
1524 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1525 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1526 umock_c_reset_all_calls();
1527
1528 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, strlen(TEST_YELLOWVALUE) + 1)) /*changing bluekey value to yellow*/
1529 .ValidateArgumentBuffer(1, TEST_BLUEVALUE, strlen(TEST_BLUEVALUE) + 1);
1530
1531 ///act
1532 result1 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_YELLOWVALUE);
1533 result3 = Map_GetInternals(handle, &keys, &values, &count);
1534
1535 ///assert
1536 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1537 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1538 ASSERT_ARE_EQUAL(size_t, 2, count);
1539 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1540 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1541 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
1542 ASSERT_ARE_EQUAL(char_ptr, TEST_YELLOWVALUE, values[1]);
1543
1544 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1545
1546 ///cleanup
1547 Map_Destroy(handle);
1548 }
1549
1550 /*Tests_SRS_MAP_02_016: [If the key already exists, then Map_AddOrUpdate shall overwrite the value of the existing key with parameter value.]*/
1551 TEST_FUNCTION(Map_AddOrUpdate_with_2_pair_overwrites_secondValue_doesn_not_change_the_value_when_gballoc_fails)
1552 {
1553 ///arrange
1554 const char*const* keys;
1555 const char*const* values;
1556 MAP_RESULT result1;
1557 MAP_RESULT result3;
1558 size_t count;
1559 MAP_HANDLE handle = Map_Create(NULL);
1560 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1561 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
1562 umock_c_reset_all_calls();
1563
1564 whenShallrealloc_fail = currentrealloc_call + 1;
1565 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, strlen(TEST_YELLOWVALUE) + 1)) /*changing bluekey value to yellow*/
1566 .ValidateArgumentBuffer(1, TEST_BLUEVALUE, strlen(TEST_BLUEVALUE) + 1);
1567
1568 ///act
1569 result1 = Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_YELLOWVALUE);
1570 result3 = Map_GetInternals(handle, &keys, &values, &count);
1571
1572 ///assert
1573 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_ERROR, result1);
1574 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1575 ASSERT_ARE_EQUAL(size_t, 2, count);
1576 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1577 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1578 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
1579 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
1580
1581 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1582
1583 ///cleanup
1584 Map_Destroy(handle);
1585 }
1586
1587 /*Tests_SRS_MAP_02_020: [If parameter handle is NULL then Map_Delete shall return MAP_INVALIDARG.]*/
1588 TEST_FUNCTION(Map_Delete_with_NULL_handle_fails)
1589 {
1590 ///arrange
1591
1592 ///act
1593 MAP_RESULT result1 = Map_Delete(NULL, TEST_BLUEKEY);
1594
1595 ///assert
1596 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1597 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1598
1599 ///cleanup
1600 }
1601
1602 /*Tests_SRS_MAP_02_021: [If parameter key is NULL then Map_Delete shall return MAP_INVALIDARG.]*/
1603 TEST_FUNCTION(Map_Delete_with_NULL_key_fails)
1604 {
1605 ///arrange
1606 MAP_HANDLE handle = Map_Create(NULL);
1607 MAP_RESULT result1;
1608 umock_c_reset_all_calls();
1609
1610 ///act
1611 result1 = Map_Delete(handle, NULL);
1612
1613 ///assert
1614 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1615 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1616
1617 ///cleanup
1618 Map_Destroy(handle);
1619 }
1620
1621 /*Tests_SRS_MAP_02_022: [If key does not exist then Map_Delete shall return MAP_KEYNOTFOUND.]*/
1622 TEST_FUNCTION(Map_Delete_with_not_found_key_succeeds_1)
1623 {
1624 ///arrange
1625 MAP_HANDLE handle = Map_Create(NULL);
1626 MAP_RESULT result1;
1627 umock_c_reset_all_calls();
1628
1629 ///act
1630 result1 = Map_Delete(handle, TEST_REDKEY);
1631
1632 ///assert
1633 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_KEYNOTFOUND, result1);
1634 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1635
1636 ///cleanup
1637 Map_Destroy(handle);
1638 }
1639
1640 /*Tests_SRS_MAP_02_022: [If key does not exist then Map_Delete shall return MAP_KEYNOTFOUND.]*/
1641 TEST_FUNCTION(Map_Delete_with_not_found_key_succeeds_2)
1642 {
1643 ///arrange
1644 MAP_HANDLE handle = Map_Create(NULL);
1645 MAP_RESULT result1;
1646 (void)Map_AddOrUpdate(handle, TEST_YELLOWKEY, TEST_YELLOWVALUE);
1647 umock_c_reset_all_calls();
1648
1649 ///act
1650 result1 = Map_Delete(handle, TEST_REDKEY);
1651
1652 ///assert
1653 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_KEYNOTFOUND, result1);
1654 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1655
1656 ///cleanup
1657 Map_Destroy(handle);
1658 }
1659
1660 /*Tests_SRS_MAP_02_023: [Otherwise, Map_Delete shall remove the key and its associated value from the map and return MAP_OK.] */
1661 TEST_FUNCTION(Map_Delete_with_1_found_key_succeeds)
1662 {
1663 ///arrange
1664 MAP_HANDLE handle = Map_Create(NULL);
1665 const char*const* keys;
1666 const char*const* values;
1667 size_t count;
1668 MAP_RESULT result1;
1669 MAP_RESULT result3;
1670 (void)Map_AddOrUpdate(handle, TEST_YELLOWKEY, TEST_YELLOWVALUE);
1671 umock_c_reset_all_calls();
1672
1673 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow key*/
1674 .ValidateArgumentBuffer(1, TEST_YELLOWKEY, strlen(TEST_YELLOWKEY) + 1);
1675
1676 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow value*/
1677 .ValidateArgumentBuffer(1, TEST_YELLOWVALUE, strlen(TEST_YELLOWVALUE) + 1);
1678
1679 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*ungrowing values*/
1680 .IgnoreArgument(1);
1681
1682 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*ungowing keys*/
1683 .IgnoreArgument(1);
1684
1685 ///act
1686 result1 = Map_Delete(handle, TEST_YELLOWKEY);
1687 result3 = Map_GetInternals(handle, &keys, &values, &count);
1688
1689 ///assert
1690 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1691 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1692 ASSERT_ARE_EQUAL(size_t, 0, count);
1693 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1694
1695 ///cleanup
1696 Map_Destroy(handle);
1697 }
1698
1699 /*Tests_SRS_MAP_02_023: [Otherwise, Map_Delete shall remove the key and its associated value from the map and return MAP_OK.] */
1700 TEST_FUNCTION(Map_Delete_with_1_found_key_succeeds_2)
1701 {
1702 ///arrange
1703 MAP_HANDLE handle = Map_Create(NULL);
1704 const char*const* keys;
1705 const char*const* values;
1706 size_t count;
1707 MAP_RESULT result1;
1708 MAP_RESULT result3;
1709 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1710 (void)Map_AddOrUpdate(handle, TEST_YELLOWKEY, TEST_YELLOWVALUE);
1711
1712 umock_c_reset_all_calls();
1713
1714 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow key*/
1715 .ValidateArgumentBuffer(1, TEST_YELLOWKEY, strlen(TEST_YELLOWKEY) + 1);
1716
1717 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow value*/
1718 .ValidateArgumentBuffer(1, TEST_YELLOWVALUE, strlen(TEST_YELLOWVALUE) + 1);
1719
1720 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1* sizeof(const char*))) /*ungrowing values*/
1721 .IgnoreArgument(1);
1722
1723 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*ungrowing keys*/
1724 .IgnoreArgument(1);
1725
1726 ///act
1727 result1 = Map_Delete(handle, TEST_YELLOWKEY);
1728 result3 = Map_GetInternals(handle, &keys, &values, &count);
1729
1730 ///assert
1731 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1732 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1733 ASSERT_ARE_EQUAL(size_t, 1, count);
1734 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
1735 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
1736 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1737
1738 ///cleanup
1739 Map_Destroy(handle);
1740 }
1741
1742 /*Tests_SRS_MAP_02_023: [Otherwise, Map_Delete shall remove the key and its associated value from the map and return MAP_OK.] */
1743 TEST_FUNCTION(Map_Delete_with_1_found_key_succeeds_3)
1744 {
1745 ///arrange
1746 MAP_HANDLE handle = Map_Create(NULL);
1747 const char*const* keys;
1748 const char*const* values;
1749 size_t count;
1750 MAP_RESULT result1;
1751 MAP_RESULT result3;
1752 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1753 (void)Map_AddOrUpdate(handle, TEST_YELLOWKEY, TEST_YELLOWVALUE);
1754
1755 umock_c_reset_all_calls();
1756
1757 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow key*/
1758 .ValidateArgumentBuffer(1, TEST_REDKEY, strlen(TEST_REDKEY) + 1);
1759
1760 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*freeing yellow value*/
1761 .ValidateArgumentBuffer(1, TEST_REDVALUE, strlen(TEST_REDVALUE) + 1);
1762
1763 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*ungrowing values*/
1764 .IgnoreArgument(1);
1765
1766 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 1 * sizeof(const char*))) /*ungrowing keys*/
1767 .IgnoreArgument(1);
1768
1769 ///act
1770 result1 = Map_Delete(handle, TEST_REDKEY);
1771 result3 = Map_GetInternals(handle, &keys, &values, &count);
1772
1773 ///assert
1774 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1775 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
1776 ASSERT_ARE_EQUAL(size_t, 1, count);
1777 ASSERT_ARE_EQUAL(char_ptr, TEST_YELLOWKEY, keys[0]);
1778 ASSERT_ARE_EQUAL(char_ptr, TEST_YELLOWVALUE, values[0]);
1779 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1780
1781 ///cleanup
1782 Map_Destroy(handle);
1783 }
1784
1785 /*Tests_SRS_MAP_02_024: [If parameter handle, key or keyExists are NULL then Map_ContainsKey shall return MAP_INVALIDARG.]*/
1786 TEST_FUNCTION(Map_ContainsKey_fails_with_invalid_arg_1)
1787 {
1788 ///arrange
1789 bool exists;
1790 MAP_RESULT result1;
1791 umock_c_reset_all_calls();
1792
1793 ///act
1794 result1 = Map_ContainsKey(NULL,TEST_REDKEY, &exists);
1795
1796 ///assert
1797 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1798 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1799
1800 ///cleanup
1801 }
1802
1803 /*Tests_SRS_MAP_02_024: [If parameter handle, key or keyExists are NULL then Map_ContainsKey shall return MAP_INVALIDARG.]*/
1804 TEST_FUNCTION(Map_ContainsKey_fails_with_invalid_arg_2)
1805 {
1806 ///arrange
1807 bool exists;
1808 MAP_HANDLE handle = Map_Create(NULL);
1809 MAP_RESULT result1;
1810 umock_c_reset_all_calls();
1811
1812 ///act
1813 result1 = Map_ContainsKey(handle, NULL, &exists);
1814
1815 ///assert
1816 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1817 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1818
1819 ///cleanup
1820 Map_Destroy(handle);
1821 }
1822
1823 /*Tests_SRS_MAP_02_024: [If parameter handle, key or keyExists are NULL then Map_ContainsKey shall return MAP_INVALIDARG.]*/
1824 TEST_FUNCTION(Map_ContainsKey_fails_with_invalid_arg_3)
1825 {
1826 ///arrange
1827 MAP_HANDLE handle = Map_Create(NULL);
1828 MAP_RESULT result1;
1829 umock_c_reset_all_calls();
1830
1831 ///act
1832 result1 = Map_ContainsKey(handle, TEST_REDKEY, NULL);
1833
1834 ///assert
1835 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1836 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1837
1838 ///cleanup
1839 Map_Destroy(handle);
1840 }
1841
1842 /*Tests_SRS_MAP_02_025: [Otherwise if a key exists then Map_ContainsKey shall return MAP_OK and shall write in keyExists "true".]*/
1843 /*Tests_SRS_MAP_02_026: [If a key doesn't exist, then Map_ContainsKey shall return MAP_OK and write in keyExists "false".] */
1844 TEST_FUNCTION(Map_ContainsKey_fails_with_known_key_succeeds)
1845 {
1846 ///arrange
1847 MAP_HANDLE handle = Map_Create(NULL);
1848 bool e1, e2;
1849 MAP_RESULT result1;
1850 MAP_RESULT result2;
1851 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1852 umock_c_reset_all_calls();
1853
1854 ///act
1855 result1 = Map_ContainsKey(handle, TEST_REDKEY, &e1);
1856 result2 = Map_ContainsKey(handle, TEST_BLUEKEY, &e2);
1857
1858 ///assert
1859 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1860 ASSERT_IS_TRUE(e1);
1861
1862 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
1863 ASSERT_IS_FALSE(e2);
1864 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1865
1866 ///cleanup
1867 Map_Destroy(handle);
1868 }
1869
1870 /*Tests_SRS_MAP_02_027: [If parameter handle, value or valueExists is NULL then Map_ContainsValue shall return MAP_INVALIDARG.]*/
1871 TEST_FUNCTION(Map_ContainsValue_fails_with_NULL_handle)
1872 {
1873 ///arrange
1874 bool e1;
1875 MAP_RESULT result1;
1876 umock_c_reset_all_calls();
1877
1878 ///act
1879 result1 = Map_ContainsValue(NULL, TEST_REDKEY, &e1);
1880
1881 ///assert
1882 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1883 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1884
1885 ///cleanup
1886 }
1887
1888 /*Tests_SRS_MAP_02_027: [If parameter handle, value or valueExists is NULL then Map_ContainsValue shall return MAP_INVALIDARG.]*/
1889 TEST_FUNCTION(Map_ContainsValue_fails_with_NULL_key)
1890 {
1891 ///arrange
1892 MAP_HANDLE handle = Map_Create(NULL);
1893 bool e1;
1894 MAP_RESULT result1;
1895 umock_c_reset_all_calls();
1896
1897 ///act
1898 result1 = Map_ContainsValue(handle, NULL, &e1);
1899
1900 ///assert
1901 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1902 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1903
1904 ///cleanup
1905 Map_Destroy(handle);
1906 }
1907
1908 /*Tests_SRS_MAP_02_027: [If parameter handle, value or valueExists is NULL then Map_ContainsValue shall return MAP_INVALIDARG.]*/
1909 TEST_FUNCTION(Map_ContainsValue_fails_with_NULL_exists)
1910 {
1911 ///arrange
1912 MAP_HANDLE handle = Map_Create(NULL);
1913 MAP_RESULT result1;
1914 umock_c_reset_all_calls();
1915
1916 ///act
1917 result1 = Map_ContainsValue(handle, TEST_REDKEY, NULL);
1918
1919 ///assert
1920 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result1);
1921 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1922
1923 ///cleanup
1924 Map_Destroy(handle);
1925 }
1926
1927 /*Tests_SRS_MAP_02_028: [Otherwise, if a pair <key, value> has its value equal to the parameter value, the Map_ContainsValue shall return MAP_OK and shall write in valueExists "true".]*/
1928 /*Tests_SRS_MAP_02_029: [Otherwise, if such a <key, value> does not exist, then Map_ContainsValue shall return MAP_OK and shall write in valueExists "false".] */
1929 TEST_FUNCTION(Map_ContainsValue_succeeds)
1930 {
1931 ///arrange
1932 MAP_HANDLE handle = Map_Create(NULL);
1933 bool e1, e2;
1934 MAP_RESULT result1;
1935 MAP_RESULT result2;
1936 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
1937 umock_c_reset_all_calls();
1938
1939 ///act
1940 result1 = Map_ContainsValue(handle, TEST_REDVALUE, &e1);
1941 result2 = Map_ContainsValue(handle, TEST_BLUEVALUE, &e2);
1942
1943 ///assert
1944 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result1);
1945 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
1946 ASSERT_IS_TRUE(e1);
1947 ASSERT_IS_FALSE(e2);
1948 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1949
1950 ///cleanup
1951 Map_Destroy(handle);
1952 }
1953
1954 /*Tests_SRS_MAP_02_040: [If parameter handle or key is NULL then Map_GetValueFromKey returns NULL.]*/
1955 TEST_FUNCTION(Map_GetValueFromKey_returns_NULL__for_invalid_handle)
1956 {
1957 ///arrange
1958
1959 ///act
1960 const char* result = Map_GetValueFromKey(NULL, TEST_REDKEY);
1961
1962 ///assert
1963 ASSERT_IS_NULL(result);
1964 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1965
1966 ///cleanup
1967 }
1968
1969 /*Tests_SRS_MAP_02_040: [If parameter handle or key is NULL then Map_GetValueFromKey returns NULL.]*/
1970 TEST_FUNCTION(Map_GetValueFromKey_returns_NULL_for_NULL_key)
1971 {
1972 ///arrange
1973 MAP_HANDLE handle = Map_Create(NULL);
1974 const char* result;
1975 umock_c_reset_all_calls();
1976
1977 ///act
1978 result = Map_GetValueFromKey(handle, NULL);
1979
1980 ///assert
1981 ASSERT_IS_NULL(result);
1982 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1983
1984 ///cleanup
1985 Map_Destroy(handle);
1986 }
1987
1988 /*Tests_SRS_MAP_02_041: [If the key is not found, then Map_GetValueFromKey returns NULL.]*/
1989 TEST_FUNCTION(Map_GetValueFromKey_returns_NULL_for_notfound_key)
1990 {
1991 ///arrange
1992 MAP_HANDLE handle = Map_Create(NULL);
1993 const char* result;
1994 umock_c_reset_all_calls();
1995
1996 ///act
1997 result = Map_GetValueFromKey(handle, TEST_REDKEY);
1998
1999 ///assert
2000 ASSERT_IS_NULL(result);
2001 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2002
2003 ///cleanup
2004 Map_Destroy(handle);
2005 }
2006
2007 /*Tests_SRS_MAP_02_042: [Otherwise, Map_GetValueFromKey returns the key's value.] */
2008 TEST_FUNCTION(Map_GetValueFromKey_returns_non_NULL_for_found_key)
2009 {
2010 ///arrange
2011 MAP_HANDLE handle = Map_Create(NULL);
2012 const char* result;
2013 Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2014 umock_c_reset_all_calls();
2015
2016 ///act
2017 result = Map_GetValueFromKey(handle, TEST_REDKEY);
2018
2019 ///assert
2020 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, result);
2021 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2022
2023 ///cleanup
2024 Map_Destroy(handle);
2025 }
2026
2027 /*Tests_SRS_MAP_02_046: [If parameter handle, keys, values or count is NULL then Map_GetInternals shall return MAP_INVALIDARG.] */
2028 TEST_FUNCTION(Map_GetInternals_fails_with_NULL_arg_1)
2029 {
2030 ///arrange
2031 const char*const* keys;
2032 const char*const* values;
2033 size_t size;
2034
2035 ///act
2036 MAP_RESULT result = Map_GetInternals(NULL, &keys, &values, &size);
2037
2038 ///assert
2039 ASSERT_ARE_EQUAL(MAP_RESULT,MAP_INVALIDARG, result);
2040 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2041 }
2042
2043 /*Tests_SRS_MAP_02_046: [If parameter handle, keys, values or count is NULL then Map_GetInternals shall return MAP_INVALIDARG.] */
2044 TEST_FUNCTION(Map_GetInternals_fails_with_NULL_arg_2)
2045 {
2046 ///arrange
2047 const char*const* values;
2048 size_t size;
2049 MAP_RESULT result;
2050 MAP_HANDLE handle = Map_Create(NULL);
2051 umock_c_reset_all_calls();
2052
2053 ///act
2054 result = Map_GetInternals(handle, NULL, &values, &size);
2055
2056 ///assert
2057 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
2058 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2059
2060 ///cleanup
2061 Map_Destroy(handle);
2062 }
2063
2064 /*Tests_SRS_MAP_02_046: [If parameter handle, keys, values or count is NULL then Map_GetInternals shall return MAP_INVALIDARG.] */
2065 TEST_FUNCTION(Map_GetInternals_fails_with_NULL_arg_3)
2066 {
2067 ///arrange
2068 const char*const* keys;
2069 size_t size;
2070 MAP_RESULT result;
2071 MAP_HANDLE handle = Map_Create(NULL);
2072 umock_c_reset_all_calls();
2073
2074 ///act
2075 result = Map_GetInternals(handle, &keys, NULL, &size);
2076
2077 ///assert
2078 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
2079 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2080
2081 ///cleanup
2082 Map_Destroy(handle);
2083 }
2084
2085 /*Tests_SRS_MAP_02_046: [If parameter handle, keys, values or count is NULL then Map_GetInternals shall return MAP_INVALIDARG.] */
2086 TEST_FUNCTION(Map_GetInternals_fails_with_NULL_arg_4)
2087 {
2088 ///arrange
2089 const char*const* keys;
2090 const char*const* values;
2091 MAP_RESULT result;
2092 MAP_HANDLE handle = Map_Create(NULL);
2093 umock_c_reset_all_calls();
2094
2095 ///act
2096 result = Map_GetInternals(handle, &keys, &values, NULL);
2097
2098 ///assert
2099 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_INVALIDARG, result);
2100 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2101
2102 ///cleanup
2103 Map_Destroy(handle);
2104 }
2105
2106 /*Tests_SRS_MAP_02_043: [Map_GetInternals shall produce in *keys an pointer to an array of const char* having all the keys stored so far by the map.]*/
2107 /*Tests_SRS_MAP_02_044: [Map_GetInternals shall produce in *values a pointer to an array of const char* having all the values stored so far by the map.]*/
2108 /*Tests_SRS_MAP_02_045: [ Map_GetInternals shall produce in *count the number of stored keys and values.]*/
2109 /*tested by every test in this suite... almost*/
2110
2111 /*Tests_SRS_MAP_02_038: [Map_Clone returns NULL if parameter handle is NULL.]*/
2112 TEST_FUNCTION(Map_Clone_with_NULL_handle_returns_NULL)
2113 {
2114 ///arrange
2115
2116 ///act
2117 MAP_HANDLE result = Map_Clone(NULL);
2118
2119 ///assert
2120 ASSERT_IS_NULL(result);
2121 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2122
2123 ///cleanup
2124 }
2125
2126 /*Tests_SRS_MAP_02_039: [Map_Clone shall make a copy of the map indicated by parameter handle and return a non-NULL handle to it.]*/
2127 TEST_FUNCTION(Map_Clone_with_empty_map_returns_empty_map)
2128 {
2129 ///arrange
2130 const char*const* keys;
2131 const char*const* values;
2132 size_t count;
2133 MAP_HANDLE result;
2134 MAP_HANDLE handle = Map_Create(NULL);
2135 umock_c_reset_all_calls();
2136
2137 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
2138 .IgnoreAllArguments();
2139
2140 ///act
2141 result = Map_Clone(handle);
2142
2143 ///assert
2144 ASSERT_IS_NOT_NULL(result);
2145 (void)Map_GetInternals(result, &keys, &values, &count);
2146 ASSERT_IS_NULL(keys);
2147 ASSERT_IS_NULL(values);
2148 ASSERT_ARE_EQUAL(size_t, 0, count);
2149 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2150
2151 ///cleanup
2152 Map_Destroy(handle);
2153 Map_Destroy(result);
2154 }
2155
2156 /*Tests_SRS_MAP_02_039: [Map_Clone shall make a copy of the map indicated by parameter handle and return a non-NULL handle to it.]*/
2157 TEST_FUNCTION(Map_Clone_with_empty_fails_when_malloc_fails)
2158 {
2159 ///arrange
2160 MAP_HANDLE result;
2161 MAP_HANDLE handle = Map_Create(NULL);
2162 umock_c_reset_all_calls();
2163
2164 whenShallcalloc_fail = currentcalloc_call + 1;
2165 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
2166 .IgnoreAllArguments();
2167
2168 ///act
2169 result = Map_Clone(handle);
2170
2171 ///assert
2172 ASSERT_IS_NULL(result);
2173 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2174
2175 ///cleanup
2176 Map_Destroy(handle);
2177 }
2178
2179 /*Tests_SRS_MAP_02_039: [Map_Clone shall make a copy of the map indicated by parameter handle and return a non-NULL handle to it.]*/
2180 TEST_FUNCTION(Map_Clone_with_map_with_1_element_succeeds)
2181 {
2182 ///arrange
2183 MAP_HANDLE result;
2184 const char*const* keys;
2185 const char*const* values;
2186 size_t count;
2187 MAP_HANDLE handle = Map_Create(NULL);
2188 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2189 umock_c_reset_all_calls();
2190
2191 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2192 .IgnoreAllArguments();
2193
2194 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for keys*/
2195
2196 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2197
2198 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for values*/
2199
2200 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*this is creating a clone of RED value*/
2201
2202 ///act
2203 result = Map_Clone(handle);
2204
2205 ///assert
2206 ASSERT_IS_NOT_NULL(result);
2207 (void)Map_GetInternals(result, &keys, &values, &count);
2208 ASSERT_IS_NOT_NULL(keys);
2209 ASSERT_IS_NOT_NULL(values);
2210 ASSERT_ARE_EQUAL(size_t, 1, count);
2211 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
2212 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
2213 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2214
2215 ///cleanup
2216 Map_Destroy(handle);
2217 Map_Destroy(result);
2218 }
2219
2220 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2221 TEST_FUNCTION(Map_Clone_with_map_with_1_element_fails_when_gbaloc_fails_1)
2222 {
2223 ///arrange
2224 MAP_HANDLE result;
2225 MAP_HANDLE handle = Map_Create(NULL);
2226 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2227 umock_c_reset_all_calls();
2228
2229 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2230 .IgnoreAllArguments();
2231
2232 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for keys*/
2233
2234 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2235
2236 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for values*/
2237
2238 whenShallmalloc_fail = currentmalloc_call + 4;
2239 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*this is creating a clone of RED value*/
2240
2241 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2242 .IgnoreArgument(1);
2243 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2244 .IgnoreArgument(1);
2245 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2246 .IgnoreArgument(1);
2247 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2248 .IgnoreArgument(1);
2249
2250 ///act
2251 result = Map_Clone(handle);
2252
2253 ///assert
2254 ASSERT_IS_NULL(result);
2255 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2256
2257 ///cleanup
2258 Map_Destroy(handle);
2259 Map_Destroy(result);
2260 }
2261
2262 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2263 TEST_FUNCTION(Map_Clone_with_map_with_1_element_fails_when_gbaloc_fails_2)
2264 {
2265 ///arrange
2266 MAP_HANDLE result;
2267 MAP_HANDLE handle = Map_Create(NULL);
2268 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2269 umock_c_reset_all_calls();
2270
2271 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2272 .IgnoreAllArguments();
2273
2274 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for keys*/
2275
2276 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2277
2278 whenShallmalloc_fail = currentmalloc_call + 3;
2279 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for values*/
2280
2281 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2282 .IgnoreArgument(1);
2283 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2284 .IgnoreArgument(1);
2285 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2286 .IgnoreArgument(1);
2287
2288 ///act
2289 result = Map_Clone(handle);
2290
2291 ///assert
2292 ASSERT_IS_NULL(result);
2293 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2294
2295 ///cleanup
2296 Map_Destroy(handle);
2297 Map_Destroy(result);
2298 }
2299
2300 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2301 TEST_FUNCTION(Map_Clone_with_map_with_1_element_fails_when_gbaloc_fails_3)
2302 {
2303 ///arrange
2304 MAP_HANDLE result;
2305 MAP_HANDLE handle = Map_Create(NULL);
2306 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2307 umock_c_reset_all_calls();
2308
2309 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2310 .IgnoreAllArguments();
2311
2312 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for keys*/
2313
2314 whenShallmalloc_fail = currentmalloc_call + 2;
2315 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2316
2317 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2318 .IgnoreArgument(1);
2319 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2320 .IgnoreArgument(1);
2321
2322 ///act
2323 result = Map_Clone(handle);
2324
2325 ///assert
2326 ASSERT_IS_NULL(result);
2327 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2328
2329 ///cleanup
2330 Map_Destroy(handle);
2331 Map_Destroy(result);
2332 }
2333
2334 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2335 TEST_FUNCTION(Map_Clone_with_map_with_1_element_fails_when_gbaloc_fails_4)
2336 {
2337 ///arrange
2338 MAP_HANDLE result;
2339 MAP_HANDLE handle = Map_Create(NULL);
2340 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2341 umock_c_reset_all_calls();
2342
2343 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2344 .IgnoreAllArguments();
2345 whenShallmalloc_fail = currentmalloc_call + 1;
2346 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(char*))); /*this is creating a clone of the storage for keys*/
2347 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2348 .IgnoreArgument(1);
2349
2350 ///act
2351 result = Map_Clone(handle);
2352
2353 ///assert
2354 ASSERT_IS_NULL(result);
2355 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2356
2357 ///cleanup
2358 Map_Destroy(handle);
2359 Map_Destroy(result);
2360 }
2361
2362 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2363 TEST_FUNCTION(Map_Clone_with_map_with_1_element_fails_when_gbaloc_fails_5)
2364 {
2365 ///arrange
2366 MAP_HANDLE result;
2367 MAP_HANDLE handle = Map_Create(NULL);
2368 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2369 umock_c_reset_all_calls();
2370
2371 whenShallcalloc_fail = currentcalloc_call + 1;
2372 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2373 .IgnoreAllArguments();
2374
2375 ///act
2376 result = Map_Clone(handle);
2377
2378 ///assert
2379 ASSERT_IS_NULL(result);
2380 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2381
2382 ///cleanup
2383 Map_Destroy(handle);
2384 Map_Destroy(result);
2385 }
2386
2387 /*Tests_SRS_MAP_02_039: [Map_Clone shall make a copy of the map indicated by parameter handle and return a non-NULL handle to it.]*/
2388 TEST_FUNCTION(Map_Clone_with_map_with_2_element_succeeds)
2389 {
2390 ///arrange
2391 MAP_HANDLE result;
2392 const char*const* keys;
2393 const char*const* values;
2394 size_t count;
2395 MAP_HANDLE handle = Map_Create(NULL);
2396 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2397 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2398 umock_c_reset_all_calls();
2399
2400 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2401 .IgnoreAllArguments();
2402
2403 STRICT_EXPECTED_CALL(gballoc_malloc(2*sizeof(char*))); /*this is creating a clone of the storage for keys*/
2404
2405 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2406 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*this is creating a clone of BLUE key*/
2407
2408 STRICT_EXPECTED_CALL(gballoc_malloc(2*sizeof(char*))); /*this is creating a clone of the storage for values*/
2409
2410 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*this is creating a clone of RED value*/
2411 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*this is creating a clone of RED value*/
2412
2413 ///act
2414 result = Map_Clone(handle);
2415
2416 ///assert
2417 ASSERT_IS_NOT_NULL(result);
2418 (void)Map_GetInternals(result, &keys, &values, &count);
2419 ASSERT_IS_NOT_NULL(keys);
2420 ASSERT_IS_NOT_NULL(values);
2421 ASSERT_ARE_EQUAL(size_t, 2, count);
2422 ASSERT_ARE_EQUAL(char_ptr, TEST_REDKEY, keys[0]);
2423 ASSERT_ARE_EQUAL(char_ptr, TEST_REDVALUE, values[0]);
2424 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEKEY, keys[1]);
2425 ASSERT_ARE_EQUAL(char_ptr, TEST_BLUEVALUE, values[1]);
2426 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2427
2428 ///cleanup
2429 Map_Destroy(handle);
2430 Map_Destroy(result);
2431 }
2432
2433 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2434 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_1)
2435 {
2436 ///arrange
2437 MAP_HANDLE result;
2438 MAP_HANDLE handle = Map_Create(NULL);
2439 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2440 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2441 umock_c_reset_all_calls();
2442
2443 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2444 .IgnoreAllArguments();
2445
2446 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2447
2448 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2449
2450 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*this is creating a clone of BLUE key*/
2451
2452 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for values*/
2453
2454 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*this is creating a clone of RED value*/
2455
2456 whenShallmalloc_fail = currentmalloc_call + 6;
2457 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEVALUE) + 1)); /*this is creating a clone of BLUE value*/
2458
2459 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2460 .IgnoreArgument(1);
2461 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2462 .IgnoreArgument(1);
2463 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2464 .IgnoreArgument(1);
2465 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2466 .IgnoreArgument(1);
2467 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2468 .IgnoreArgument(1);
2469 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2470 .IgnoreArgument(1);
2471
2472 ///act
2473 result = Map_Clone(handle);
2474
2475 ///assert
2476 ASSERT_IS_NULL(result);
2477 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2478
2479 ///cleanup
2480 Map_Destroy(handle);
2481 Map_Destroy(result);
2482 }
2483
2484 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2485 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_2)
2486 {
2487 ///arrange
2488 MAP_HANDLE result;
2489 MAP_HANDLE handle = Map_Create(NULL);
2490 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2491 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2492 umock_c_reset_all_calls();
2493
2494 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2495 .IgnoreAllArguments();
2496
2497 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2498
2499 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2500
2501 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*this is creating a clone of BLUE key*/
2502
2503 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for values*/
2504
2505 whenShallmalloc_fail = currentmalloc_call + 5;
2506 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDVALUE) + 1)); /*this is creating a clone of RED value*/
2507
2508 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2509 .IgnoreArgument(1);
2510 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2511 .IgnoreArgument(1);
2512 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2513 .IgnoreArgument(1);
2514 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2515 .IgnoreArgument(1);
2516 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2517 .IgnoreArgument(1);
2518
2519 ///act
2520 result = Map_Clone(handle);
2521
2522 ///assert
2523 ASSERT_IS_NULL(result);
2524 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2525
2526 ///cleanup
2527 Map_Destroy(handle);
2528 Map_Destroy(result);
2529 }
2530
2531 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2532 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_3)
2533 {
2534 ///arrange
2535 MAP_HANDLE result;
2536 MAP_HANDLE handle = Map_Create(NULL);
2537 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2538 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2539 umock_c_reset_all_calls();
2540
2541 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2542 .IgnoreAllArguments();
2543
2544 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2545
2546 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2547
2548 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*this is creating a clone of BLUE key*/
2549
2550 whenShallmalloc_fail = currentmalloc_call + 4;
2551 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for values*/
2552
2553 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2554 .IgnoreArgument(1);
2555 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2556 .IgnoreArgument(1);
2557 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2558 .IgnoreArgument(1);
2559 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2560 .IgnoreArgument(1);
2561
2562 ///act
2563 result = Map_Clone(handle);
2564
2565 ///assert
2566 ASSERT_IS_NULL(result);
2567 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2568
2569 ///cleanup
2570 Map_Destroy(handle);
2571 Map_Destroy(result);
2572 }
2573
2574 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2575 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_4)
2576 {
2577 ///arrange
2578 MAP_HANDLE result;
2579 MAP_HANDLE handle = Map_Create(NULL);
2580 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2581 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2582 umock_c_reset_all_calls();
2583
2584 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2585 .IgnoreAllArguments();
2586
2587 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2588
2589 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1)); /*this is creating a clone of RED key*/
2590
2591 whenShallmalloc_fail = currentmalloc_call + 3;
2592 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_BLUEKEY) + 1)); /*this is creating a clone of BLUE key*/
2593
2594 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2595 .IgnoreArgument(1);
2596 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2597 .IgnoreArgument(1);
2598 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2599 .IgnoreArgument(1);
2600
2601 ///act
2602 result = Map_Clone(handle);
2603
2604 ///assert
2605 ASSERT_IS_NULL(result);
2606 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2607
2608 ///cleanup
2609 Map_Destroy(handle);
2610 Map_Destroy(result);
2611 }
2612
2613 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2614 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_5)
2615 {
2616 ///arrange
2617 MAP_HANDLE result;
2618 MAP_HANDLE handle = Map_Create(NULL);
2619 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2620 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2621 umock_c_reset_all_calls();
2622
2623 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2624 .IgnoreAllArguments();
2625
2626 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2627
2628 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_REDKEY) + 1))
2629 .SetReturn(NULL); /*this is creating a clone of RED key*/
2630
2631 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2632 .IgnoreArgument(1);
2633 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2634 .IgnoreArgument(1);
2635
2636 ///act
2637 result = Map_Clone(handle);
2638
2639 ///assert
2640 ASSERT_IS_NULL(result);
2641 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2642
2643 ///cleanup
2644 Map_Destroy(handle);
2645 Map_Destroy(result);
2646 }
2647
2648 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2649 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_6)
2650 {
2651 ///arrange
2652 MAP_HANDLE result;
2653 MAP_HANDLE handle = Map_Create(NULL);
2654 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2655 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2656 umock_c_reset_all_calls();
2657
2658 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2659 .IgnoreAllArguments();
2660
2661 whenShallmalloc_fail = currentmalloc_call + 1;
2662 STRICT_EXPECTED_CALL(gballoc_malloc(2 * sizeof(char*))); /*this is creating a clone of the storage for keys*/
2663 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
2664 .IgnoreArgument(1);
2665
2666 ///act
2667 result = Map_Clone(handle);
2668
2669 ///assert
2670 ASSERT_IS_NULL(result);
2671 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2672
2673 ///cleanup
2674 Map_Destroy(handle);
2675 Map_Destroy(result);
2676 }
2677
2678 /*Tests_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
2679 TEST_FUNCTION(Map_Clone_with_map_with_2_element_fails_when_gballoc_fails_7)
2680 {
2681 ///arrange
2682 MAP_HANDLE result;
2683 MAP_HANDLE handle = Map_Create(NULL);
2684 (void)Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2685 (void)Map_AddOrUpdate(handle, TEST_BLUEKEY, TEST_BLUEVALUE);
2686 umock_c_reset_all_calls();
2687
2688 whenShallcalloc_fail = currentcalloc_call + 1;
2689 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)) /*this is creating the HANDLE structure*/
2690 .IgnoreAllArguments();
2691
2692 ///act
2693 result = Map_Clone(handle);
2694
2695 ///assert
2696 ASSERT_IS_NULL(result);
2697 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2698
2699 ///cleanup
2700 Map_Destroy(handle);
2701 Map_Destroy(result);
2702 }
2703
2704 /* Tests_SRS_MAP_07_009: [If the mapFilterCallback function is not NULL, then the return value will be check and if it is not zero then Map_Add shall return MAP_FILTER_REJECT.] */
2705 TEST_FUNCTION(Map_Add_With_Filter_Succeed)
2706 {
2707 ///arrange
2708 MAP_HANDLE handle = Map_Create(DontAllowCapitalsFilters);
2709 MAP_RESULT result1;
2710 MAP_RESULT result2;
2711 MAP_RESULT result3;
2712 umock_c_reset_all_calls();
2713
2714 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*)));
2715 STRICT_EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*)));
2716 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_GREENKEY) + 1));
2717 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_GREENVALUE) + 1));
2718
2719 ///act
2720 result1 = Map_Add(handle, TEST_REDKEY, TEST_REDVALUE);
2721 result2 = Map_Add(handle, TEST_YELLOWKEY, TEST_YELLOWVALUE);
2722 result3 = Map_Add(handle, TEST_GREENKEY, TEST_GREENVALUE);
2723
2724 ///assert
2725 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_FILTER_REJECT, result1);
2726 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_FILTER_REJECT, result2);
2727 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result3);
2728 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2729
2730 ///cleanup
2731 Map_Destroy(handle);
2732 }
2733
2734 /* Tests_SRS_MAP_07_008: [If the mapFilterCallback function is not NULL, then the return value will be check and if it is not zero then Map_AddOrUpdate shall return MAP_FILTER_REJECT.] */
2735 TEST_FUNCTION(Map_AddOrUpdate_With_Filter_Succeed)
2736 {
2737 ///arrange
2738 MAP_HANDLE handle = Map_Create(DontAllowCapitalsFilters);
2739 MAP_RESULT result1;
2740 MAP_RESULT result2;
2741 umock_c_reset_all_calls();
2742
2743 EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*)));
2744 EXPECTED_CALL(gballoc_realloc(NULL, sizeof(const char*)));
2745 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_GREENKEY) + 1));
2746 STRICT_EXPECTED_CALL(gballoc_malloc(strlen(TEST_GREENVALUE) + 1));
2747
2748 ///act
2749 result1 = Map_AddOrUpdate(handle, TEST_REDKEY, TEST_REDVALUE);
2750 result2 = Map_AddOrUpdate(handle, TEST_GREENKEY, TEST_GREENVALUE);
2751
2752 ///assert
2753 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_FILTER_REJECT, result1);
2754 ASSERT_ARE_EQUAL(MAP_RESULT, MAP_OK, result2);
2755 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2756
2757 ///cleanup
2758 Map_Destroy(handle);
2759 }
2760
2761 /*Tests_SRS_MAP_02_052: [If parameter handle is NULL then Map_ToJSON shall return NULL.] */
2762 TEST_FUNCTION(Map_ToJSON_fails_with_NULL_argument)
2763 {
2764 ///arrange
2765
2766 ///act
2767 STRING_HANDLE toJSON = Map_ToJSON(NULL);
2768
2769 ///assert
2770 ASSERT_IS_NULL(toJSON);
2771 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2772
2773 ///cleanup
2774 }
2775
2776 /*Tests_SRS_MAP_02_048: [Map_ToJSON shall produce a STRING_HANDLE representing the content of the MAP.]*/
2777 /*Tests_SRS_MAP_02_049: [If the MAP is empty, then Map_ToJSON shall produce the string "{}".] */
2778 TEST_FUNCTION(Map_ToJSON_with_empty_MAP_produces_empty_JSON)
2779 {
2780 ///arrange
2781 MAP_HANDLE handle = Map_Create(NULL);
2782 STRING_HANDLE toJSON;
2783 umock_c_reset_all_calls();
2784
2785 STRICT_EXPECTED_CALL(STRING_construct("{"))
2786 .IgnoreArgument(1);
2787
2788 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))
2789 .IgnoreArgument(1);
2790
2791 ///act
2792 toJSON = Map_ToJSON(handle);
2793
2794 ///assert
2795 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2796
2797 ///cleanup
2798 Map_Destroy(handle);
2799 STRING_delete(toJSON);
2800 }
2801
2802 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
2803 TEST_FUNCTION(Map_ToJSON_with_empty_MAP_produces_empty_JSON_fails_when_STRING_concat_fails)
2804 {
2805 ///arrange
2806 MAP_HANDLE handle = Map_Create(NULL);
2807 STRING_HANDLE toJSON;
2808 umock_c_reset_all_calls();
2809
2810 STRICT_EXPECTED_CALL(STRING_construct("{"))
2811 .IgnoreArgument(1);
2812
2813 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))
2814 .IgnoreArgument(1).SetReturn(1);
2815
2816 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
2817 .IgnoreArgument(1);
2818
2819 ///act
2820 toJSON = Map_ToJSON(handle);
2821
2822 ///assert
2823 ASSERT_IS_NULL(toJSON);
2824 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2825
2826 ///cleanup
2827 Map_Destroy(handle);
2828 }
2829
2830 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
2831 TEST_FUNCTION(Map_ToJSON_with_empty_MAP_produces_empty_JSON_fails_when_STRING_construct_fails)
2832 {
2833 ///arrange
2834 MAP_HANDLE handle = Map_Create(NULL);
2835 STRING_HANDLE toJSON;
2836 umock_c_reset_all_calls();
2837
2838 STRICT_EXPECTED_CALL(STRING_construct("{"))
2839 .IgnoreArgument(1).SetReturn(NULL);
2840
2841 ///act
2842 toJSON = Map_ToJSON(handle);
2843
2844 ///assert
2845 ASSERT_IS_NULL(toJSON);
2846 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2847
2848 ///cleanup
2849 Map_Destroy(handle);
2850 }
2851
2852 /*Tests_SRS_MAP_02_050: [If the map has properties then Map_ToJSON shall produce the following string:{"name1":"value1", "name2":"value2" ...}] */
2853 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_succeeds)
2854 {
2855 ///arrange
2856 MAP_HANDLE handle = Map_Create(NULL);
2857 STRING_HANDLE toJSON;
2858 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
2859 umock_c_reset_all_calls();
2860
2861 STRICT_EXPECTED_CALL(STRING_construct("{"))
2862 .IgnoreArgument(1);
2863
2864 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
2865 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
2866 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
2867 .IgnoreArgument(1)
2868 .IgnoreArgument(2);
2869 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
2870 .IgnoreArgument(1);
2871 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
2872 .IgnoreArgument(1)
2873 .IgnoreArgument(2);
2874
2875 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
2876 .IgnoreArgument(1);
2877 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
2878 .IgnoreArgument(1);
2879
2880 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))/*now JSON is {"redkey":"redoor"}*/
2881 .IgnoreArgument(1);
2882
2883 ///act
2884 toJSON = Map_ToJSON(handle);
2885
2886 ///assert
2887 ASSERT_IS_NOT_NULL(toJSON);
2888 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2889
2890 ///cleanup
2891 Map_Destroy(handle);
2892 STRING_delete(toJSON);
2893 }
2894
2895 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
2896 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_1)
2897 {
2898 ///arrange
2899 MAP_HANDLE handle = Map_Create(NULL);
2900 STRING_HANDLE toJSON;
2901 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
2902 umock_c_reset_all_calls();
2903
2904 STRICT_EXPECTED_CALL(STRING_construct("{"))
2905 .IgnoreArgument(1);
2906
2907 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
2908 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
2909 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
2910 .IgnoreArgument(1)
2911 .IgnoreArgument(2);
2912 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
2913 .IgnoreArgument(1);
2914 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
2915 .IgnoreArgument(1)
2916 .IgnoreArgument(2);
2917
2918 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
2919 .IgnoreArgument(1);
2920 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
2921 .IgnoreArgument(1);
2922
2923 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))/*now JSON is {"redkey":"redoor"}*/
2924 .IgnoreArgument(1).SetReturn(1);
2925
2926 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
2927 .IgnoreArgument(1);
2928
2929 ///act
2930 toJSON = Map_ToJSON(handle);
2931
2932 ///assert
2933 ASSERT_IS_NULL(toJSON);
2934 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2935
2936 ///cleanup
2937 Map_Destroy(handle);
2938 }
2939
2940 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
2941 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_2)
2942 {
2943 ///arrange
2944 MAP_HANDLE handle = Map_Create(NULL);
2945 STRING_HANDLE toJSON;
2946 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
2947 umock_c_reset_all_calls();
2948
2949 STRICT_EXPECTED_CALL(STRING_construct("{"))
2950 .IgnoreArgument(1);
2951
2952 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
2953 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
2954 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
2955 .IgnoreArgument(1)
2956 .IgnoreArgument(2);
2957 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
2958 .IgnoreArgument(1);
2959
2960 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
2961 .IgnoreArgument(1)
2962 .IgnoreArgument(2)
2963 .SetReturn(1);
2964
2965 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
2966 .IgnoreArgument(1);
2967 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
2968 .IgnoreArgument(1);
2969
2970 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
2971 .IgnoreArgument(1);
2972
2973 ///act
2974 toJSON = Map_ToJSON(handle);
2975
2976 ///assert
2977 ASSERT_IS_NULL(toJSON);
2978 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2979
2980 ///cleanup
2981 Map_Destroy(handle);
2982 }
2983
2984 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
2985 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_3)
2986 {
2987 ///arrange
2988 MAP_HANDLE handle = Map_Create(NULL);
2989 STRING_HANDLE toJSON;
2990 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
2991 umock_c_reset_all_calls();
2992
2993 STRICT_EXPECTED_CALL(STRING_construct("{"))
2994 .IgnoreArgument(1);
2995
2996 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
2997 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
2998 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
2999 .IgnoreArgument(1)
3000 .IgnoreArgument(2);
3001 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3002 .IgnoreArgument(1)
3003 .SetReturn(1);
3004
3005 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3006 .IgnoreArgument(1);
3007 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3008 .IgnoreArgument(1);
3009
3010 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3011 .IgnoreArgument(1);
3012
3013 ///act
3014 toJSON = Map_ToJSON(handle);
3015
3016 ///assert
3017 ASSERT_IS_NULL(toJSON);
3018 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3019
3020 ///cleanup
3021 Map_Destroy(handle);
3022 }
3023
3024 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3025 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_4)
3026 {
3027 ///arrange
3028 MAP_HANDLE handle = Map_Create(NULL);
3029 STRING_HANDLE toJSON;
3030 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3031 umock_c_reset_all_calls();
3032
3033 STRICT_EXPECTED_CALL(STRING_construct("{"))
3034 .IgnoreArgument(1);
3035
3036 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3037 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3038 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3039 .IgnoreArgument(1)
3040 .IgnoreArgument(2)
3041 .SetReturn(1);
3042
3043 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3044 .IgnoreArgument(1);
3045 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3046 .IgnoreArgument(1);
3047
3048 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3049 .IgnoreArgument(1);
3050
3051 ///act
3052 toJSON = Map_ToJSON(handle);
3053
3054 ///assert
3055 ASSERT_IS_NULL(toJSON);
3056 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3057
3058 ///cleanup
3059 Map_Destroy(handle);
3060 }
3061
3062 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3063 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_5)
3064 {
3065 ///arrange
3066 MAP_HANDLE handle = Map_Create(NULL);
3067 STRING_HANDLE toJSON;
3068 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3069 umock_c_reset_all_calls();
3070
3071 STRICT_EXPECTED_CALL(STRING_construct("{"))
3072 .IgnoreArgument(1);
3073
3074 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3075 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor"))
3076 .SetReturn(NULL); /*prepare the value*/
3077
3078 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3079 .IgnoreArgument(1);
3080
3081 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3082 .IgnoreArgument(1);
3083
3084 ///act
3085 toJSON = Map_ToJSON(handle);
3086
3087 ///assert
3088 ASSERT_IS_NULL(toJSON);
3089 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3090
3091 ///cleanup
3092 Map_Destroy(handle);
3093 }
3094
3095 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3096 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_6)
3097 {
3098 ///arrange
3099 MAP_HANDLE handle = Map_Create(NULL);
3100 STRING_HANDLE toJSON;
3101 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3102 umock_c_reset_all_calls();
3103
3104 STRICT_EXPECTED_CALL(STRING_construct("{"))
3105 .IgnoreArgument(1);
3106
3107 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")).SetReturn(NULL); /*prepare the key*/
3108
3109 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3110 .IgnoreArgument(1);
3111
3112 ///act
3113 toJSON = Map_ToJSON(handle);
3114
3115 ///assert
3116 ASSERT_IS_NULL(toJSON);
3117 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3118
3119 ///cleanup
3120 Map_Destroy(handle);
3121 }
3122
3123 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3124 TEST_FUNCTION(Map_ToJSON_with_1_MAP_element_fail_when_STRING_fails_7)
3125 {
3126 ///arrange
3127 MAP_HANDLE handle = Map_Create(NULL);
3128 STRING_HANDLE toJSON;
3129 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3130 umock_c_reset_all_calls();
3131
3132 STRICT_EXPECTED_CALL(STRING_construct("{"))
3133 .IgnoreArgument(1)
3134 .SetReturn(NULL);
3135
3136 ///act
3137 toJSON = Map_ToJSON(handle);
3138
3139 ///assert
3140 ASSERT_IS_NULL(toJSON);
3141 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3142
3143 ///cleanup
3144 Map_Destroy(handle);
3145 }
3146
3147 /*Tests_SRS_MAP_02_050: [If the map has properties then Map_ToJSON shall produce the following string:{"name1":"value1", "name2":"value2" ...}] */
3148 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_succeeds)
3149 {
3150 ///arrange
3151 MAP_HANDLE handle = Map_Create(NULL);
3152 STRING_HANDLE toJSON;
3153 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3154 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3155 umock_c_reset_all_calls();
3156
3157 STRICT_EXPECTED_CALL(STRING_construct("{"))
3158 .IgnoreArgument(1);
3159
3160 { /*artificial scope for first key:value*/
3161 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3162 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3163 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3164 .IgnoreArgument(1)
3165 .IgnoreArgument(2);
3166 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3167 .IgnoreArgument(1);
3168 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3169 .IgnoreArgument(1)
3170 .IgnoreArgument(2);
3171
3172 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3173 .IgnoreArgument(1);
3174 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3175 .IgnoreArgument(1);
3176 }
3177
3178 { /*artificial scope for second key:value*/
3179 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3180 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3181 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3182 .IgnoreArgument(1);
3183 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3184 .IgnoreArgument(1)
3185 .IgnoreArgument(2);
3186 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3187 .IgnoreArgument(1);
3188 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3189 .IgnoreArgument(1)
3190 .IgnoreArgument(2);
3191
3192 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3193 .IgnoreArgument(1);
3194 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3195 .IgnoreArgument(1);
3196 }
3197
3198 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))/*now JSON is {"redkey":"redoor"}*/
3199 .IgnoreArgument(1);
3200
3201 ///act
3202 toJSON = Map_ToJSON(handle);
3203
3204 ///assert
3205 ASSERT_IS_NOT_NULL(toJSON);
3206 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3207
3208 ///cleanup
3209 Map_Destroy(handle);
3210 STRING_delete(toJSON);
3211 }
3212
3213 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3214 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_1)
3215 {
3216 ///arrange
3217 MAP_HANDLE handle = Map_Create(NULL);
3218 STRING_HANDLE toJSON;
3219 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3220 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3221 umock_c_reset_all_calls();
3222
3223 STRICT_EXPECTED_CALL(STRING_construct("{"))
3224 .IgnoreArgument(1);
3225
3226 { /*artificial scope for first key:value*/
3227 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3228 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3229 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3230 .IgnoreArgument(1)
3231 .IgnoreArgument(2);
3232 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3233 .IgnoreArgument(1);
3234 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3235 .IgnoreArgument(1)
3236 .IgnoreArgument(2);
3237
3238 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3239 .IgnoreArgument(1);
3240 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3241 .IgnoreArgument(1);
3242 }
3243
3244 { /*artificial scope for second key:value*/
3245 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3246 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3247 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3248 .IgnoreArgument(1);
3249 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3250 .IgnoreArgument(1)
3251 .IgnoreArgument(2);
3252 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3253 .IgnoreArgument(1);
3254 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3255 .IgnoreArgument(1)
3256 .IgnoreArgument(2);
3257
3258 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3259 .IgnoreArgument(1);
3260 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3261 .IgnoreArgument(1);
3262 }
3263
3264 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, "}"))/*now JSON is {"redkey":"redoor"}*/
3265 .IgnoreArgument(1)
3266 .SetReturn(1);
3267
3268 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3269 .IgnoreArgument(1);
3270
3271 ///act
3272 toJSON = Map_ToJSON(handle);
3273
3274 ///assert
3275 ASSERT_IS_NULL(toJSON);
3276 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3277
3278 ///cleanup
3279 Map_Destroy(handle);
3280 }
3281
3282 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3283 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_2)
3284 {
3285 ///arrange
3286 MAP_HANDLE handle = Map_Create(NULL);
3287 STRING_HANDLE toJSON;
3288 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3289 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3290 umock_c_reset_all_calls();
3291
3292 STRICT_EXPECTED_CALL(STRING_construct("{"))
3293 .IgnoreArgument(1);
3294
3295 { /*artificial scope for first key:value*/
3296 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3297 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3298 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3299 .IgnoreArgument(1)
3300 .IgnoreArgument(2);
3301 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3302 .IgnoreArgument(1);
3303 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3304 .IgnoreArgument(1)
3305 .IgnoreArgument(2);
3306
3307 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3308 .IgnoreArgument(1);
3309 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3310 .IgnoreArgument(1);
3311 }
3312
3313 { /*artificial scope for second key:value*/
3314 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3315 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3316 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3317 .IgnoreArgument(1);
3318 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3319 .IgnoreArgument(1)
3320 .IgnoreArgument(2);
3321 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3322 .IgnoreArgument(1);
3323 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3324 .IgnoreArgument(1)
3325 .IgnoreArgument(2)
3326 .SetReturn(1);
3327
3328 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3329 .IgnoreArgument(1);
3330 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3331 .IgnoreArgument(1);
3332 }
3333
3334 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3335 .IgnoreArgument(1);
3336
3337 ///act
3338 toJSON = Map_ToJSON(handle);
3339
3340 ///assert
3341 ASSERT_IS_NULL(toJSON);
3342 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3343
3344 ///cleanup
3345 Map_Destroy(handle);
3346 }
3347
3348 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3349 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_3)
3350 {
3351 ///arrange
3352 MAP_HANDLE handle = Map_Create(NULL);
3353 STRING_HANDLE toJSON;
3354 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3355 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3356 umock_c_reset_all_calls();
3357
3358 STRICT_EXPECTED_CALL(STRING_construct("{"))
3359 .IgnoreArgument(1);
3360
3361 { /*artificial scope for first key:value*/
3362 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3363 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3364 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3365 .IgnoreArgument(1)
3366 .IgnoreArgument(2);
3367 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3368 .IgnoreArgument(1);
3369 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3370 .IgnoreArgument(1)
3371 .IgnoreArgument(2);
3372
3373 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3374 .IgnoreArgument(1);
3375 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3376 .IgnoreArgument(1);
3377 }
3378
3379 { /*artificial scope for second key:value*/
3380 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3381 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3382 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3383 .IgnoreArgument(1);
3384 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3385 .IgnoreArgument(1)
3386 .IgnoreArgument(2);
3387 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3388 .IgnoreArgument(1)
3389 .SetReturn(1);
3390
3391 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3392 .IgnoreArgument(1);
3393 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3394 .IgnoreArgument(1);
3395 }
3396
3397 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3398 .IgnoreArgument(1);
3399
3400 ///act
3401 toJSON = Map_ToJSON(handle);
3402
3403 ///assert
3404 ASSERT_IS_NULL(toJSON);
3405 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3406
3407 ///cleanup
3408 Map_Destroy(handle);
3409 }
3410
3411 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3412 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_4)
3413 {
3414 ///arrange
3415 MAP_HANDLE handle = Map_Create(NULL);
3416 STRING_HANDLE toJSON;
3417 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3418 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3419 umock_c_reset_all_calls();
3420
3421 STRICT_EXPECTED_CALL(STRING_construct("{"))
3422 .IgnoreArgument(1);
3423
3424 { /*artificial scope for first key:value*/
3425 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3426 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3427 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3428 .IgnoreArgument(1)
3429 .IgnoreArgument(2);
3430 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3431 .IgnoreArgument(1);
3432 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3433 .IgnoreArgument(1)
3434 .IgnoreArgument(2);
3435
3436 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3437 .IgnoreArgument(1);
3438 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3439 .IgnoreArgument(1);
3440 }
3441
3442 { /*artificial scope for second key:value*/
3443 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3444 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3445 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3446 .IgnoreArgument(1);
3447
3448 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3449 .IgnoreArgument(1)
3450 .IgnoreArgument(2)
3451 .SetReturn(1);
3452
3453 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3454 .IgnoreArgument(1);
3455 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3456 .IgnoreArgument(1);
3457 }
3458
3459 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3460 .IgnoreArgument(1);
3461
3462 ///act
3463 toJSON = Map_ToJSON(handle);
3464
3465 ///assert
3466 ASSERT_IS_NULL(toJSON);
3467 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3468
3469 ///cleanup
3470 Map_Destroy(handle);
3471 }
3472
3473 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3474 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_5)
3475 {
3476 ///arrange
3477 MAP_HANDLE handle = Map_Create(NULL);
3478 STRING_HANDLE toJSON;
3479 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3480 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3481 umock_c_reset_all_calls();
3482
3483 STRICT_EXPECTED_CALL(STRING_construct("{"))
3484 .IgnoreArgument(1);
3485
3486 { /*artificial scope for first key:value*/
3487 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3488 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3489 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3490 .IgnoreArgument(1)
3491 .IgnoreArgument(2);
3492 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3493 .IgnoreArgument(1);
3494 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3495 .IgnoreArgument(1)
3496 .IgnoreArgument(2);
3497
3498 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3499 .IgnoreArgument(1);
3500 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3501 .IgnoreArgument(1);
3502 }
3503
3504 { /*artificial scope for second key:value*/
3505 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3506 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")); /*prepare the value*/
3507 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ","))
3508 .IgnoreArgument(1).SetReturn(1);
3509
3510 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3511 .IgnoreArgument(1);
3512 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3513 .IgnoreArgument(1);
3514 }
3515
3516 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3517 .IgnoreArgument(1);
3518
3519 ///act
3520 toJSON = Map_ToJSON(handle);
3521
3522 ///assert
3523 ASSERT_IS_NULL(toJSON);
3524 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3525
3526 ///cleanup
3527 Map_Destroy(handle);
3528 }
3529
3530 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3531 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_6)
3532 {
3533 ///arrange
3534 MAP_HANDLE handle = Map_Create(NULL);
3535 STRING_HANDLE toJSON;
3536 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3537 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3538 umock_c_reset_all_calls();
3539
3540 STRICT_EXPECTED_CALL(STRING_construct("{"))
3541 .IgnoreArgument(1);
3542
3543 { /*artificial scope for first key:value*/
3544 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3545 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3546 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3547 .IgnoreArgument(1)
3548 .IgnoreArgument(2);
3549 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3550 .IgnoreArgument(1);
3551 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3552 .IgnoreArgument(1)
3553 .IgnoreArgument(2);
3554 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3555 .IgnoreArgument(1);
3556 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3557 .IgnoreArgument(1);
3558 }
3559
3560 { /*artificial scope for second key:value*/
3561 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")); /*prepare the key*/
3562 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowdoor")).SetReturn(NULL); /*prepare the value*/
3563 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3564 .IgnoreArgument(1);
3565 }
3566
3567 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3568 .IgnoreArgument(1);
3569
3570 ///act
3571 toJSON = Map_ToJSON(handle);
3572
3573 ///assert
3574 ASSERT_IS_NULL(toJSON);
3575 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3576
3577 ///cleanup
3578 Map_Destroy(handle);
3579 }
3580
3581 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3582 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_7)
3583 {
3584 ///arrange
3585 MAP_HANDLE handle = Map_Create(NULL);
3586 STRING_HANDLE toJSON;
3587 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3588 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3589 umock_c_reset_all_calls();
3590
3591 STRICT_EXPECTED_CALL(STRING_construct("{"))
3592 .IgnoreArgument(1);
3593
3594 { /*artificial scope for first key:value*/
3595 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3596 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3597 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3598 .IgnoreArgument(1)
3599 .IgnoreArgument(2);
3600 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3601 .IgnoreArgument(1);
3602 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3603 .IgnoreArgument(1)
3604 .IgnoreArgument(2);
3605 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3606 .IgnoreArgument(1);
3607 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3608 .IgnoreArgument(1);
3609 }
3610
3611 { /*artificial scope for second key:value*/
3612 STRICT_EXPECTED_CALL(STRING_new_JSON("yellowkey")).SetReturn(NULL); /*prepare the key*/
3613 }
3614
3615 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3616 .IgnoreArgument(1);
3617
3618 ///act
3619 toJSON = Map_ToJSON(handle);
3620
3621 ///assert
3622 ASSERT_IS_NULL(toJSON);
3623 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3624
3625 ///cleanup
3626 Map_Destroy(handle);
3627 }
3628
3629 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3630 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_8)
3631 {
3632 ///arrange
3633 MAP_HANDLE handle = Map_Create(NULL);
3634 STRING_HANDLE toJSON;
3635 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3636 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3637 umock_c_reset_all_calls();
3638
3639 STRICT_EXPECTED_CALL(STRING_construct("{"))
3640 .IgnoreArgument(1);
3641
3642 { /*artificial scope for first key:value*/
3643 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3644 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3645 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3646 .IgnoreArgument(1)
3647 .IgnoreArgument(2);
3648 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3649 .IgnoreArgument(1);
3650 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3651 .IgnoreArgument(1)
3652 .IgnoreArgument(2)
3653 .SetReturn(1);
3654 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3655 .IgnoreArgument(1);
3656 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3657 .IgnoreArgument(1);
3658 }
3659
3660 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3661 .IgnoreArgument(1);
3662
3663 ///act
3664 toJSON = Map_ToJSON(handle);
3665
3666 ///assert
3667 ASSERT_IS_NULL(toJSON);
3668 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3669
3670 ///cleanup
3671 Map_Destroy(handle);
3672 }
3673
3674 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3675 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_9)
3676 {
3677 ///arrange
3678 MAP_HANDLE handle = Map_Create(NULL);
3679 STRING_HANDLE toJSON;
3680 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3681 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3682 umock_c_reset_all_calls();
3683
3684 STRICT_EXPECTED_CALL(STRING_construct("{"))
3685 .IgnoreArgument(1);
3686
3687 { /*artificial scope for first key:value*/
3688 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3689 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3690 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3691 .IgnoreArgument(1)
3692 .IgnoreArgument(2);
3693 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3694 .IgnoreArgument(1);
3695 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey":"reddoor"*/
3696 .IgnoreArgument(1)
3697 .IgnoreArgument(2)
3698 .SetReturn(1);
3699 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3700 .IgnoreArgument(1);
3701 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3702 .IgnoreArgument(1);
3703 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3704 .IgnoreArgument(1);
3705 }
3706
3707 ///act
3708 toJSON = Map_ToJSON(handle);
3709
3710 ///assert
3711 ASSERT_IS_NULL(toJSON);
3712 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3713
3714 ///cleanup
3715 Map_Destroy(handle);
3716 }
3717
3718 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3719 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_10)
3720 {
3721 ///arrange
3722 MAP_HANDLE handle = Map_Create(NULL);
3723 STRING_HANDLE toJSON;
3724 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3725 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3726 umock_c_reset_all_calls();
3727
3728 STRICT_EXPECTED_CALL(STRING_construct("{"))
3729 .IgnoreArgument(1);
3730
3731 { /*artificial scope for first key:value*/
3732 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3733 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3734 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3735 .IgnoreArgument(1)
3736 .IgnoreArgument(2);
3737 STRICT_EXPECTED_CALL(STRING_concat(IGNORED_PTR_ARG, ":")) /*now JSON is {"redkey":*/
3738 .IgnoreArgument(1)
3739 .SetReturn(1);
3740 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3741 .IgnoreArgument(1);
3742 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3743 .IgnoreArgument(1);
3744 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3745 .IgnoreArgument(1);
3746 }
3747
3748 ///act
3749 toJSON = Map_ToJSON(handle);
3750
3751 ///assert
3752 ASSERT_IS_NULL(toJSON);
3753 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3754
3755 ///cleanup
3756 Map_Destroy(handle);
3757 }
3758
3759 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3760 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_11)
3761 {
3762 ///arrange
3763 MAP_HANDLE handle = Map_Create(NULL);
3764 STRING_HANDLE toJSON;
3765 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3766 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3767 umock_c_reset_all_calls();
3768
3769 STRICT_EXPECTED_CALL(STRING_construct("{"))
3770 .IgnoreArgument(1);
3771
3772 { /*artificial scope for first key:value*/
3773 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3774 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")); /*prepare the value*/
3775 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) /*now JSON is {"redkey"*/
3776 .IgnoreArgument(1)
3777 .IgnoreArgument(2)
3778 .SetReturn(1);
3779 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3780 .IgnoreArgument(1);
3781 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the value*/
3782 .IgnoreArgument(1);
3783 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3784 .IgnoreArgument(1);
3785 }
3786
3787 ///act
3788 toJSON = Map_ToJSON(handle);
3789
3790 ///assert
3791 ASSERT_IS_NULL(toJSON);
3792 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3793
3794 ///cleanup
3795 Map_Destroy(handle);
3796 }
3797
3798 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3799 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_12)
3800 {
3801 ///arrange
3802 MAP_HANDLE handle = Map_Create(NULL);
3803 STRING_HANDLE toJSON;
3804 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3805 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3806 umock_c_reset_all_calls();
3807
3808 STRICT_EXPECTED_CALL(STRING_construct("{"))
3809 .IgnoreArgument(1);
3810
3811 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")); /*prepare the key*/
3812 STRICT_EXPECTED_CALL(STRING_new_JSON("reddoor")).SetReturn(NULL); /*prepare the value*/
3813 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*delete the key*/
3814 .IgnoreArgument(1);
3815 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3816 .IgnoreArgument(1);
3817
3818 ///act
3819 toJSON = Map_ToJSON(handle);
3820
3821 ///assert
3822 ASSERT_IS_NULL(toJSON);
3823 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3824
3825 ///cleanup
3826 Map_Destroy(handle);
3827 }
3828
3829 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3830 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_13)
3831 {
3832 ///arrange
3833 MAP_HANDLE handle = Map_Create(NULL);
3834 STRING_HANDLE toJSON;
3835 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3836 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3837 umock_c_reset_all_calls();
3838
3839 STRICT_EXPECTED_CALL(STRING_construct("{"))
3840 .IgnoreArgument(1);
3841 STRICT_EXPECTED_CALL(STRING_new_JSON("redkey")).SetReturn(NULL); /*prepare the key*/
3842 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
3843 .IgnoreArgument(1);
3844
3845 ///act
3846 toJSON = Map_ToJSON(handle);
3847
3848 ///assert
3849 ASSERT_IS_NULL(toJSON);
3850 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3851
3852 ///cleanup
3853 Map_Destroy(handle);
3854 }
3855
3856 /*Tests_SRS_MAP_02_051: [If any error occurs while producing the output, then Map_ToJSON shall fail and return NULL.] */
3857 TEST_FUNCTION(Map_ToJSON_with_2_MAP_elements_fails_when_STRING_fails_14)
3858 {
3859 ///arrange
3860 MAP_HANDLE handle = Map_Create(NULL);
3861 STRING_HANDLE toJSON;
3862 (void)Map_AddOrUpdate(handle, "redkey", "reddoor");
3863 (void)Map_AddOrUpdate(handle, "yellowkey", "yellowdoor");
3864 umock_c_reset_all_calls();
3865
3866 STRICT_EXPECTED_CALL(STRING_construct("{"))
3867 .IgnoreArgument(1)
3868 .SetReturn(NULL);
3869
3870 ///act
3871 toJSON = Map_ToJSON(handle);
3872
3873 ///assert
3874 ASSERT_IS_NULL(toJSON);
3875 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3876
3877 ///cleanup
3878 Map_Destroy(handle);
3879 }
3880
3881
3882 END_TEST_SUITE(map_unittests)