Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/buffer_ut/buffer_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 <cstddef>
7 #else
8 #include <stdlib.h>
9 #include <stddef.h>
10 #endif
11
12 #include "azure_macro_utils/macro_utils.h"
13 #include "umock_c/umock_c.h"
14 #include "azure_c_shared_utility/buffer_.h"
15 #include "testrunnerswitcher.h"
16
17 static size_t currentmalloc_call = 0;
18 static size_t whenShallmalloc_fail = 0;
19
20 static size_t currentcalloc_call = 0;
21 static size_t whenShallcalloc_fail = 0;
22
23 static size_t currentrealloc_call = 0;
24 static size_t whenShallrealloc_fail = 0;
25
26 void* my_gballoc_malloc(size_t size)
27 {
28 void* result;
29 currentmalloc_call++;
30 if (whenShallmalloc_fail > 0)
31 {
32 if (currentmalloc_call == whenShallmalloc_fail)
33 {
34 result = NULL;
35 }
36 else
37 {
38 result = malloc(size);
39 }
40 }
41 else
42 {
43 result = malloc(size);
44 }
45 return result;
46 }
47
48 void* my_gballoc_calloc(size_t nmemb, size_t size)
49 {
50 void* result;
51 currentcalloc_call++;
52 if (whenShallcalloc_fail > 0)
53 {
54 if (currentcalloc_call == whenShallcalloc_fail)
55 {
56 result = NULL;
57 }
58 else
59 {
60 result = calloc(nmemb, size);
61 }
62 }
63 else
64 {
65 result = calloc(nmemb, size);
66 }
67 return result;
68 }
69
70 void* my_gballoc_realloc(void* ptr, size_t size)
71 {
72 void* result;
73 currentrealloc_call++;
74 if (whenShallrealloc_fail > 0)
75 {
76 if (currentrealloc_call == whenShallrealloc_fail)
77 {
78 result = NULL;
79 }
80 else
81 {
82 result = realloc(ptr, size);
83 }
84 }
85 else
86 {
87 result = realloc(ptr, size);
88 }
89
90 return result;
91 }
92
93 void my_gballoc_free(void* ptr)
94 {
95 free(ptr);
96 }
97
98 #define ENABLE_MOCKS
99 #include "azure_c_shared_utility/gballoc.h"
100
101 #define ALLOCATION_SIZE 16
102 #define TOTAL_ALLOCATION_SIZE 32
103
104 #define BUFFER_TEST1_SIZE 5
105 #define BUFFER_TEST2_SIZE 6
106
107 static const unsigned char BUFFER_Test1[] = {0x01,0x02,0x03,0x04,0x05};
108 static const unsigned char BUFFER_Test2[] = {0x06,0x07,0x08,0x09,0x10,0x11};
109 static const unsigned char BUFFER_TEST_VALUE[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16};
110 static const unsigned char ADDITIONAL_BUFFER[] = {0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26};
111 static const unsigned char TOTAL_BUFFER[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26};
112
113 static TEST_MUTEX_HANDLE g_testByTest;
114
115 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
116
117 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
118 {
119 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
120 }
121
122 BEGIN_TEST_SUITE(Buffer_UnitTests)
123
124 TEST_SUITE_INITIALIZE(setsBufferTempSize)
125 {
126 g_testByTest = TEST_MUTEX_CREATE();
127 ASSERT_IS_NOT_NULL(g_testByTest);
128
129 umock_c_init(on_umock_c_error);
130
131 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
132 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
133 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
134 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
135 }
136
137 TEST_SUITE_CLEANUP(TestClassCleanup)
138 {
139 umock_c_deinit();
140
141 TEST_MUTEX_DESTROY(g_testByTest);
142 }
143
144 TEST_FUNCTION_INITIALIZE(f)
145 {
146 if (TEST_MUTEX_ACQUIRE(g_testByTest))
147 {
148 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
149 }
150
151 umock_c_reset_all_calls();
152
153 currentmalloc_call = 0;
154 whenShallmalloc_fail = 0;
155
156 currentcalloc_call = 0;
157 whenShallcalloc_fail = 0;
158
159 currentrealloc_call = 0;
160 whenShallrealloc_fail = 0;
161 }
162
163 TEST_FUNCTION_CLEANUP(cleans)
164 {
165 TEST_MUTEX_RELEASE(g_testByTest);
166 }
167
168 /* Tests_SRS_BUFFER_07_001: [BUFFER_new shall allocate a BUFFER_HANDLE that will contain a NULL unsigned char*.] */
169 TEST_FUNCTION(BUFFER_new_Succeed)
170 {
171 ///arrange
172 BUFFER_HANDLE g_hBuffer;
173 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
174 .IgnoreAllArguments();
175
176 ///act
177 g_hBuffer = BUFFER_new();
178
179 ///assert
180 ASSERT_IS_NOT_NULL(g_hBuffer);
181 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
182
183 ///cleanup
184 BUFFER_delete(g_hBuffer);
185 }
186
187 /* BUFFER_delete Tests BEGIN */
188 /* Tests_SRS_BUFFER_07_003: [BUFFER_delete shall delete the data associated with the BUFFER_HANDLE.] */
189 TEST_FUNCTION(BUFFER_delete_Succeed)
190 {
191 ///arrange
192 BUFFER_HANDLE g_hBuffer;
193 g_hBuffer = BUFFER_new();
194 umock_c_reset_all_calls();
195
196 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
197 .IgnoreArgument(1);
198
199 ///act
200 BUFFER_delete(g_hBuffer);
201
202 ///assert
203 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
204
205 ///cleanup
206 //none
207 }
208
209 /* Tests_SRS_BUFFER_07_003: [BUFFER_delete shall delete the data associated with the BUFFER_HANDLE.] */
210 TEST_FUNCTION(BUFFER_delete_Alloc_Succeed)
211 {
212 ///arrange
213 BUFFER_HANDLE g_hBuffer;
214 g_hBuffer = BUFFER_new();
215 BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
216 umock_c_reset_all_calls();
217
218 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
219 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
220
221 ///act
222 BUFFER_delete(g_hBuffer);
223
224 ///assert
225 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
226
227 ///cleanup
228 //none
229 }
230
231 /* Tests_SRS_BUFFER_07_004: [BUFFER_delete shall not delete any BUFFER_HANDLE that is NULL.] */
232 TEST_FUNCTION(BUFFER_delete_NULL_HANDLE_Succeed)
233 {
234 ///arrange
235
236 ///act
237 BUFFER_delete(NULL);
238
239 ///assert
240 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
241 }
242
243 /* BUFFER_pre_Build Tests BEGIN */
244 /* Tests_SRS_BUFFER_07_005: [BUFFER_pre_build allocates size_t bytes of BUFFER_HANDLE and returns zero on success.] */
245 TEST_FUNCTION(BUFFER_pre_build_Succeed)
246 {
247 ///arrange
248 int nResult;
249 BUFFER_HANDLE g_hBuffer;
250 g_hBuffer = BUFFER_new();
251 umock_c_reset_all_calls();
252
253 STRICT_EXPECTED_CALL(gballoc_malloc(ALLOCATION_SIZE));
254
255 ///act
256 nResult = BUFFER_pre_build(g_hBuffer, ALLOCATION_SIZE);
257
258 ///assert
259 ASSERT_ARE_EQUAL(int, nResult, 0);
260 ASSERT_ARE_EQUAL(size_t, BUFFER_length(g_hBuffer), ALLOCATION_SIZE);
261 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
262
263 ///cleanup
264 BUFFER_delete(g_hBuffer);
265 }
266
267 /* Tests_SRS_BUFFER_07_006: [If handle is NULL or size is 0 then BUFFER_pre_build shall return a nonzero value.] */
268 /* Tests_SRS_BUFFER_07_013: [BUFFER_pre_build shall return nonzero if any error is encountered.] */
269 TEST_FUNCTION(BUFFER_pre_build_HANDLE_NULL_Fail)
270 {
271 ///arrange
272
273 ///act
274 int nResult = BUFFER_pre_build(NULL, ALLOCATION_SIZE);
275
276 ///assert
277 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
278 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
279
280 ///cleanup
281 //none
282 }
283
284 /* Tests_SRS_BUFFER_07_006: [If handle is NULL or size is 0 then BUFFER_pre_build shall return a nonzero value.] */
285 TEST_FUNCTION(BUFFER_pre_Size_Zero_Fail)
286 {
287 ///arrange
288 int nResult;
289 BUFFER_HANDLE g_hBuffer;
290 g_hBuffer = BUFFER_new();
291 umock_c_reset_all_calls();
292
293 ///act
294 nResult = BUFFER_pre_build(g_hBuffer, 0);
295
296 ///assert
297 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
298 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
299
300 ///cleanup
301 BUFFER_delete(g_hBuffer);
302 }
303
304 /* Tests_SRS_BUFFER_07_013: [BUFFER_pre_build shall return nonzero if any error is encountered.] */
305 TEST_FUNCTION(BUFFER_pre_build_HANDLE_NULL_Size_Zero_Fail)
306 {
307 ///arrange
308
309 ///act
310 int nResult = BUFFER_pre_build(NULL, 0);
311
312 ///assert
313 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
314 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
315 }
316
317 /* Tests_SRS_BUFFER_07_007: [BUFFER_pre_build shall return nonzero if the buffer has been previously allocated and is not NULL.] */
318 /* Tests_SRS_BUFFER_07_013: [BUFFER_pre_build shall return nonzero if any error is encountered.] */
319 TEST_FUNCTION(BUFFER_pre_build_Multiple_Alloc_Fail)
320 {
321 ///arrange
322 BUFFER_HANDLE g_hBuffer;
323 int nResult;
324 g_hBuffer = BUFFER_new();
325 nResult = BUFFER_pre_build(g_hBuffer, ALLOCATION_SIZE);
326 umock_c_reset_all_calls();
327
328 ///act
329 nResult = BUFFER_pre_build(g_hBuffer, ALLOCATION_SIZE);
330
331 ///assert
332 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
333 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
334
335 ///cleanup
336 BUFFER_delete(g_hBuffer);
337 }
338
339 /* Tests_SRS_BUFFER_07_008: [BUFFER_build allocates size_t bytes, copies the unsigned char* into the buffer and returns zero on success.] */
340 TEST_FUNCTION(BUFFER_build_Succeed)
341 {
342 ///arrange
343 int nResult;
344 BUFFER_HANDLE g_hBuffer;
345
346 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
347 .IgnoreAllArguments();
348
349 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, ALLOCATION_SIZE))
350 .IgnoreArgument(1);
351
352 ///act
353 g_hBuffer = BUFFER_new();
354
355 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
356
357 ///assert
358 ASSERT_ARE_EQUAL(size_t, BUFFER_length(g_hBuffer), ALLOCATION_SIZE);
359 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(g_hBuffer), BUFFER_TEST_VALUE, ALLOCATION_SIZE));
360 ASSERT_ARE_EQUAL(int, nResult, 0);
361 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
362
363 ///cleanup
364 BUFFER_delete(g_hBuffer);
365 }
366
367 /* Tests_SRS_BUFFER_07_009: [BUFFER_build shall return nonzero if handle is NULL ] */
368 TEST_FUNCTION(BUFFER_build_NULL_HANDLE_Fail)
369 {
370 ///arrange
371
372 ///act
373 int nResult = BUFFER_build(NULL, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
374
375 ///assert
376 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
377 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
378 }
379
380 /* Tests_SRS_BUFFER_01_001: [If size is positive and source is NULL, BUFFER_build shall return nonzero] */
381 TEST_FUNCTION(BUFFER_build_Content_NULL_Fail)
382 {
383 ///arrange
384 int nResult;
385 BUFFER_HANDLE g_hBuffer;
386 g_hBuffer = BUFFER_new();
387 umock_c_reset_all_calls();
388
389 ///act
390 nResult = BUFFER_build(g_hBuffer, NULL, ALLOCATION_SIZE);
391
392 ///assert
393 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
394 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
395
396 ///cleanup
397 BUFFER_delete(g_hBuffer);
398 }
399
400 /* Tests_SRS_BUFFER_01_002: [The size argument can be zero, in which case the underlying buffer held by the buffer instance shall be freed.] */
401 TEST_FUNCTION(BUFFER_build_Size_Zero_non_NULL_buffer_Succeeds)
402 {
403 ///arrange
404 int nResult;
405 BUFFER_HANDLE g_hBuffer;
406 g_hBuffer = BUFFER_new();
407 umock_c_reset_all_calls();
408
409 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
410 .IgnoreArgument(1);
411
412 ///act
413 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, 0);
414
415 ///assert
416 ASSERT_ARE_EQUAL(int, nResult, 0);
417 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
418
419 ///cleanup
420 BUFFER_delete(g_hBuffer);
421 }
422
423 /* Tests_SRS_BUFFER_01_002: [The size argument can be zero, in which case the underlying buffer held by the buffer instance shall be freed.] */
424 TEST_FUNCTION(BUFFER_build_Size_Zero_NULL_buffer_Succeeds)
425 {
426 ///arrange
427 int nResult;
428 BUFFER_HANDLE g_hBuffer;
429 g_hBuffer = BUFFER_new();
430 umock_c_reset_all_calls();
431
432 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
433 .IgnoreArgument(1);
434
435 ///act
436 nResult = BUFFER_build(g_hBuffer, NULL, 0);
437
438 ///assert
439 ASSERT_ARE_EQUAL(int, nResult, 0);
440 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
441
442 ///cleanup
443 BUFFER_delete(g_hBuffer);
444 }
445
446 /* Tests_SRS_BUFFER_07_029: [ BUFFER_append_build shall return nonzero if handle or source are NULL or if size is 0. ] */
447 TEST_FUNCTION(BUFFER_append_build_handle_NULL_fail)
448 {
449 ///arrange
450 int nResult;
451 BUFFER_HANDLE hBuffer;
452 hBuffer = BUFFER_new();
453 umock_c_reset_all_calls();
454
455 ///act
456 nResult = BUFFER_append_build(NULL, BUFFER_Test1, BUFFER_TEST1_SIZE);
457
458 ///assert
459 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
460 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
461
462 ///cleanup
463 BUFFER_delete(hBuffer);
464 }
465
466 /* Tests_SRS_BUFFER_07_029: [ BUFFER_append_build shall return nonzero if handle or source are NULL or if size is 0. ] */
467 TEST_FUNCTION(BUFFER_append_build_buffer_NULL_buffer_fail)
468 {
469 ///arrange
470 int nResult;
471 BUFFER_HANDLE hBuffer;
472 hBuffer = BUFFER_new();
473 umock_c_reset_all_calls();
474
475 ///act
476 nResult = BUFFER_append_build(hBuffer, NULL, BUFFER_TEST1_SIZE);
477
478 ///assert
479 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
480 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
481
482 ///cleanup
483 BUFFER_delete(hBuffer);
484 }
485
486 /* Tests_SRS_BUFFER_07_029: [ BUFFER_append_build shall return nonzero if handle or source are NULL or if size is 0. ] */
487 TEST_FUNCTION(BUFFER_append_build_Size_Zero_NULL_buffer_fail)
488 {
489 ///arrange
490 int nResult;
491 BUFFER_HANDLE hBuffer;
492 hBuffer = BUFFER_new();
493 umock_c_reset_all_calls();
494
495 ///act
496 nResult = BUFFER_append_build(hBuffer, BUFFER_Test1, 0);
497
498 ///assert
499 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
500 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
501
502 ///cleanup
503 BUFFER_delete(hBuffer);
504 }
505
506 /* Tests_SRS_BUFFER_07_030: [ if handle->buffer is NULL BUFFER_append_build shall allocate the a buffer of size bytes... ] */
507 /* Tests_SRS_BUFFER_07_031: [ ... and copy the contents of source to handle->buffer. ] */
508 /* Tests_SRS_BUFFER_07_034: [ On success BUFFER_append_build shall return 0 ] */
509 TEST_FUNCTION(BUFFER_append_build_buffer_NULL_succeed)
510 {
511 //arrange
512 int nResult;
513 BUFFER_HANDLE hBuffer;
514 hBuffer = BUFFER_new();
515 umock_c_reset_all_calls();
516
517 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
518
519 //act
520 nResult = BUFFER_append_build(hBuffer, BUFFER_Test1, BUFFER_TEST1_SIZE);
521
522 //assert
523 ASSERT_ARE_EQUAL(int, nResult, 0);
524 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), BUFFER_Test1, BUFFER_TEST1_SIZE));
525 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
526
527 //cleanup
528 BUFFER_delete(hBuffer);
529 }
530
531 /* Tests_SRS_BUFFER_07_035: [ If any error is encountered BUFFER_append_build shall return a non-null value. ] */
532 TEST_FUNCTION(BUFFER_append_build_buffer_NULL_fail)
533 {
534 //arrange
535 int nResult;
536 BUFFER_HANDLE hBuffer;
537 hBuffer = BUFFER_new();
538 umock_c_reset_all_calls();
539
540 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)).SetReturn(NULL);
541
542 //act
543 nResult = BUFFER_append_build(hBuffer, BUFFER_Test1, BUFFER_TEST1_SIZE);
544
545 //assert
546 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
547 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
548
549 //cleanup
550 BUFFER_delete(hBuffer);
551 }
552
553 /* Tests_SRS_BUFFER_07_032: [ if handle->buffer is not NULL BUFFER_append_build shall realloc the buffer to be the handle->size + size ] */
554 /* Tests_SRS_BUFFER_07_033: [ ... and copy the contents of source to the end of the buffer. ] */
555 /* Tests_SRS_BUFFER_07_034: [ On success BUFFER_append_build shall return 0 ] */
556 TEST_FUNCTION(BUFFER_append_build_succeed)
557 {
558 //arrange
559 int nResult;
560 BUFFER_HANDLE hBuffer;
561 hBuffer = BUFFER_create(BUFFER_TEST_VALUE, ALLOCATION_SIZE);
562
563 umock_c_reset_all_calls();
564
565 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
566
567 //act
568 nResult = BUFFER_append_build(hBuffer, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
569
570 //assert
571 ASSERT_ARE_EQUAL(int, nResult, 0);
572 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), TOTAL_ALLOCATION_SIZE);
573
574 ASSERT_ARE_EQUAL(int, memcmp(BUFFER_u_char(hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE), 0);
575 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
576
577 //cleanup
578 BUFFER_delete(hBuffer);
579 }
580
581 /* Tests_SRS_BUFFER_07_035: [ If any error is encountered BUFFER_append_build shall return a non-null value. ] */
582 TEST_FUNCTION(BUFFER_append_build_fail)
583 {
584 //arrange
585 int nResult;
586 BUFFER_HANDLE hBuffer;
587 hBuffer = BUFFER_create(BUFFER_TEST_VALUE, ALLOCATION_SIZE);
588
589 umock_c_reset_all_calls();
590
591 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG)).SetReturn(NULL);
592
593 //act
594 nResult = BUFFER_append_build(hBuffer, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
595
596 //assert
597 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
598 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
599
600 //cleanup
601 BUFFER_delete(hBuffer);
602 }
603
604 /* Tests_SRS_BUFFER_07_011: [BUFFER_build shall overwrite previous contents if the buffer has been previously allocated.] */
605 TEST_FUNCTION(BUFFER_build_when_the_buffer_is_already_allocated_and_the_same_amount_of_bytes_is_needed_succeeds)
606 {
607 ///arrange
608 int nResult;
609 BUFFER_HANDLE g_hBuffer;
610 g_hBuffer = BUFFER_new();
611 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
612 umock_c_reset_all_calls();
613
614 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, ALLOCATION_SIZE))
615 .IgnoreArgument(1);
616
617 ///act
618 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
619
620 ///assert
621 ASSERT_ARE_EQUAL(int, nResult, 0);
622 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
623
624 ///cleanup
625 BUFFER_delete(g_hBuffer);
626 }
627
628 /* Tests_SRS_BUFFER_07_011: [BUFFER_build shall overwrite previous contents if the buffer has been previously allocated.] */
629 TEST_FUNCTION(BUFFER_build_when_the_buffer_is_already_allocated_and_more_bytes_are_needed_succeeds)
630 {
631 ///arrange
632 int nResult;
633 BUFFER_HANDLE g_hBuffer;
634 g_hBuffer = BUFFER_new();
635 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE - 1);
636 umock_c_reset_all_calls();
637
638 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, ALLOCATION_SIZE))
639 .IgnoreArgument(1);
640
641 ///act
642 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
643
644 ///assert
645 ASSERT_ARE_EQUAL(int, nResult, 0);
646 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
647
648 ///cleanup
649 BUFFER_delete(g_hBuffer);
650 }
651
652 /* Tests_SRS_BUFFER_07_011: [BUFFER_build shall overwrite previous contents if the buffer has been previously allocated.] */
653 TEST_FUNCTION(BUFFER_build_when_the_buffer_is_already_allocated_and_less_bytes_are_needed_succeeds)
654 {
655 ///arrange
656 int nResult;
657 BUFFER_HANDLE g_hBuffer;
658 g_hBuffer = BUFFER_new();
659 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
660 umock_c_reset_all_calls();
661
662 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, ALLOCATION_SIZE - 1))
663 .IgnoreArgument(1);
664
665 ///act
666 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE - 1);
667
668 ///assert
669 ASSERT_ARE_EQUAL(int, nResult, 0);
670 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
671
672 ///cleanup
673 BUFFER_delete(g_hBuffer);
674 }
675
676 /* BUFFER_unbuild Tests BEGIN */
677 /* Tests_SRS_BUFFER_07_012: [BUFFER_unbuild shall clear the underlying unsigned char* data associated with the BUFFER_HANDLE this will return zero on success.] */
678 TEST_FUNCTION(BUFFER_unbuild_Succeed)
679 {
680 ///arrange
681 int nResult;
682 BUFFER_HANDLE g_hBuffer;
683 g_hBuffer = BUFFER_new();
684 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
685 umock_c_reset_all_calls();
686
687 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
688 .IgnoreArgument(1);
689
690 ///act
691 nResult = BUFFER_unbuild(g_hBuffer);
692
693 ///assert
694 ASSERT_ARE_EQUAL(int, nResult, 0);
695 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
696
697 ///cleanup
698 BUFFER_delete(g_hBuffer);
699 }
700
701 /* Tests_SRS_BUFFER_07_014: [BUFFER_unbuild shall return a nonzero value if BUFFER_HANDLE is NULL.] */
702 TEST_FUNCTION(BUFFER_unbuild_HANDLE_NULL_Fail)
703 {
704 ///arrange
705
706 ///act
707 int nResult = BUFFER_unbuild(NULL);
708
709 ///assert
710 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
711 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
712 }
713
714 /* Codes_SRS_BUFFER_07_015: [BUFFER_unbuild shall always return success if the unsigned char* referenced by BUFFER_HANDLE is NULL.] */
715 TEST_FUNCTION(BUFFER_unbuild_Multiple_Alloc_Fail)
716 {
717 ///arrange
718 int nResult;
719 BUFFER_HANDLE g_hBuffer;
720 g_hBuffer = BUFFER_new();
721 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
722 nResult = BUFFER_unbuild(g_hBuffer);
723 umock_c_reset_all_calls();
724
725 ///act
726 nResult = BUFFER_unbuild(g_hBuffer);
727
728 ///assert
729 ASSERT_ARE_EQUAL(int, nResult, 0);
730 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
731
732 ///cleanup
733 BUFFER_delete(g_hBuffer);
734 }
735
736 /* BUFFER_enlarge Tests BEGIN */
737 /* Tests_SRS_BUFFER_07_016: [BUFFER_enlarge shall increase the size of the unsigned char* referenced by BUFFER_HANDLE.] */
738 TEST_FUNCTION(BUFFER_enlarge_Succeed)
739 {
740 ///arrange
741 int nResult;
742 BUFFER_HANDLE g_hBuffer;
743 g_hBuffer = BUFFER_new();
744 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
745 umock_c_reset_all_calls();
746
747 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, 2 * ALLOCATION_SIZE))
748 .IgnoreArgument(1);
749
750 ///act
751 nResult = BUFFER_enlarge(g_hBuffer, ALLOCATION_SIZE);
752
753 ///assert
754 ASSERT_ARE_EQUAL(int, nResult, 0);
755 ASSERT_ARE_EQUAL(size_t, BUFFER_length(g_hBuffer), TOTAL_ALLOCATION_SIZE);
756 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
757
758 ///cleanup
759 BUFFER_delete(g_hBuffer);
760 }
761
762 /* Tests_SRS_BUFFER_07_017: [BUFFER_enlarge shall return a nonzero result if any parameters are NULL or zero.] */
763 /* Tests_SRS_BUFFER_07_018: [BUFFER_enlarge shall return a nonzero result if any error is encountered.] */
764 TEST_FUNCTION(BUFFER_enlarge_NULL_HANDLE_Fail)
765 {
766 ///arrange
767
768 ///act
769 int nResult = BUFFER_enlarge(NULL, ALLOCATION_SIZE);
770
771 ///assert
772 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
773 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
774 }
775
776 /* Tests_SRS_BUFFER_07_036: [ if handle is NULL, BUFFER_shrink shall return a non-null value ]*/
777 TEST_FUNCTION(BUFFER_shrink_handle_NULL_fail)
778 {
779 //arrange
780 int result;
781 //act
782 result = BUFFER_shrink(NULL, ALLOCATION_SIZE, true);
783
784 //assert
785 ASSERT_ARE_NOT_EQUAL(int, result, 0);
786 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
787
788 //cleanup
789 }
790
791 /* Tests_SRS_BUFFER_07_037: [ If decreaseSize is equal zero, BUFFER_shrink shall return a non-null value ] */
792 TEST_FUNCTION(BUFFER_shrink_decrease_size_0_fail)
793 {
794 //arrange
795 int nResult;
796 BUFFER_HANDLE hBuffer;
797 hBuffer = BUFFER_new();
798 nResult = BUFFER_build(hBuffer, TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
799 umock_c_reset_all_calls();
800
801 //act
802 nResult = BUFFER_shrink(hBuffer, 0, true);
803
804 //assert
805 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
806 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE));
807 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), TOTAL_ALLOCATION_SIZE);
808 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
809
810 //cleanup
811 BUFFER_delete(hBuffer);
812 }
813
814 /* Tests_SRS_BUFFER_07_038: [ If decreaseSize is less than the size of the buffer, BUFFER_shrink shall return a non-null value ] */
815 TEST_FUNCTION(BUFFER_shrink_decrease_size_less_than_len_succeed)
816 {
817 //arrange
818 int nResult;
819 BUFFER_HANDLE hBuffer;
820 hBuffer = BUFFER_new();
821 nResult = BUFFER_build(hBuffer, TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
822 umock_c_reset_all_calls();
823
824 //act
825 nResult = BUFFER_shrink(hBuffer, TOTAL_ALLOCATION_SIZE+1, true);
826
827 //assert
828 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
829 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE));
830 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), TOTAL_ALLOCATION_SIZE);
831 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
832
833 //cleanup
834 BUFFER_delete(hBuffer);
835 }
836
837 /* Tests_SRS_BUFFER_07_042: [ If a failure is encountered, BUFFER_shrink shall return a non-null value ] */
838 TEST_FUNCTION(BUFFER_shrink_malloc_fail)
839 {
840 //arrange
841 int nResult;
842 BUFFER_HANDLE hBuffer;
843 hBuffer = BUFFER_new();
844 nResult = BUFFER_build(hBuffer, TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
845 umock_c_reset_all_calls();
846
847 STRICT_EXPECTED_CALL(gballoc_malloc(TOTAL_ALLOCATION_SIZE - ALLOCATION_SIZE)).SetReturn(NULL);
848
849 //act
850 nResult = BUFFER_shrink(hBuffer, ALLOCATION_SIZE, true);
851
852 //assert
853 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
854 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE));
855 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), TOTAL_ALLOCATION_SIZE);
856 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
857
858 //cleanup
859 BUFFER_delete(hBuffer);
860 }
861
862 /* Tests_SRS_BUFFER_07_039: [ BUFFER_shrink shall allocate a temporary buffer of existing buffer size minus decreaseSize. ] */
863 /* Tests_SRS_BUFFER_07_040: [ if the fromEnd variable is true, BUFFER_shrink shall remove the end of the buffer of size decreaseSize. ] */
864 TEST_FUNCTION(BUFFER_shrink_from_end_succeed)
865 {
866 //arrange
867 int nResult;
868 BUFFER_HANDLE hBuffer;
869 hBuffer = BUFFER_new();
870 nResult = BUFFER_build(hBuffer, TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
871 umock_c_reset_all_calls();
872
873 STRICT_EXPECTED_CALL(gballoc_malloc(TOTAL_ALLOCATION_SIZE-ALLOCATION_SIZE));
874 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
875
876 //act
877 nResult = BUFFER_shrink(hBuffer, ALLOCATION_SIZE, true);
878
879 //assert
880 ASSERT_ARE_EQUAL(int, nResult, 0);
881 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), BUFFER_Test1, BUFFER_TEST1_SIZE));
882 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), ALLOCATION_SIZE);
883 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
884
885 //cleanup
886 BUFFER_delete(hBuffer);
887 }
888
889 /* Tests_SRS_BUFFER_07_039: [ BUFFER_shrink shall allocate a temporary buffer of existing buffer size minus decreaseSize. ] */
890 /* Tests_SRS_BUFFER_07_040: [ if the fromEnd variable is true, BUFFER_shrink shall remove the end of the buffer of size decreaseSize. ] */
891 /* Tests_SRS_BUFFER_07_043: [ If the decreaseSize is equal the buffer size , BUFFER_shrink shall deallocate the buffer and set the size to zero. ] */
892 TEST_FUNCTION(BUFFER_shrink_all_buffer_succeed)
893 {
894 //arrange
895 int nResult;
896 BUFFER_HANDLE hBuffer;
897 hBuffer = BUFFER_new();
898 nResult = BUFFER_build(hBuffer, TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
899 umock_c_reset_all_calls();
900
901 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
902
903 //act
904 nResult = BUFFER_shrink(hBuffer, TOTAL_ALLOCATION_SIZE, true);
905
906 //assert
907 ASSERT_ARE_EQUAL(int, nResult, 0);
908 ASSERT_IS_NULL(BUFFER_u_char(hBuffer));
909 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), 0);
910 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
911
912 //cleanup
913 BUFFER_delete(hBuffer);
914 }
915
916 /* Tests_SRS_BUFFER_07_039: [ BUFFER_shrink shall allocate a temporary buffer of existing buffer size minus decreaseSize. ] */
917 /* Tests_SRS_BUFFER_07_041: [ if the fromEnd variable is false, BUFFER_shrink shall remove the beginning of the buffer of size decreaseSize. ] */
918 TEST_FUNCTION(BUFFER_shrink_from_beginning_succeed)
919 {
920 const unsigned char TEST_TOTAL_BUFFER[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
921
922 //arrange
923 int nResult;
924 BUFFER_HANDLE hBuffer;
925 hBuffer = BUFFER_new();
926 nResult = BUFFER_build(hBuffer, TEST_TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE);
927 umock_c_reset_all_calls();
928
929 STRICT_EXPECTED_CALL(gballoc_malloc(TOTAL_ALLOCATION_SIZE-ALLOCATION_SIZE));
930 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
931
932 //act
933 nResult = BUFFER_shrink(hBuffer, ALLOCATION_SIZE, false);
934
935 //assert
936 ASSERT_ARE_EQUAL(int, nResult, 0);
937 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hBuffer), ADDITIONAL_BUFFER, ALLOCATION_SIZE));
938 ASSERT_ARE_EQUAL(size_t, BUFFER_length(hBuffer), ALLOCATION_SIZE);
939 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
940
941 //cleanup
942 BUFFER_delete(hBuffer);
943 }
944
945
946 /* Tests_SRS_BUFFER_07_017: [BUFFER_enlarge shall return a nonzero result if any parameters are NULL or zero.] */
947 /* Tests_SRS_BUFFER_07_018: [BUFFER_enlarge shall return a nonzero result if any error is encountered.] */
948 TEST_FUNCTION(BUFFER_enlarge_Size_Zero_Fail)
949 {
950 ///arrange
951 int nResult;
952 BUFFER_HANDLE g_hBuffer;
953 g_hBuffer = BUFFER_new();
954 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
955 umock_c_reset_all_calls();
956
957 ///act
958 nResult = BUFFER_enlarge(g_hBuffer, 0);
959
960 ///assert
961 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
962 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
963
964 ///cleanup
965 BUFFER_delete(g_hBuffer);
966 }
967
968 /* BUFFER_content Tests BEGIN */
969 /* Tests_SRS_BUFFER_07_019: [BUFFER_content shall return the data contained within the BUFFER_HANDLE.] */
970 TEST_FUNCTION(BUFFER_content_Succeed)
971 {
972 ///arrange
973 int nResult;
974 const unsigned char* content;
975 BUFFER_HANDLE g_hBuffer;
976 g_hBuffer = BUFFER_new();
977 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
978 umock_c_reset_all_calls();
979
980 ///act
981 content = NULL;
982 nResult = BUFFER_content(g_hBuffer, &content);
983
984 ///assert
985 ASSERT_ARE_EQUAL(int, nResult, 0);
986 ASSERT_ARE_EQUAL(int, 0, memcmp(content, BUFFER_TEST_VALUE, ALLOCATION_SIZE));
987 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
988
989 ///cleanup
990 BUFFER_delete(g_hBuffer);
991 }
992
993 /* Tests_SRS_BUFFER_07_020: [If the handle and/or content*is NULL BUFFER_content shall return nonzero.] */
994 TEST_FUNCTION(BUFFER_content_HANDLE_NULL_Fail)
995 {
996 ///arrange
997
998 ///act
999 const unsigned char* content = NULL;
1000 int nResult = BUFFER_content(NULL, &content);
1001
1002 ///assert
1003 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1004 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1005 ASSERT_IS_NULL(content);
1006
1007 ///cleanup
1008
1009 }
1010
1011 /* Tests_SRS_BUFFER_07_020: [If the handle and/or content*is NULL BUFFER_content shall return nonzero.] */
1012 TEST_FUNCTION(BUFFER_content_Char_NULL_Fail)
1013 {
1014 ///arrange
1015 int nResult;
1016 BUFFER_HANDLE g_hBuffer;
1017 g_hBuffer = BUFFER_new();
1018 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1019 umock_c_reset_all_calls();
1020
1021 ///act
1022 nResult = BUFFER_content(g_hBuffer, NULL);
1023
1024 ///assert
1025 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1026 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1027
1028 ///cleanup
1029 BUFFER_delete(g_hBuffer);
1030 }
1031
1032 /* BUFFER_size Tests BEGIN */
1033 /* Tests_SRS_BUFFER_07_021: [BUFFER_size shall place the size of the associated buffer in the size variable and return zero on success.] */
1034 TEST_FUNCTION(BUFFER_size_Succeed)
1035 {
1036 ///arrange
1037 int nResult;
1038 size_t size;
1039 BUFFER_HANDLE g_hBuffer;
1040 g_hBuffer = BUFFER_new();
1041 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1042 umock_c_reset_all_calls();
1043
1044 ///act
1045 size = 0;
1046 nResult = BUFFER_size(g_hBuffer, &size);
1047
1048 ///assert
1049 ASSERT_ARE_EQUAL(int, nResult, 0);
1050 ASSERT_ARE_EQUAL(size_t, size, ALLOCATION_SIZE);
1051 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1052
1053
1054 ///cleanup
1055 BUFFER_delete(g_hBuffer);
1056 }
1057
1058 /* Tests_SRS_BUFFER_07_022: [BUFFER_size shall return a nonzero value for any error that is encountered.] */
1059 TEST_FUNCTION(BUFFER_size_HANDLE_NULL_Fail)
1060 {
1061 ///arrange
1062
1063 ///act
1064 size_t size = 0;
1065 int nResult = BUFFER_size(NULL, &size);
1066
1067 ///assert
1068 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1069 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1070 }
1071
1072 /* Tests_SRS_BUFFER_07_022: [BUFFER_size shall return a nonzero value for any error that is encountered.] */
1073 TEST_FUNCTION(BUFFER_size_Size_t_NULL_Fail)
1074 {
1075 ///arrange
1076 int nResult;
1077 BUFFER_HANDLE g_hBuffer;
1078 g_hBuffer = BUFFER_new();
1079 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1080 umock_c_reset_all_calls();
1081
1082 ///act
1083 nResult = BUFFER_size(g_hBuffer, NULL);
1084
1085 ///assert
1086 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1087 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1088
1089 ///cleanup
1090 BUFFER_delete(g_hBuffer);
1091 }
1092
1093 /* BUFFER_append Tests BEGIN */
1094 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1095 TEST_FUNCTION(BUFFER_append_Succeed)
1096 {
1097 ///arrange
1098 int nResult;
1099 BUFFER_HANDLE hAppend;
1100 BUFFER_HANDLE g_hBuffer;
1101 g_hBuffer = BUFFER_new();
1102 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1103 hAppend = BUFFER_new();
1104 nResult = BUFFER_build(hAppend, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
1105 umock_c_reset_all_calls();
1106
1107 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, ALLOCATION_SIZE + ALLOCATION_SIZE))
1108 .IgnoreArgument(1);
1109
1110 ///act
1111 nResult = BUFFER_append(g_hBuffer, hAppend);
1112
1113 ///assert
1114 ASSERT_ARE_EQUAL(int, nResult, 0);
1115 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(g_hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE));
1116 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hAppend), ADDITIONAL_BUFFER, ALLOCATION_SIZE));
1117 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1118
1119 ///cleanup
1120 BUFFER_delete(hAppend);
1121 BUFFER_delete(g_hBuffer);
1122 }
1123
1124 /* Tests_SRS_BUFFER_07_023: [BUFFER_append shall return a nonzero upon any error that is encountered.] */
1125 TEST_FUNCTION(BUFFER_append_HANDLE_NULL_Fail)
1126 {
1127 ///arrange
1128 int nResult;
1129 BUFFER_HANDLE hAppend = BUFFER_new();
1130 nResult = BUFFER_build(hAppend, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
1131 umock_c_reset_all_calls();
1132
1133 ///act
1134 nResult = BUFFER_append(NULL, hAppend);
1135
1136 ///assert
1137 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1138 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1139
1140 ///cleanup
1141 BUFFER_delete(hAppend);
1142 }
1143
1144 /* Tests_SRS_BUFFER_07_023: [BUFFER_append shall return a nonzero upon any error that is encountered.] */
1145 TEST_FUNCTION(BUFFER_append_APPEND_HANDLE_NULL_Fail)
1146 {
1147 ///arrange
1148 int nResult;
1149 BUFFER_HANDLE g_hBuffer;
1150 g_hBuffer = BUFFER_new();
1151 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1152 umock_c_reset_all_calls();
1153
1154 ///act
1155 nResult = BUFFER_append(g_hBuffer, NULL);
1156
1157 ///assert
1158 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1159 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1160
1161 ///cleanup
1162 BUFFER_delete(g_hBuffer);
1163 }
1164
1165 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1166 TEST_FUNCTION(BUFFER_append_HANDLE2_SIZE_ZERO_SUCCEED)
1167 {
1168 ///arrange
1169 int nResult;
1170 size_t howBig;
1171 BUFFER_HANDLE handle1 = BUFFER_create(BUFFER_Test1, BUFFER_TEST1_SIZE);
1172 BUFFER_HANDLE handle2 = BUFFER_create(BUFFER_Test2, 0);
1173 // umock_c_reset_all_calls();
1174
1175 ///act
1176 nResult = BUFFER_append(handle1, handle2);
1177
1178 ///assert
1179 ASSERT_ARE_EQUAL(int, nResult, 0);
1180 howBig = BUFFER_length(handle1);
1181 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(handle1), BUFFER_Test1, BUFFER_TEST1_SIZE));
1182 ASSERT_ARE_EQUAL(size_t, BUFFER_TEST1_SIZE, howBig);
1183
1184 //ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1185
1186 ///cleanup
1187 BUFFER_delete(handle1);
1188 BUFFER_delete(handle2);
1189 }
1190
1191 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1192 TEST_FUNCTION(BUFFER_append_HANDLE1_SIZE_ZERO_SUCCEED)
1193 {
1194 ///arrange
1195 int nResult;
1196 size_t howBig;
1197 BUFFER_HANDLE handle1 = BUFFER_create(BUFFER_Test1, 0);
1198 BUFFER_HANDLE handle2 = BUFFER_create(BUFFER_Test2, BUFFER_TEST2_SIZE);
1199 // umock_c_reset_all_calls();
1200
1201 ///act
1202 nResult = BUFFER_append(handle1, handle2);
1203
1204 ///assert
1205 ASSERT_ARE_EQUAL(int, nResult, 0);
1206 howBig = BUFFER_length(handle1);
1207 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(handle1), BUFFER_Test2, BUFFER_TEST2_SIZE));
1208 ASSERT_ARE_EQUAL(size_t, BUFFER_TEST2_SIZE, howBig);
1209
1210 //ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1211
1212 ///cleanup
1213 BUFFER_delete(handle1);
1214 BUFFER_delete(handle2);
1215 }
1216
1217 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1218 TEST_FUNCTION(BUFFER_prepend_HANDLE1_SIZE_ZERO_SUCCEED)
1219 {
1220 ///arrange
1221 int nResult;
1222 size_t howBig;
1223 BUFFER_HANDLE handle1 = BUFFER_create(BUFFER_Test1, 0);
1224 BUFFER_HANDLE handle2 = BUFFER_create(BUFFER_Test2, BUFFER_TEST2_SIZE);
1225 // umock_c_reset_all_calls();
1226
1227 ///act
1228 nResult = BUFFER_prepend(handle1, handle2);
1229
1230 ///assert
1231 ASSERT_ARE_EQUAL(int, nResult, 0);
1232 howBig = BUFFER_length(handle1);
1233 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(handle1), BUFFER_Test2, BUFFER_TEST2_SIZE));
1234 ASSERT_ARE_EQUAL(size_t, BUFFER_TEST2_SIZE, howBig);
1235
1236 //ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1237
1238 ///cleanup
1239 BUFFER_delete(handle1);
1240 BUFFER_delete(handle2);
1241 }
1242
1243 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1244 TEST_FUNCTION(BUFFER_prepend_HANDLE2_SIZE_ZERO_SUCCEED)
1245 {
1246 ///arrange
1247 int nResult;
1248 size_t howBig;
1249 BUFFER_HANDLE handle1 = BUFFER_create(BUFFER_Test1, BUFFER_TEST1_SIZE);
1250 BUFFER_HANDLE handle2 = BUFFER_create(BUFFER_Test2, 0);
1251 // umock_c_reset_all_calls();
1252
1253 ///act
1254 nResult = BUFFER_prepend(handle1, handle2);
1255
1256 ///assert
1257 ASSERT_ARE_EQUAL(int, nResult, 0);
1258 howBig = BUFFER_length(handle1);
1259 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(handle1), BUFFER_Test1, BUFFER_TEST1_SIZE));
1260 ASSERT_ARE_EQUAL(size_t, BUFFER_TEST1_SIZE, howBig);
1261
1262 //ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1263
1264 ///cleanup
1265 BUFFER_delete(handle1);
1266 BUFFER_delete(handle2);
1267 }
1268
1269
1270 /* Tests_SRS_BUFFER_01_005: [ BUFFER_prepend shall return a non-zero upon value any error that is encountered. ]*/
1271 TEST_FUNCTION(BUFFER_prepend_APPEND_HANDLE1_NULL_Fail)
1272 {
1273 ///arrange
1274 int nResult;
1275 BUFFER_HANDLE g_hBuffer;
1276 g_hBuffer = BUFFER_new();
1277 nResult = BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1278 umock_c_reset_all_calls();
1279
1280 ///act
1281 nResult = BUFFER_prepend(g_hBuffer, NULL);
1282
1283 ///assert
1284 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1285 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1286
1287 ///cleanup
1288 BUFFER_delete(g_hBuffer);
1289 }
1290
1291 /* Tests_SRS_BUFFER_01_005: [ BUFFER_prepend shall return a non-zero upon value any error that is encountered. ]*/
1292 TEST_FUNCTION(BUFFER_prepend_APPEND_HANDLE2_NULL_Fail)
1293 {
1294 ///arrange
1295 int nResult;
1296 BUFFER_HANDLE hAppend = BUFFER_new();
1297 nResult = BUFFER_build(hAppend, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
1298 umock_c_reset_all_calls();
1299
1300 ///act
1301 nResult = BUFFER_prepend(NULL, hAppend);
1302
1303 ///assert
1304 ASSERT_ARE_NOT_EQUAL(int, nResult, 0);
1305 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1306
1307 ///cleanup
1308 BUFFER_delete(hAppend);
1309 }
1310
1311 /* Tests_SRS_BUFFER_07_024: [BUFFER_append concatenates b2 onto b1 without modifying b2 and shall return zero on success.] */
1312 TEST_FUNCTION(BUFFER_prepend_Succeed)
1313 {
1314 ///arrange
1315 int nResult;
1316 BUFFER_HANDLE g_hBuffer;
1317 BUFFER_HANDLE hAppend;
1318 g_hBuffer = BUFFER_new();
1319 nResult = BUFFER_build(g_hBuffer, ADDITIONAL_BUFFER, ALLOCATION_SIZE);
1320 hAppend = BUFFER_new();
1321 nResult = BUFFER_build(hAppend, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1322 umock_c_reset_all_calls();
1323
1324 STRICT_EXPECTED_CALL(gballoc_malloc(ALLOCATION_SIZE + ALLOCATION_SIZE));
1325 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
1326
1327 ///act
1328 nResult = BUFFER_prepend(g_hBuffer, hAppend);
1329
1330 ///assert
1331 ASSERT_ARE_EQUAL(int, nResult, 0);
1332 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(g_hBuffer), TOTAL_BUFFER, TOTAL_ALLOCATION_SIZE));
1333 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hAppend), BUFFER_TEST_VALUE, ALLOCATION_SIZE));
1334
1335 //TOTAL_BUFFER
1336 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1337
1338 ///cleanup
1339 BUFFER_delete(hAppend);
1340 BUFFER_delete(g_hBuffer);
1341 }
1342
1343 /* BUFFER_u_char */
1344
1345 /* Tests_SRS_BUFFER_07_025: [BUFFER_u_char shall return a pointer to the underlying unsigned char*.] */
1346 TEST_FUNCTION(BUFFER_U_CHAR_Succeed)
1347 {
1348 ///arrange
1349 BUFFER_HANDLE g_hBuffer;
1350 unsigned char* u;
1351 g_hBuffer = BUFFER_new();
1352 (void)BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1353 umock_c_reset_all_calls();
1354
1355 ///act
1356 u = BUFFER_u_char(g_hBuffer);
1357
1358 ///assert
1359 ASSERT_ARE_EQUAL(int, 0, memcmp(u, BUFFER_TEST_VALUE, ALLOCATION_SIZE) );
1360 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1361
1362 ///cleanup
1363 BUFFER_delete(g_hBuffer);
1364 }
1365
1366 /* Tests_SRS_BUFFER_07_026: [BUFFER_u_char shall return NULL for any error that is encountered.] */
1367 TEST_FUNCTION(BUFFER_U_CHAR_HANDLE_NULL_Fail)
1368 {
1369 ///arrange
1370
1371 ///act
1372 ASSERT_IS_NULL(BUFFER_u_char(NULL));
1373
1374 /// assert
1375 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1376 }
1377
1378 /* Tests_SRS_BUFFER_07_029: [BUFFER_u_char shall return NULL if underlying buffer size is zero.] */
1379 TEST_FUNCTION(BUFFER_U_CHAR_HANDLE_SIZE_ZERO_Fail)
1380 {
1381 ///arrange
1382 unsigned char c = 'c';
1383 BUFFER_HANDLE g_hBuffer = BUFFER_create(&c, 0);
1384 umock_c_reset_all_calls();
1385
1386 ///act
1387 ASSERT_IS_NULL(BUFFER_u_char(g_hBuffer));
1388
1389 /// assert
1390 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1391
1392 /// cleanup
1393 BUFFER_delete(g_hBuffer);
1394 }
1395
1396 /* BUFFER_length */
1397
1398 /* Tests_SRS_BUFFER_07_027: [BUFFER_length shall return the size of the underlying buffer.] */
1399 TEST_FUNCTION(BUFFER_length_Succeed)
1400 {
1401 ///arrange
1402 BUFFER_HANDLE g_hBuffer;
1403 size_t l;
1404 g_hBuffer = BUFFER_new();
1405 (void)BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1406 umock_c_reset_all_calls();
1407
1408 ///act
1409 l = BUFFER_length(g_hBuffer);
1410
1411 ///assert
1412 ASSERT_ARE_EQUAL(size_t, l, ALLOCATION_SIZE);
1413 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1414
1415 ///cleanup
1416 BUFFER_delete(g_hBuffer);
1417 }
1418
1419 /* Tests_SRS_BUFFER_07_028: [BUFFER_length shall return zero for any error that is encountered.] */
1420 TEST_FUNCTION(BUFFER_length_HANDLE_NULL_Succeed)
1421 {
1422 ///arrange
1423
1424 ///act
1425 size_t size = BUFFER_length(NULL);
1426
1427 ///assert
1428 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1429 ASSERT_ARE_EQUAL(size_t, size, 0);
1430 }
1431
1432 TEST_FUNCTION(BUFFER_Clone_Succeed)
1433 {
1434 ///arrange
1435 BUFFER_HANDLE g_hBuffer;
1436 BUFFER_HANDLE hclone;
1437 g_hBuffer = BUFFER_new();
1438 (void)BUFFER_build(g_hBuffer, BUFFER_TEST_VALUE, ALLOCATION_SIZE);
1439 umock_c_reset_all_calls();
1440
1441 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments();
1442 STRICT_EXPECTED_CALL(gballoc_malloc(ALLOCATION_SIZE));
1443
1444 ///act
1445 hclone = BUFFER_clone(g_hBuffer);
1446
1447 ///assert
1448 ASSERT_ARE_EQUAL(int, 0, memcmp(BUFFER_u_char(hclone), BUFFER_TEST_VALUE, ALLOCATION_SIZE) );
1449 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1450
1451 ///cleanup
1452 BUFFER_delete(g_hBuffer);
1453 BUFFER_delete(hclone);
1454 }
1455
1456 TEST_FUNCTION(BUFFER_Clone_HANDLE_NULL_Fail)
1457 {
1458 ///arrange
1459
1460 ///act
1461 BUFFER_HANDLE result = BUFFER_clone(NULL);
1462
1463 ///assert
1464 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1465 ASSERT_IS_NULL(result);
1466 }
1467
1468 /*Tests_SRS_BUFFER_02_001: [If source is NULL then BUFFER_create shall return NULL.] */
1469 TEST_FUNCTION(BUFFER_create_with_NULL_source_fails)
1470 {
1471 ///arrange
1472
1473 ///act
1474 BUFFER_HANDLE res = BUFFER_create(NULL, 0);
1475
1476 ///assert
1477 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1478 ASSERT_IS_NULL(res);
1479
1480 ///cleanup
1481 }
1482
1483 /*Tests_SRS_BUFFER_02_002: [Otherwise, BUFFER_create shall allocate memory to hold size bytes and shall copy from source size bytes into the newly allocated memory.] */
1484 /*Tests_SRS_BUFFER_02_004: [Otherwise, BUFFER_create shall return a non-NULL handle*/
1485 TEST_FUNCTION(BUFFER_create_happy_path)
1486 {
1487 ///arrange
1488 BUFFER_HANDLE res;
1489 const unsigned char* data;
1490 size_t howBig;
1491 char c = '3';
1492
1493 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1494 .IgnoreAllArguments();
1495
1496 STRICT_EXPECTED_CALL(gballoc_malloc(1));
1497
1498 ///act
1499 res = BUFFER_create((const unsigned char*)&c, 1);
1500
1501 ///assert
1502 ASSERT_IS_NOT_NULL(res);
1503 howBig = BUFFER_length(res);
1504 ASSERT_ARE_EQUAL(size_t, 1, howBig);
1505 data = BUFFER_u_char(res);
1506 ASSERT_ARE_EQUAL(uint8_t, '3', data[0]);
1507
1508 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1509
1510 ///cleanup
1511 BUFFER_delete(res);
1512 }
1513
1514 /*Tests_SRS_BUFFER_02_002: [Otherwise, BUFFER_create shall allocate memory to hold size bytes and shall copy from source size bytes into the newly allocated memory.] */
1515 /* Tests_SRS_BUFFER_02_005: [If size parameter is 0 then 1 byte of memory shall be allocated yet size of the buffer shall be set to 0.]*/
1516 TEST_FUNCTION(BUFFER_create_ZERO_SIZE_SUCCEED)
1517 {
1518 ///arrange
1519 size_t howBig;
1520 BUFFER_HANDLE res;
1521 const unsigned char* data;
1522 char c = '3';
1523
1524 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1525 .IgnoreAllArguments();
1526
1527 STRICT_EXPECTED_CALL(gballoc_malloc(1));
1528
1529 ///act
1530 res = BUFFER_create((const unsigned char*)&c, 0);
1531 ///assert
1532 ASSERT_IS_NOT_NULL(res);
1533 howBig = BUFFER_length(res);
1534 data = BUFFER_u_char(res);
1535 ASSERT_IS_NULL(data);
1536 ASSERT_ARE_EQUAL(size_t, 0, howBig);
1537
1538 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1539
1540 ///cleanup
1541 BUFFER_delete(res);
1542 }
1543
1544 /*Tests_SRS_BUFFER_02_003: [If allocating memory fails, then BUFFER_create shall return NULL.] */
1545 TEST_FUNCTION(BUFFER_create_fails_when_gballoc_fails_1)
1546 {
1547 ///arrange
1548 char c = '3';
1549 BUFFER_HANDLE res;
1550
1551 whenShallmalloc_fail = 1;
1552 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
1553 STRICT_EXPECTED_CALL(gballoc_malloc(1));
1554 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
1555
1556 ///act
1557 res = BUFFER_create((const unsigned char*)&c, 1);
1558
1559 ///assert
1560 ASSERT_IS_NULL(res);
1561 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1562
1563 ///cleanup
1564 BUFFER_delete(res);
1565 }
1566
1567 /*Tests_SRS_BUFFER_02_003: [If allocating memory fails, then BUFFER_create shall return NULL.] */
1568 TEST_FUNCTION(BUFFER_create_fails_when_gballoc_fails_2)
1569 {
1570 ///arrange
1571 char c = '3';
1572 BUFFER_HANDLE res;
1573
1574 whenShallcalloc_fail = 1;
1575 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1576 .IgnoreAllArguments();
1577
1578 ///act
1579 res = BUFFER_create((const unsigned char*)&c, 1);
1580
1581 ///assert
1582 ASSERT_IS_NULL(res);
1583 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1584
1585 ///cleanup
1586 BUFFER_delete(res);
1587 }
1588
1589 // Tests_SRS_BUFFER_07_029: [ BUFFER_create_with_size shall create a BUFFER_HANDLE with a pre allocated underlying buffer size.]
1590 // Tests_SRS_BUFFER_07_031: [ BUFFER_create_with_size shall allocate a buffer of buff_size. ]
1591 // Tests_SRS_BUFFER_07_033: [ Otherwise, BUFFER_create_with_size shall return a non-NULL handle. ]
1592 TEST_FUNCTION(BUFFER_create_with_size_succeeds)
1593 {
1594 //arrange
1595 BUFFER_HANDLE res;
1596 size_t alloc_size = 32;
1597
1598 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1599 .IgnoreAllArguments();
1600 STRICT_EXPECTED_CALL(gballoc_malloc(alloc_size));
1601
1602 //act
1603 res = BUFFER_create_with_size(alloc_size);
1604
1605 //assert
1606 ASSERT_IS_NOT_NULL(res);
1607 ASSERT_ARE_EQUAL(size_t, alloc_size, BUFFER_length(res));
1608 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1609
1610 //cleanup
1611 BUFFER_delete(res);
1612 }
1613
1614 // Tests_SRS_BUFFER_07_030: [ If buff_size is 0 BUFFER_create_with_size shall create a valid non-NULL handle of zero size. ]
1615 TEST_FUNCTION(BUFFER_create_with_size_size_zero_succeeds)
1616 {
1617 //arrange
1618 BUFFER_HANDLE res;
1619 size_t alloc_size = 0;
1620
1621 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1622 .IgnoreAllArguments();
1623
1624 //act
1625 res = BUFFER_create_with_size(alloc_size);
1626
1627 //assert
1628 ASSERT_IS_NOT_NULL(res);
1629 ASSERT_ARE_EQUAL(size_t, alloc_size, BUFFER_length(res));
1630 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1631
1632 //cleanup
1633 BUFFER_delete(res);
1634 }
1635
1636 // Tests_SRS_BUFFER_07_032: [ If allocating memory fails, then BUFFER_create_with_size shall return NULL. ]
1637 TEST_FUNCTION(BUFFER_create_with_size_malloc_fails)
1638 {
1639 //arrange
1640 BUFFER_HANDLE res;
1641 size_t alloc_size = 32;
1642
1643 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1644 .IgnoreAllArguments()
1645 .SetReturn(NULL);
1646
1647 //act
1648 res = BUFFER_create_with_size(alloc_size);
1649
1650 //assert
1651 ASSERT_IS_NULL(res);
1652 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1653
1654 //cleanup
1655 }
1656
1657 // Tests_SRS_BUFFER_07_031: [ BUFFER_create_with_size shall allocate a buffer of buff_size. ]
1658 TEST_FUNCTION(BUFFER_create_with_size_2nd_malloc_fails)
1659 {
1660 //arrange
1661 BUFFER_HANDLE res;
1662 size_t alloc_size = 32;
1663
1664 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
1665 .IgnoreAllArguments();
1666 STRICT_EXPECTED_CALL(gballoc_malloc(alloc_size)).SetReturn(NULL);
1667 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
1668
1669 //act
1670 res = BUFFER_create_with_size(alloc_size);
1671
1672 //assert
1673 ASSERT_IS_NULL(res);
1674 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1675
1676 //cleanup
1677 }
1678
1679 /* BUFFER_fill */
1680
1681 /* Tests_SRS_BUFFER_07_001: [ BUFFER_fill shall fill the supplied BUFFER_HANDLE with the supplied fill character. ] */
1682 TEST_FUNCTION(BUFFER_fill_succeed)
1683 {
1684 int result;
1685 char* expected;
1686 char* actual;
1687
1688 //arrange
1689 BUFFER_HANDLE buffer = BUFFER_new();
1690 const unsigned char RESULT_BUFFER[] = { '@', '@', '@', '@', '@' };
1691 (void)BUFFER_build(buffer, BUFFER_Test1, BUFFER_TEST1_SIZE);
1692 umock_c_reset_all_calls();
1693
1694 //act
1695 result = BUFFER_fill(buffer, '@');
1696
1697 expected = umockc_stringify_buffer(RESULT_BUFFER, BUFFER_TEST1_SIZE);
1698 actual = umockc_stringify_buffer(BUFFER_u_char(buffer), BUFFER_length(buffer));
1699
1700 //assert
1701 ASSERT_ARE_EQUAL(int, 0, result);
1702 ASSERT_ARE_EQUAL(char_ptr, expected, actual);
1703 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1704
1705 //cleanup
1706 BUFFER_delete(buffer);
1707 my_gballoc_free(expected);
1708 my_gballoc_free(actual);
1709 }
1710
1711 /* Tests_SRS_BUFFER_07_002: [ If handle is NULL BUFFER_fill shall return a non-zero value. ] */
1712 TEST_FUNCTION(BUFFER_fill_handle_NULL_fail)
1713 {
1714 int result;
1715
1716 //arrange
1717 umock_c_reset_all_calls();
1718
1719 //act
1720 result = BUFFER_fill(NULL, '@');
1721
1722 ///assert
1723 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1724 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1725
1726 //cleanup
1727 }
1728
1729 /* Tests_SRS_BUFFER_07_001: [ BUFFER_fill shall fill the supplied BUFFER_HANDLE with the supplied fill character. ] */
1730 TEST_FUNCTION(BUFFER_fill_empty_buffer_succeed)
1731 {
1732 int result;
1733
1734 //arrange
1735 BUFFER_HANDLE buffer = BUFFER_new();
1736
1737 umock_c_reset_all_calls();
1738
1739 //act
1740 result = BUFFER_fill(buffer, '@');
1741
1742 ///assert
1743 ASSERT_ARE_EQUAL(int, 0, result);
1744 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1745
1746 //cleanup
1747 BUFFER_delete(buffer);
1748 }
1749
1750 END_TEST_SUITE(Buffer_UnitTests)