Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/lock_ut/lock_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 "testrunnerswitcher.h"
12 #include "azure_c_shared_utility/crt_abstractions.h"
13 #include "azure_c_shared_utility/lock.h"
14 #include "umock_c/umock_c.h"
15
16 static void* my_gballoc_malloc(size_t size)
17 {
18 return malloc(size);
19 }
20
21 static void my_gballoc_free(void* ptr)
22 {
23 free(ptr);
24 }
25
26 #define ENABLE_MOCKS
27 #include "azure_c_shared_utility/gballoc.h"
28 #undef ENABLE_MOCKS
29
30 TEST_DEFINE_ENUM_TYPE(LOCK_RESULT, LOCK_RESULT_VALUES);
31
32 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
33
34 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
35 {
36 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
37 }
38
39 static TEST_MUTEX_HANDLE g_testByTest;
40
41 BEGIN_TEST_SUITE(LOCK_UnitTests)
42
43 TEST_SUITE_INITIALIZE(a)
44 {
45 g_testByTest = TEST_MUTEX_CREATE();
46 ASSERT_IS_NOT_NULL(g_testByTest);
47
48 umock_c_init(on_umock_c_error);
49
50 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
51 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
52 }
53
54 TEST_SUITE_CLEANUP(b)
55 {
56 umock_c_deinit();
57 }
58
59 TEST_FUNCTION_INITIALIZE(f)
60 {
61 if (TEST_MUTEX_ACQUIRE(g_testByTest))
62 {
63 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
64 }
65
66 umock_c_reset_all_calls();
67 }
68
69 TEST_FUNCTION_CLEANUP(cleans)
70 {
71 TEST_MUTEX_RELEASE(g_testByTest);
72 }
73
74 /* Tests_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */
75 TEST_FUNCTION(LOCK_Lock_Init_succeeds)
76 {
77 //arrange
78 #ifdef WIN32
79 STRICT_EXPECTED_CALL(malloc(IGNORED_NUM_ARG));
80 #endif
81
82 //act
83 LOCK_HANDLE handle = Lock_Init();
84
85 //assert
86 ASSERT_IS_NOT_NULL(handle);
87 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
88
89 //cleanup
90 (void)Lock_Deinit(handle);
91 }
92
93 /* Tests_SRS_LOCK_10_005: [Lock on success shall return LOCK_OK] */
94 TEST_FUNCTION(LOCK_Init_Lock_succeeds)
95 {
96 //arrange
97 LOCK_HANDLE handle = Lock_Init();
98
99 //act
100 LOCK_RESULT result = Lock(handle);
101
102 //assert
103 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_OK, result);
104
105 //cleanup
106 (void)Unlock(handle);
107 (void)Lock_Deinit(handle);
108 }
109
110 /* Tests_SRS_LOCK_10_009: [Unlock on success shall return LOCK_OK] */
111 TEST_FUNCTION(LOCK_Init_Lock_Unlock_succeeds)
112 {
113 //arrange
114 LOCK_RESULT result;
115 LOCK_HANDLE handle = Lock_Init();
116 (void)Lock(handle);
117
118 //act
119 result = Unlock(handle);
120
121 //assert
122 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_OK, result);
123
124 //cleanup
125 (void)Lock_Deinit(handle);
126 }
127
128 /* Tests_SRS_LOCK_10_002: [Lock_Init on success shall return a valid lock handle which should be a non NULL value] */
129 TEST_FUNCTION(LOCK_Init_DeInit_succeeds)
130 {
131 //arrange
132 LOCK_HANDLE handle = Lock_Init();
133
134 umock_c_reset_all_calls();
135
136 #ifdef WIN32
137 STRICT_EXPECTED_CALL(free(IGNORED_PTR_ARG));
138 #endif
139
140 //act
141 LOCK_RESULT result = Lock_Deinit(handle);
142 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
143
144 //assert
145 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_OK, result);
146 }
147
148 /* Tests_SRS_LOCK_10_007: [Lock_Deinit on NULL handle passed returns LOCK_ERROR] */
149 TEST_FUNCTION(LOCK_Lock_NULL_fails)
150 {
151 //arrange
152
153 //act
154 LOCK_RESULT result = Lock(NULL);
155
156 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_ERROR, result);
157 }
158
159 /* Tests_SRS_LOCK_10_011: [Unlock on NULL handle passed returns LOCK_ERROR] */
160 TEST_FUNCTION(LOCK_Unlock_NULL_fails)
161 {
162 //arrange
163
164 //act
165 LOCK_RESULT result = Unlock(NULL);
166
167 /*Tests_SRS_LOCK_10_011:[ This API on NULL handle passed returns LOCK_ERROR]*/
168 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_ERROR, result);
169 }
170
171 TEST_FUNCTION(LOCK_DeInit_NULL_fails)
172 {
173 //arrange
174
175 //act
176 LOCK_RESULT result = Lock_Deinit(NULL);
177
178 //assert
179 ASSERT_ARE_EQUAL(LOCK_RESULT, LOCK_ERROR, result);
180 }
181
182 /* Extra negative tests - only supported on Win32. */
183 #ifdef WIN32
184 TEST_FUNCTION(LOCK_Lock_Init_fails_if_malloc_fails)
185 {
186 //arrange
187 STRICT_EXPECTED_CALL(malloc(IGNORED_NUM_ARG))
188 .SetReturn(NULL);
189
190 //act
191 LOCK_HANDLE handle = Lock_Init();
192
193 //assert
194 ASSERT_IS_NULL(handle);
195 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
196
197 //cleanup
198 (void)Lock_Deinit(handle);
199 }
200 #endif
201
202 END_TEST_SUITE(LOCK_UnitTests);