Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/sha_ut/sha_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 /**
11 * Include the C standards here.
12 */
13 #ifdef __cplusplus
14 #include <cstddef>
15 #include <ctime>
16 #else
17 #include <stddef.h>
18 #include <time.h>
19 #endif
20
21 /**
22 * Include the test tools.
23 */
24 #include "testrunnerswitcher.h"
25 #include "umock_c/umock_c.h"
26 #include "umock_c/umocktypes_charptr.h"
27 #include "umock_c/umock_c_negative_tests.h"
28 #include "azure_macro_utils/macro_utils.h"
29
30 #define ENABLE_MOCKS
31 #undef ENABLE_MOCKS
32
33 #include "azure_c_shared_utility/sha.h"
34
35 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
36
37 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
38 {
39 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
40 }
41
42 /**
43 * This is necessary for the test suite, just keep as is.
44 */
45 static TEST_MUTEX_HANDLE g_testByTest;
46
47 BEGIN_TEST_SUITE(sha_ut)
48
49 TEST_SUITE_INITIALIZE(TestClassInitialize)
50 {
51 g_testByTest = TEST_MUTEX_CREATE();
52 ASSERT_IS_NOT_NULL(g_testByTest);
53
54 (void)umock_c_init(on_umock_c_error);
55 }
56 TEST_SUITE_CLEANUP(TestClassCleanup)
57 {
58 umock_c_deinit();
59
60 TEST_MUTEX_DESTROY(g_testByTest);
61 }
62
63 TEST_FUNCTION_INITIALIZE(initialize)
64 {
65 if (TEST_MUTEX_ACQUIRE(g_testByTest))
66 {
67 ASSERT_FAIL("Could not acquire test serialization mutex.");
68 }
69
70 umock_c_reset_all_calls();
71 }
72
73 TEST_FUNCTION_CLEANUP(cleans)
74 {
75 TEST_MUTEX_RELEASE(g_testByTest);
76 }
77
78 TEST_FUNCTION(SHA224Reset_succeeds)
79 {
80 //arrange
81 int result;
82 SHA224Context sha_ctx;
83
84 //act
85 result = SHA224Reset(&sha_ctx);
86
87 //assert
88 ASSERT_ARE_EQUAL(int, 0, result);
89 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
90
91 //cleanup
92 }
93 TEST_FUNCTION(SHA256Reset_succeeds)
94 {
95 //arrange
96 int result;
97 SHA256Context sha_ctx;
98
99 //act
100 result = SHA256Reset(&sha_ctx);
101
102 //assert
103 ASSERT_ARE_EQUAL(int, 0, result);
104 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
105
106 //cleanup
107 }
108
109 TEST_FUNCTION(SHA256Reset_ctx_NULL_fail)
110 {
111 //arrange
112 int result;
113
114 //act
115 result = SHA256Reset(NULL);
116
117 //assert
118 ASSERT_ARE_NOT_EQUAL(int, 0, result);
119 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
120
121 //cleanup
122 }
123
124 TEST_FUNCTION(SHA256Input_2nd_call_fail)
125 {
126 //arrange
127 int result;
128 SHA256Context sha_ctx;
129 uint8_t bytes[8];
130 unsigned int count = 8;
131 uint8_t msg_bits = 111;
132
133 //act
134 result = SHA256Reset(&sha_ctx);
135 result = SHA256Input(&sha_ctx, bytes, count);
136 result = SHA256FinalBits(&sha_ctx, msg_bits, 1);
137 result = SHA256Input(&sha_ctx, bytes, count);
138
139 //assert
140 ASSERT_ARE_NOT_EQUAL(int, 0, result);
141 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
142
143 //cleanup
144 }
145
146 TEST_FUNCTION(SHA224Input_succeeds)
147 {
148 //arrange
149 int result;
150 SHA224Context sha_ctx;
151 uint8_t bytes[32];
152 unsigned int count = 32;
153
154 //act
155 result = SHA224Reset(&sha_ctx);
156 result = SHA224Input(&sha_ctx, bytes, count);
157
158 //assert
159 ASSERT_ARE_EQUAL(int, 0, result);
160 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
161
162 //cleanup
163 }
164
165 TEST_FUNCTION(SHA256Input_succeeds)
166 {
167 //arrange
168 int result;
169 SHA256Context sha_ctx;
170 uint8_t bytes[32];
171 unsigned int count = 32;
172
173 //act
174 result = SHA256Reset(&sha_ctx);
175 result = SHA256Input(&sha_ctx, bytes, count);
176
177 //assert
178 ASSERT_ARE_EQUAL(int, 0, result);
179 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
180
181 //cleanup
182 }
183
184 TEST_FUNCTION(SHA256Input_large_bytes_succeeds)
185 {
186 //arrange
187 int result;
188 SHA256Context sha_ctx;
189 uint8_t bytes[128];
190 unsigned int count = 128;
191
192 //act
193 result = SHA256Reset(&sha_ctx);
194 result = SHA256Input(&sha_ctx, bytes, count);
195
196 //assert
197 ASSERT_ARE_EQUAL(int, 0, result);
198 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
199
200 //cleanup
201 }
202
203 TEST_FUNCTION(SHA256Input_ctx_NULL_fail)
204 {
205 //arrange
206 int result;
207 uint8_t bytes[32];
208 unsigned int count = 32;
209
210 //act
211 result = SHA256Input(NULL, bytes, count);
212
213 //assert
214 ASSERT_ARE_NOT_EQUAL(int, 0, result);
215 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
216
217 //cleanup
218 }
219
220 TEST_FUNCTION(SHA256Input_bytes_NULL_count_invalid_fail)
221 {
222 //arrange
223 int result;
224 SHA256Context sha_ctx;
225 unsigned int count = 10;
226
227 //act
228 result = SHA256Reset(&sha_ctx);
229 result = SHA256Input(&sha_ctx, NULL, count);
230
231 //assert
232 ASSERT_ARE_NOT_EQUAL(int, 0, result);
233 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
234
235 //cleanup
236 }
237
238 TEST_FUNCTION(SHA256Input_bytes_NULL_succeeds)
239 {
240 //arrange
241 int result;
242 SHA256Context sha_ctx;
243 unsigned int count = 0;
244
245 //act
246 result = SHA256Reset(&sha_ctx);
247 result = SHA256Input(&sha_ctx, NULL, count);
248
249 //assert
250 ASSERT_ARE_EQUAL(int, 0, result);
251 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
252
253 //cleanup
254 }
255
256 TEST_FUNCTION(SHA256FinalBits_succeeds)
257 {
258 //arrange
259 int result;
260 SHA256Context sha_ctx;
261 uint8_t bytes[1024];
262 unsigned int count = 1024;
263 uint8_t msg_bits = 87;
264
265 //act
266 result = SHA256Reset(&sha_ctx);
267 result = SHA256Input(&sha_ctx, bytes, count);
268 result = SHA256FinalBits(&sha_ctx, msg_bits, 2);
269
270 //assert
271 ASSERT_ARE_EQUAL(int, 0, result);
272 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
273
274 //cleanup
275 }
276
277 TEST_FUNCTION(SHA224FinalBits_succeeds)
278 {
279 //arrange
280 int result;
281 SHA224Context sha_ctx;
282 uint8_t bytes[1024];
283 unsigned int count = 1024;
284 uint8_t msg_bits = 87;
285
286 //act
287 result = SHA224Reset(&sha_ctx);
288 result = SHA224Input(&sha_ctx, bytes, count);
289 result = SHA224FinalBits(&sha_ctx, msg_bits, 2);
290
291 //assert
292 ASSERT_ARE_EQUAL(int, 0, result);
293 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
294
295 //cleanup
296 }
297
298 TEST_FUNCTION(SHA256FinalBits_ctx_NULL_fail)
299 {
300 //arrange
301 int result;
302 uint8_t msg_bits = 234;
303
304 //act
305 result = SHA256FinalBits(NULL, msg_bits, 2);
306
307 //assert
308 ASSERT_ARE_NOT_EQUAL(int, 0, result);
309 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
310
311 //cleanup
312 }
313
314 TEST_FUNCTION(SHA256FinalBits_msg_bit_0_success)
315 {
316 //arrange
317 int result;
318 SHA256Context sha_ctx;
319 uint8_t bytes[32];
320 unsigned int count = 32;
321 uint8_t msg_bits = 0;
322
323 //act
324 result = SHA256Reset(&sha_ctx);
325 result = SHA256Input(&sha_ctx, bytes, count);
326 result = SHA256FinalBits(&sha_ctx, msg_bits, 0);
327
328 //assert
329 ASSERT_ARE_EQUAL(int, 0, result);
330 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
331
332 //cleanup
333 }
334
335 TEST_FUNCTION(SHA256FinalBits_2nd_call_fail)
336 {
337 //arrange
338 int result;
339 SHA256Context sha_ctx;
340 uint8_t bytes[32];
341 unsigned int count = 32;
342 uint8_t msg_bits = 234;
343
344 //act
345 result = SHA256Reset(&sha_ctx);
346 result = SHA256Input(&sha_ctx, bytes, count);
347 result = SHA256FinalBits(&sha_ctx, msg_bits, 2);
348 result = SHA256FinalBits(&sha_ctx, msg_bits, 2);
349
350 //assert
351 ASSERT_ARE_NOT_EQUAL(int, 0, result);
352 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
353
354 //cleanup
355 }
356
357 TEST_FUNCTION(SHA256Result_succeeds)
358 {
359 //arrange
360 int result;
361 SHA256Context sha_ctx;
362 uint8_t bytes[256];
363 unsigned int count = 32;
364 uint8_t msg_bits = 234;
365 uint8_t Message_Digest[SHA256HashSize];
366
367 //act
368 result = SHA256Reset(&sha_ctx);
369 result = SHA256Input(&sha_ctx, bytes, count);
370 result = SHA256FinalBits(&sha_ctx, msg_bits, 2);
371 result = SHA256Result(&sha_ctx, Message_Digest);
372
373 //assert
374 ASSERT_ARE_EQUAL(int, 0, result);
375 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
376
377 //cleanup
378 }
379
380 TEST_FUNCTION(SHA224Result_succeeds)
381 {
382 //arrange
383 int result;
384 SHA224Context sha_ctx;
385 uint8_t bytes[32];
386 unsigned int count = 32;
387 uint8_t msg_bits = 87;
388 uint8_t Message_Digest[SHA224HashSize];
389
390 //act
391 result = SHA224Reset(&sha_ctx);
392 result = SHA224Input(&sha_ctx, bytes, count);
393 result = SHA224FinalBits(&sha_ctx, msg_bits, 2);
394 result = SHA224Result(&sha_ctx, Message_Digest);
395
396 //assert
397 ASSERT_ARE_EQUAL(int, 0, result);
398 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
399
400 //cleanup
401 }
402
403 TEST_FUNCTION(SHA256Result_ctx_NULL_fail)
404 {
405 //arrange
406 int result;
407 uint8_t Message_Digest[SHA256HashSize];
408
409 //act
410 result = SHA256Result(NULL, Message_Digest);
411
412 //assert
413 ASSERT_ARE_NOT_EQUAL(int, 0, result);
414 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
415
416 //cleanup
417 }
418
419 TEST_FUNCTION(SHA256Result_msg_digest_NULL_succeeds)
420 {
421 //arrange
422 int result;
423 SHA256Context sha_ctx;
424
425 //act
426 result = SHA256Reset(&sha_ctx);
427 result = SHA256Result(&sha_ctx, NULL);
428
429 //assert
430 ASSERT_ARE_NOT_EQUAL(int, 0, result);
431 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
432
433 //cleanup
434 }
435
436 END_TEST_SUITE(sha_ut)