Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/constmap_ut/constmap_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 #include <cstring>
7 #else
8 #include <stdlib.h>
9 #include <string.h>
10 #endif
11
12 #include "azure_macro_utils/macro_utils.h"
13 #include "testrunnerswitcher.h"
14
15 static size_t currentmalloc_call;
16 static size_t whenShallmalloc_fail;
17
18 void* my_gballoc_malloc(size_t size)
19 {
20 void* result;
21 currentmalloc_call++;
22 if (whenShallmalloc_fail > 0)
23 {
24 if (currentmalloc_call == whenShallmalloc_fail)
25 {
26 result = NULL;
27 }
28 else
29 {
30 result = malloc(size);
31 }
32 }
33 else
34 {
35 result = malloc(size);
36 }
37 return result;
38 }
39
40 void my_gballoc_free(void* ptr)
41 {
42 free(ptr);
43 }
44
45 #define ENABLE_MOCKS
46 #include "umock_c/umock_c.h"
47 #include "umock_c/umocktypes_charptr.h"
48 #include "azure_c_shared_utility/map.h"
49 #include "azure_c_shared_utility/gballoc.h"
50
51 #undef ENABLE_MOCKS
52 #include "azure_c_shared_utility/constmap.h"
53
54 static TEST_MUTEX_HANDLE g_testByTest;
55
56 TEST_DEFINE_ENUM_TYPE(CONSTMAP_RESULT, CONSTMAP_RESULT_VALUES);
57
58 #define VALID_MAP_HANDLE (MAP_HANDLE)0xDEAF
59 #define VALID_CONST_CHAR_POINTER (const char*const*)0xDADA
60 #define VALID_MAP_CLONE1 (MAP_HANDLE)0xDEDE
61 #define VALID_MAP_CLONE2 (MAP_HANDLE)0xDEDD
62 #define INVALID_MAP_HANDLE (MAP_HANDLE)0xDEAD
63 #define INVALID_CLONE_HANDLE (MAP_HANDLE)0xDEAE
64 #define VALID_KV_COUNT (size_t)100
65 #define VALID_VALUE "value"
66
67 static MAP_RESULT currentMapResult;
68
69 MAP_HANDLE my_Map_Clone(MAP_HANDLE sourceMap)
70 {
71 MAP_HANDLE result;
72
73 if (sourceMap == VALID_MAP_HANDLE)
74 {
75 result = VALID_MAP_CLONE1;
76 }
77 else if (sourceMap == VALID_MAP_CLONE1)
78 {
79 result = VALID_MAP_CLONE2;
80 }
81 else if (sourceMap == INVALID_CLONE_HANDLE)
82 {
83 result = INVALID_MAP_HANDLE;
84 }
85 else
86 {
87 result = NULL;
88 }
89
90 return result;
91 }
92
93 MAP_RESULT my_Map_ContainsKey(MAP_HANDLE handle, const char* key, bool* keyExists)
94 {
95 MAP_RESULT result = currentMapResult;
96 (void)handle, (void)key;
97 if (result == MAP_OK)
98 {
99 *keyExists = true;
100 }
101 return result;
102 }
103
104 MAP_RESULT my_Map_ContainsValue(MAP_HANDLE handle, const char* value, bool* valueExists)
105 {
106 MAP_RESULT result = currentMapResult;
107 (void)handle, (void)value;
108 if (result == MAP_OK)
109 {
110 *valueExists = true;
111 }
112 return result;
113 }
114
115 const char* my_Map_GetValueFromKey(MAP_HANDLE sourceMap, const char* key)
116 {
117 const char* result;
118 (void)key, (void)sourceMap;
119 if (currentMapResult == MAP_OK)
120 {
121 result = VALID_VALUE;
122 }
123 else
124 {
125 result = NULL;
126 }
127 return result;
128 }
129
130 MAP_RESULT my_Map_GetInternals(MAP_HANDLE handle, const char*const** keys, const char*const** values, size_t* count)
131 {
132 MAP_RESULT result = currentMapResult;
133 (void)handle;
134 *keys = VALID_CONST_CHAR_POINTER;
135 *values = VALID_CONST_CHAR_POINTER;
136 *count = VALID_KV_COUNT;
137 return result;
138 }
139
140 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
141
142 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
143 {
144 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
145 }
146
147 BEGIN_TEST_SUITE(constmap_unittests)
148
149 TEST_SUITE_INITIALIZE(TestClassInitialize)
150 {
151 int result;
152 g_testByTest = TEST_MUTEX_CREATE();
153 ASSERT_IS_NOT_NULL(g_testByTest);
154
155 umock_c_init(on_umock_c_error);
156
157 REGISTER_UMOCK_ALIAS_TYPE(CONSTMAP_HANDLE, void*);
158 REGISTER_UMOCK_ALIAS_TYPE(MAP_HANDLE, void*);
159 result = umocktypes_charptr_register_types();
160 ASSERT_ARE_EQUAL(int, 0, result);
161
162 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
163 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
164 REGISTER_GLOBAL_MOCK_HOOK(Map_Clone, my_Map_Clone);
165 REGISTER_GLOBAL_MOCK_HOOK(Map_ContainsKey, my_Map_ContainsKey);
166 REGISTER_GLOBAL_MOCK_HOOK(Map_ContainsValue, my_Map_ContainsValue);
167 REGISTER_GLOBAL_MOCK_HOOK(Map_GetValueFromKey, my_Map_GetValueFromKey);
168 REGISTER_GLOBAL_MOCK_HOOK(Map_GetInternals, my_Map_GetInternals);
169 }
170
171 TEST_SUITE_CLEANUP(TestClassCleanup)
172 {
173 umock_c_deinit();
174
175 TEST_MUTEX_DESTROY(g_testByTest);
176 }
177
178 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
179 {
180 if (TEST_MUTEX_ACQUIRE(g_testByTest))
181 {
182 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
183 }
184 currentmalloc_call = 0;
185 whenShallmalloc_fail = 0;
186 currentMapResult = MAP_OK;
187
188 umock_c_reset_all_calls();
189 }
190
191 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
192 {
193 TEST_MUTEX_RELEASE(g_testByTest);
194 }
195
196 /*Tests_SRS_CONSTMAP_17_001: [ConstMap_Create shall create an immutable map, populated by the key, value pairs in the source map.]*/
197 /*Tests_SRS_CONSTMAP_17_048: [ConstMap_Create shall accept any non-NULL MAP_HANDLE as input.]*/
198 /*Tests_SRS_CONSTMAP_17_003: [Otherwise, it shall return a non-NULL handle that can be used in subsequent calls.]*/
199 /*Tests_SRS_CONSTMAP_17_004: [If the reference count is zero, ConstMap_Destroy shall release all resources associated with the immutable map.]*/
200 TEST_FUNCTION(ConstMap_Create_Destroy_Success)
201 {
202 // Arrange
203 MAP_HANDLE sourceMap;
204 CONSTMAP_HANDLE aHandle;
205 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
206 .IgnoreArgument(1);
207 STRICT_EXPECTED_CALL(Map_Clone(VALID_MAP_HANDLE));
208
209 STRICT_EXPECTED_CALL(Map_Destroy(VALID_MAP_CLONE1));
210 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
211 .IgnoreArgument(1);
212
213 sourceMap = VALID_MAP_HANDLE;
214
215 ///Act
216 aHandle = ConstMap_Create(sourceMap);
217
218 ASSERT_IS_NOT_NULL(aHandle);
219
220 ConstMap_Destroy(aHandle);
221
222 ///Assert
223 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
224
225 //Ablution
226
227 }
228
229 /* Tests_SRS_CONSTMAP_17_002: [If during creation there are any errors, then ConstMap_Create shall return NULL.]*/
230 TEST_FUNCTION(ConstMap_Create_Malloc_Failed)
231 {
232 // Arrange
233 MAP_HANDLE sourceMap;
234 CONSTMAP_HANDLE aHandle;
235 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
236 .IgnoreArgument(1);
237 whenShallmalloc_fail = 1;
238
239 sourceMap = VALID_MAP_HANDLE;
240
241 ///Act
242 aHandle = ConstMap_Create(sourceMap);
243
244 ///Assert
245 ASSERT_IS_NULL(aHandle);
246
247 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
248
249 //Ablution
250
251 }
252
253 /*Tests_SRS_CONSTMAP_17_002: [If during creation there are any errors, then ConstMap_Create shall return NULL.] */
254 TEST_FUNCTION(ConstMap_Clone_Map_Failed)
255 {
256 // Arrange
257 MAP_HANDLE sourceMap;
258 CONSTMAP_HANDLE aHandle;
259 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
260 .IgnoreArgument(1);
261 STRICT_EXPECTED_CALL(Map_Clone(INVALID_MAP_HANDLE));
262 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
263 .IgnoreArgument(1);
264
265 sourceMap = INVALID_MAP_HANDLE;
266
267 ///Act
268 aHandle = ConstMap_Create(sourceMap);
269
270 ///Assert
271 ASSERT_IS_NULL(aHandle);
272
273 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
274
275 //Ablution
276
277 }
278
279 /*Tests_SRS_CONSTMAP_17_039: [ConstMap_Clone shall increase the internal reference count of the immutable map indicated by parameter handle] */
280 TEST_FUNCTION(ConstMap_Clone_Destroy_Success)
281 {
282 // Arrange
283 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
284 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
285 CONSTMAP_HANDLE aClone = ConstMap_Clone(aHandle);
286
287 umock_c_reset_all_calls();
288
289 ///Act
290 ConstMap_Destroy(aClone);
291
292 ///Assert
293 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
294
295 //Ablution
296 ConstMap_Destroy(aHandle);
297
298 }
299 /*Tests_SRS_CONSTMAP_17_005: [If parameter handle is NULL then ConstMap_Destroy shall take no action.]*/
300 TEST_FUNCTION(ConstMap_Destroy_Null)
301 {
302 ///Arrange
303 CONSTMAP_HANDLE handle = NULL;
304
305 ///Act
306 ConstMap_Destroy(handle);
307
308 ///Assert
309 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
310
311 ///Ablution
312 }
313
314 /*Tests_SRS_CONSTMAP_17_039: [ConstMap_Clone shall increase the internal reference count of the immutable map indicated by parameter handle]*/
315 /*Tests_SRS_CONSTMAP_17_050: [ConstMap_Clone shall return the non-NULL handle. ]*/
316 TEST_FUNCTION(ConstMap_Clone_Success)
317 {
318 // Arrange
319 CONSTMAP_HANDLE aClone;
320 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
321 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
322
323 umock_c_reset_all_calls();
324
325 ///Act
326 aClone = ConstMap_Clone(aHandle);
327
328 ///Assert
329 ASSERT_ARE_EQUAL(void_ptr, aHandle, aClone);
330
331 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
332
333 //Ablution
334 ConstMap_Destroy(aClone);
335 ConstMap_Destroy(aHandle);
336
337 }
338
339 /*Tests_SRS_CONSTMAP_17_038: [ConstMap_Clone returns NULL if parameter handle is NULL.] */
340 TEST_FUNCTION(ConstMap_Clone_Null)
341 {
342 // Arrange
343 CONSTMAP_HANDLE aHandle = NULL;
344
345 ///Act
346 CONSTMAP_HANDLE aClone = ConstMap_Clone(aHandle);
347
348 ///Assert
349 ASSERT_IS_NULL(aClone);
350 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
351
352 //Ablution
353 }
354
355 /*Tests_SRS_CONSTMAP_17_052: [ConstMap_CloneWriteable shall create a new, writeable map, populated by the key, value pairs in the parameter defined by handle.]*/
356 /*Tests_SRS_CONSTMAP_17_054: [Otherwise, ConstMap_CloneWriteable shall return a non-NULL handle that can be used in subsequent calls.]*/
357 TEST_FUNCTION(ConstMap_CloneWritable_Success)
358 {
359 // Arrange
360 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
361 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
362 MAP_HANDLE newMap = NULL;
363
364 umock_c_reset_all_calls();
365
366 STRICT_EXPECTED_CALL(Map_Clone(VALID_MAP_CLONE1)).IgnoreArgument(1);
367
368 //Act
369 newMap = ConstMap_CloneWriteable(aHandle);
370
371 //Assert
372 ASSERT_ARE_EQUAL(void_ptr, VALID_MAP_CLONE2, newMap);
373
374 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
375
376 //Ablution
377 ConstMap_Destroy(aHandle);
378 Map_Destroy(sourceMap);
379 Map_Destroy(newMap);
380 }
381
382 /*Tests_SRS_CONSTMAP_17_053: [If during cloning, any operation fails, then ConstMap_CloneWriteableap_Clone shall return NULL.]*/
383 TEST_FUNCTION(ConstMap_CloneWritable_Fail)
384 {
385 // Arrange
386 MAP_HANDLE sourceMap = INVALID_CLONE_HANDLE;
387 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
388 MAP_HANDLE newMap = NULL;
389
390 umock_c_reset_all_calls();
391
392 STRICT_EXPECTED_CALL(Map_Clone(INVALID_MAP_HANDLE)).IgnoreArgument(1);
393
394 //Act
395 newMap = ConstMap_CloneWriteable(aHandle);
396
397 //Assert
398 ASSERT_IS_NULL(newMap);
399
400 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
401
402 //Ablution
403 ConstMap_Destroy(aHandle);
404 Map_Destroy(sourceMap);
405 }
406
407 /*Tests_SRS_CONSTMAP_17_051: [ConstMap_CloneWriteable returns NULL if parameter handle is NULL. ]*/
408 TEST_FUNCTION(ConstMap_CloneWritable_NULL)
409 {
410 // Arrange
411 MAP_HANDLE newMap = NULL;
412
413 //Act
414 newMap = ConstMap_CloneWriteable(NULL);
415
416 //Assert
417 ASSERT_IS_NULL(newMap);
418
419 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
420
421 //Ablution
422 }
423
424
425 /*Tests_SRS_CONSTMAP_17_025: [Otherwise if a key exists then ConstMap_ContainsKey shall return true.]*/
426 TEST_FUNCTION(ConstMap_ContainsKey_Success)
427 {
428 // Arrange
429 const char * key = "aKey";
430 bool keyExists;
431
432 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
433 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
434
435 umock_c_reset_all_calls();
436
437 // Call to Map
438 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
439 .IgnoreArgument(1).IgnoreArgument(3);
440
441 ///Act
442 keyExists = ConstMap_ContainsKey(aHandle, key);
443
444
445 ///Assert
446 ASSERT_IS_TRUE(keyExists);
447
448 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
449
450 //Ablution
451 ConstMap_Destroy(aHandle);
452 }
453
454 /*Tests_SRS_CONSTMAP_17_024: [If parameter handle or key are NULL then ConstMap_ContainsKey shall return false.]*/
455 TEST_FUNCTION(ConstMap_ContainsKey_Null)
456 {
457 // Arrange
458 const char * key1 = "aKey";
459 const char * key2 = NULL;
460 bool keyExists1;
461 bool keyExists2;
462 CONSTMAP_HANDLE aHandle1 = NULL;
463 CONSTMAP_HANDLE aHandle2;
464 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
465
466 aHandle2 = ConstMap_Create(sourceMap);
467 umock_c_reset_all_calls();
468
469 ///Act
470 // NULL Handle
471 keyExists1 = ConstMap_ContainsKey(aHandle1, key1);
472
473 // NULL key
474 keyExists2 = ConstMap_ContainsKey(aHandle2, key2);
475
476 ///Assert
477 ASSERT_IS_FALSE(keyExists1);
478 ASSERT_IS_FALSE(keyExists2);
479 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
480
481 //Ablution
482 ConstMap_Destroy(aHandle2);
483
484 }
485
486 /*Tests_SRS_CONSTMAP_17_026: [If a key doesn't exist, then ConstMap_ContainsKey shall return false.]*/
487 TEST_FUNCTION(ConstMap_ContainsKey_Failures)
488 {
489 // Arrange
490 MAP_RESULT mapErrorList[] = {
491 MAP_ERROR,
492 MAP_INVALIDARG,
493 MAP_KEYEXISTS,
494 MAP_KEYNOTFOUND,
495 MAP_FILTER_REJECT
496 };
497 size_t errors = sizeof(mapErrorList) / sizeof(MAP_RESULT);
498 size_t e;
499 const char * key = "aKey";
500 bool keyExists;
501
502 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
503 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
504 umock_c_reset_all_calls();
505
506 // Call to Map_ContainsKey (match with mapErrorList size)
507 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
508 .IgnoreArgument(1).IgnoreArgument(3);
509 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
510 .IgnoreArgument(1).IgnoreArgument(3);
511 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
512 .IgnoreArgument(1).IgnoreArgument(3);
513 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
514 .IgnoreArgument(1).IgnoreArgument(3);
515 STRICT_EXPECTED_CALL(Map_ContainsKey(IGNORED_PTR_ARG, key, IGNORED_PTR_ARG))
516 .IgnoreArgument(1).IgnoreArgument(3);
517
518
519 ///Act
520 for (e = 0; e < errors; e++)
521 {
522 currentMapResult = mapErrorList[e];
523 keyExists = ConstMap_ContainsKey(aHandle, key);
524 ASSERT_IS_FALSE(keyExists);
525 }
526
527 ///Assert
528
529 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
530
531 //Ablution
532 ConstMap_Destroy(aHandle);
533 }
534
535 /*Tests_SRS_CONSTMAP_17_028: [Otherwise, if a pair has its value equal to the parameter value, the ConstMap_ContainsValue shall return true.]*/
536 TEST_FUNCTION(ConstMap_ContainsValue_Success)
537 {
538 // Arrange
539 const char * value = "aValue";
540 bool valueExists;
541
542 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
543 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
544
545 umock_c_reset_all_calls();
546
547 // Call to Map
548 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
549 .IgnoreArgument(1).IgnoreArgument(3);
550
551 ///Act
552 valueExists = ConstMap_ContainsValue(aHandle, value);
553
554 ///Assert
555 ASSERT_IS_TRUE(valueExists);
556
557 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
558
559 //Ablution
560 ConstMap_Destroy(aHandle);
561 }
562
563 /*Tests_SRS_CONSTMAP_17_027: [If parameter handle or value is NULL then ConstMap_ContainsValue shall return false.]*/
564 TEST_FUNCTION(ConstMap_ContainsValue_Null)
565 {
566 // Arrange
567 const char * value1 = "aValue";
568 bool valueExists1;
569 const char * value2 = NULL;
570 bool valueExists2;
571 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
572 CONSTMAP_HANDLE aHandle1 = NULL;
573 CONSTMAP_HANDLE aHandle2 = NULL;
574
575 aHandle2 = ConstMap_Create(sourceMap);
576
577 umock_c_reset_all_calls();
578
579 ///Act
580 valueExists1 = ConstMap_ContainsValue(aHandle1, value1);
581 valueExists2 = ConstMap_ContainsValue(aHandle2, value2);
582
583
584 ///Assert
585 ASSERT_IS_FALSE(valueExists1);
586 ASSERT_IS_FALSE(valueExists2);
587
588 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
589
590 //Ablution
591 ConstMap_Destroy(aHandle2);
592 }
593
594 /* Tests_SRS_CONSTMAP_17_029: [Otherwise, if such a does not exist, then ConstMap_ContainsValue shall return false.]*/
595 TEST_FUNCTION(ConstMap_ContainsValue_Failures)
596 {
597 // Arrange
598 MAP_RESULT mapErrorList[] = {
599 MAP_ERROR,
600 MAP_INVALIDARG,
601 MAP_KEYEXISTS,
602 MAP_KEYNOTFOUND,
603 MAP_FILTER_REJECT
604 };
605 size_t errors = sizeof(mapErrorList) / sizeof(MAP_RESULT);
606 size_t e;
607 const char * value = "aValue";
608 bool valueExists;
609
610 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
611 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
612 umock_c_reset_all_calls();
613
614 // Call to Map_ContainsValue (match with mapErrorList size)
615 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
616 .IgnoreArgument(1).IgnoreArgument(3);
617 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
618 .IgnoreArgument(1).IgnoreArgument(3);
619 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
620 .IgnoreArgument(1).IgnoreArgument(3);
621 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
622 .IgnoreArgument(1).IgnoreArgument(3);
623 STRICT_EXPECTED_CALL(Map_ContainsValue(IGNORED_PTR_ARG, value, IGNORED_PTR_ARG))
624 .IgnoreArgument(1).IgnoreArgument(3);
625
626 ///Act
627 for (e = 0; e < errors; e++)
628 {
629 currentMapResult = mapErrorList[e];
630 valueExists = ConstMap_ContainsValue(aHandle, value);
631 ASSERT_IS_FALSE(valueExists);
632 }
633
634 ///Assert
635
636 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
637
638 //Ablution
639 ConstMap_Destroy(aHandle);
640 }
641
642 /* Tests_SRS_CONSTMAP_17_042: [Otherwise, ConstMap_GetValue returns the key's value.]*/
643 TEST_FUNCTION(ConstMap_GetValue_Success)
644 {
645 // Arrange
646 const char * key = "aKey";
647 const char * value;
648
649 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
650 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
651 umock_c_reset_all_calls();
652
653 // Call to Map
654 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
655 .IgnoreArgument(1);
656
657 ///Act
658 value = ConstMap_GetValue(aHandle, key);
659
660
661 ///Assert
662 ASSERT_ARE_EQUAL(char_ptr, VALID_VALUE, value);
663
664 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
665
666 //Ablution
667 ConstMap_Destroy(aHandle);
668
669 }
670
671 TEST_FUNCTION(ConstMap_GetValue_Null)
672 {
673 // Arrange
674 const char * key1 = "aKey";
675 const char * value1;
676 CONSTMAP_HANDLE aHandle1 = NULL;
677 const char * key2 = NULL;
678 const char * value2;
679 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
680 CONSTMAP_HANDLE aHandle2 = ConstMap_Create(sourceMap);
681
682 umock_c_reset_all_calls();
683
684 ///Act
685 value1 = ConstMap_GetValue(aHandle1, key1);
686 value2 = ConstMap_GetValue(aHandle2, key2);
687
688 ///Assert
689 ASSERT_IS_NULL(value1);
690 ASSERT_IS_NULL(value2);
691
692 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
693
694 //Ablution
695 ConstMap_Destroy(aHandle2);
696
697 }
698
699 /*Tests_SRS_CONSTMAP_17_040: [If parameter handle or key is NULL then ConstMap_GetValue returns NULL.] */
700 /*Tests_SRS_CONSTMAP_17_041: [If the key is not found, then ConstMap_GetValue returns NULL.]*/
701 TEST_FUNCTION(ConstMap_GetValue_Failures)
702 {
703 // Arrange
704 MAP_RESULT mapErrorList[] = {
705 MAP_ERROR,
706 MAP_INVALIDARG,
707 MAP_KEYEXISTS,
708 MAP_KEYNOTFOUND,
709 MAP_FILTER_REJECT
710 };
711 size_t errors = sizeof(mapErrorList) / sizeof(MAP_RESULT);
712 size_t e;
713 const char * key = "aKey";
714 const char * value;
715
716 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
717 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
718 umock_c_reset_all_calls();
719
720 // Call to Map_ContainsKey (match with mapErrorList size)
721 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
722 .IgnoreArgument(1);
723 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
724 .IgnoreArgument(1);
725 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
726 .IgnoreArgument(1);
727 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
728 .IgnoreArgument(1);
729 STRICT_EXPECTED_CALL(Map_GetValueFromKey(IGNORED_PTR_ARG, key))
730 .IgnoreArgument(1);
731
732
733 ///Act
734 // Errors from Map_GetValueFromKey
735 for (e = 0; e < errors; e++)
736 {
737 currentMapResult = mapErrorList[e];
738 value = ConstMap_GetValue(aHandle, key);
739 ASSERT_IS_NULL(value);
740 }
741
742 ///Assert
743
744 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
745
746 //Ablution
747 ConstMap_Destroy(aHandle);
748 }
749
750 /*Tests_SRS_CONSTMAP_17_043: [ConstMap_GetInternals shall produce in *keys a pointer to an array of const char* having all the keys stored so far by the map.] */
751 /*Tests_SRS_CONSTMAP_17_044: [ConstMap_GetInternals shall produce in *values a pointer to an array of const char* having all the values stored so far by the map.] */
752 /*Tests_SRS_CONSTMAP_17_045: [ ConstMap_GetInternals shall produce in *count the number of stored keys and values.]*/
753 TEST_FUNCTION(ConstMap_GetInternals_Success)
754 {
755 // Arrange
756 CONSTMAP_RESULT result;
757 const char*const* keys;
758 const char*const* values;
759 size_t count;
760
761 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
762 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
763 umock_c_reset_all_calls();
764
765 // Call to Map
766 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
767 .IgnoreArgument(1);
768
769 ///Act
770 result = ConstMap_GetInternals(aHandle, &keys, &values, &count);
771
772 ///Assert
773 ASSERT_ARE_EQUAL(CONSTMAP_RESULT, CONSTMAP_OK, result);
774 ASSERT_ARE_EQUAL(void_ptr, VALID_CONST_CHAR_POINTER, keys);
775 ASSERT_ARE_EQUAL(void_ptr, VALID_CONST_CHAR_POINTER, values);
776 ASSERT_ARE_EQUAL(size_t, VALID_KV_COUNT, count);
777
778 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
779
780 //Ablution
781 ConstMap_Destroy(aHandle);
782 }
783
784 /*Tests_SRS_CONSTMAP_17_046: [If parameter handle, keys, values or count is NULL then ConstMap_GetInternals shall return CONSTMAP_INVALIDARG.]*/
785 TEST_FUNCTION(ConstMap_GetInternals_Null)
786 {
787 // Arrange
788 const char*const* keys;
789 const char*const* values;
790 size_t count;
791
792 CONSTMAP_HANDLE aHandle = NULL;
793
794 ///Act
795 CONSTMAP_RESULT result = ConstMap_GetInternals(aHandle, &keys, &values, &count);
796
797 ///Assert
798 ASSERT_ARE_EQUAL(CONSTMAP_RESULT, CONSTMAP_INVALIDARG, result);
799
800 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
801
802 //Ablution
803 }
804
805 TEST_FUNCTION(ConstMap_GetInternals_Failures)
806 {
807 // Arrange
808 MAP_RESULT mapErrorList[] = {
809 MAP_ERROR,
810 MAP_INVALIDARG,
811 MAP_KEYEXISTS,
812 MAP_KEYNOTFOUND,
813 MAP_FILTER_REJECT
814 };
815 size_t errors = sizeof(mapErrorList) / sizeof(MAP_RESULT);
816 CONSTMAP_RESULT constErrorList[] = {
817 CONSTMAP_ERROR,
818 CONSTMAP_INVALIDARG,
819 CONSTMAP_ERROR,
820 CONSTMAP_KEYNOTFOUND,
821 CONSTMAP_ERROR
822 };
823 size_t e;
824 const char*const* keys;
825 const char*const* values;
826 size_t count;
827
828 MAP_HANDLE sourceMap = VALID_MAP_HANDLE;
829 CONSTMAP_HANDLE aHandle = ConstMap_Create(sourceMap);
830
831 umock_c_reset_all_calls();
832
833 // Call to Map_GetInternals (match with mapErrorList size)
834 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
835 .IgnoreArgument(1);
836 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
837 .IgnoreArgument(1);
838 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
839 .IgnoreArgument(1);
840 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
841 .IgnoreArgument(1);
842 STRICT_EXPECTED_CALL(Map_GetInternals(IGNORED_PTR_ARG, &keys, &values, &count))
843 .IgnoreArgument(1);
844
845 ///Act
846 for (e = 0; e < errors; e++)
847 {
848 CONSTMAP_RESULT result;
849 currentMapResult = mapErrorList[e];
850 result = ConstMap_GetInternals(aHandle, &keys, &values, &count);
851 ASSERT_ARE_EQUAL(CONSTMAP_RESULT, constErrorList[e], result);
852 }
853
854 ///Assert
855 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
856
857 //Ablution
858 ConstMap_Destroy(aHandle);
859 }
860
861 END_TEST_SUITE(constmap_unittests)