Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/timer_win32_ut/timer_ut.c

raw
1 // Copyright(C) Microsoft Corporation.All rights reserved.
2
3 #ifdef __cplusplus
4 #include <cstdlib>
5 #else
6 #include <stdlib.h>
7 #endif
8
9 #include "azure_macro_utils/macro_utils.h"
10
11 static void* my_gballoc_malloc(size_t size)
12 {
13 return malloc(size);
14 }
15
16 static void my_gballoc_free(void* s)
17 {
18 free(s);
19 }
20
21 #include "testrunnerswitcher.h"
22 #include "windows.h"
23 #include "umock_c/umock_c.h"
24 #include "umock_c/umocktypes_stdint.h"
25 #include "umock_c/umocktypes_charptr.h"
26 #include "umock_c/umocktypes.h"
27 #include "umock_c/umock_c_negative_tests.h"
28 #include "umock_c/umocktypes_bool.h"
29 #include "azure_c_shared_utility/timer.h"
30
31 #define ENABLE_MOCKS
32 #include "azure_c_shared_utility/gballoc.h"
33 #undef ENABLE_MOCKS
34
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38 MOCKABLE_FUNCTION(, BOOLEAN, mocked_QueryPerformanceCounter, LARGE_INTEGER*, lpPerformanceCount)
39 MOCKABLE_FUNCTION(, BOOLEAN, mocked_QueryPerformanceFrequency, LARGE_INTEGER*, lpFrequency)
40 #ifdef __cplusplus
41 }
42 #endif
43 static TEST_MUTEX_HANDLE test_serialize_mutex;
44
45
46 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
47
48 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
49 {
50 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
51 }
52
53 BEGIN_TEST_SUITE(timer_unittests)
54
55 TEST_SUITE_INITIALIZE(suite_init)
56 {
57 int result;
58
59 test_serialize_mutex = TEST_MUTEX_CREATE();
60 ASSERT_IS_NOT_NULL(test_serialize_mutex);
61
62 result = umock_c_init(on_umock_c_error);
63 ASSERT_ARE_EQUAL(int, 0, result, "umock_c_init");
64
65 result = umocktypes_stdint_register_types();
66 ASSERT_ARE_EQUAL(int, 0, result, "umocktypes_stdint_register_types failed");
67
68 result = umocktypes_charptr_register_types();
69 ASSERT_ARE_EQUAL(int, 0, result, "umocktypes_charptr_register_types failed");
70
71 result = umocktypes_bool_register_types();
72 ASSERT_ARE_EQUAL(int, 0, result, "umocktypes_bool_register_types failed");
73
74 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
75 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
76 }
77
78 TEST_SUITE_CLEANUP(suite_cleanup)
79 {
80 umock_c_deinit();
81 umock_c_negative_tests_deinit();
82 TEST_MUTEX_DESTROY(test_serialize_mutex);
83 }
84
85 TEST_FUNCTION_INITIALIZE(init)
86 {
87 if (TEST_MUTEX_ACQUIRE(test_serialize_mutex))
88 {
89 ASSERT_FAIL("Could not acquire test serialization mutex.");
90 }
91
92 umock_c_reset_all_calls();
93 }
94
95 /* timer_create */
96 TEST_FUNCTION(timer_create_malloc_fails)
97 {
98 //arrange
99 STRICT_EXPECTED_CALL(malloc(IGNORED_NUM_ARG))
100 .SetReturn(NULL);
101
102 //act
103 TIMER_HANDLE timer = timer_create();
104
105 //assert
106 ASSERT_IS_NULL(timer, "timer_create failed.");
107 }
108
109 static void test_timer_create_success_expectations(void)
110 {
111 LARGE_INTEGER frequency, start_time;
112 frequency.QuadPart = 10;
113 start_time.QuadPart = 1;
114 STRICT_EXPECTED_CALL(malloc(IGNORED_NUM_ARG));
115 STRICT_EXPECTED_CALL(mocked_QueryPerformanceFrequency(IGNORED_PTR_ARG))
116 .CopyOutArgumentBuffer_lpFrequency(&frequency, sizeof(frequency));
117 STRICT_EXPECTED_CALL(mocked_QueryPerformanceCounter(IGNORED_PTR_ARG))
118 .CopyOutArgumentBuffer_lpPerformanceCount(&start_time, sizeof(start_time));
119 }
120
121 TEST_FUNCTION(timer_create_succeeds)
122 {
123 //arrange
124 test_timer_create_success_expectations();
125
126 //act
127 TIMER_HANDLE timer = timer_create();
128
129 //assert
130 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
131 ASSERT_IS_NOT_NULL(timer, "timer_create failed.");
132
133 //cleanup
134 timer_destroy(timer);
135 }
136
137 /* timer_start*/
138 TEST_FUNCTION(timer_start_returns_if_timer_is_null)
139 {
140 //arrange
141 //act
142 timer_start(NULL);
143
144 //assert
145 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
146 }
147
148 TEST_FUNCTION(timer_start_succeeds)
149 {
150 //arrange
151 LARGE_INTEGER stop_time;
152 stop_time.QuadPart = 100;
153 test_timer_create_success_expectations();
154 TIMER_HANDLE timer = timer_create();
155 umock_c_reset_all_calls();
156 STRICT_EXPECTED_CALL(mocked_QueryPerformanceCounter(IGNORED_PTR_ARG))
157 .CopyOutArgumentBuffer_lpPerformanceCount(&stop_time, sizeof(stop_time));
158
159 //act
160 timer_start(timer);
161
162 //assert
163 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
164
165 //cleanup
166 timer_destroy(timer);
167 }
168
169 /*timer_get_elapsed*/
170 TEST_FUNCTION(timer_get_elapsed_fails_if_timer_is_null)
171 {
172 //arrange
173 //act
174 double start = timer_get_elapsed(NULL);
175
176 //assert
177 ASSERT_ARE_EQUAL(double, -1, start);
178 }
179
180 TEST_FUNCTION(timer_get_elapsed_success)
181 {
182 //arrange
183 LARGE_INTEGER stop_time;
184 stop_time.QuadPart = 100;
185 test_timer_create_success_expectations();
186 TIMER_HANDLE timer = timer_create();
187 umock_c_reset_all_calls();
188 STRICT_EXPECTED_CALL(mocked_QueryPerformanceCounter(IGNORED_PTR_ARG))
189 .CopyOutArgumentBuffer_lpPerformanceCount(&stop_time, sizeof(stop_time));
190
191 //act
192 double elapsed_time = timer_get_elapsed(timer);
193
194 //assert
195 ASSERT_ARE_EQUAL(double, 9.9, elapsed_time);
196
197 //cleanup
198 timer_destroy(timer);
199 }
200
201 /*timer_get_elapsed_ms*/
202 TEST_FUNCTION(timer_get_elapsed_ms_fails_if_timer_is_null)
203 {
204 //arrange
205 //act
206 double elapsed_time_ms = timer_get_elapsed_ms(NULL);
207
208 //assert
209 ASSERT_ARE_EQUAL(double, -1, elapsed_time_ms);
210 }
211
212 TEST_FUNCTION(timer_get_elapsed_ms_success)
213 {
214 //arrange
215 LARGE_INTEGER stop_time;
216 stop_time.QuadPart = 100;
217 test_timer_create_success_expectations();
218 TIMER_HANDLE timer = timer_create();
219 umock_c_reset_all_calls();
220 STRICT_EXPECTED_CALL(mocked_QueryPerformanceCounter(IGNORED_PTR_ARG))
221 .CopyOutArgumentBuffer_lpPerformanceCount(&stop_time, sizeof(stop_time));
222
223 //act
224 double elapsed_time_ms = timer_get_elapsed_ms(timer);
225
226 //assert
227 ASSERT_ARE_EQUAL(double, 9900, elapsed_time_ms);
228
229 //cleanup
230 timer_destroy(timer);
231 }
232
233 /*timer_destroy*/
234 TEST_FUNCTION(timer_destroy_returns_if_timer_is_NULL)
235 {
236 //arrange
237 //act
238 timer_destroy(NULL);
239
240 //assert
241 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
242 }
243
244 TEST_FUNCTION(timer_destroy_frees_handle)
245 {
246 //arrange
247 test_timer_create_success_expectations();
248 TIMER_HANDLE timer = timer_create();
249 umock_c_reset_all_calls();
250 STRICT_EXPECTED_CALL(free(IGNORED_PTR_ARG));
251
252 //act
253 timer_destroy(timer);
254
255 //assert
256 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
257 }
258
259 TEST_FUNCTION_CLEANUP(cleanup)
260 {
261 TEST_MUTEX_RELEASE(test_serialize_mutex);
262 }
263
264 END_TEST_SUITE(timer_unittests)