Debian Codegraph @

src/vendor/azure-uamqp-c/tests/message_ut/message_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 "testrunnerswitcher.h"
14 #include "umock_c/umock_c.h"
15 #include "umock_c/umock_c_negative_tests.h"
16
17 // TODO: Add tests for each part of the message where the value is cleared and then read
18
19 static void* my_gballoc_malloc(size_t size)
20 {
21 return malloc(size);
22 }
23
24 static void* my_gballoc_calloc(size_t nmemb, size_t size)
25 {
26 return calloc(nmemb, size);
27 }
28
29 static void* my_gballoc_realloc(void* ptr, size_t size)
30 {
31 return realloc(ptr, size);
32 }
33
34 static void my_gballoc_free(void* ptr)
35 {
36 free(ptr);
37 }
38
39 #define ENABLE_MOCKS
40
41 #include "azure_c_shared_utility/gballoc.h"
42 #include "azure_uamqp_c/amqpvalue.h"
43 #include "azure_uamqp_c/amqp_definitions.h"
44
45 #undef ENABLE_MOCKS
46
47 #include "azure_uamqp_c/message.h"
48
49 TEST_DEFINE_ENUM_TYPE(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_VALUES)
50
51 static const HEADER_HANDLE test_header = (HEADER_HANDLE)0x4242;
52 static const HEADER_HANDLE cloned_header = (HEADER_HANDLE)0x4243;
53 static const delivery_annotations test_delivery_annotations = (delivery_annotations)0x4244;
54 static const delivery_annotations cloned_delivery_annotations = (delivery_annotations)0x4245;
55 static const delivery_annotations other_cloned_delivery_annotations = (delivery_annotations)0x4246;
56 static const message_annotations test_message_annotations = (message_annotations)0x4247;
57 static const message_annotations cloned_message_annotations = (message_annotations)0x4248;
58 static const message_annotations other_cloned_message_annotations = (message_annotations)0x4249;
59 static const PROPERTIES_HANDLE test_message_properties = (PROPERTIES_HANDLE)0x424A;
60 static const PROPERTIES_HANDLE cloned_message_properties = (PROPERTIES_HANDLE)0x4250;
61 static const PROPERTIES_HANDLE other_cloned_message_properties = (PROPERTIES_HANDLE)0x4251;
62 static const AMQP_VALUE test_application_properties = (AMQP_VALUE)0x4252;
63 static const AMQP_VALUE cloned_application_properties = (AMQP_VALUE)0x4253;
64 static const AMQP_VALUE other_cloned_application_properties = (AMQP_VALUE)0x4254;
65 static const annotations test_footer = (annotations)0x4255;
66 static const annotations cloned_footer = (annotations)0x4256;
67 static const annotations other_cloned_footer = (annotations)0x4257;
68 static const AMQP_VALUE test_amqp_value_1 = (AMQP_VALUE)0x4258;
69 static const AMQP_VALUE test_amqp_value_2 = (AMQP_VALUE)0x4259;
70 static const AMQP_VALUE cloned_amqp_value = (AMQP_VALUE)0x425A;
71 static const AMQP_VALUE test_sequence_1 = (AMQP_VALUE)0x425B;
72 static const AMQP_VALUE cloned_sequence_1 = (AMQP_VALUE)0x425C;
73 static const AMQP_VALUE test_sequence_2 = (AMQP_VALUE)0x425D;
74 static const AMQP_VALUE cloned_sequence_2 = (AMQP_VALUE)0x4260;
75
76 static const HEADER_HANDLE another_test_header = (HEADER_HANDLE)0x4261;
77
78 static TEST_MUTEX_HANDLE g_testByTest;
79
80 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
81
82 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
83 {
84 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
85 }
86
87 static void stringify_bytes(const unsigned char* bytes, size_t byte_count, char* output_string)
88 {
89 size_t i;
90 size_t pos = 0;
91
92 output_string[pos++] = '[';
93 for (i = 0; i < byte_count; i++)
94 {
95 (void)sprintf(&output_string[pos], "0x%02X", bytes[i]);
96 if (i < byte_count - 1)
97 {
98 strcat(output_string, ",");
99 }
100 pos = strlen(output_string);
101 }
102 output_string[pos++] = ']';
103 output_string[pos++] = '\0';
104 }
105
106 BEGIN_TEST_SUITE(message_ut)
107
108 TEST_SUITE_INITIALIZE(suite_init)
109 {
110 g_testByTest = TEST_MUTEX_CREATE();
111 ASSERT_IS_NOT_NULL(g_testByTest);
112
113 umock_c_init(on_umock_c_error);
114
115 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
116 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
117 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
118 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
119 REGISTER_GLOBAL_MOCK_RETURN(header_clone, cloned_header);
120 REGISTER_GLOBAL_MOCK_RETURN(annotations_clone, cloned_delivery_annotations);
121 REGISTER_GLOBAL_MOCK_RETURN(properties_clone, cloned_message_properties);
122 REGISTER_UMOCK_ALIAS_TYPE(HEADER_HANDLE, void*);
123 REGISTER_UMOCK_ALIAS_TYPE(AMQP_VALUE, void*);
124 REGISTER_UMOCK_ALIAS_TYPE(PROPERTIES_HANDLE, void*);
125 }
126
127 TEST_SUITE_CLEANUP(suite_cleanup)
128 {
129 umock_c_deinit();
130
131 TEST_MUTEX_DESTROY(g_testByTest);
132 }
133
134 TEST_FUNCTION_INITIALIZE(test_init)
135 {
136 if (TEST_MUTEX_ACQUIRE(g_testByTest))
137 {
138 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
139 }
140
141 umock_c_reset_all_calls();
142 }
143
144 TEST_FUNCTION_CLEANUP(test_cleanup)
145 {
146 TEST_MUTEX_RELEASE(g_testByTest);
147 }
148
149 /* message_create */
150
151 /* Tests_SRS_MESSAGE_01_001: [`message_create` shall create a new AMQP message instance and on success it shall return a non-NULL handle for the newly created message instance.] */
152 TEST_FUNCTION(message_create_succeeds)
153 {
154 // arrange
155 MESSAGE_HANDLE message;
156
157 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
158
159 // act
160 message = message_create();
161
162 // assert
163 ASSERT_IS_NOT_NULL(message);
164 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
165
166 // cleanup
167 message_destroy(message);
168 }
169
170 /* Tests_SRS_MESSAGE_01_001: [`message_create` shall create a new AMQP message instance and on success it shall return a non-NULL handle for the newly created message instance.] */
171 TEST_FUNCTION(message_create_2_times_yields_2_different_message_instances)
172 {
173 // arrange
174 MESSAGE_HANDLE message1;
175 MESSAGE_HANDLE message2;
176
177 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
178 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
179
180 // act
181 message1 = message_create();
182 message2 = message_create();
183
184 // assert
185 ASSERT_IS_NOT_NULL(message1, "Creating the first message failed");
186 ASSERT_IS_NOT_NULL(message2, "Creating the second message failed");
187 ASSERT_ARE_NOT_EQUAL(void_ptr, message1, message2);
188 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
189
190 // cleanup
191 message_destroy(message1);
192 message_destroy(message2);
193 }
194
195 /* Tests_SRS_MESSAGE_01_002: [If allocating memory for the message fails, `message_create` shall fail and return NULL.] */
196 TEST_FUNCTION(when_allocating_memory_for_the_message_fails_then_message_create_fails)
197 {
198 // arrange
199 MESSAGE_HANDLE message;
200 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
201 .SetReturn(NULL);
202
203 // act
204 message = message_create();
205
206 // assert
207 ASSERT_IS_NULL(message);
208 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
209 }
210
211 /* message_clone */
212
213 /* Tests_SRS_MESSAGE_01_003: [`message_clone` shall clone a message entirely and on success return a non-NULL handle to the cloned message.] */
214 /* Tests_SRS_MESSAGE_01_005: [If a header exists on the source message it shall be cloned by using `header_clone`.] */
215 /* Tests_SRS_MESSAGE_01_006: [If delivery annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
216 /* Tests_SRS_MESSAGE_01_007: [If message annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
217 /* Tests_SRS_MESSAGE_01_008: [If message properties exist on the source message they shall be cloned by using `properties_clone`.] */
218 /* Tests_SRS_MESSAGE_01_009: [If application properties exist on the source message they shall be cloned by using `amqpvalue_clone`.] */
219 /* Tests_SRS_MESSAGE_01_010: [If a footer exists on the source message it shall be cloned by using `annotations_clone`.] */
220 /* Tests_SRS_MESSAGE_01_011: [If an AMQP data has been set as message body on the source message it shall be cloned by allocating memory for the binary payload.] */
221 TEST_FUNCTION(message_clone_with_a_message_that_has_all_fields_set_and_amqp_data_body_succeeds)
222 {
223 // arrange
224 MESSAGE_HANDLE message;
225 MESSAGE_HANDLE source_message = message_create();
226 unsigned char data_section[2] = { 0x42, 0x43 };
227 BINARY_DATA binary_data;
228
229 binary_data.bytes = data_section;
230 binary_data.length = sizeof(data_section);
231
232 umock_c_reset_all_calls();
233
234 STRICT_EXPECTED_CALL(header_clone(test_header))
235 .SetReturn(cloned_header);
236 (void)message_set_header(source_message, test_header);
237 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
238 .SetReturn(cloned_delivery_annotations);
239 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
240 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
241 .SetReturn(cloned_message_annotations);
242 (void)message_set_message_annotations(source_message, test_message_annotations);
243 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
244 .SetReturn(cloned_message_properties);
245 (void)message_set_properties(source_message, test_message_properties);
246 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
247 .SetReturn(cloned_application_properties);
248 (void)message_set_application_properties(source_message, test_application_properties);
249 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
250 .SetReturn(cloned_footer);
251 (void)message_set_footer(source_message, test_footer);
252 (void)message_add_body_amqp_data(source_message, binary_data);
253 umock_c_reset_all_calls();
254
255 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
256 STRICT_EXPECTED_CALL(header_clone(cloned_header));
257 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
258 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
259 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
260 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
261 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
262 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
263 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(data_section)));
264
265 // act
266 message = message_clone(source_message);
267
268 // assert
269 ASSERT_IS_NOT_NULL(message);
270 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
271
272 // cleanup
273 message_destroy(source_message);
274 message_destroy(message);
275 }
276
277 /* Tests_SRS_MESSAGE_01_003: [`message_clone` shall clone a message entirely and on success return a non-NULL handle to the cloned message.] */
278 /* Tests_SRS_MESSAGE_01_005: [If a header exists on the source message it shall be cloned by using `header_clone`.] */
279 /* Tests_SRS_MESSAGE_01_006: [If delivery annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
280 /* Tests_SRS_MESSAGE_01_007: [If message annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
281 /* Tests_SRS_MESSAGE_01_008: [If message properties exist on the source message they shall be cloned by using `properties_clone`.] */
282 /* Tests_SRS_MESSAGE_01_009: [If application properties exist on the source message they shall be cloned by using `amqpvalue_clone`.] */
283 /* Tests_SRS_MESSAGE_01_010: [If a footer exists on the source message it shall be cloned by using `annotations_clone`.] */
284 /* Tests_SRS_MESSAGE_01_159: [If an AMQP value has been set as message body on the source message it shall be cloned by calling `amqpvalue_clone`. ]*/
285 TEST_FUNCTION(message_clone_with_a_message_that_has_all_fields_set_and_amqp_value_body_succeeds)
286 {
287 // arrange
288 MESSAGE_HANDLE message;
289 MESSAGE_HANDLE source_message = message_create();
290 umock_c_reset_all_calls();
291
292 STRICT_EXPECTED_CALL(header_clone(test_header))
293 .SetReturn(cloned_header);
294 (void)message_set_header(source_message, test_header);
295 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
296 .SetReturn(cloned_delivery_annotations);
297 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
298 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
299 .SetReturn(cloned_message_annotations);
300 (void)message_set_message_annotations(source_message, test_message_annotations);
301 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
302 .SetReturn(cloned_message_properties);
303 (void)message_set_properties(source_message, test_message_properties);
304 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
305 .SetReturn(cloned_application_properties);
306 (void)message_set_application_properties(source_message, test_application_properties);
307 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
308 .SetReturn(cloned_footer);
309 (void)message_set_footer(source_message, test_footer);
310 STRICT_EXPECTED_CALL(annotations_clone(test_amqp_value_1))
311 .SetReturn(cloned_amqp_value);
312 (void)message_set_body_amqp_value(source_message, test_amqp_value_1);
313 umock_c_reset_all_calls();
314
315 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
316 STRICT_EXPECTED_CALL(header_clone(cloned_header));
317 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
318 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
319 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
320 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
321 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
322 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_amqp_value));
323
324 // act
325 message = message_clone(source_message);
326
327 // assert
328 ASSERT_IS_NOT_NULL(message);
329 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
330
331 // cleanup
332 message_destroy(source_message);
333 message_destroy(message);
334 }
335
336 /* Tests_SRS_MESSAGE_01_003: [`message_clone` shall clone a message entirely and on success return a non-NULL handle to the cloned message.] */
337 /* Tests_SRS_MESSAGE_01_005: [If a header exists on the source message it shall be cloned by using `header_clone`.] */
338 /* Tests_SRS_MESSAGE_01_006: [If delivery annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
339 /* Tests_SRS_MESSAGE_01_007: [If message annotations exist on the source message they shall be cloned by using `annotations_clone`.] */
340 /* Tests_SRS_MESSAGE_01_008: [If message properties exist on the source message they shall be cloned by using `properties_clone`.] */
341 /* Tests_SRS_MESSAGE_01_009: [If application properties exist on the source message they shall be cloned by using `amqpvalue_clone`.] */
342 /* Tests_SRS_MESSAGE_01_010: [If a footer exists on the source message it shall be cloned by using `annotations_clone`.] */
343 /* Tests_SRS_MESSAGE_01_160: [ If AMQP sequences are set as AMQP body they shall be cloned by calling `amqpvalue_clone`. ] */
344 TEST_FUNCTION(message_clone_with_a_message_that_has_all_fields_set_and_amqp_sequence_body_succeeds)
345 {
346 // arrange
347 MESSAGE_HANDLE message;
348 MESSAGE_HANDLE source_message = message_create();
349 unsigned char data_section[2] = { 0x42, 0x43 };
350 BINARY_DATA binary_data;
351
352 binary_data.bytes = data_section;
353 binary_data.length = sizeof(data_section);
354
355 umock_c_reset_all_calls();
356
357 STRICT_EXPECTED_CALL(header_clone(test_header))
358 .SetReturn(cloned_header);
359 (void)message_set_header(source_message, test_header);
360 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
361 .SetReturn(cloned_delivery_annotations);
362 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
363 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
364 .SetReturn(cloned_message_annotations);
365 (void)message_set_message_annotations(source_message, test_message_annotations);
366 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
367 .SetReturn(cloned_message_properties);
368 (void)message_set_properties(source_message, test_message_properties);
369 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
370 .SetReturn(cloned_application_properties);
371 (void)message_set_application_properties(source_message, test_application_properties);
372 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
373 .SetReturn(cloned_footer);
374 (void)message_set_footer(source_message, test_footer);
375 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
376 .SetReturn(cloned_sequence_1);
377 (void)message_add_body_amqp_sequence(source_message, test_sequence_1);
378 umock_c_reset_all_calls();
379
380 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
381 STRICT_EXPECTED_CALL(header_clone(cloned_header));
382 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
383 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
384 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
385 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
386 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
387 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
388 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_sequence_1));
389
390 // act
391 message = message_clone(source_message);
392
393 // assert
394 ASSERT_IS_NOT_NULL(message);
395 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
396
397 // cleanup
398 message_destroy(source_message);
399 message_destroy(message);
400 }
401
402 /* Tests_SRS_MESSAGE_01_012: [ If any cloning operation for the members of the source message fails, then `message_clone` shall fail and return NULL. ]*/
403 TEST_FUNCTION(when_any_clone_operations_fails_message_clone_for_a_message_with_data_body_fails)
404 {
405 // arrange
406 MESSAGE_HANDLE source_message = message_create();
407 unsigned char data_section[2] = { 0x42, 0x43 };
408 BINARY_DATA binary_data;
409 size_t count;
410 size_t index;
411
412 int negativeTestsInitResult = umock_c_negative_tests_init();
413 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
414
415 binary_data.bytes = data_section;
416 binary_data.length = sizeof(data_section);
417
418 umock_c_reset_all_calls();
419
420 STRICT_EXPECTED_CALL(header_clone(test_header))
421 .SetReturn(cloned_header);
422 (void)message_set_header(source_message, test_header);
423 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
424 .SetReturn(cloned_delivery_annotations);
425 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
426 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
427 .SetReturn(cloned_message_annotations);
428 (void)message_set_message_annotations(source_message, test_message_annotations);
429 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
430 .SetReturn(cloned_message_properties);
431 (void)message_set_properties(source_message, test_message_properties);
432 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
433 .SetReturn(cloned_application_properties);
434 (void)message_set_application_properties(source_message, test_application_properties);
435 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
436 .SetReturn(cloned_footer);
437 (void)message_set_footer(source_message, test_footer);
438 (void)message_add_body_amqp_data(source_message, binary_data);
439 umock_c_reset_all_calls();
440
441 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
442 STRICT_EXPECTED_CALL(header_clone(cloned_header));
443 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
444 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
445 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
446 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
447 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
448 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
449 STRICT_EXPECTED_CALL(gballoc_malloc(sizeof(data_section)));
450
451 umock_c_negative_tests_snapshot();
452
453 count = umock_c_negative_tests_call_count();
454 for (index = 0; index < count - 4; index++)
455 {
456 MESSAGE_HANDLE message;
457 char tmp_msg[128];
458 (void)sprintf(tmp_msg, "Failure in test %u/%u", (unsigned int)(index + 1), (unsigned int)count);
459
460 umock_c_negative_tests_reset();
461 umock_c_negative_tests_fail_call(index);
462
463 // act
464 message = message_clone(source_message);
465
466 // assert
467 ASSERT_IS_NULL(message, tmp_msg);
468 }
469
470 // cleanup
471 umock_c_negative_tests_deinit();
472 message_destroy(source_message);
473 }
474
475 /* Tests_SRS_MESSAGE_01_012: [ If any cloning operation for the members of the source message fails, then `message_clone` shall fail and return NULL. ]*/
476 TEST_FUNCTION(when_any_clone_operations_fails_message_clone_for_a_message_with_value_body_fails)
477 {
478 // arrange
479 MESSAGE_HANDLE source_message = message_create();
480 size_t count;
481 size_t index;
482
483 int negativeTestsInitResult = umock_c_negative_tests_init();
484 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
485 umock_c_reset_all_calls();
486
487 STRICT_EXPECTED_CALL(header_clone(test_header))
488 .SetReturn(cloned_header);
489 (void)message_set_header(source_message, test_header);
490 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
491 .SetReturn(cloned_delivery_annotations);
492 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
493 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
494 .SetReturn(cloned_message_annotations);
495 (void)message_set_message_annotations(source_message, test_message_annotations);
496 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
497 .SetReturn(cloned_message_properties);
498 (void)message_set_properties(source_message, test_message_properties);
499 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
500 .SetReturn(cloned_application_properties);
501 (void)message_set_application_properties(source_message, test_application_properties);
502 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
503 .SetReturn(cloned_footer);
504 (void)message_set_footer(source_message, test_footer);
505 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1))
506 .SetReturn(cloned_amqp_value);
507 (void)message_set_body_amqp_value(source_message, test_amqp_value_1);
508 umock_c_reset_all_calls();
509
510 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
511 STRICT_EXPECTED_CALL(header_clone(cloned_header));
512 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
513 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
514 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
515 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
516 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
517 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_amqp_value));
518
519 umock_c_negative_tests_snapshot();
520
521 count = umock_c_negative_tests_call_count();
522 for (index = 0; index < count - 4; index++)
523 {
524 MESSAGE_HANDLE message;
525 char tmp_msg[128];
526 (void)sprintf(tmp_msg, "Failure in test %u/%u", (unsigned int)(index + 1), (unsigned int)count);
527
528 umock_c_negative_tests_reset();
529 umock_c_negative_tests_fail_call(index);
530
531 // act
532 message = message_clone(source_message);
533
534 // assert
535 ASSERT_IS_NULL(message, tmp_msg);
536 }
537
538 // cleanup
539 umock_c_negative_tests_deinit();
540 message_destroy(source_message);
541 }
542
543 /* Tests_SRS_MESSAGE_01_012: [ If any cloning operation for the members of the source message fails, then `message_clone` shall fail and return NULL. ]*/
544 TEST_FUNCTION(when_any_clone_operations_fails_message_clone_for_a_message_with_sequence_body_fails)
545 {
546 // arrange
547 MESSAGE_HANDLE source_message = message_create();
548 size_t count;
549 size_t index;
550
551 int negativeTestsInitResult = umock_c_negative_tests_init();
552 ASSERT_ARE_EQUAL(int, 0, negativeTestsInitResult);
553 umock_c_reset_all_calls();
554
555 STRICT_EXPECTED_CALL(header_clone(test_header))
556 .SetReturn(cloned_header);
557 (void)message_set_header(source_message, test_header);
558 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
559 .SetReturn(cloned_delivery_annotations);
560 (void)message_set_delivery_annotations(source_message, test_delivery_annotations);
561 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
562 .SetReturn(cloned_message_annotations);
563 (void)message_set_message_annotations(source_message, test_message_annotations);
564 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
565 .SetReturn(cloned_message_properties);
566 (void)message_set_properties(source_message, test_message_properties);
567 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
568 .SetReturn(cloned_application_properties);
569 (void)message_set_application_properties(source_message, test_application_properties);
570 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
571 .SetReturn(cloned_footer);
572 (void)message_set_footer(source_message, test_footer);
573 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
574 .SetReturn(cloned_sequence_1);
575 (void)message_add_body_amqp_sequence(source_message, test_sequence_1);
576 umock_c_reset_all_calls();
577
578 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
579 STRICT_EXPECTED_CALL(header_clone(cloned_header));
580 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations));
581 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations));
582 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties));
583 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_application_properties));
584 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer));
585 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
586 STRICT_EXPECTED_CALL(amqpvalue_clone(cloned_sequence_1));
587
588 umock_c_negative_tests_snapshot();
589
590 count = umock_c_negative_tests_call_count();
591 for (index = 0; index < count - 4; index++)
592 {
593 MESSAGE_HANDLE message;
594 char tmp_msg[128];
595 (void)sprintf(tmp_msg, "Failure in test %u/%u", (unsigned int)(index + 1), (unsigned int)count);
596
597 umock_c_negative_tests_reset();
598 umock_c_negative_tests_fail_call(index);
599
600 // act
601 message = message_clone(source_message);
602
603 // assert
604 ASSERT_IS_NULL(message, tmp_msg);
605 }
606
607 // cleanup
608 umock_c_negative_tests_deinit();
609 message_destroy(source_message);
610 }
611
612 /* Tests_SRS_MESSAGE_01_062: [If `source_message` is NULL, `message_clone` shall fail and return NULL.] */
613 TEST_FUNCTION(message_clone_with_NULL_message_source_fails)
614 {
615 // arrange
616
617 // act
618 MESSAGE_HANDLE message = message_clone(NULL);
619
620 // assert
621 ASSERT_IS_NULL(message);
622 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
623 }
624
625 /* Tests_SRS_MESSAGE_01_004: [If allocating memory for the new cloned message fails, `message_clone` shall fail and return NULL.] */
626 TEST_FUNCTION(when_allocating_memory_fails_then_message_clone_fails)
627 {
628 // arrange
629 MESSAGE_HANDLE message;
630 MESSAGE_HANDLE source_message = message_create();
631 umock_c_reset_all_calls();
632
633 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
634 .SetReturn(NULL);
635
636 // act
637 message = message_clone(source_message);
638
639 // assert
640 ASSERT_IS_NULL(message);
641 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
642
643 // cleanup
644 message_destroy(source_message);
645 }
646
647 /* message_destroy */
648
649 /* Tests_SRS_MESSAGE_01_013: [ `message_destroy` shall free all resources allocated by the message instance identified by the `message` argument. ]*/
650 TEST_FUNCTION(message_destroy_frees_the_allocated_memory)
651 {
652 // arrange
653 MESSAGE_HANDLE message = message_create();
654 umock_c_reset_all_calls();
655 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
656
657 // act
658 message_destroy(message);
659
660 // assert
661 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
662 }
663
664 /* Tests_SRS_MESSAGE_01_014: [ If `message` is NULL, `message_destroy` shall do nothing. ]*/
665 TEST_FUNCTION(message_destroy_with_NULL_does_nothing)
666 {
667 // arrange
668
669 // act
670 message_destroy(NULL);
671
672 // assert
673 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
674 }
675
676 /* Tests_SRS_MESSAGE_01_015: [ The message header shall be freed by calling `header_destroy`. ]*/
677 TEST_FUNCTION(when_a_header_was_set_it_is_destroyed)
678 {
679 // arrange
680 MESSAGE_HANDLE message = message_create();
681 umock_c_reset_all_calls();
682 STRICT_EXPECTED_CALL(header_clone(test_header));
683 (void)message_set_header(message, test_header);
684 umock_c_reset_all_calls();
685
686 STRICT_EXPECTED_CALL(header_destroy(cloned_header));
687 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
688
689 // act
690 message_destroy(message);
691
692 // assert
693 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
694 }
695
696 /* Tests_SRS_MESSAGE_01_016: [ The delivery annotations shall be freed by calling `annotations_destroy`. ]*/
697 TEST_FUNCTION(when_delivery_annotations_were_set_they_are_destroyed)
698 {
699 // arrange
700 MESSAGE_HANDLE message = message_create();
701 umock_c_reset_all_calls();
702 STRICT_EXPECTED_CALL(amqpvalue_clone(test_delivery_annotations))
703 .SetReturn(cloned_delivery_annotations);
704 (void)message_set_delivery_annotations(message, test_delivery_annotations);
705 umock_c_reset_all_calls();
706
707 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_delivery_annotations));
708 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
709
710 // act
711 message_destroy(message);
712
713 // assert
714 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
715 }
716
717 /* Tests_SRS_MESSAGE_01_017: [ The message annotations shall be freed by calling `annotations_destroy`. ]*/
718 TEST_FUNCTION(when_message_annotations_were_set_they_are_destroyed)
719 {
720 // arrange
721 MESSAGE_HANDLE message = message_create();
722 umock_c_reset_all_calls();
723 STRICT_EXPECTED_CALL(amqpvalue_clone(test_message_annotations))
724 .SetReturn(cloned_message_annotations);
725 (void)message_set_message_annotations(message, test_message_annotations);
726 umock_c_reset_all_calls();
727
728 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_message_annotations));
729 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
730
731 // act
732 message_destroy(message);
733
734 // assert
735 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
736 }
737
738 /* Tests_SRS_MESSAGE_01_018: [ The message properties shall be freed by calling `properties_destroy`. ]*/
739 TEST_FUNCTION(when_message_properties_were_set_they_are_destroyed)
740 {
741 // arrange
742 MESSAGE_HANDLE message = message_create();
743 umock_c_reset_all_calls();
744 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
745 .SetReturn(cloned_message_properties);
746 (void)message_set_properties(message, test_message_properties);
747 umock_c_reset_all_calls();
748
749 STRICT_EXPECTED_CALL(properties_destroy(cloned_message_properties));
750 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
751
752 // act
753 message_destroy(message);
754
755 // assert
756 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
757 }
758
759 /* Tests_SRS_MESSAGE_01_019: [ The application properties shall be freed by calling `amqpvalue_destroy`. ]*/
760 TEST_FUNCTION(when_application_properties_were_set_they_are_destroyed)
761 {
762 // arrange
763 MESSAGE_HANDLE message = message_create();
764 umock_c_reset_all_calls();
765 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
766 .SetReturn(cloned_application_properties);
767 (void)message_set_application_properties(message, test_application_properties);
768 umock_c_reset_all_calls();
769
770 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_application_properties));
771 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
772
773 // act
774 message_destroy(message);
775
776 // assert
777 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
778 }
779
780 /* Tests_SRS_MESSAGE_01_020: [ The message footer shall be freed by calling `annotations_destroy`. ]*/
781 TEST_FUNCTION(when_message_footer_was_set_it_is_destroyed)
782 {
783 // arrange
784 MESSAGE_HANDLE message = message_create();
785 umock_c_reset_all_calls();
786 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
787 .SetReturn(cloned_footer);
788 (void)message_set_footer(message, test_footer);
789 umock_c_reset_all_calls();
790
791 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_footer));
792 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
793
794 // act
795 message_destroy(message);
796
797 // assert
798 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
799 }
800
801 /* Tests_SRS_MESSAGE_01_021: [ If the message body is made of an AMQP value, the value shall be freed by calling `amqpvalue_destroy`. ]*/
802 TEST_FUNCTION(when_an_AMQP_value_is_set_as_body_message_destroy_frees_it)
803 {
804 // arrange
805 MESSAGE_HANDLE message = message_create();
806 umock_c_reset_all_calls();
807 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1))
808 .SetReturn(cloned_amqp_value);
809 (void)message_set_body_amqp_value(message, test_amqp_value_1);
810 umock_c_reset_all_calls();
811
812 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_amqp_value));
813 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
814
815 // act
816 message_destroy(message);
817
818 // assert
819 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
820 }
821
822 /* Tests_SRS_MESSAGE_01_136: [ If the message body is made of several AMQP data items, they shall all be freed. ]*/
823 TEST_FUNCTION(when_an_AMQP_data_is_set_as_body_message_destroy_frees_it)
824 {
825 // arrange
826 MESSAGE_HANDLE message = message_create();
827 unsigned char data_bytes_1[] = { 0x42 };
828 BINARY_DATA binary_data_1;
829 binary_data_1.bytes = data_bytes_1;
830 binary_data_1.length = sizeof(data_bytes_1);
831 umock_c_reset_all_calls();
832 (void)message_add_body_amqp_data(message, binary_data_1);
833 umock_c_reset_all_calls();
834
835 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
836 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
837 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
838
839 // act
840 message_destroy(message);
841
842 // assert
843 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
844 }
845
846 /* Tests_SRS_MESSAGE_01_136: [ If the message body is made of several AMQP data items, they shall all be freed. ]*/
847 TEST_FUNCTION(when_two_AMQP_data_items_are_set_as_body_message_destroy_frees_them)
848 {
849 // arrange
850 MESSAGE_HANDLE message = message_create();
851 unsigned char data_bytes_1[] = { 0x42 };
852 BINARY_DATA binary_data_1;
853 unsigned char data_bytes_2[] = { 0x43 };
854 BINARY_DATA binary_data_2;
855 binary_data_1.bytes = data_bytes_1;
856 binary_data_1.length = sizeof(data_bytes_1);
857 binary_data_2.bytes = data_bytes_2;
858 binary_data_2.length = sizeof(data_bytes_2);
859 umock_c_reset_all_calls();
860 (void)message_add_body_amqp_data(message, binary_data_1);
861 (void)message_add_body_amqp_data(message, binary_data_2);
862 umock_c_reset_all_calls();
863
864 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
865 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
866 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
867 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
868
869 // act
870 message_destroy(message);
871
872 // assert
873 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
874 }
875
876 /* Tests_SRS_MESSAGE_01_136: [ If the message body is made of several AMQP sequences, they shall all be freed. ]*/
877 /* Tests_SRS_MESSAGE_01_137: [ Each sequence shall be freed by calling `amqpvalue_destroy`. ]*/
878 TEST_FUNCTION(when_one_AMQP_sequence_is_set_as_body_message_destroy_frees_it)
879 {
880 // arrange
881 MESSAGE_HANDLE message = message_create();
882 umock_c_reset_all_calls();
883 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
884 .SetReturn(cloned_sequence_1);
885 (void)message_add_body_amqp_sequence(message, test_sequence_1);
886 umock_c_reset_all_calls();
887
888 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_sequence_1));
889 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
890 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
891
892 // act
893 message_destroy(message);
894
895 // assert
896 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
897 }
898
899 /* Tests_SRS_MESSAGE_01_136: [ If the message body is made of several AMQP sequences, they shall all be freed. ]*/
900 /* Tests_SRS_MESSAGE_01_137: [ Each sequence shall be freed by calling `amqpvalue_destroy`. ]*/
901 TEST_FUNCTION(when_two_AMQP_sequences_are_set_as_body_message_destroy_frees_them)
902 {
903 // arrange
904 MESSAGE_HANDLE message = message_create();
905 umock_c_reset_all_calls();
906 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
907 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
908 .SetReturn(cloned_sequence_1);
909 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
910 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_2))
911 .SetReturn(cloned_sequence_2);
912 (void)message_add_body_amqp_sequence(message, test_sequence_1);
913 (void)message_add_body_amqp_sequence(message, test_sequence_2);
914 umock_c_reset_all_calls();
915
916 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_sequence_1));
917 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_sequence_2));
918 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
919 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
920
921 // act
922 message_destroy(message);
923
924 // assert
925 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
926 }
927
928 /* Tests_SRS_MESSAGE_01_015: [ The message header shall be freed by calling `header_destroy`. ]*/
929 /* Tests_SRS_MESSAGE_01_016: [ The delivery annotations shall be freed by calling `annotations_destroy`. ]*/
930 /* Tests_SRS_MESSAGE_01_017: [ The message annotations shall be freed by calling `annotations_destroy`. ]*/
931 /* Tests_SRS_MESSAGE_01_018: [ The message properties shall be freed by calling `properties_destroy`. ]*/
932 /* Tests_SRS_MESSAGE_01_019: [ The application properties shall be freed by calling `amqpvalue_destroy`. ]*/
933 /* Tests_SRS_MESSAGE_01_020: [ The message footer shall be freed by calling `annotations_destroy`. ]*/
934 /* Tests_SRS_MESSAGE_01_136: [ If the message body is made of several AMQP sequences, they shall all be freed. ]*/
935 /* Tests_SRS_MESSAGE_01_137: [ Each sequence shall be freed by calling `amqpvalue_destroy`. ]*/
936 TEST_FUNCTION(when_all_message_sections_are_set_and_seuqnces_are_used_then_they_are_all_destroyed)
937 {
938 // arrange
939 MESSAGE_HANDLE message = message_create();
940 umock_c_reset_all_calls();
941 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
942 .SetReturn(cloned_footer);
943 (void)message_set_footer(message, test_footer);
944 STRICT_EXPECTED_CALL(amqpvalue_clone(test_application_properties))
945 .SetReturn(cloned_application_properties);
946 (void)message_set_application_properties(message, test_application_properties);
947 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
948 .SetReturn(cloned_message_properties);
949 (void)message_set_properties(message, test_message_properties);
950 STRICT_EXPECTED_CALL(amqpvalue_clone(test_message_annotations))
951 .SetReturn(cloned_message_annotations);
952 (void)message_set_message_annotations(message, test_message_annotations);
953 STRICT_EXPECTED_CALL(amqpvalue_clone(test_delivery_annotations))
954 .SetReturn(cloned_delivery_annotations);
955 (void)message_set_delivery_annotations(message, test_delivery_annotations);
956 STRICT_EXPECTED_CALL(header_clone(test_header));
957 (void)message_set_header(message, test_header);
958 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
959 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
960 .SetReturn(cloned_sequence_1);
961 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
962 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_2))
963 .SetReturn(cloned_sequence_2);
964 (void)message_add_body_amqp_sequence(message, test_sequence_1);
965 (void)message_add_body_amqp_sequence(message, test_sequence_2);
966 umock_c_reset_all_calls();
967
968 STRICT_EXPECTED_CALL(header_destroy(cloned_header));
969 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_delivery_annotations));
970 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_message_annotations));
971 STRICT_EXPECTED_CALL(properties_destroy(cloned_message_properties));
972 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_application_properties));
973 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_footer));
974 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_sequence_1));
975 STRICT_EXPECTED_CALL(amqpvalue_destroy(cloned_sequence_2));
976 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
977 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
978
979 // act
980 message_destroy(message);
981
982 // assert
983 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
984 }
985
986 /* message_set_header */
987
988 /* Tests_SRS_MESSAGE_01_022: [ `message_set_header` shall copy the contents of `message_header` as the header for the message instance identified by message. ]*/
989 /* Tests_SRS_MESSAGE_01_023: [ On success it shall return 0. ]*/
990 /* Tests_SRS_MESSAGE_01_025: [ Cloning the header shall be done by calling `header_clone`. ]*/
991 TEST_FUNCTION(message_set_header_copies_the_header)
992 {
993 // arrange
994 int result;
995 MESSAGE_HANDLE message = message_create();
996 umock_c_reset_all_calls();
997
998 STRICT_EXPECTED_CALL(header_clone(test_header));
999
1000 // act
1001 result = message_set_header(message, test_header);
1002
1003 // assert
1004 ASSERT_ARE_EQUAL(int, 0, result);
1005 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1006
1007 // cleanup
1008 message_destroy(message);
1009 }
1010
1011 /* Tests_SRS_MESSAGE_01_024: [ If `message` is NULL, `message_set_header` shall fail and return a non-zero value. ]*/
1012 TEST_FUNCTION(message_set_header_with_NULL_message_fails)
1013 {
1014 // arrange
1015 int result;
1016
1017 // act
1018 result = message_set_header(NULL, test_header);
1019
1020 // assert
1021 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1022 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1023 }
1024
1025 /* Tests_SRS_MESSAGE_01_024: [ If `message` is NULL, `message_set_header` shall fail and return a non-zero value. ]*/
1026 TEST_FUNCTION(message_set_header_with_NULL_is_allowed)
1027 {
1028 // arrange
1029 int result;
1030 MESSAGE_HANDLE message = message_create();
1031 umock_c_reset_all_calls();
1032
1033 // act
1034 result = message_set_header(message, NULL);
1035
1036 // assert
1037 ASSERT_ARE_EQUAL(int, 0, result);
1038 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1039
1040 // cleanup
1041 message_destroy(message);
1042 }
1043
1044 /* Tests_SRS_MESSAGE_01_026: [ If `header_clone` fails, `message_set_header` shall fail and return a non-zero value. ]*/
1045 TEST_FUNCTION(when_header_clone_fails_message_set_header_fails)
1046 {
1047 // arrange
1048 int result;
1049 MESSAGE_HANDLE message = message_create();
1050 umock_c_reset_all_calls();
1051
1052 STRICT_EXPECTED_CALL(header_clone(test_header))
1053 .SetReturn(NULL);
1054
1055 // act
1056 result = message_set_header(message, test_header);
1057
1058 // assert
1059 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1060 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1061
1062 // cleanup
1063 message_destroy(message);
1064 }
1065
1066 /* Tests_SRS_MESSAGE_01_138: [ If setting the header fails, the previous value shall be preserved. ]*/
1067 TEST_FUNCTION(when_header_clone_fails_previous_header_is_kept)
1068 {
1069 // arrange
1070 HEADER_HANDLE result_header;
1071 int result;
1072 MESSAGE_HANDLE message = message_create();
1073 umock_c_reset_all_calls();
1074
1075 STRICT_EXPECTED_CALL(header_clone(test_header))
1076 .SetReturn(cloned_header);
1077 (void)message_set_header(message, test_header);
1078 STRICT_EXPECTED_CALL(header_clone(another_test_header))
1079 .SetReturn(NULL);
1080 (void)message_set_header(message, another_test_header);
1081 STRICT_EXPECTED_CALL(header_clone(cloned_header))
1082 .SetReturn(cloned_header);
1083
1084 // act
1085 result = message_get_header(message, &result_header);
1086
1087 // assert
1088 ASSERT_ARE_EQUAL(void_ptr, cloned_header, result_header);
1089 ASSERT_ARE_EQUAL(int, 0, result);
1090 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1091
1092 // cleanup
1093 message_destroy(message);
1094 }
1095
1096 /* Tests_SRS_MESSAGE_01_139: [ If `message_header` is NULL, the previously stored header associated with `message` shall be freed. ]*/
1097 TEST_FUNCTION(when_setting_a_NULL_header_previous_header_is_freed)
1098 {
1099 // arrange
1100 HEADER_HANDLE result_header;
1101 int result;
1102 MESSAGE_HANDLE message = message_create();
1103 umock_c_reset_all_calls();
1104
1105 STRICT_EXPECTED_CALL(header_clone(test_header))
1106 .SetReturn(cloned_header);
1107 (void)message_set_header(message, test_header);
1108 STRICT_EXPECTED_CALL(header_destroy(cloned_header));
1109 (void)message_set_header(message, NULL);
1110
1111 // act
1112 result = message_get_header(message, &result_header);
1113
1114 // assert
1115 ASSERT_IS_NULL(result_header);
1116 ASSERT_ARE_EQUAL(int, 0, result);
1117 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1118
1119 // cleanup
1120 message_destroy(message);
1121 }
1122
1123 /* Tests_SRS_MESSAGE_01_139: [ If `message_header` is NULL, the previously stored header associated with `message` shall be freed. ]*/
1124 TEST_FUNCTION(when_setting_a_NULL_header_twice_does_not_crash)
1125 {
1126 // arrange
1127 int result;
1128 MESSAGE_HANDLE message = message_create();
1129 umock_c_reset_all_calls();
1130
1131 STRICT_EXPECTED_CALL(header_clone(test_header))
1132 .SetReturn(cloned_header);
1133 (void)message_set_header(message, test_header);
1134 (void)message_set_header(message, NULL);
1135 umock_c_reset_all_calls();
1136
1137 // act
1138 result = message_set_header(message, NULL);
1139
1140 // assert
1141 ASSERT_ARE_EQUAL(int, 0, result);
1142 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1143
1144 // cleanup
1145 message_destroy(message);
1146 }
1147
1148 /* message_get_header */
1149
1150 /* Tests_SRS_MESSAGE_01_027: [ `message_get_header` shall copy the contents of header for the message instance identified by `message` into the argument `message_header`. ]*/
1151 /* Tests_SRS_MESSAGE_01_028: [ On success, `message_get_header` shall return 0.]*/
1152 /* Tests_SRS_MESSAGE_01_030: [ Cloning the header shall be done by calling `header_clone`. ]*/
1153 TEST_FUNCTION(message_get_header_gets_the_value)
1154 {
1155 // arrange
1156 HEADER_HANDLE expected_header = (HEADER_HANDLE)0x5678;
1157 HEADER_HANDLE result_header;
1158 int result;
1159 MESSAGE_HANDLE message = message_create();
1160 umock_c_reset_all_calls();
1161
1162 STRICT_EXPECTED_CALL(header_clone(test_header))
1163 .SetReturn(cloned_header);
1164 (void)message_set_header(message, test_header);
1165
1166 STRICT_EXPECTED_CALL(header_clone(cloned_header))
1167 .SetReturn(expected_header);
1168
1169 // act
1170 result = message_get_header(message, &result_header);
1171
1172 // assert
1173 ASSERT_ARE_EQUAL(void_ptr, expected_header, result_header);
1174 ASSERT_ARE_EQUAL(int, 0, result);
1175 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1176
1177 // cleanup
1178 message_destroy(message);
1179 }
1180
1181 /* Tests_SRS_MESSAGE_01_028: [ On success, `message_get_header` shall return 0.]*/
1182 /* Tests_SRS_MESSAGE_01_143: [ If no header has been set, `message_get_header` shall set `message_header` to NULL. ]*/
1183 TEST_FUNCTION(message_get_header_when_no_header_was_set_yields_NULL)
1184 {
1185 // arrange
1186 HEADER_HANDLE result_header;
1187 int result;
1188 MESSAGE_HANDLE message = message_create();
1189 umock_c_reset_all_calls();
1190
1191 // act
1192 result = message_get_header(message, &result_header);
1193
1194 // assert
1195 ASSERT_IS_NULL(result_header);
1196 ASSERT_ARE_EQUAL(int, 0, result);
1197 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1198
1199 // cleanup
1200 message_destroy(message);
1201 }
1202
1203 /* Tests_SRS_MESSAGE_01_029: [ If `message` or `message_header` is NULL, `message_get_header` shall fail and return a non-zero value. ]*/
1204 TEST_FUNCTION(message_get_header_with_NULL_message_header_fails)
1205 {
1206 // arrange
1207 int result;
1208 MESSAGE_HANDLE message = message_create();
1209 umock_c_reset_all_calls();
1210
1211 STRICT_EXPECTED_CALL(header_clone(test_header))
1212 .SetReturn(cloned_header);
1213 (void)message_set_header(message, test_header);
1214
1215 // act
1216 result = message_get_header(message, NULL);
1217
1218 // assert
1219 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1220 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1221
1222 // cleanup
1223 message_destroy(message);
1224 }
1225
1226 /* Tests_SRS_MESSAGE_01_029: [ If `message` or `message_header` is NULL, `message_get_header` shall fail and return a non-zero value. ]*/
1227 TEST_FUNCTION(message_get_header_with_NULL_message_fails)
1228 {
1229 // arrange
1230 int result;
1231 HEADER_HANDLE result_header;
1232
1233 // act
1234 result = message_get_header(NULL, &result_header);
1235
1236 // assert
1237 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1238 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1239 }
1240
1241 /* Tests_SRS_MESSAGE_01_031: [ If `header_clone` fails, `message_get_header` shall fail and return a non-zero value. ]*/
1242 TEST_FUNCTION(when_header_clone_fails_message_get_header_fails)
1243 {
1244 // arrange
1245 HEADER_HANDLE result_header;
1246 int result;
1247 MESSAGE_HANDLE message = message_create();
1248 umock_c_reset_all_calls();
1249
1250 STRICT_EXPECTED_CALL(header_clone(test_header))
1251 .SetReturn(cloned_header);
1252 (void)message_set_header(message, test_header);
1253
1254 STRICT_EXPECTED_CALL(header_clone(cloned_header))
1255 .SetReturn(NULL);
1256
1257 // act
1258 result = message_get_header(message, &result_header);
1259
1260 // assert
1261 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1262 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1263
1264 // cleanup
1265 message_destroy(message);
1266 }
1267
1268 /* message_set_delivery_annotations */
1269
1270 /* Tests_SRS_MESSAGE_01_032: [ `message_set_delivery_annotations` shall copy the contents of `annotations` as the delivery annotations for the message instance identified by `message`. ]*/
1271 /* Tests_SRS_MESSAGE_01_033: [ On success it shall return 0. ]*/
1272 /* Tests_SRS_MESSAGE_01_035: [ Cloning the delivery annotations shall be done by calling `annotations_clone`. ]*/
1273 TEST_FUNCTION(message_set_delivery_annotations_copies_the_annotations)
1274 {
1275 // arrange
1276 int result;
1277 MESSAGE_HANDLE message = message_create();
1278 umock_c_reset_all_calls();
1279
1280 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations));
1281
1282 // act
1283 result = message_set_delivery_annotations(message, test_delivery_annotations);
1284
1285 // assert
1286 ASSERT_ARE_EQUAL(int, 0, result);
1287 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1288
1289 // cleanup
1290 message_destroy(message);
1291 }
1292
1293 /* Tests_SRS_MESSAGE_01_032: [ `message_set_delivery_annotations` shall copy the contents of `annotations` as the delivery annotations for the message instance identified by `message`. ]*/
1294 /* Tests_SRS_MESSAGE_01_033: [ On success it shall return 0. ]*/
1295 /* Tests_SRS_MESSAGE_01_035: [ Cloning the delivery annotations shall be done by calling `annotations_clone`. ]*/
1296 TEST_FUNCTION(message_set_delivery_annotations_with_NULL_annotations_succeeds)
1297 {
1298 // arrange
1299 int result;
1300 MESSAGE_HANDLE message = message_create();
1301 umock_c_reset_all_calls();
1302
1303 // act
1304 result = message_set_delivery_annotations(message, NULL);
1305
1306 // assert
1307 ASSERT_ARE_EQUAL(int, 0, result);
1308 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1309
1310 // cleanup
1311 message_destroy(message);
1312 }
1313
1314 /* Tests_SRS_MESSAGE_01_034: [ If `message` is NULL, `message_set_delivery_annotations` shall fail and return a non-zero value. ]*/
1315 TEST_FUNCTION(message_set_delivery_annotations_with_NULL_message_fails)
1316 {
1317 // arrange
1318 int result;
1319
1320 // act
1321 result = message_set_delivery_annotations(NULL, test_delivery_annotations);
1322
1323 // assert
1324 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1325 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1326 }
1327
1328 /* Tests_SRS_MESSAGE_01_141: [ If `annotations` is NULL, the previously stored delivery annotations associated with `message` shall be freed. ]*/
1329 TEST_FUNCTION(message_set_delivery_annotations_with_NULL_delivery_annotations_frees_previous_delivery_annotations)
1330 {
1331 // arrange
1332 int result;
1333 MESSAGE_HANDLE message = message_create();
1334 umock_c_reset_all_calls();
1335 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1336 .SetReturn(cloned_delivery_annotations);
1337 (void)message_set_delivery_annotations(message, test_delivery_annotations);
1338 umock_c_reset_all_calls();
1339
1340 STRICT_EXPECTED_CALL(annotations_destroy(cloned_delivery_annotations));
1341
1342 // act
1343 result = message_set_delivery_annotations(message, NULL);
1344
1345 // assert
1346 ASSERT_ARE_EQUAL(int, 0, result);
1347 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1348
1349 // cleanup
1350 message_destroy(message);
1351 }
1352
1353 /* Tests_SRS_MESSAGE_01_141: [ If `annotations` is NULL, the previously stored delivery annotations associated with `message` shall be freed. ]*/
1354 TEST_FUNCTION(message_set_delivery_annotations_with_NULL_twice_does_not_crash)
1355 {
1356 // arrange
1357 int result;
1358 MESSAGE_HANDLE message = message_create();
1359 umock_c_reset_all_calls();
1360 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1361 .SetReturn(cloned_delivery_annotations);
1362 (void)message_set_delivery_annotations(message, test_delivery_annotations);
1363 (void)message_set_delivery_annotations(message, NULL);
1364 umock_c_reset_all_calls();
1365
1366 // act
1367 result = message_set_delivery_annotations(message, NULL);
1368
1369 // assert
1370 ASSERT_ARE_EQUAL(int, 0, result);
1371 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1372
1373 // cleanup
1374 message_destroy(message);
1375 }
1376
1377 /* Tests_SRS_MESSAGE_01_036: [ If `annotations_clone` fails, `message_set_delivery_annotations` shall fail and return a non-zero value. ]*/
1378 TEST_FUNCTION(when_cloning_delivery_anootations_fails_message_set_delivery_annotations_fails)
1379 {
1380 // arrange
1381 int result;
1382 MESSAGE_HANDLE message = message_create();
1383 umock_c_reset_all_calls();
1384
1385 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1386 .SetReturn(NULL);
1387
1388 // act
1389 result = message_set_delivery_annotations(message, test_delivery_annotations);
1390
1391 // assert
1392 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1393 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1394
1395 // cleanup
1396 message_destroy(message);
1397 }
1398
1399 /* Tests_SRS_MESSAGE_01_140: [** If setting the delivery annotations fails, the previous value shall be preserved. ]*/
1400 TEST_FUNCTION(when_cloning_delivery_anootations_fails_the_previous_value_is_preserved)
1401 {
1402 // arrange
1403 delivery_annotations stored_delivery_annotations;
1404 int result;
1405 MESSAGE_HANDLE message = message_create();
1406 umock_c_reset_all_calls();
1407
1408 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1409 .SetReturn(cloned_delivery_annotations);
1410 message_set_delivery_annotations(message, test_delivery_annotations);
1411 umock_c_reset_all_calls();
1412
1413 // fail the set delivery annotations
1414 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1415 .SetReturn(NULL);
1416 message_set_delivery_annotations(message, test_delivery_annotations);
1417 umock_c_reset_all_calls();
1418
1419 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations))
1420 .SetReturn(other_cloned_delivery_annotations);
1421
1422 // act
1423 result = message_get_delivery_annotations(message, &stored_delivery_annotations);
1424
1425 // assert
1426 ASSERT_ARE_EQUAL(int, 0, result);
1427 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_delivery_annotations, (void*)stored_delivery_annotations);
1428 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1429
1430 // cleanup
1431 message_destroy(message);
1432 }
1433
1434 /* message_get_delivery_annotations */
1435
1436 /* Tests_SRS_MESSAGE_01_037: [ `message_get_delivery_annotations` shall copy the contents of delivery annotations for the message instance identified by `message` into the argument `annotations`. ]*/
1437 /* Tests_SRS_MESSAGE_01_038: [ On success, `message_get_delivery_annotations` shall return 0. ]*/
1438 /* Tests_SRS_MESSAGE_01_040: [ Cloning the delivery annotations shall be done by calling `annotations_clone`. ]*/
1439 TEST_FUNCTION(message_get_delivery_annotations_clones_thestored_delivery_annotations)
1440 {
1441 // arrange
1442 delivery_annotations stored_delivery_annotations;
1443 int result;
1444 MESSAGE_HANDLE message = message_create();
1445 umock_c_reset_all_calls();
1446
1447 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1448 .SetReturn(cloned_delivery_annotations);
1449 message_set_delivery_annotations(message, test_delivery_annotations);
1450 umock_c_reset_all_calls();
1451
1452 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations))
1453 .SetReturn(other_cloned_delivery_annotations);
1454
1455 // act
1456 result = message_get_delivery_annotations(message, &stored_delivery_annotations);
1457
1458 // assert
1459 ASSERT_ARE_EQUAL(int, 0, result);
1460 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_delivery_annotations, (void*)stored_delivery_annotations);
1461 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1462
1463 // cleanup
1464 message_destroy(message);
1465 }
1466
1467 /* Tests_SRS_MESSAGE_01_039: [ If `message` or `annotations` is NULL, `message_get_delivery_annotations` shall fail and return a non-zero value. ]*/
1468 TEST_FUNCTION(message_get_delivery_annotations_with_NULL_delivery_annotations_fails)
1469 {
1470 // arrange
1471 int result;
1472 MESSAGE_HANDLE message = message_create();
1473 umock_c_reset_all_calls();
1474
1475 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1476 .SetReturn(cloned_delivery_annotations);
1477 message_set_delivery_annotations(message, test_delivery_annotations);
1478 umock_c_reset_all_calls();
1479
1480 // act
1481 result = message_get_delivery_annotations(message, NULL);
1482
1483 // assert
1484 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1485 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1486
1487 // cleanup
1488 message_destroy(message);
1489 }
1490
1491 /* Tests_SRS_MESSAGE_01_039: [ If `message` or `annotations` is NULL, `message_get_delivery_annotations` shall fail and return a non-zero value. ]*/
1492 TEST_FUNCTION(message_get_delivery_annotations_with_NULL_message)
1493 {
1494 // arrange
1495 delivery_annotations stored_delivery_annotations;
1496 int result;
1497
1498 // act
1499 result = message_get_delivery_annotations(NULL, &stored_delivery_annotations);
1500
1501 // assert
1502 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1503 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1504 }
1505
1506 /* Tests_SRS_MESSAGE_01_041: [ If `annotations_clone` fails, `message_get_delivery_annotations` shall fail and return a non-zero value. ]*/
1507 TEST_FUNCTION(when_annotations_clone_fails_message_get_delivery_annotations_fails)
1508 {
1509 // arrange
1510 delivery_annotations stored_delivery_annotations;
1511 int result;
1512 MESSAGE_HANDLE message = message_create();
1513 umock_c_reset_all_calls();
1514
1515 STRICT_EXPECTED_CALL(annotations_clone(test_delivery_annotations))
1516 .SetReturn(cloned_delivery_annotations);
1517 message_set_delivery_annotations(message, test_delivery_annotations);
1518 umock_c_reset_all_calls();
1519
1520 STRICT_EXPECTED_CALL(annotations_clone(cloned_delivery_annotations))
1521 .SetReturn(NULL);
1522
1523 // act
1524 result = message_get_delivery_annotations(message, &stored_delivery_annotations);
1525
1526 // assert
1527 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1528 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1529
1530 // cleanup
1531 message_destroy(message);
1532 }
1533
1534 /* Tests_SRS_MESSAGE_01_142: [ If no delivery annotations have been set, `message_get_delivery_annotations` shall set `annotations` to NULL. ]*/
1535 TEST_FUNCTION(message_get_delivery_annotations_when_not_set_yields_NULL)
1536 {
1537 // arrange
1538 delivery_annotations stored_delivery_annotations = (delivery_annotations)0x0001;
1539 int result;
1540 MESSAGE_HANDLE message = message_create();
1541 umock_c_reset_all_calls();
1542
1543 // act
1544 result = message_get_delivery_annotations(message, &stored_delivery_annotations);
1545
1546 // assert
1547 ASSERT_ARE_EQUAL(int, 0, result);
1548 ASSERT_ARE_EQUAL(void_ptr, NULL, (void*)stored_delivery_annotations);
1549 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1550
1551 // cleanup
1552 message_destroy(message);
1553 }
1554
1555 /* message_set_message_annotations */
1556
1557 /* Tests_SRS_MESSAGE_01_042: [ `message_set_message_annotations` shall copy the contents of `message_annotations` as the message annotations for the message instance identified by `message`. ]*/
1558 /* Tests_SRS_MESSAGE_01_043: [ On success it shall return 0. ]*/
1559 /* Tests_SRS_MESSAGE_01_045: [ Cloning the message annotations shall be done by calling `annotations_clone`. ]*/
1560 TEST_FUNCTION(message_set_message_annotations_copies_the_message_annotations)
1561 {
1562 // arrange
1563 int result;
1564 MESSAGE_HANDLE message = message_create();
1565 umock_c_reset_all_calls();
1566
1567 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations));
1568
1569 // act
1570 result = message_set_message_annotations(message, test_message_annotations);
1571
1572 // assert
1573 ASSERT_ARE_EQUAL(int, 0, result);
1574 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1575
1576 // cleanup
1577 message_destroy(message);
1578 }
1579
1580 /* Tests_SRS_MESSAGE_01_044: [ If `message` is NULL, `message_set_message_annotations` shall fail and return a non-zero value. ]*/
1581 TEST_FUNCTION(message_set_message_annotations_with_NULL_message_fails)
1582 {
1583 // arrange
1584 int result;
1585
1586 // act
1587 result = message_set_message_annotations(NULL, test_message_annotations);
1588
1589 // assert
1590 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1591 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1592 }
1593
1594 /* Tests_SRS_MESSAGE_01_046: [ If `annotations_clone` fails, `message_set_message_annotations` shall fail and return a non-zero value. ]*/
1595 TEST_FUNCTION(when_annotations_clone_fails_message_set_message_annotations_also_fails)
1596 {
1597 // arrange
1598 int result;
1599 MESSAGE_HANDLE message = message_create();
1600 umock_c_reset_all_calls();
1601
1602 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1603 .SetReturn(NULL);
1604
1605 // act
1606 result = message_set_message_annotations(message, test_message_annotations);
1607
1608 // assert
1609 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1610 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1611
1612 // cleanup
1613 message_destroy(message);
1614 }
1615
1616 /* Tests_SRS_MESSAGE_01_144: [ If setting the message annotations fails, the previous value shall be preserved. ]*/
1617 TEST_FUNCTION(when_annotations_clone_fails_message_set_message_annotations_preserves_the_previous_value)
1618 {
1619 // arrange
1620 message_annotations stored_message_annotations;
1621 int result;
1622 MESSAGE_HANDLE message = message_create();
1623 umock_c_reset_all_calls();
1624
1625 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1626 .SetReturn(cloned_message_annotations);
1627 (void)message_set_message_annotations(message, test_message_annotations);
1628 umock_c_reset_all_calls();
1629
1630 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1631 .SetReturn(NULL);
1632 (void)message_set_message_annotations(message, test_message_annotations);
1633 umock_c_reset_all_calls();
1634
1635 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations))
1636 .SetReturn(other_cloned_message_annotations);
1637
1638 // act
1639 result = message_get_message_annotations(message, &stored_message_annotations);
1640
1641 // assert
1642 ASSERT_ARE_EQUAL(int, 0, result);
1643 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_message_annotations, (void*)stored_message_annotations);
1644 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1645
1646 // cleanup
1647 message_destroy(message);
1648 }
1649
1650 /* Tests_SRS_MESSAGE_01_145: [ If `annotations` is NULL, the previously stored message annotations associated with `message` shall be freed. ]*/
1651 TEST_FUNCTION(message_set_message_annotations_with_NULL_frees_previous_value)
1652 {
1653 // arrange
1654 int result;
1655 MESSAGE_HANDLE message = message_create();
1656 umock_c_reset_all_calls();
1657
1658 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1659 .SetReturn(cloned_message_annotations);
1660 (void)message_set_message_annotations(message, test_message_annotations);
1661 umock_c_reset_all_calls();
1662
1663 STRICT_EXPECTED_CALL(annotations_destroy(cloned_message_annotations));
1664
1665 // act
1666 result = message_set_message_annotations(message, NULL);
1667
1668 // assert
1669 ASSERT_ARE_EQUAL(int, 0, result);
1670 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1671
1672 // cleanup
1673 message_destroy(message);
1674 }
1675
1676 /* Tests_SRS_MESSAGE_01_145: [ If `annotations` is NULL, the previously stored message annotations associated with `message` shall be freed. ]*/
1677 TEST_FUNCTION(message_set_message_annotations_with_NULL_twice_does_not_crash)
1678 {
1679 // arrange
1680 int result;
1681 MESSAGE_HANDLE message = message_create();
1682 umock_c_reset_all_calls();
1683
1684 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1685 .SetReturn(cloned_message_annotations);
1686 (void)message_set_message_annotations(message, test_message_annotations);
1687 message_set_message_annotations(message, NULL);
1688 umock_c_reset_all_calls();
1689
1690 // act
1691 result = message_set_message_annotations(message, NULL);
1692
1693 // assert
1694 ASSERT_ARE_EQUAL(int, 0, result);
1695 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1696
1697 // cleanup
1698 message_destroy(message);
1699 }
1700
1701 /* message_get_message_annotations */
1702
1703 /* Tests_SRS_MESSAGE_01_047: [ `message_get_message_annotations` shall copy the contents of message annotations for the message instance identified by `message` into the argument `annotations`. ]*/
1704 /* Tests_SRS_MESSAGE_01_048: [ On success, `message_get_message_annotations` shall return 0. ]*/
1705 /* Tests_SRS_MESSAGE_01_050: [ Cloning the message annotations shall be done by calling `annotations_clone`. ]*/
1706 TEST_FUNCTION(message_get_message_annotations_clones_the_stored_message_annotations)
1707 {
1708 // arrange
1709 message_annotations stored_message_annotations;
1710 int result;
1711 MESSAGE_HANDLE message = message_create();
1712 umock_c_reset_all_calls();
1713
1714 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1715 .SetReturn(cloned_message_annotations);
1716 (void)message_set_message_annotations(message, test_message_annotations);
1717 umock_c_reset_all_calls();
1718
1719 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations))
1720 .SetReturn(other_cloned_message_annotations);
1721
1722 // act
1723 result = message_get_message_annotations(message, &stored_message_annotations);
1724
1725 // assert
1726 ASSERT_ARE_EQUAL(int, 0, result);
1727 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_message_annotations, (void*)stored_message_annotations);
1728 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1729
1730 // cleanup
1731 message_destroy(message);
1732 }
1733
1734 /* Tests_SRS_MESSAGE_01_049: [ If `message` or `annotations` is NULL, `message_get_message_annotations` shall fail and return a non-zero value. ]*/
1735 TEST_FUNCTION(message_get_message_annotations_with_NULL_message_annotations_fails)
1736 {
1737 // arrange
1738 int result;
1739 MESSAGE_HANDLE message = message_create();
1740 umock_c_reset_all_calls();
1741
1742 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1743 .SetReturn(cloned_message_annotations);
1744 (void)message_set_message_annotations(message, test_message_annotations);
1745 umock_c_reset_all_calls();
1746
1747 // act
1748 result = message_get_message_annotations(message, NULL);
1749
1750 // assert
1751 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1752 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1753
1754 // cleanup
1755 message_destroy(message);
1756 }
1757
1758 /* Tests_SRS_MESSAGE_01_049: [ If `message` or `annotations` is NULL, `message_get_message_annotations` shall fail and return a non-zero value. ]*/
1759 TEST_FUNCTION(message_get_message_annotations_with_NULL_message_fails)
1760 {
1761 // arrange
1762 message_annotations stored_message_annotations;
1763 int result;
1764
1765 // act
1766 result = message_get_message_annotations(NULL, &stored_message_annotations);
1767
1768 // assert
1769 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1770 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1771 }
1772
1773 /* Tests_SRS_MESSAGE_01_051: [ If `annotations_clone` fails, `message_get_message_annotations` shall fail and return a non-zero value. ]*/
1774 TEST_FUNCTION(when_annotations_clone_fails_message_get_message_annotations_fails)
1775 {
1776 // arrange
1777 message_annotations stored_message_annotations;
1778 int result;
1779 MESSAGE_HANDLE message = message_create();
1780 umock_c_reset_all_calls();
1781
1782 STRICT_EXPECTED_CALL(annotations_clone(test_message_annotations))
1783 .SetReturn(cloned_message_annotations);
1784 (void)message_set_message_annotations(message, test_message_annotations);
1785 umock_c_reset_all_calls();
1786
1787 STRICT_EXPECTED_CALL(annotations_clone(cloned_message_annotations))
1788 .SetReturn(NULL);
1789
1790 // act
1791 result = message_get_message_annotations(message, &stored_message_annotations);
1792
1793 // assert
1794 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1795 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1796
1797 // cleanup
1798 message_destroy(message);
1799 }
1800
1801 /* Tests_SRS_MESSAGE_01_146: [ If no message annotations have been set, `message_get_message_annotations` shall set `annotations` to NULL. ]*/
1802 /* Tests_SRS_MESSAGE_01_048: [ On success, `message_get_message_annotations` shall return 0. ]*/
1803 TEST_FUNCTION(when_no_message_annotations_have_been_set_message_get_message_annotations_yields_NULL)
1804 {
1805 // arrange
1806 message_annotations stored_message_annotations;
1807 int result;
1808 MESSAGE_HANDLE message = message_create();
1809 umock_c_reset_all_calls();
1810
1811 // act
1812 result = message_get_message_annotations(message, &stored_message_annotations);
1813
1814 // assert
1815 ASSERT_ARE_EQUAL(int, 0, result);
1816 ASSERT_ARE_EQUAL(void_ptr, NULL, (void*)stored_message_annotations);
1817 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1818
1819 // cleanup
1820 message_destroy(message);
1821 }
1822
1823 /* message_set_properties */
1824
1825 /* Tests_SRS_MESSAGE_01_052: [ `message_set_properties` shall copy the contents of `properties` as the message properties for the message instance identified by `message`. ]*/
1826 /* Tests_SRS_MESSAGE_01_053: [ On success it shall return 0. ]*/
1827 /* Tests_SRS_MESSAGE_01_055: [ Cloning the message properties shall be done by calling `properties_clone`. ]*/
1828 TEST_FUNCTION(message_set_properties_copies_the_message_properties)
1829 {
1830 // arrange
1831 int result;
1832 MESSAGE_HANDLE message = message_create();
1833 umock_c_reset_all_calls();
1834
1835 STRICT_EXPECTED_CALL(properties_clone(test_message_properties));
1836
1837 // act
1838 result = message_set_properties(message, test_message_properties);
1839
1840 // assert
1841 ASSERT_ARE_EQUAL(int, 0, result);
1842 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1843
1844 // cleanup
1845 message_destroy(message);
1846 }
1847
1848 /* Tests_SRS_MESSAGE_01_054: [ If `message` is NULL, `message_set_properties` shall fail and return a non-zero value. ]*/
1849 TEST_FUNCTION(message_set_properties_with_NULL_message_fails)
1850 {
1851 // arrange
1852 int result;
1853
1854 // act
1855 result = message_set_properties(NULL, test_message_properties);
1856
1857 // assert
1858 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1859 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1860 }
1861
1862 /* Tests_SRS_MESSAGE_01_056: [ If `properties_clone` fails, `message_set_properties` shall fail and return a non-zero value. ]*/
1863 TEST_FUNCTION(when_properties_clone_fails_message_set_properties_also_fails)
1864 {
1865 // arrange
1866 int result;
1867 MESSAGE_HANDLE message = message_create();
1868 umock_c_reset_all_calls();
1869
1870 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1871 .SetReturn(NULL);
1872
1873 // act
1874 result = message_set_properties(message, test_message_properties);
1875
1876 // assert
1877 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1878 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1879
1880 // cleanup
1881 message_destroy(message);
1882 }
1883
1884 /* Tests_SRS_MESSAGE_01_063: [ If setting the message properties fails, the previous value shall be preserved. ]*/
1885 TEST_FUNCTION(when_properties_clone_fails_message_set_properties_preserves_the_previous_value)
1886 {
1887 // arrange
1888 PROPERTIES_HANDLE stored_message_properties;
1889 int result;
1890 MESSAGE_HANDLE message = message_create();
1891 umock_c_reset_all_calls();
1892
1893 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1894 .SetReturn(cloned_message_properties);
1895 (void)message_set_properties(message, test_message_properties);
1896 umock_c_reset_all_calls();
1897
1898 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1899 .SetReturn(NULL);
1900 (void)message_set_properties(message, test_message_properties);
1901 umock_c_reset_all_calls();
1902
1903 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties))
1904 .SetReturn(other_cloned_message_properties);
1905
1906 // act
1907 result = message_get_properties(message, &stored_message_properties);
1908
1909 // assert
1910 ASSERT_ARE_EQUAL(int, 0, result);
1911 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_message_properties, stored_message_properties);
1912 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1913
1914 // cleanup
1915 message_destroy(message);
1916 }
1917
1918 /* Tests_SRS_MESSAGE_01_147: [ If `properties` is NULL, the previously stored message properties associated with `message` shall be freed. ]*/
1919 TEST_FUNCTION(message_set_properties_with_NULL_message_properties_frees_the_previously_stored_value)
1920 {
1921 // arrange
1922 int result;
1923 MESSAGE_HANDLE message = message_create();
1924 umock_c_reset_all_calls();
1925
1926 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1927 .SetReturn(cloned_message_properties);
1928 (void)message_set_properties(message, test_message_properties);
1929 umock_c_reset_all_calls();
1930
1931 STRICT_EXPECTED_CALL(properties_destroy(cloned_message_properties));
1932
1933 // act
1934 result = message_set_properties(message, NULL);
1935
1936 // assert
1937 ASSERT_ARE_EQUAL(int, 0, result);
1938 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1939
1940 // cleanup
1941 message_destroy(message);
1942 }
1943
1944 /* Tests_SRS_MESSAGE_01_147: [ If `properties` is NULL, the previously stored message properties associated with `message` shall be freed. ]*/
1945 TEST_FUNCTION(message_set_properties_with_NULL_twice_message_properties_does_not_crash)
1946 {
1947 // arrange
1948 int result;
1949 MESSAGE_HANDLE message = message_create();
1950 umock_c_reset_all_calls();
1951
1952 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1953 .SetReturn(cloned_message_properties);
1954 (void)message_set_properties(message, test_message_properties);
1955 (void)message_set_properties(message, NULL);
1956 umock_c_reset_all_calls();
1957
1958 // act
1959 result = message_set_properties(message, NULL);
1960
1961 // assert
1962 ASSERT_ARE_EQUAL(int, 0, result);
1963 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1964
1965 // cleanup
1966 message_destroy(message);
1967 }
1968
1969 /* message_get_properties */
1970
1971 /* Tests_SRS_MESSAGE_01_057: [ `message_get_properties` shall copy the contents of message properties for the message instance identified by `message` into the argument `properties`. ]*/
1972 /* Tests_SRS_MESSAGE_01_058: [ On success, `message_get_properties` shall return 0. ]*/
1973 /* Tests_SRS_MESSAGE_01_060: [ Cloning the message properties shall be done by calling `properties_clone`. ]*/
1974 TEST_FUNCTION(message_get_properties_clones_the_stored_properties)
1975 {
1976 // arrange
1977 PROPERTIES_HANDLE stored_message_properties;
1978 int result;
1979 MESSAGE_HANDLE message = message_create();
1980 umock_c_reset_all_calls();
1981
1982 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
1983 .SetReturn(cloned_message_properties);
1984 (void)message_set_properties(message, test_message_properties);
1985 umock_c_reset_all_calls();
1986
1987 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties))
1988 .SetReturn(other_cloned_message_properties);
1989
1990 // act
1991 result = message_get_properties(message, &stored_message_properties);
1992
1993 // assert
1994 ASSERT_ARE_EQUAL(int, 0, result);
1995 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_message_properties, (void*)stored_message_properties);
1996 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1997
1998 // cleanup
1999 message_destroy(message);
2000 }
2001
2002 /* Tests_SRS_MESSAGE_01_059: [ If `message` or `properties` is NULL, `message_get_properties` shall fail and return a non-zero value. ]*/
2003 TEST_FUNCTION(message_get_properties_with_NULL_properties_fails)
2004 {
2005 // arrange
2006 int result;
2007 MESSAGE_HANDLE message = message_create();
2008 umock_c_reset_all_calls();
2009
2010 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
2011 .SetReturn(cloned_message_properties);
2012 (void)message_set_properties(message, test_message_properties);
2013 umock_c_reset_all_calls();
2014
2015 // act
2016 result = message_get_properties(message, NULL);
2017
2018 // assert
2019 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2020 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2021
2022 // cleanup
2023 message_destroy(message);
2024 }
2025
2026 /* Tests_SRS_MESSAGE_01_059: [ If `message` or `properties` is NULL, `message_get_properties` shall fail and return a non-zero value. ]*/
2027 TEST_FUNCTION(message_get_properties_with_NULL_message_fails)
2028 {
2029 // arrange
2030 PROPERTIES_HANDLE stored_message_properties;
2031 int result;
2032
2033 // act
2034 result = message_get_properties(NULL, &stored_message_properties);
2035
2036 // assert
2037 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2038 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2039 }
2040
2041 /* Tests_SRS_MESSAGE_01_061: [ If `properties_clone` fails, `message_get_properties` shall fail and return a non-zero value. ]*/
2042 TEST_FUNCTION(when_properties_clone_fails_message_get_properties_fails)
2043 {
2044 // arrange
2045 PROPERTIES_HANDLE stored_message_properties;
2046 int result;
2047 MESSAGE_HANDLE message = message_create();
2048 umock_c_reset_all_calls();
2049
2050 STRICT_EXPECTED_CALL(properties_clone(test_message_properties))
2051 .SetReturn(cloned_message_properties);
2052 (void)message_set_properties(message, test_message_properties);
2053 umock_c_reset_all_calls();
2054
2055 STRICT_EXPECTED_CALL(properties_clone(cloned_message_properties))
2056 .SetReturn(NULL);
2057
2058 // act
2059 result = message_get_properties(message, &stored_message_properties);
2060
2061 // assert
2062 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2063 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2064
2065 // cleanup
2066 message_destroy(message);
2067 }
2068
2069 /* Tests_SRS_MESSAGE_01_148: [ If no message properties have been set, `message_get_properties` shall set `properties` to NULL. ]*/
2070 /* Tests_SRS_MESSAGE_01_058: [ On success, `message_get_properties` shall return 0. ]*/
2071 TEST_FUNCTION(message_get_properties_when_no_message_properties_have_been_set_yields_NULL)
2072 {
2073 // arrange
2074 PROPERTIES_HANDLE stored_message_properties;
2075 int result;
2076 MESSAGE_HANDLE message = message_create();
2077 umock_c_reset_all_calls();
2078
2079 // act
2080 result = message_get_properties(message, &stored_message_properties);
2081
2082 // assert
2083 ASSERT_ARE_EQUAL(int, 0, result);
2084 ASSERT_ARE_EQUAL(void_ptr, NULL, (void*)stored_message_properties);
2085 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2086
2087 // cleanup
2088 message_destroy(message);
2089 }
2090
2091 /* message_set_application_properties */
2092
2093 /* Tests_SRS_MESSAGE_01_064: [ `message_set_application_properties` shall copy the contents of `application_properties` as the application properties for the message instance identified by `message`. ]*/
2094 /* Tests_SRS_MESSAGE_01_065: [ On success it shall return 0. ]*/
2095 /* Tests_SRS_MESSAGE_01_067: [ Cloning the message properties shall be done by calling `application_properties_clone`. ]*/
2096 TEST_FUNCTION(message_set_application_properties_copies_the_application_properties)
2097 {
2098 // arrange
2099 int result;
2100 MESSAGE_HANDLE message = message_create();
2101 umock_c_reset_all_calls();
2102
2103 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties));
2104
2105 // act
2106 result = message_set_application_properties(message, test_application_properties);
2107
2108 // assert
2109 ASSERT_ARE_EQUAL(int, 0, result);
2110 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2111
2112 // cleanup
2113 message_destroy(message);
2114 }
2115
2116 /* Tests_SRS_MESSAGE_01_066: [ If `message` is NULL, `message_set_application_properties` shall fail and return a non-zero value. ]*/
2117 TEST_FUNCTION(message_set_application_properties_with_NULL_message_fails)
2118 {
2119 // arrange
2120 int result;
2121
2122 // act
2123 result = message_set_application_properties(NULL, test_application_properties);
2124
2125 // assert
2126 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2127 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2128 }
2129
2130 /* Tests_SRS_MESSAGE_01_068: [ If `application_properties_clone` fails, `message_set_application_properties` shall fail and return a non-zero value. ]*/
2131 TEST_FUNCTION(when_cloning_the_application_properties_fails_message_set_application_properties_fails)
2132 {
2133 // arrange
2134 int result;
2135 MESSAGE_HANDLE message = message_create();
2136 umock_c_reset_all_calls();
2137
2138 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2139 .SetReturn(NULL);
2140
2141 // act
2142 result = message_set_application_properties(message, test_application_properties);
2143
2144 // assert
2145 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2146 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2147
2148 // cleanup
2149 message_destroy(message);
2150 }
2151
2152 /* Tests_SRS_MESSAGE_01_069: [ If setting the application properties fails, the previous value shall be preserved. ]*/
2153 TEST_FUNCTION(when_cloning_the_application_properties_fails_the_previous_value_is_preserved)
2154 {
2155 // arrange
2156 AMQP_VALUE stored_application_properties;
2157 int result;
2158 MESSAGE_HANDLE message = message_create();
2159 umock_c_reset_all_calls();
2160
2161 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2162 .SetReturn(cloned_application_properties);
2163
2164 (void)message_set_application_properties(message, test_application_properties);
2165 umock_c_reset_all_calls();
2166
2167 STRICT_EXPECTED_CALL(application_properties_clone(cloned_application_properties))
2168 .SetReturn(NULL);
2169 (void)message_set_application_properties(message, cloned_application_properties);
2170 umock_c_reset_all_calls();
2171
2172 STRICT_EXPECTED_CALL(application_properties_clone(cloned_application_properties))
2173 .SetReturn(other_cloned_application_properties);
2174
2175 // act
2176 result = message_get_application_properties(message, &stored_application_properties);
2177
2178 // assert
2179 ASSERT_ARE_EQUAL(int, 0, result);
2180 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_application_properties, (void*)stored_application_properties);
2181 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2182
2183 // cleanup
2184 message_destroy(message);
2185 }
2186
2187 /* Tests_SRS_MESSAGE_01_149: [ If `application_properties` is NULL, the previously stored application properties associated with `message` shall be freed. ]*/
2188 TEST_FUNCTION(message_set_application_properties_with_NULL_application_properties_frees_the_previous_value)
2189 {
2190 // arrange
2191 int result;
2192 MESSAGE_HANDLE message = message_create();
2193 umock_c_reset_all_calls();
2194
2195 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2196 .SetReturn(cloned_application_properties);
2197
2198 (void)message_set_application_properties(message, test_application_properties);
2199 umock_c_reset_all_calls();
2200
2201 STRICT_EXPECTED_CALL(application_properties_destroy(cloned_application_properties));
2202
2203 // act
2204 result = message_set_application_properties(message, NULL);
2205
2206 // assert
2207 ASSERT_ARE_EQUAL(int, 0, result);
2208 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2209
2210 // cleanup
2211 message_destroy(message);
2212 }
2213
2214 /* Tests_SRS_MESSAGE_01_149: [ If `application_properties` is NULL, the previously stored application properties associated with `message` shall be freed. ]*/
2215 TEST_FUNCTION(message_set_application_properties_with_NULL_twice_does_not_crash)
2216 {
2217 // arrange
2218 int result;
2219 MESSAGE_HANDLE message = message_create();
2220 umock_c_reset_all_calls();
2221
2222 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2223 .SetReturn(cloned_application_properties);
2224
2225 (void)message_set_application_properties(message, test_application_properties);
2226 (void)message_set_application_properties(message, NULL);
2227 umock_c_reset_all_calls();
2228
2229 // act
2230 result = message_set_application_properties(message, NULL);
2231
2232 // assert
2233 ASSERT_ARE_EQUAL(int, 0, result);
2234 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2235
2236 // cleanup
2237 message_destroy(message);
2238 }
2239
2240 /* message_get_application_properties */
2241
2242 /* Tests_SRS_MESSAGE_01_070: [ `message_get_application_properties` shall copy the contents of application message properties for the message instance identified by `message` into the argument `application_properties`. ]*/
2243 /* Tests_SRS_MESSAGE_01_071: [ On success, `message_get_application_properties` shall return 0. ]*/
2244 /* Tests_SRS_MESSAGE_01_073: [ Cloning the application properties shall be done by calling `application_properties_clone`. ]*/
2245 TEST_FUNCTION(message_get_application_properties_clones_the_stored_application_properties)
2246 {
2247 // arrange
2248 AMQP_VALUE stored_application_properties;
2249 int result;
2250 MESSAGE_HANDLE message = message_create();
2251 umock_c_reset_all_calls();
2252
2253 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2254 .SetReturn(cloned_application_properties);
2255 (void)message_set_application_properties(message, test_application_properties);
2256 umock_c_reset_all_calls();
2257
2258 STRICT_EXPECTED_CALL(application_properties_clone(cloned_application_properties))
2259 .SetReturn(other_cloned_application_properties);
2260
2261 // act
2262 result = message_get_application_properties(message, &stored_application_properties);
2263
2264 // assert
2265 ASSERT_ARE_EQUAL(int, 0, result);
2266 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_application_properties, (void*)stored_application_properties);
2267 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2268
2269 // cleanup
2270 message_destroy(message);
2271 }
2272
2273 /* Tests_SRS_MESSAGE_01_072: [ If `message` or `application_properties` is NULL, `message_get_application_properties` shall fail and return a non-zero value. ]*/
2274 TEST_FUNCTION(message_get_application_properties_with_NULL_application_properties_fails)
2275 {
2276 // arrange
2277 int result;
2278 MESSAGE_HANDLE message = message_create();
2279 umock_c_reset_all_calls();
2280
2281 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2282 .SetReturn(cloned_application_properties);
2283 (void)message_set_application_properties(message, test_application_properties);
2284 umock_c_reset_all_calls();
2285
2286 // act
2287 result = message_get_application_properties(message, NULL);
2288
2289 // assert
2290 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2291 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2292
2293 // cleanup
2294 message_destroy(message);
2295 }
2296
2297 /* Tests_SRS_MESSAGE_01_072: [ If `message` or `application_properties` is NULL, `message_get_application_properties` shall fail and return a non-zero value. ]*/
2298 TEST_FUNCTION(message_get_application_properties_with_NULL_message_fails)
2299 {
2300 // arrange
2301 AMQP_VALUE stored_application_properties;
2302 int result;
2303
2304 // act
2305 result = message_get_application_properties(NULL, &stored_application_properties);
2306
2307 // assert
2308 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2309 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2310 }
2311
2312 /* Tests_SRS_MESSAGE_01_074: [ If `application_properties_clone` fails, `message_get_application_properties` shall fail and return a non-zero value. ]*/
2313 TEST_FUNCTION(when_cloning_the_application_properties_fails_message_get_application_properties_fails)
2314 {
2315 // arrange
2316 AMQP_VALUE stored_application_properties;
2317 int result;
2318 MESSAGE_HANDLE message = message_create();
2319 umock_c_reset_all_calls();
2320
2321 STRICT_EXPECTED_CALL(application_properties_clone(test_application_properties))
2322 .SetReturn(cloned_application_properties);
2323 (void)message_set_application_properties(message, test_application_properties);
2324 umock_c_reset_all_calls();
2325
2326 STRICT_EXPECTED_CALL(application_properties_clone(cloned_application_properties))
2327 .SetReturn(NULL);
2328
2329 // act
2330 result = message_get_application_properties(message, &stored_application_properties);
2331
2332 // assert
2333 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2334 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2335
2336 // cleanup
2337 message_destroy(message);
2338 }
2339
2340 /* Tests_SRS_MESSAGE_01_150: [ If no application properties have been set, `message_get_application_properties` shall set `application_properties` to NULL. ]*/
2341 /* Tests_SRS_MESSAGE_01_071: [ On success, `message_get_application_properties` shall return 0. ]*/
2342 TEST_FUNCTION(message_get_application_properties_when_no_application_properties_have_been_set_yields_NULL)
2343 {
2344 // arrange
2345 AMQP_VALUE stored_application_properties;
2346 int result;
2347 MESSAGE_HANDLE message = message_create();
2348 umock_c_reset_all_calls();
2349
2350 // act
2351 result = message_get_application_properties(message, &stored_application_properties);
2352
2353 // assert
2354 ASSERT_ARE_EQUAL(int, 0, result);
2355 ASSERT_ARE_EQUAL(void_ptr, NULL, (void*)stored_application_properties);
2356 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2357
2358 // cleanup
2359 message_destroy(message);
2360 }
2361
2362 /* message_set_footer */
2363
2364 /* Tests_SRS_MESSAGE_01_075: [ `message_set_footer` shall copy the contents of `footer` as the footer contents for the message instance identified by `message`. ]*/
2365 /* Tests_SRS_MESSAGE_01_076: [ On success it shall return 0. ]*/
2366 /* Tests_SRS_MESSAGE_01_078: [ Cloning the footer shall be done by calling `annotations_clone`. ]*/
2367 TEST_FUNCTION(message_set_footer_copies_the_footer)
2368 {
2369 // arrange
2370 int result;
2371 MESSAGE_HANDLE message = message_create();
2372 umock_c_reset_all_calls();
2373
2374 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2375 .SetReturn(cloned_footer);
2376
2377 // act
2378 result = message_set_footer(message, test_footer);
2379
2380 // assert
2381 ASSERT_ARE_EQUAL(int, 0, result);
2382 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2383
2384 // cleanup
2385 message_destroy(message);
2386 }
2387
2388 /* Tests_SRS_MESSAGE_01_077: [ If `message` is NULL, `message_set_footer` shall fail and return a non-zero value. ]*/
2389 TEST_FUNCTION(message_set_footer_with_NULL_message_fails)
2390 {
2391 // arrange
2392 int result;
2393
2394 // act
2395 result = message_set_footer(NULL, test_footer);
2396
2397 // assert
2398 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2399 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2400 }
2401
2402 /* Tests_SRS_MESSAGE_01_079: [ If `annotations_clone` fails, `message_set_footer` shall fail and return a non-zero value. ]*/
2403 TEST_FUNCTION(when_annotations_clone_fails_message_set_footer_fails)
2404 {
2405 // arrange
2406 int result;
2407 MESSAGE_HANDLE message = message_create();
2408 umock_c_reset_all_calls();
2409
2410 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2411 .SetReturn(NULL);
2412
2413 // act
2414 result = message_set_footer(message, test_footer);
2415
2416 // assert
2417 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2418 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2419
2420 // cleanup
2421 message_destroy(message);
2422 }
2423
2424 /* Tests_SRS_MESSAGE_01_080: [ If setting the footer fails, the previous value shall be preserved. ]*/
2425 TEST_FUNCTION(when_annotations_clone_fails_the_footer_on_the_message_is_preserved)
2426 {
2427 // arrange
2428 annotations stored_footer;
2429 int result;
2430 MESSAGE_HANDLE message = message_create();
2431 umock_c_reset_all_calls();
2432
2433 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2434 .SetReturn(cloned_footer);
2435 (void)message_set_footer(message, test_footer);
2436 umock_c_reset_all_calls();
2437
2438 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2439 .SetReturn(NULL);
2440 (void)message_set_footer(message, test_footer);
2441 umock_c_reset_all_calls();
2442
2443 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer))
2444 .SetReturn(other_cloned_footer);
2445
2446 // act
2447 result = message_get_footer(message, &stored_footer);
2448
2449 // assert
2450 ASSERT_ARE_EQUAL(int, 0, result);
2451 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_footer, stored_footer);
2452 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2453
2454 // cleanup
2455 message_destroy(message);
2456 }
2457
2458 /* Tests_SRS_MESSAGE_01_151: [ If `footer` is NULL, the previously stored footer associated with `message` shall be freed. ]*/
2459 TEST_FUNCTION(message_set_footer_with_NULL_footer_frees_the_previous_value)
2460 {
2461 // arrange
2462 int result;
2463 MESSAGE_HANDLE message = message_create();
2464 umock_c_reset_all_calls();
2465
2466 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2467 .SetReturn(cloned_footer);
2468 (void)message_set_footer(message, test_footer);
2469 umock_c_reset_all_calls();
2470
2471 STRICT_EXPECTED_CALL(annotations_destroy(cloned_footer));
2472
2473 // act
2474 result = message_set_footer(message, NULL);
2475
2476 // assert
2477 ASSERT_ARE_EQUAL(int, 0, result);
2478 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2479
2480 // cleanup
2481 message_destroy(message);
2482 }
2483
2484 /* Tests_SRS_MESSAGE_01_151: [ If `footer` is NULL, the previously stored footer associated with `message` shall be freed. ]*/
2485 TEST_FUNCTION(message_set_footer_with_NULL_footer_twice_does_not_crash)
2486 {
2487 // arrange
2488 int result;
2489 MESSAGE_HANDLE message = message_create();
2490 umock_c_reset_all_calls();
2491
2492 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2493 .SetReturn(cloned_footer);
2494 (void)message_set_footer(message, test_footer);
2495 (void)message_set_footer(message, NULL);
2496 umock_c_reset_all_calls();
2497
2498 // act
2499 result = message_set_footer(message, NULL);
2500
2501 // assert
2502 ASSERT_ARE_EQUAL(int, 0, result);
2503 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2504
2505 // cleanup
2506 message_destroy(message);
2507 }
2508
2509 /* message_get_footer */
2510
2511 /* Tests_SRS_MESSAGE_01_081: [ `message_get_footer` shall copy the contents of footer for the message instance identified by `message` into the argument `footer`. ]*/
2512 /* Tests_SRS_MESSAGE_01_082: [ On success, `message_get_footer` shall return 0. ]*/
2513 /* Tests_SRS_MESSAGE_01_084: [ Cloning the footer shall be done by calling `annotations_clone`. ]*/
2514 TEST_FUNCTION(message_get_footer_clones_the_footer)
2515 {
2516 // arrange
2517 annotations stored_footer;
2518 int result;
2519 MESSAGE_HANDLE message = message_create();
2520 umock_c_reset_all_calls();
2521
2522 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2523 .SetReturn(cloned_footer);
2524 (void)message_set_footer(message, test_footer);
2525 umock_c_reset_all_calls();
2526
2527 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer))
2528 .SetReturn(other_cloned_footer);
2529
2530 // act
2531 result = message_get_footer(message, &stored_footer);
2532
2533 // assert
2534 ASSERT_ARE_EQUAL(int, 0, result);
2535 ASSERT_ARE_EQUAL(void_ptr, (void*)other_cloned_footer, (void*)stored_footer);
2536 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2537
2538 // cleanup
2539 message_destroy(message);
2540 }
2541
2542 /* Tests_SRS_MESSAGE_01_083: [ If `message` or `footer` is NULL, `message_get_footer` shall fail and return a non-zero value. ]*/
2543 TEST_FUNCTION(message_get_footer_with_NULL_footer_fails)
2544 {
2545 // arrange
2546 int result;
2547 MESSAGE_HANDLE message = message_create();
2548 umock_c_reset_all_calls();
2549
2550 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2551 .SetReturn(cloned_footer);
2552 (void)message_set_footer(message, test_footer);
2553 umock_c_reset_all_calls();
2554
2555 // act
2556 result = message_get_footer(message, NULL);
2557
2558 // assert
2559 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2560 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2561
2562 // cleanup
2563 message_destroy(message);
2564 }
2565
2566 /* Tests_SRS_MESSAGE_01_083: [ If `message` or `footer` is NULL, `message_get_footer` shall fail and return a non-zero value. ]*/
2567 TEST_FUNCTION(message_get_footer_with_NULL_message_fails)
2568 {
2569 // arrange
2570 annotations stored_footer;
2571 int result;
2572
2573 // act
2574 result = message_get_footer(NULL, &stored_footer);
2575
2576 // assert
2577 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2578 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2579 }
2580
2581 /* Tests_SRS_MESSAGE_01_085: [ If `annotations_clone` fails, `message_get_footer` shall fail and return a non-zero value. ]*/
2582 TEST_FUNCTION(when_cloning_the_footer_fails_message_get_footer_fails)
2583 {
2584 // arrange
2585 annotations stored_footer;
2586 int result;
2587 MESSAGE_HANDLE message = message_create();
2588 umock_c_reset_all_calls();
2589
2590 STRICT_EXPECTED_CALL(annotations_clone(test_footer))
2591 .SetReturn(cloned_footer);
2592 (void)message_set_footer(message, test_footer);
2593 umock_c_reset_all_calls();
2594
2595 STRICT_EXPECTED_CALL(annotations_clone(cloned_footer))
2596 .SetReturn(NULL);
2597
2598 // act
2599 result = message_get_footer(message, &stored_footer);
2600
2601 // assert
2602 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2603 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2604
2605 // cleanup
2606 message_destroy(message);
2607 }
2608
2609 /* Tests_SRS_MESSAGE_01_152: [ If no footer has been set, `message_get_footer` shall set `footer` to NULL. ]*/
2610 TEST_FUNCTION(message_get_footer_when_no_footer_has_been_set_yields_NULL)
2611 {
2612 // arrange
2613 annotations stored_footer;
2614 int result;
2615 MESSAGE_HANDLE message = message_create();
2616 umock_c_reset_all_calls();
2617
2618 // act
2619 result = message_get_footer(message, &stored_footer);
2620
2621 // assert
2622 ASSERT_ARE_EQUAL(int, 0, result);
2623 ASSERT_ARE_EQUAL(void_ptr, NULL, (void*)stored_footer);
2624 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2625
2626 // cleanup
2627 message_destroy(message);
2628 }
2629
2630 /* message_add_body_amqp_data */
2631
2632 /* Tests_SRS_MESSAGE_01_086: [ `message_add_body_amqp_data` shall add the contents of `amqp_data` to the list of AMQP data values for the body of the message identified by `message`. ]*/
2633 /* Tests_SRS_MESSAGE_01_087: [ On success it shall return 0. ]*/
2634 TEST_FUNCTION(message_add_body_amqp_data_adds_one_amqp_data_item)
2635 {
2636 // arrange
2637 int result;
2638 BINARY_DATA amqp_data;
2639 unsigned char amqp_data_bytes[] = { 0x42 };
2640 MESSAGE_HANDLE message = message_create();
2641 umock_c_reset_all_calls();
2642
2643 amqp_data.bytes = amqp_data_bytes;
2644 amqp_data.length = sizeof(amqp_data_bytes);
2645
2646 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2647 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
2648
2649 // act
2650 result = message_add_body_amqp_data(message, amqp_data);
2651
2652 // assert
2653 ASSERT_ARE_EQUAL(int, 0, result);
2654 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2655
2656 // cleanup
2657 message_destroy(message);
2658 }
2659
2660 /* Tests_SRS_MESSAGE_01_088: [ If `message` is NULL, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2661 TEST_FUNCTION(message_add_body_amqp_data_with_NULL_message_fails)
2662 {
2663 // arrange
2664 int result;
2665 BINARY_DATA amqp_data;
2666 unsigned char amqp_data_bytes[] = { 0x42 };
2667
2668 amqp_data.bytes = amqp_data_bytes;
2669 amqp_data.length = sizeof(amqp_data_bytes);
2670
2671 // act
2672 result = message_add_body_amqp_data(NULL, amqp_data);
2673
2674 // assert
2675 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2676 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2677 }
2678
2679 /* Tests_SRS_MESSAGE_01_089: [ If the `bytes` member of `amqp_data` is NULL and the `size` member is non-zero, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2680 TEST_FUNCTION(message_add_body_amqp_data_with_NULL_buffer_and_non_zero_size_fails)
2681 {
2682 // arrange
2683 int result;
2684 BINARY_DATA amqp_data;
2685 MESSAGE_HANDLE message = message_create();
2686 umock_c_reset_all_calls();
2687
2688 amqp_data.bytes = NULL;
2689 amqp_data.length = 1;
2690
2691 // act
2692 result = message_add_body_amqp_data(message, amqp_data);
2693
2694 // assert
2695 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2696 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2697
2698 // cleanup
2699 message_destroy(message);
2700 }
2701
2702 /* Tests_SRS_MESSAGE_01_089: [ If the `bytes` member of `amqp_data` is NULL and the `size` member is non-zero, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2703 TEST_FUNCTION(message_add_body_amqp_data_with_NULL_buffer_and_zero_size_succeeds)
2704 {
2705 // arrange
2706 int result;
2707 BINARY_DATA amqp_data;
2708 MESSAGE_HANDLE message = message_create();
2709 umock_c_reset_all_calls();
2710
2711 amqp_data.bytes = NULL;
2712 amqp_data.length = 0;
2713
2714 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2715
2716 // act
2717 result = message_add_body_amqp_data(message, amqp_data);
2718
2719 // assert
2720 ASSERT_ARE_EQUAL(int, 0, result);
2721 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2722
2723 // cleanup
2724 message_destroy(message);
2725 }
2726
2727 /* Tests_SRS_MESSAGE_01_089: [ If the `bytes` member of `amqp_data` is NULL and the `size` member is non-zero, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2728 TEST_FUNCTION(message_add_body_amqp_data_with_non_NULL_buffer_and_zero_size_succeeds)
2729 {
2730 // arrange
2731 int result;
2732 BINARY_DATA amqp_data;
2733 unsigned char amqp_data_bytes[] = { 0x42 };
2734 MESSAGE_HANDLE message = message_create();
2735 umock_c_reset_all_calls();
2736
2737 amqp_data.bytes = amqp_data_bytes;
2738 amqp_data.length = 0;
2739
2740 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2741
2742 // act
2743 result = message_add_body_amqp_data(message, amqp_data);
2744
2745 // assert
2746 ASSERT_ARE_EQUAL(int, 0, result);
2747 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2748
2749 // cleanup
2750 message_destroy(message);
2751 }
2752
2753 /* Tests_SRS_MESSAGE_01_153: [ If allocating memory to store the added AMQP data fails, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2754 TEST_FUNCTION(when_reallocating_memory_for_the_data_array_fails_message_add_body_amqp_data_fails)
2755 {
2756 // arrange
2757 int result;
2758 BINARY_DATA amqp_data;
2759 unsigned char amqp_data_bytes[] = { 0x42 };
2760 MESSAGE_HANDLE message = message_create();
2761 umock_c_reset_all_calls();
2762
2763 amqp_data.bytes = amqp_data_bytes;
2764 amqp_data.length = 0;
2765
2766 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
2767 .SetReturn(NULL);
2768
2769 // act
2770 result = message_add_body_amqp_data(message, amqp_data);
2771
2772 // assert
2773 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2774 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2775
2776 // cleanup
2777 message_destroy(message);
2778 }
2779
2780 /* Tests_SRS_MESSAGE_01_153: [ If allocating memory to store the added AMQP data fails, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2781 TEST_FUNCTION(when_allocating_memory_for_the_AMQP_data_item_fails_message_add_body_amqp_data_fails)
2782 {
2783 // arrange
2784 int result;
2785 BINARY_DATA amqp_data;
2786 unsigned char amqp_data_bytes[] = { 0x42 };
2787 MESSAGE_HANDLE message = message_create();
2788 umock_c_reset_all_calls();
2789
2790 amqp_data.bytes = amqp_data_bytes;
2791 amqp_data.length = sizeof(amqp_data_bytes);
2792
2793 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2794 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
2795 .SetReturn(NULL);
2796
2797 // act
2798 result = message_add_body_amqp_data(message, amqp_data);
2799
2800 // assert
2801 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2802 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2803
2804 // cleanup
2805 message_destroy(message);
2806 }
2807
2808 /* Tests_SRS_MESSAGE_01_090: [ If adding the body AMQP data fails, the previous body content shall be preserved. ]*/
2809 TEST_FUNCTION(when_reallocating_memory_for_the_data_array_fails_message_add_body_amqp_data_preserves_the_previous_empty_body_value)
2810 {
2811 // arrange
2812 int result;
2813 BINARY_DATA amqp_data;
2814 unsigned char amqp_data_bytes[] = { 0x42 };
2815 size_t body_amqp_data_count;
2816 MESSAGE_HANDLE message = message_create();
2817 MESSAGE_BODY_TYPE body_type;
2818 umock_c_reset_all_calls();
2819
2820 amqp_data.bytes = amqp_data_bytes;
2821 amqp_data.length = sizeof(amqp_data_bytes);
2822
2823 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
2824 .SetReturn(NULL);
2825 (void)message_add_body_amqp_data(message, amqp_data);
2826 umock_c_reset_all_calls();
2827
2828 // act
2829 result = message_get_body_amqp_data_count(message, &body_amqp_data_count);
2830
2831 // assert
2832 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2833 (void)message_get_body_type(message, &body_type);
2834 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_NONE, body_type);
2835 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2836
2837 // cleanup
2838 message_destroy(message);
2839 }
2840
2841 /* Tests_SRS_MESSAGE_01_090: [ If adding the body AMQP data fails, the previous body content shall be preserved. ]*/
2842 TEST_FUNCTION(when_reallocating_memory_for_the_data_array_fails_message_add_body_amqp_data_preserves_the_previous_body_value_with_1_amqp_data)
2843 {
2844 // arrange
2845 int result;
2846 BINARY_DATA amqp_data;
2847 BINARY_DATA read_amqp_data;
2848 unsigned char amqp_data_bytes[] = { 0x42 };
2849 size_t body_amqp_data_count;
2850 MESSAGE_HANDLE message = message_create();
2851 MESSAGE_BODY_TYPE body_type;
2852 char expected_bytes[128];
2853 char actual_bytes[128];
2854 umock_c_reset_all_calls();
2855
2856 amqp_data.bytes = amqp_data_bytes;
2857 amqp_data.length = sizeof(amqp_data_bytes);
2858
2859 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2860 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
2861
2862 (void)message_add_body_amqp_data(message, amqp_data);
2863 umock_c_reset_all_calls();
2864
2865 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
2866 .SetReturn(NULL);
2867
2868 message_add_body_amqp_data(message, amqp_data);
2869
2870 // act
2871 result = message_get_body_amqp_data_count(message, &body_amqp_data_count);
2872
2873 // assert
2874 ASSERT_ARE_EQUAL(int, 0, result);
2875 ASSERT_ARE_EQUAL(size_t, 1, body_amqp_data_count);
2876 (void)message_get_body_type(message, &body_type);
2877 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_DATA, body_type);
2878 (void)message_get_body_amqp_data_in_place(message, 0, &read_amqp_data);
2879 stringify_bytes(read_amqp_data.bytes, read_amqp_data.length, actual_bytes);
2880 stringify_bytes(amqp_data_bytes, sizeof(amqp_data_bytes), expected_bytes);
2881 ASSERT_ARE_EQUAL(char_ptr, expected_bytes, actual_bytes);
2882 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2883
2884 // cleanup
2885 message_destroy(message);
2886 }
2887
2888 /* Tests_SRS_MESSAGE_01_091: [ If the body was already set to an AMQP value or a list of AMQP sequences, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2889 TEST_FUNCTION(message_add_body_amqp_data_when_body_is_a_list_of_sequences_fails)
2890 {
2891 // arrange
2892 int result;
2893 BINARY_DATA amqp_data;
2894 unsigned char amqp_data_bytes[] = { 0x42 };
2895 size_t body_amqp_sequence_count;
2896 MESSAGE_HANDLE message = message_create();
2897 MESSAGE_BODY_TYPE body_type;
2898 umock_c_reset_all_calls();
2899
2900 amqp_data.bytes = amqp_data_bytes;
2901 amqp_data.length = sizeof(amqp_data_bytes);
2902
2903 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2904
2905 (void)message_add_body_amqp_sequence(message, test_sequence_1);
2906 umock_c_reset_all_calls();
2907
2908 // act
2909 result = message_add_body_amqp_data(message, amqp_data);
2910
2911 // assert
2912 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2913 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2914 message_get_body_amqp_sequence_count(message, &body_amqp_sequence_count);
2915 ASSERT_ARE_EQUAL(size_t, 1, body_amqp_sequence_count);
2916 (void)message_get_body_type(message, &body_type);
2917 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_SEQUENCE, body_type);
2918
2919 // cleanup
2920 message_destroy(message);
2921 }
2922
2923 /* Tests_SRS_MESSAGE_01_091: [ If the body was already set to an AMQP value or a list of AMQP sequences, `message_add_body_amqp_data` shall fail and return a non-zero value. ]*/
2924 TEST_FUNCTION(when_reallocating_memory_for_the_data_array_fails_message_add_body_amqp_data_preserves_the_previous_body_value_with_amqp_value)
2925 {
2926 // arrange
2927 int result;
2928 BINARY_DATA amqp_data;
2929 unsigned char amqp_data_bytes[] = { 0x42 };
2930 MESSAGE_HANDLE message = message_create();
2931 MESSAGE_BODY_TYPE body_type;
2932 umock_c_reset_all_calls();
2933
2934 amqp_data.bytes = amqp_data_bytes;
2935 amqp_data.length = sizeof(amqp_data_bytes);
2936
2937 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1));
2938
2939 (void)message_set_body_amqp_value(message, test_amqp_value_1);
2940 umock_c_reset_all_calls();
2941
2942 // act
2943 result = message_add_body_amqp_data(message, amqp_data);
2944
2945 // assert
2946 ASSERT_ARE_NOT_EQUAL(int, 0, result);
2947 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2948 message_get_body_type(message, &body_type);
2949 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_VALUE, body_type);
2950
2951 // cleanup
2952 message_destroy(message);
2953 }
2954
2955 /* message_get_body_amqp_data_in_place */
2956
2957 /* Tests_SRS_MESSAGE_01_092: [ `message_get_body_amqp_data_in_place` shall place the contents of the `index`th AMQP data for the message instance identified by `message` into the argument `amqp_data`, without copying the binary payload memory. ]*/
2958 /* Tests_SRS_MESSAGE_01_093: [ On success, `message_get_body_amqp_data_in_place` shall return 0. ]*/
2959 TEST_FUNCTION(message_get_body_amqp_data_yields_the_amqp_data)
2960 {
2961 // arrange
2962 int result;
2963 unsigned char amqp_data_bytes[] = { 0x42 };
2964 BINARY_DATA amqp_data;
2965 BINARY_DATA read_amqp_data;
2966 MESSAGE_HANDLE message = message_create();
2967 char expected_bytes[128];
2968 char actual_bytes[128];
2969 umock_c_reset_all_calls();
2970
2971 amqp_data.bytes = amqp_data_bytes;
2972 amqp_data.length = sizeof(amqp_data_bytes);
2973
2974 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
2975 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
2976
2977 (void)message_add_body_amqp_data(message, amqp_data);
2978 umock_c_reset_all_calls();
2979
2980 // act
2981 result = message_get_body_amqp_data_in_place(message, 0, &read_amqp_data);
2982
2983 // assert
2984 ASSERT_ARE_EQUAL(int, 0, result);
2985 stringify_bytes(read_amqp_data.bytes, read_amqp_data.length, actual_bytes);
2986 stringify_bytes(amqp_data_bytes, sizeof(amqp_data_bytes), expected_bytes);
2987 ASSERT_ARE_EQUAL(char_ptr, expected_bytes, actual_bytes);
2988 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2989
2990 // cleanup
2991 message_destroy(message);
2992 }
2993
2994 /* Tests_SRS_MESSAGE_01_092: [ `message_get_body_amqp_data_in_place` shall place the contents of the `index`th AMQP data for the message instance identified by `message` into the argument `amqp_data`, without copying the binary payload memory. ]*/
2995 /* Tests_SRS_MESSAGE_01_093: [ On success, `message_get_body_amqp_data_in_place` shall return 0. ]*/
2996 TEST_FUNCTION(message_get_body_amqp_data_can_get_both_values_when_2_values_are_in_the_body)
2997 {
2998 // arrange
2999 int result1;
3000 int result2;
3001 unsigned char amqp_data_bytes_1[] = { 0x42 };
3002 unsigned char amqp_data_bytes_2[] = { 0x43, 0x44 };
3003 BINARY_DATA amqp_data_1;
3004 BINARY_DATA amqp_data_2;
3005 BINARY_DATA read_amqp_data_1;
3006 BINARY_DATA read_amqp_data_2;
3007 MESSAGE_HANDLE message = message_create();
3008 char expected_bytes[128];
3009 char actual_bytes[128];
3010 umock_c_reset_all_calls();
3011
3012 amqp_data_1.bytes = amqp_data_bytes_1;
3013 amqp_data_1.length = sizeof(amqp_data_bytes_1);
3014 amqp_data_2.bytes = amqp_data_bytes_2;
3015 amqp_data_2.length = sizeof(amqp_data_bytes_2);
3016
3017 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3018 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3019
3020 (void)message_add_body_amqp_data(message, amqp_data_1);
3021 umock_c_reset_all_calls();
3022
3023 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3024 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3025
3026 (void)message_add_body_amqp_data(message, amqp_data_2);
3027 umock_c_reset_all_calls();
3028
3029 // act
3030 result1 = message_get_body_amqp_data_in_place(message, 0, &read_amqp_data_1);
3031 result2 = message_get_body_amqp_data_in_place(message, 1, &read_amqp_data_2);
3032
3033 // assert
3034 ASSERT_ARE_EQUAL(int, 0, result1);
3035 ASSERT_ARE_EQUAL(int, 0, result2);
3036 stringify_bytes(read_amqp_data_1.bytes, read_amqp_data_1.length, actual_bytes);
3037 stringify_bytes(amqp_data_bytes_1, sizeof(amqp_data_bytes_1), expected_bytes);
3038 ASSERT_ARE_EQUAL(char_ptr, expected_bytes, actual_bytes);
3039 stringify_bytes(read_amqp_data_2.bytes, read_amqp_data_2.length, actual_bytes);
3040 stringify_bytes(amqp_data_bytes_2, sizeof(amqp_data_bytes_2), expected_bytes);
3041 ASSERT_ARE_EQUAL(char_ptr, expected_bytes, actual_bytes);
3042 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3043
3044 // cleanup
3045 message_destroy(message);
3046 }
3047
3048 /* Tests_SRS_MESSAGE_01_095: [ If `index` indicates an AMQP data entry that is out of bounds, `message_get_body_amqp_data_in_place` shall fail and return a non-zero value. ]*/
3049 TEST_FUNCTION(message_get_body_amqp_data_in_place_when_no_amqp_data_was_added_fails)
3050 {
3051 // arrange
3052 int result;
3053 BINARY_DATA read_amqp_data;
3054 MESSAGE_HANDLE message = message_create();
3055 umock_c_reset_all_calls();
3056
3057 // act
3058 result = message_get_body_amqp_data_in_place(message, 0, &read_amqp_data);
3059
3060 // assert
3061 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3062 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3063
3064 // cleanup
3065 message_destroy(message);
3066 }
3067
3068 /* Tests_SRS_MESSAGE_01_095: [ If `index` indicates an AMQP data entry that is out of bounds, `message_get_body_amqp_data_in_place` shall fail and return a non-zero value. ]*/
3069 TEST_FUNCTION(message_get_body_amqp_data_in_place_when_index_is_out_of_bounds_with_one_element_added_fails)
3070 {
3071 // arrange
3072 int result;
3073 unsigned char amqp_data_bytes[] = { 0x42 };
3074 BINARY_DATA amqp_data;
3075 BINARY_DATA read_amqp_data;
3076 MESSAGE_HANDLE message = message_create();
3077 umock_c_reset_all_calls();
3078
3079 amqp_data.bytes = amqp_data_bytes;
3080 amqp_data.length = sizeof(amqp_data_bytes);
3081
3082 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3083 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3084
3085 (void)message_add_body_amqp_data(message, amqp_data);
3086 umock_c_reset_all_calls();
3087
3088 // act
3089 result = message_get_body_amqp_data_in_place(message, 1, &read_amqp_data);
3090
3091 // assert
3092 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3093 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3094
3095 // cleanup
3096 message_destroy(message);
3097 }
3098
3099 /* Tests_SRS_MESSAGE_01_094: [ If `message` or `amqp_data` is NULL, `message_get_body_amqp_data_in_place` shall fail and return a non-zero value. ]*/
3100 TEST_FUNCTION(message_get_body_amqp_data_with_NULL_amqp_data_fails)
3101 {
3102 // arrange
3103 int result;
3104 unsigned char amqp_data_bytes[] = { 0x42 };
3105 BINARY_DATA amqp_data;
3106 MESSAGE_HANDLE message = message_create();
3107 umock_c_reset_all_calls();
3108
3109 amqp_data.bytes = amqp_data_bytes;
3110 amqp_data.length = sizeof(amqp_data_bytes);
3111
3112 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3113 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3114
3115 (void)message_add_body_amqp_data(message, amqp_data);
3116 umock_c_reset_all_calls();
3117
3118 // act
3119 result = message_get_body_amqp_data_in_place(message, 0, NULL);
3120
3121 // assert
3122 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3123 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3124
3125 // cleanup
3126 message_destroy(message);
3127 }
3128
3129 /* Tests_SRS_MESSAGE_01_094: [ If `message` or `amqp_data` is NULL, `message_get_body_amqp_data_in_place` shall fail and return a non-zero value. ]*/
3130 TEST_FUNCTION(message_get_body_amqp_data_with_NULL_message_data_fails)
3131 {
3132 // arrange
3133 int result;
3134 BINARY_DATA read_amqp_data;
3135
3136 // act
3137 result = message_get_body_amqp_data_in_place(NULL, 0, &read_amqp_data);
3138
3139 // assert
3140 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3141 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3142 }
3143
3144 /* Tests_SRS_MESSAGE_01_096: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_DATA`, `message_get_body_amqp_data_in_place` shall fail and return a non-zero value. ]*/
3145 TEST_FUNCTION(message_get_body_amqp_data_when_body_is_amqp_value)
3146 {
3147 // arrange
3148 int result;
3149 BINARY_DATA read_amqp_data;
3150 MESSAGE_HANDLE message = message_create();
3151 umock_c_reset_all_calls();
3152
3153 (void)message_set_body_amqp_value(message, test_amqp_value_1);
3154 umock_c_reset_all_calls();
3155
3156 // act
3157 result = message_get_body_amqp_data_in_place(message, 1, &read_amqp_data);
3158
3159 // assert
3160 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3161 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3162
3163 // cleanup
3164 message_destroy(message);
3165 }
3166
3167 /* message_get_body_amqp_data_count */
3168
3169 /* Tests_SRS_MESSAGE_01_097: [ `message_get_body_amqp_data_count` shall fill in `count` the number of AMQP data chunks that are stored by the message identified by `message`. ]*/
3170 /* Tests_SRS_MESSAGE_01_098: [ On success, `message_get_body_amqp_data_count` shall return 0. ]*/
3171 TEST_FUNCTION(message_get_body_amqp_data_count_with_one_amqp_data_returns_1)
3172 {
3173
3174 // arrange
3175 int result;
3176 unsigned char amqp_data_bytes[] = { 0x42 };
3177 BINARY_DATA amqp_data;
3178 MESSAGE_HANDLE message = message_create();
3179 size_t amqp_data_count;
3180 umock_c_reset_all_calls();
3181
3182 amqp_data.bytes = amqp_data_bytes;
3183 amqp_data.length = sizeof(amqp_data_bytes);
3184
3185 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3186 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3187
3188 (void)message_add_body_amqp_data(message, amqp_data);
3189 umock_c_reset_all_calls();
3190
3191 // act
3192 result = message_get_body_amqp_data_count(message, &amqp_data_count);
3193
3194 // assert
3195 ASSERT_ARE_EQUAL(int, 0, result);
3196 ASSERT_ARE_EQUAL(size_t, 1, amqp_data_count);
3197 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3198
3199 // cleanup
3200 message_destroy(message);
3201 }
3202
3203 /* Tests_SRS_MESSAGE_01_097: [ `message_get_body_amqp_data_count` shall fill in `count` the number of AMQP data chunks that are stored by the message identified by `message`. ]*/
3204 /* Tests_SRS_MESSAGE_01_098: [ On success, `message_get_body_amqp_data_count` shall return 0. ]*/
3205 TEST_FUNCTION(message_get_body_amqp_data_count_with_two_amqp_data_returns_2)
3206 {
3207
3208 // arrange
3209 int result;
3210 unsigned char amqp_data_bytes_1[] = { 0x42 };
3211 unsigned char amqp_data_bytes_2[] = { 0x42 };
3212 BINARY_DATA amqp_data_1;
3213 BINARY_DATA amqp_data_2;
3214 MESSAGE_HANDLE message = message_create();
3215 size_t amqp_data_count;
3216 umock_c_reset_all_calls();
3217
3218 amqp_data_1.bytes = amqp_data_bytes_1;
3219 amqp_data_1.length = sizeof(amqp_data_bytes_1);
3220 amqp_data_2.bytes = amqp_data_bytes_2;
3221 amqp_data_2.length = sizeof(amqp_data_bytes_2);
3222
3223 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3224 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3225 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3226 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3227
3228 (void)message_add_body_amqp_data(message, amqp_data_1);
3229 (void)message_add_body_amqp_data(message, amqp_data_2);
3230 umock_c_reset_all_calls();
3231
3232 // act
3233 result = message_get_body_amqp_data_count(message, &amqp_data_count);
3234
3235 // assert
3236 ASSERT_ARE_EQUAL(int, 0, result);
3237 ASSERT_ARE_EQUAL(size_t, 2, amqp_data_count);
3238 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3239
3240 // cleanup
3241 message_destroy(message);
3242 }
3243
3244 /* Tests_SRS_MESSAGE_01_100: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_DATA`, `message_get_body_amqp_data_count` shall fail and return a non-zero value. ]*/
3245 TEST_FUNCTION(message_get_body_amqp_data_count_when_no_amqp_data_values_are_set_fails)
3246 {
3247 // arrange
3248 int result;
3249 MESSAGE_HANDLE message = message_create();
3250 size_t amqp_data_count;
3251 umock_c_reset_all_calls();
3252
3253 // act
3254 result = message_get_body_amqp_data_count(message, &amqp_data_count);
3255
3256 // assert
3257 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3258 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3259
3260 // cleanup
3261 message_destroy(message);
3262 }
3263
3264 /* Tests_SRS_MESSAGE_01_099: [ If `message` or `count` is NULL, `message_get_body_amqp_data_count` shall fail and return a non-zero value. ]*/
3265 TEST_FUNCTION(message_get_body_amqp_data_count_with_NULL_count_fails)
3266 {
3267
3268 // arrange
3269 int result;
3270 unsigned char amqp_data_bytes[] = { 0x42 };
3271 BINARY_DATA amqp_data;
3272 MESSAGE_HANDLE message = message_create();
3273 umock_c_reset_all_calls();
3274
3275 amqp_data.bytes = amqp_data_bytes;
3276 amqp_data.length = sizeof(amqp_data_bytes);
3277
3278 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3279 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
3280
3281 (void)message_add_body_amqp_data(message, amqp_data);
3282 umock_c_reset_all_calls();
3283
3284 // act
3285 result = message_get_body_amqp_data_count(message, NULL);
3286
3287 // assert
3288 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3289 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3290
3291 // cleanup
3292 message_destroy(message);
3293 }
3294
3295 /* Tests_SRS_MESSAGE_01_099: [ If `message` or `count` is NULL, `message_get_body_amqp_data_count` shall fail and return a non-zero value. ]*/
3296 TEST_FUNCTION(message_get_body_amqp_data_count_with_NULL_message_fails)
3297 {
3298
3299 // arrange
3300 int result;
3301 size_t amqp_data_count;
3302
3303 // act
3304 result = message_get_body_amqp_data_count(NULL, &amqp_data_count);
3305
3306 // assert
3307 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3308 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3309 }
3310
3311 /* message_set_body_amqp_value */
3312
3313 /* Tests_SRS_MESSAGE_01_101: [ `message_set_body_amqp_value` shall set the contents of body as being the AMQP value indicate by `body_amqp_value`. ]*/
3314 /* Tests_SRS_MESSAGE_01_102: [ On success it shall return 0. ]*/
3315 /* Tests_SRS_MESSAGE_01_154: [ Cloning the amqp value shall be done by calling `amqpvalue_clone`. ]*/
3316 TEST_FUNCTION(message_set_body_amqp_value_sets_the_body_to_the_amqp_value)
3317 {
3318
3319 // arrange
3320 int result;
3321 MESSAGE_HANDLE message = message_create();
3322 umock_c_reset_all_calls();
3323
3324 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1));
3325
3326 // act
3327 result = message_set_body_amqp_value(message, test_amqp_value_1);
3328
3329 // assert
3330 ASSERT_ARE_EQUAL(int, 0, result);
3331 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3332
3333 // cleanup
3334 message_destroy(message);
3335 }
3336
3337 /* Tests_SRS_MESSAGE_01_103: [ If `message` or `body_amqp_value` is NULL, `message_set_body_amqp_value` shall fail and return a non-zero value. ]*/
3338 TEST_FUNCTION(message_set_body_amqp_value_with_NULL_body_amqp_value_fails)
3339 {
3340
3341 // arrange
3342 int result;
3343 MESSAGE_HANDLE message = message_create();
3344 umock_c_reset_all_calls();
3345
3346 // act
3347 result = message_set_body_amqp_value(message, NULL);
3348
3349 // assert
3350 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3351 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3352
3353 // cleanup
3354 message_destroy(message);
3355 }
3356
3357 /* Codes_SRS_MESSAGE_01_103: [ If `message` or `body_amqp_value` is NULL, `message_set_body_amqp_value` shall fail and return a non-zero value. ]*/
3358 TEST_FUNCTION(message_set_body_amqp_value_with_NULL_message_fails)
3359 {
3360
3361 // arrange
3362 int result;
3363 MESSAGE_HANDLE message = message_create();
3364 umock_c_reset_all_calls();
3365
3366 // act
3367 result = message_set_body_amqp_value(NULL, test_amqp_value_1);
3368
3369 // assert
3370 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3371 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3372
3373 // cleanup
3374 message_destroy(message);
3375 }
3376
3377 /* Tests_SRS_MESSAGE_01_155: [ If `amqpvalue_clone` fails, `message_set_body_amqp_value` shall fail and return a non-zero value. ]*/
3378 TEST_FUNCTION(when_amqpvalue_clone_fails_message_set_body_amqp_value_fails)
3379 {
3380
3381 // arrange
3382 int result;
3383 MESSAGE_HANDLE message = message_create();
3384 umock_c_reset_all_calls();
3385
3386 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1))
3387 .SetReturn(NULL);
3388
3389 // act
3390 result = message_set_body_amqp_value(message, test_amqp_value_1);
3391
3392 // assert
3393 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3394 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3395
3396 // cleanup
3397 message_destroy(message);
3398 }
3399
3400 /* Tests_SRS_MESSAGE_01_104: [ If setting the body AMQP value fails, the previous value shall be preserved. ]*/
3401 TEST_FUNCTION(when_cloning_the_amqp_value_fails_the_previous_value_is_preserved)
3402 {
3403
3404 // arrange
3405 int result;
3406 AMQP_VALUE read_amqp_value;
3407 MESSAGE_HANDLE message = message_create();
3408 umock_c_reset_all_calls();
3409
3410 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1))
3411 .SetReturn(cloned_amqp_value);
3412 (void)message_set_body_amqp_value(message, test_amqp_value_1);
3413 umock_c_reset_all_calls();
3414
3415 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_2))
3416 .SetReturn(NULL);
3417 (void)message_set_body_amqp_value(message, test_amqp_value_2);
3418 umock_c_reset_all_calls();
3419
3420 // act
3421 result = message_get_body_amqp_value_in_place(message, &read_amqp_value);
3422
3423 // assert
3424 ASSERT_ARE_EQUAL(int, 0, result);
3425 ASSERT_ARE_EQUAL(void_ptr, cloned_amqp_value, read_amqp_value);
3426 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3427
3428 // cleanup
3429 message_destroy(message);
3430 }
3431
3432 /* Tests_SRS_MESSAGE_01_105: [ If the body was already set to an AMQP data list or a list of AMQP sequences, `message_set_body_amqp_value` shall fail and return a non-zero value. ]*/
3433 TEST_FUNCTION(message_set_body_amqp_value_when_the_body_was_set_to_amqp_data_list_fails)
3434 {
3435
3436 // arrange
3437 int result;
3438 MESSAGE_HANDLE message = message_create();
3439 BINARY_DATA amqp_data;
3440 unsigned char amqp_data_bytes[] = { 0x42 };
3441 umock_c_reset_all_calls();
3442
3443 amqp_data.bytes = amqp_data_bytes;
3444 amqp_data.length = sizeof(amqp_data_bytes);
3445
3446 (void)message_add_body_amqp_data(message, amqp_data);
3447 umock_c_reset_all_calls();
3448
3449 // act
3450 result = message_set_body_amqp_value(message, test_amqp_value_1);
3451
3452 // assert
3453 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3454 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3455
3456 // cleanup
3457 message_destroy(message);
3458 }
3459
3460 /* Tests_SRS_MESSAGE_01_105: [ If the body was already set to an AMQP data list or a list of AMQP sequences, `message_set_body_amqp_value` shall fail and return a non-zero value. ]*/
3461 TEST_FUNCTION(message_set_body_amqp_value_when_the_body_was_set_to_amqp_sequence_list_fails)
3462 {
3463
3464 // arrange
3465 int result;
3466 MESSAGE_HANDLE message = message_create();
3467 umock_c_reset_all_calls();
3468
3469 // act
3470 (void)message_add_body_amqp_sequence(message, test_sequence_1);
3471 umock_c_reset_all_calls();
3472
3473 // act
3474 result = message_set_body_amqp_value(message, test_amqp_value_1);
3475
3476 // assert
3477 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3478 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3479
3480 // cleanup
3481 message_destroy(message);
3482 }
3483
3484 /* message_get_body_amqp_value_in_place */
3485
3486 /* Tests_SRS_MESSAGE_01_106: [ `message_get_body_amqp_value_in_place` shall get the body AMQP value for the message instance identified by `message` in place (not cloning) into the `body_amqp_value` argument. ]*/
3487 /* Tests_SRS_MESSAGE_01_107: [ On success, `message_get_body_amqp_value_in_place` shall return 0. ]*/
3488 TEST_FUNCTION(message_get_body_amqp_value_in_place_gets_the_amqp_value_that_was_set)
3489 {
3490
3491 // arrange
3492 int result;
3493 MESSAGE_HANDLE message = message_create();
3494 AMQP_VALUE read_amqp_value;
3495 umock_c_reset_all_calls();
3496
3497 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_1))
3498 .SetReturn(cloned_amqp_value);
3499
3500 (void)message_set_body_amqp_value(message, test_amqp_value_1);
3501 umock_c_reset_all_calls();
3502
3503 // act
3504 result = message_get_body_amqp_value_in_place(message, &read_amqp_value);
3505
3506 // assert
3507 ASSERT_ARE_EQUAL(int, 0, result);
3508 ASSERT_ARE_EQUAL(void_ptr, cloned_amqp_value, read_amqp_value);
3509 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3510
3511 // cleanup
3512 message_destroy(message);
3513 }
3514
3515 /* Tests_SRS_MESSAGE_01_108: [ If `message` or `body_amqp_value` is NULL, `message_get_body_amqp_value_in_place` shall fail and return a non-zero value. ]*/
3516 TEST_FUNCTION(message_get_body_amqp_value_in_place_with_NULL_amqp_value_fails)
3517 {
3518
3519 // arrange
3520 int result;
3521 MESSAGE_HANDLE message = message_create();
3522 umock_c_reset_all_calls();
3523
3524 STRICT_EXPECTED_CALL(amqpvalue_clone(test_amqp_value_2))
3525 .SetReturn(cloned_amqp_value);
3526
3527 (void)message_set_body_amqp_value(message, test_amqp_value_1);
3528 umock_c_reset_all_calls();
3529
3530 // act
3531 result = message_get_body_amqp_value_in_place(message, NULL);
3532
3533 // assert
3534 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3535 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3536
3537 // cleanup
3538 message_destroy(message);
3539 }
3540
3541 /* Tests_SRS_MESSAGE_01_108: [ If `message` or `body_amqp_value` is NULL, `message_get_body_amqp_value_in_place` shall fail and return a non-zero value. ]*/
3542 TEST_FUNCTION(message_get_body_amqp_value_in_place_with_NULL_message_fails)
3543 {
3544
3545 // arrange
3546 int result;
3547 AMQP_VALUE read_amqp_value;
3548
3549 // act
3550 result = message_get_body_amqp_value_in_place(NULL, &read_amqp_value);
3551
3552 // assert
3553 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3554 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3555 }
3556
3557 /* Tests_SRS_MESSAGE_01_109: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_VALUE`, `message_get_body_amqp_value_in_place` shall fail and return a non-zero value. ]*/
3558 TEST_FUNCTION(message_get_body_amqp_value_in_place_when_the_body_type_is_amqp_data_fails)
3559 {
3560
3561 // arrange
3562 int result;
3563 MESSAGE_HANDLE message = message_create();
3564 AMQP_VALUE read_amqp_value;
3565 BINARY_DATA amqp_data;
3566 unsigned char amqp_data_bytes[] = { 0x42 };
3567 umock_c_reset_all_calls();
3568
3569 amqp_data.bytes = amqp_data_bytes;
3570 amqp_data.length = sizeof(amqp_data_bytes);
3571
3572 (void)message_add_body_amqp_data(message, amqp_data);
3573 umock_c_reset_all_calls();
3574
3575 // act
3576 result = message_get_body_amqp_value_in_place(message, &read_amqp_value);
3577
3578 // assert
3579 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3580 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3581
3582 // cleanup
3583 message_destroy(message);
3584 }
3585
3586 /* Tests_SRS_MESSAGE_01_109: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_VALUE`, `message_get_body_amqp_value_in_place` shall fail and return a non-zero value. ]*/
3587 TEST_FUNCTION(message_get_body_amqp_value_in_place_when_the_body_type_is_amqp_sequence_fails)
3588 {
3589
3590 // arrange
3591 int result;
3592 MESSAGE_HANDLE message = message_create();
3593 AMQP_VALUE read_amqp_value;
3594 umock_c_reset_all_calls();
3595
3596 (void)message_add_body_amqp_sequence(message, test_sequence_1);
3597 umock_c_reset_all_calls();
3598
3599 // act
3600 result = message_get_body_amqp_value_in_place(message, &read_amqp_value);
3601
3602 // assert
3603 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3604 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3605
3606 // cleanup
3607 message_destroy(message);
3608 }
3609
3610 /* Tests_SRS_MESSAGE_01_109: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_VALUE`, `message_get_body_amqp_value_in_place` shall fail and return a non-zero value. ]*/
3611 TEST_FUNCTION(message_get_body_amqp_value_in_place_when_no_body_was_set_fails)
3612 {
3613
3614 // arrange
3615 int result;
3616 MESSAGE_HANDLE message = message_create();
3617 AMQP_VALUE read_amqp_value;
3618 umock_c_reset_all_calls();
3619
3620 // act
3621 result = message_get_body_amqp_value_in_place(message, &read_amqp_value);
3622
3623 // assert
3624 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3625 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3626
3627 // cleanup
3628 message_destroy(message);
3629 }
3630
3631 /* message_add_body_amqp_sequence */
3632
3633 /* Tests_SRS_MESSAGE_01_110: [ `message_add_body_amqp_sequence` shall add the contents of `sequence` to the list of AMQP sequences for the body of the message identified by `message`. ]*/
3634 /* Tests_SRS_MESSAGE_01_111: [ On success it shall return 0. ]*/
3635 /* Tests_SRS_MESSAGE_01_156: [ The AMQP sequence shall be cloned by calling `amqpvalue_clone`. ]*/
3636 TEST_FUNCTION(message_add_body_amqp_sequence_adds_the_sequence_to_the_body)
3637 {
3638
3639 // arrange
3640 int result;
3641 MESSAGE_HANDLE message = message_create();
3642 umock_c_reset_all_calls();
3643
3644 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3645 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1));
3646
3647 // act
3648 result = message_add_body_amqp_sequence(message, test_sequence_1);
3649
3650 // assert
3651 ASSERT_ARE_EQUAL(int, 0, result);
3652 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3653
3654 // cleanup
3655 message_destroy(message);
3656 }
3657
3658 /* Tests_SRS_MESSAGE_01_158: [ If allocating memory in order to store the sequence fails, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3659 TEST_FUNCTION(when_allocating_memory_for_the_sequence_list_fails_message_add_body_amqp_sequence_fails)
3660 {
3661
3662 // arrange
3663 int result;
3664 MESSAGE_HANDLE message = message_create();
3665 umock_c_reset_all_calls();
3666
3667 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
3668 .SetReturn(NULL);
3669
3670 // act
3671 result = message_add_body_amqp_sequence(message, test_sequence_1);
3672
3673 // assert
3674 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3675 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3676
3677 // cleanup
3678 message_destroy(message);
3679 }
3680
3681 /* Tests_SRS_MESSAGE_01_157: [ If `amqpvalue_clone` fails, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3682 TEST_FUNCTION(when_amqpvalue_clone_fails_message_add_body_amqp_sequence_fails)
3683 {
3684
3685 // arrange
3686 int result;
3687 MESSAGE_HANDLE message = message_create();
3688 umock_c_reset_all_calls();
3689
3690 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3691 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3692 .SetReturn(NULL);
3693
3694 // act
3695 result = message_add_body_amqp_sequence(message, test_sequence_1);
3696
3697 // assert
3698 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3699 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3700
3701 // cleanup
3702 message_destroy(message);
3703 }
3704
3705 /* Tests_SRS_MESSAGE_01_112: [ If `message` or `sequence` is NULL, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3706 TEST_FUNCTION(message_add_body_amqp_sequence_with_NULL_sequence_fails)
3707 {
3708
3709 // arrange
3710 int result;
3711 MESSAGE_HANDLE message = message_create();
3712 umock_c_reset_all_calls();
3713
3714 // act
3715 result = message_add_body_amqp_sequence(message, NULL);
3716
3717 // assert
3718 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3719 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3720
3721 // cleanup
3722 message_destroy(message);
3723 }
3724
3725 /* Tests_SRS_MESSAGE_01_112: [ If `message` or `sequence` is NULL, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3726 TEST_FUNCTION(message_add_body_amqp_sequence_with_NULL_message_fails)
3727 {
3728
3729 // arrange
3730 int result;
3731 MESSAGE_HANDLE message = message_create();
3732 umock_c_reset_all_calls();
3733
3734 // act
3735 result = message_add_body_amqp_sequence(NULL, test_sequence_1);
3736
3737 // assert
3738 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3739 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3740
3741 // cleanup
3742 message_destroy(message);
3743 }
3744
3745 /* Tests_SRS_MESSAGE_01_114: [ If adding the AMQP sequence fails, the previous value shall be preserved. ]*/
3746 TEST_FUNCTION(when_allocating_memory_for_the_sequence_fails_message_add_body_amqp_sequence_preserves_the_previous_sequence_body)
3747 {
3748 // arrange
3749 int result;
3750 size_t sequence_count;
3751 MESSAGE_HANDLE message = message_create();
3752 umock_c_reset_all_calls();
3753
3754 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3755 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3756 .SetReturn(cloned_sequence_1);
3757 message_add_body_amqp_sequence(message, test_sequence_1);
3758 umock_c_reset_all_calls();
3759
3760 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
3761 .SetReturn(NULL);
3762
3763 // act
3764 result = message_add_body_amqp_sequence(message, test_sequence_2);
3765
3766 // assert
3767 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3768 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3769 (void)message_get_body_amqp_sequence_count(message, &sequence_count);
3770 ASSERT_ARE_EQUAL(size_t, 1, sequence_count);
3771
3772 // cleanup
3773 message_destroy(message);
3774 }
3775
3776 /* Tests_SRS_MESSAGE_01_114: [ If adding the AMQP sequence fails, the previous value shall be preserved. ]*/
3777 TEST_FUNCTION(when_cloning_the_sequence_fails_message_add_body_amqp_sequence_preserves_the_previous_sequence_body)
3778 {
3779 // arrange
3780 int result;
3781 size_t sequence_count;
3782 MESSAGE_HANDLE message = message_create();
3783 umock_c_reset_all_calls();
3784
3785 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3786 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3787 .SetReturn(cloned_sequence_1);
3788 message_add_body_amqp_sequence(message, test_sequence_1);
3789 umock_c_reset_all_calls();
3790
3791 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3792 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_2))
3793 .SetReturn(NULL);
3794
3795 // act
3796 result = message_add_body_amqp_sequence(message, test_sequence_2);
3797
3798 // assert
3799 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3800 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3801 (void)message_get_body_amqp_sequence_count(message, &sequence_count);
3802 ASSERT_ARE_EQUAL(size_t, 1, sequence_count);
3803
3804 // cleanup
3805 message_destroy(message);
3806 }
3807
3808 /* Tests_SRS_MESSAGE_01_115: [ If the body was already set to an AMQP data list or an AMQP value, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3809 TEST_FUNCTION(message_add_body_amqp_sequence_when_the_body_was_set_to_amqp_data_fails)
3810 {
3811 // arrange
3812 int result;
3813 MESSAGE_HANDLE message = message_create();
3814 BINARY_DATA amqp_data;
3815 unsigned char amqp_data_bytes[] = { 0x42 };
3816 umock_c_reset_all_calls();
3817
3818 amqp_data.bytes = amqp_data_bytes;
3819 amqp_data.length = sizeof(amqp_data_bytes);
3820
3821 (void)message_add_body_amqp_data(message, amqp_data);
3822 umock_c_reset_all_calls();
3823
3824 // act
3825 result = message_add_body_amqp_sequence(message, test_sequence_1);
3826
3827 // assert
3828 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3829 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3830
3831 // cleanup
3832 message_destroy(message);
3833 }
3834
3835 /* Tests_SRS_MESSAGE_01_115: [ If the body was already set to an AMQP data list or an AMQP value, `message_add_body_amqp_sequence` shall fail and return a non-zero value. ]*/
3836 TEST_FUNCTION(message_add_body_amqp_sequence_when_the_body_was_set_to_amqp_value_fails)
3837 {
3838 // arrange
3839 int result;
3840 MESSAGE_HANDLE message = message_create();
3841 umock_c_reset_all_calls();
3842
3843 (void)message_set_body_amqp_value(message, test_amqp_value_1);
3844 umock_c_reset_all_calls();
3845
3846 // act
3847 result = message_add_body_amqp_sequence(message, test_sequence_1);
3848
3849 // assert
3850 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3851 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3852
3853 // cleanup
3854 message_destroy(message);
3855 }
3856
3857 /* message_get_body_amqp_sequence_in_place */
3858
3859 /* Tests_SRS_MESSAGE_01_116: [ `message_get_body_amqp_sequence_in_place` shall return in `sequence` the content of the `index`th AMQP seuquence entry for the message instance identified by `message`. ]*/
3860 /* Tests_SRS_MESSAGE_01_117: [ On success, `message_get_body_amqp_sequence_in_place` shall return 0. ]*/
3861 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_gets_the_first_item)
3862 {
3863 // arrange
3864 int result;
3865 AMQP_VALUE read_sequence;
3866 MESSAGE_HANDLE message = message_create();
3867 umock_c_reset_all_calls();
3868
3869 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3870 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3871 .SetReturn(cloned_sequence_1);
3872 message_add_body_amqp_sequence(message, test_sequence_1);
3873 umock_c_reset_all_calls();
3874
3875 // act
3876 result = message_get_body_amqp_sequence_in_place(message, 0, &read_sequence);
3877
3878 // assert
3879 ASSERT_ARE_EQUAL(int, 0, result);
3880 ASSERT_ARE_EQUAL(void_ptr, cloned_sequence_1, read_sequence);
3881 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3882
3883 // cleanup
3884 message_destroy(message);
3885 }
3886
3887 /* Tests_SRS_MESSAGE_01_116: [ `message_get_body_amqp_sequence_in_place` shall return in `sequence` the content of the `index`th AMQP seuquence entry for the message instance identified by `message`. ]*/
3888 /* Tests_SRS_MESSAGE_01_117: [ On success, `message_get_body_amqp_sequence_in_place` shall return 0. ]*/
3889 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_gets_2_items)
3890 {
3891 // arrange
3892 int result1;
3893 int result2;
3894 AMQP_VALUE read_sequence_1;
3895 AMQP_VALUE read_sequence_2;
3896 MESSAGE_HANDLE message = message_create();
3897 umock_c_reset_all_calls();
3898
3899 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3900 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3901 .SetReturn(cloned_sequence_1);
3902 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3903 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_2))
3904 .SetReturn(cloned_sequence_2);
3905 message_add_body_amqp_sequence(message, test_sequence_1);
3906 message_add_body_amqp_sequence(message, test_sequence_2);
3907 umock_c_reset_all_calls();
3908
3909 // act
3910 result1 = message_get_body_amqp_sequence_in_place(message, 0, &read_sequence_1);
3911 result2 = message_get_body_amqp_sequence_in_place(message, 1, &read_sequence_2);
3912
3913 // assert
3914 ASSERT_ARE_EQUAL(int, 0, result1);
3915 ASSERT_ARE_EQUAL(int, 0, result2);
3916 ASSERT_ARE_EQUAL(void_ptr, cloned_sequence_1, read_sequence_1);
3917 ASSERT_ARE_EQUAL(void_ptr, cloned_sequence_2, read_sequence_2);
3918 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3919
3920 // cleanup
3921 message_destroy(message);
3922 }
3923
3924 /* Tests_SRS_MESSAGE_01_118: [ If `message` or `sequence` is NULL, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
3925 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_with_NULL_sequence_fails)
3926 {
3927 // arrange
3928 int result;
3929 MESSAGE_HANDLE message = message_create();
3930 umock_c_reset_all_calls();
3931
3932 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
3933 STRICT_EXPECTED_CALL(amqpvalue_clone(test_sequence_1))
3934 .SetReturn(cloned_sequence_1);
3935 message_add_body_amqp_sequence(message, test_sequence_1);
3936 umock_c_reset_all_calls();
3937
3938 // act
3939 result = message_get_body_amqp_sequence_in_place(message, 0, NULL);
3940
3941 // assert
3942 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3943 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3944
3945 // cleanup
3946 message_destroy(message);
3947 }
3948
3949 /* Tests_SRS_MESSAGE_01_118: [ If `message` or `sequence` is NULL, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
3950 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_with_NULL_message_fails)
3951 {
3952 // arrange
3953 int result;
3954 AMQP_VALUE read_sequence;
3955 // act
3956 result = message_get_body_amqp_sequence_in_place(NULL, 0, &read_sequence);
3957
3958 // assert
3959 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3960 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3961 }
3962
3963 /* Tests_SRS_MESSAGE_01_120: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
3964 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_when_no_sequences_have_been_added_fails)
3965 {
3966 // arrange
3967 int result;
3968 AMQP_VALUE read_sequence;
3969 MESSAGE_HANDLE message = message_create();
3970 umock_c_reset_all_calls();
3971
3972 // act
3973 result = message_get_body_amqp_sequence_in_place(message, 0, &read_sequence);
3974
3975 // assert
3976 ASSERT_ARE_NOT_EQUAL(int, 0, result);
3977 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3978
3979 // cleanup
3980 message_destroy(message);
3981 }
3982
3983 /* Tests_SRS_MESSAGE_01_120: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
3984 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_when_body_type_is_AMQP_DATA_fails)
3985 {
3986 // arrange
3987 int result;
3988 AMQP_VALUE read_sequence;
3989 BINARY_DATA amqp_data;
3990 unsigned char amqp_data_bytes[] = { 0x42 };
3991 MESSAGE_HANDLE message = message_create();
3992 umock_c_reset_all_calls();
3993
3994 amqp_data.bytes = amqp_data_bytes;
3995 amqp_data.length = sizeof(amqp_data_bytes);
3996
3997 (void)message_add_body_amqp_data(message, amqp_data);
3998 umock_c_reset_all_calls();
3999
4000 // act
4001 result = message_get_body_amqp_sequence_in_place(message, 0, &read_sequence);
4002
4003 // assert
4004 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4005 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4006
4007 // cleanup
4008 message_destroy(message);
4009 }
4010
4011 /* Tests_SRS_MESSAGE_01_120: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
4012 TEST_FUNCTION(message_get_body_amqp_sequence_in_place_when_body_type_is_AMQP_VALUE_fails)
4013 {
4014 // arrange
4015 int result;
4016 AMQP_VALUE read_sequence;
4017 MESSAGE_HANDLE message = message_create();
4018 umock_c_reset_all_calls();
4019
4020 (void)message_set_body_amqp_value(message, test_amqp_value_1);
4021 umock_c_reset_all_calls();
4022
4023 // act
4024 result = message_get_body_amqp_sequence_in_place(message, 0, &read_sequence);
4025
4026 // assert
4027 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4028 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4029
4030 // cleanup
4031 message_destroy(message);
4032 }
4033
4034 /* Tests_SRS_MESSAGE_01_119: [ If `index` indicates an AMQP sequence entry that is out of bounds, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
4035 TEST_FUNCTION(message_get_body_amqp_sequence_for_index_2_when_only_one_sequence_items_is_in_the_body_fails)
4036 {
4037 // arrange
4038 int result;
4039 AMQP_VALUE read_sequence;
4040 MESSAGE_HANDLE message = message_create();
4041 umock_c_reset_all_calls();
4042
4043 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4044 umock_c_reset_all_calls();
4045
4046 // act
4047 result = message_get_body_amqp_sequence_in_place(message, 1, &read_sequence);
4048
4049 // assert
4050 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4051 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4052
4053 // cleanup
4054 message_destroy(message);
4055 }
4056
4057 /* Tests_SRS_MESSAGE_01_119: [ If `index` indicates an AMQP sequence entry that is out of bounds, `message_get_body_amqp_sequence_in_place` shall fail and return a non-zero value. ]*/
4058 TEST_FUNCTION(message_get_body_amqp_sequence_for_index_3_when_2_sequence_items_are_in_the_body_fails)
4059 {
4060 // arrange
4061 int result;
4062 AMQP_VALUE read_sequence;
4063 MESSAGE_HANDLE message = message_create();
4064 umock_c_reset_all_calls();
4065
4066 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4067 (void)message_add_body_amqp_sequence(message, test_sequence_2);
4068 umock_c_reset_all_calls();
4069
4070 // act
4071 result = message_get_body_amqp_sequence_in_place(message, 2, &read_sequence);
4072
4073 // assert
4074 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4075 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4076
4077 // cleanup
4078 message_destroy(message);
4079 }
4080
4081 /* message_get_body_amqp_sequence_count */
4082
4083 /* Tests_SRS_MESSAGE_01_121: [ `message_get_body_amqp_sequence_count` shall fill in `count` the number of AMQP sequences that are stored by the message identified by `message`. ]*/
4084 /* Tests_SRS_MESSAGE_01_122: [ On success, `message_get_body_amqp_sequence_count` shall return 0. ]*/
4085 TEST_FUNCTION(message_get_body_amqp_sequence_count_with_1_sequence_item_returns_1)
4086 {
4087 // arrange
4088 int result;
4089 size_t sequence_count;
4090 MESSAGE_HANDLE message = message_create();
4091 umock_c_reset_all_calls();
4092
4093 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4094 umock_c_reset_all_calls();
4095
4096 // act
4097 result = message_get_body_amqp_sequence_count(message, &sequence_count);
4098
4099 // assert
4100 ASSERT_ARE_EQUAL(int, 0, result);
4101 ASSERT_ARE_EQUAL(size_t, 1, sequence_count);
4102 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4103
4104 // cleanup
4105 message_destroy(message);
4106 }
4107
4108 /* Tests_SRS_MESSAGE_01_121: [ `message_get_body_amqp_sequence_count` shall fill in `count` the number of AMQP sequences that are stored by the message identified by `message`. ]*/
4109 /* Tests_SRS_MESSAGE_01_122: [ On success, `message_get_body_amqp_sequence_count` shall return 0. ]*/
4110 TEST_FUNCTION(message_get_body_amqp_sequence_count_with_2_sequence_item_returns_2)
4111 {
4112 // arrange
4113 int result;
4114 size_t sequence_count;
4115 MESSAGE_HANDLE message = message_create();
4116 umock_c_reset_all_calls();
4117
4118 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4119 (void)message_add_body_amqp_sequence(message, test_sequence_2);
4120 umock_c_reset_all_calls();
4121
4122 // act
4123 result = message_get_body_amqp_sequence_count(message, &sequence_count);
4124
4125 // assert
4126 ASSERT_ARE_EQUAL(int, 0, result);
4127 ASSERT_ARE_EQUAL(size_t, 2, sequence_count);
4128 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4129
4130 // cleanup
4131 message_destroy(message);
4132 }
4133
4134 /* Tests_SRS_MESSAGE_01_123: [ If `message` or `count` is NULL, `message_get_body_amqp_sequence_count` shall fail and return a non-zero value. ]*/
4135 TEST_FUNCTION(message_get_body_amqp_sequence_count_with_NULL_count_fails)
4136 {
4137 // arrange
4138 int result;
4139 MESSAGE_HANDLE message = message_create();
4140 umock_c_reset_all_calls();
4141
4142 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4143 umock_c_reset_all_calls();
4144
4145 // act
4146 result = message_get_body_amqp_sequence_count(message, NULL);
4147
4148 // assert
4149 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4150 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4151
4152 // cleanup
4153 message_destroy(message);
4154 }
4155
4156 /* Tests_SRS_MESSAGE_01_123: [ If `message` or `count` is NULL, `message_get_body_amqp_sequence_count` shall fail and return a non-zero value. ]*/
4157 TEST_FUNCTION(message_get_body_amqp_sequence_count_with_NULL_message_fails)
4158 {
4159 // arrange
4160 int result;
4161 size_t sequence_count;
4162
4163 // act
4164 result = message_get_body_amqp_sequence_count(NULL, &sequence_count);
4165
4166 // assert
4167 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4168 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4169 }
4170
4171 /* Tests_SRS_MESSAGE_01_124: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_count` shall fail and return a non-zero value. ]*/
4172 TEST_FUNCTION(message_get_body_amqp_sequence_count_when_no_body_was_added_to_the_message_fails)
4173 {
4174 // arrange
4175 int result;
4176 size_t sequence_count;
4177 MESSAGE_HANDLE message = message_create();
4178 umock_c_reset_all_calls();
4179
4180 // act
4181 result = message_get_body_amqp_sequence_count(message, &sequence_count);
4182
4183 // assert
4184 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4185 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4186
4187 // cleanup
4188 message_destroy(message);
4189 }
4190
4191 /* Tests_SRS_MESSAGE_01_124: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_count` shall fail and return a non-zero value. ]*/
4192 TEST_FUNCTION(message_get_body_amqp_sequence_count_when_body_is_AMQP_DATA_fails)
4193 {
4194 // arrange
4195 int result;
4196 size_t sequence_count;
4197 BINARY_DATA amqp_data;
4198 unsigned char amqp_data_bytes[] = { 0x42 };
4199 MESSAGE_HANDLE message = message_create();
4200 umock_c_reset_all_calls();
4201
4202 amqp_data.bytes = amqp_data_bytes;
4203 amqp_data.length = sizeof(amqp_data_bytes);
4204
4205 (void)message_add_body_amqp_data(message, amqp_data);
4206 umock_c_reset_all_calls();
4207
4208 // act
4209 result = message_get_body_amqp_sequence_count(message, &sequence_count);
4210
4211 // assert
4212 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4213 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4214
4215 // cleanup
4216 message_destroy(message);
4217 }
4218
4219 /* Tests_SRS_MESSAGE_01_124: [ If the body for `message` is not of type `MESSAGE_BODY_TYPE_SEQUENCE`, `message_get_body_amqp_sequence_count` shall fail and return a non-zero value. ]*/
4220 TEST_FUNCTION(message_get_body_amqp_sequence_count_when_body_is_AMQP_VALUE_fails)
4221 {
4222 // arrange
4223 int result;
4224 size_t sequence_count;
4225 MESSAGE_HANDLE message = message_create();
4226 umock_c_reset_all_calls();
4227
4228 (void)message_set_body_amqp_value(message, test_amqp_value_1);
4229 umock_c_reset_all_calls();
4230
4231 // act
4232 result = message_get_body_amqp_sequence_count(message, &sequence_count);
4233
4234 // assert
4235 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4236 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4237
4238 // cleanup
4239 message_destroy(message);
4240 }
4241
4242 /* message_get_body_type */
4243
4244 /* Tests_SRS_MESSAGE_01_125: [ `message_get_body_type` shall fill in `body_type` the AMQP message body type. ]*/
4245 /* Tests_SRS_MESSAGE_01_126: [ On success, `message_get_body_type` shall return 0. ]*/
4246 TEST_FUNCTION(message_get_body_type_when_body_is_AMQP_DATA_yields_AMQP_VALUE)
4247 {
4248 // arrange
4249 int result;
4250 MESSAGE_HANDLE message = message_create();
4251 MESSAGE_BODY_TYPE body_type;
4252 BINARY_DATA amqp_data;
4253 unsigned char amqp_data_bytes[] = { 0x42 };
4254 umock_c_reset_all_calls();
4255
4256 amqp_data.bytes = amqp_data_bytes;
4257 amqp_data.length = sizeof(amqp_data_bytes);
4258
4259 (void)message_add_body_amqp_data(message, amqp_data);
4260 umock_c_reset_all_calls();
4261
4262 // act
4263 result = message_get_body_type(message, &body_type);
4264
4265 // assert
4266 ASSERT_ARE_EQUAL(int, 0, result);
4267 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_DATA, body_type);
4268 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4269
4270 // cleanup
4271 message_destroy(message);
4272 }
4273
4274 /* Tests_SRS_MESSAGE_01_125: [ `message_get_body_type` shall fill in `body_type` the AMQP message body type. ]*/
4275 /* Tests_SRS_MESSAGE_01_126: [ On success, `message_get_body_type` shall return 0. ]*/
4276 TEST_FUNCTION(message_get_body_type_when_body_is_AMQP_VALUE_yields_AMQP_VALUE)
4277 {
4278 // arrange
4279 int result;
4280 MESSAGE_HANDLE message = message_create();
4281 MESSAGE_BODY_TYPE body_type;
4282 umock_c_reset_all_calls();
4283
4284 (void)message_set_body_amqp_value(message, test_amqp_value_1);
4285 umock_c_reset_all_calls();
4286
4287 // act
4288 result = message_get_body_type(message, &body_type);
4289
4290 // assert
4291 ASSERT_ARE_EQUAL(int, 0, result);
4292 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_VALUE, body_type);
4293 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4294
4295 // cleanup
4296 message_destroy(message);
4297 }
4298
4299 /* Tests_SRS_MESSAGE_01_125: [ `message_get_body_type` shall fill in `body_type` the AMQP message body type. ]*/
4300 /* Tests_SRS_MESSAGE_01_126: [ On success, `message_get_body_type` shall return 0. ]*/
4301 TEST_FUNCTION(message_get_body_type_when_body_is_AMQP_SEQUENCE_yields_AMQP_SEQUENCE)
4302 {
4303 // arrange
4304 int result;
4305 MESSAGE_HANDLE message = message_create();
4306 MESSAGE_BODY_TYPE body_type;
4307 umock_c_reset_all_calls();
4308
4309 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4310 umock_c_reset_all_calls();
4311
4312 // act
4313 result = message_get_body_type(message, &body_type);
4314
4315 // assert
4316 ASSERT_ARE_EQUAL(int, 0, result);
4317 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_SEQUENCE, body_type);
4318 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4319
4320 // cleanup
4321 message_destroy(message);
4322 }
4323
4324 /* Tests_SRS_MESSAGE_01_127: [ If `message` or `body_type` is NULL, `message_get_body_type` shall fail and return a non-zero value. ]*/
4325 TEST_FUNCTION(message_get_body_type_with_NULL_body_type_fails)
4326 {
4327 // arrange
4328 int result;
4329 MESSAGE_HANDLE message = message_create();
4330 umock_c_reset_all_calls();
4331
4332 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4333 umock_c_reset_all_calls();
4334
4335 // act
4336 result = message_get_body_type(message, NULL);
4337
4338 // assert
4339 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4340 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4341
4342 // cleanup
4343 message_destroy(message);
4344 }
4345
4346 /* Tests_SRS_MESSAGE_01_127: [ If `message` or `body_type` is NULL, `message_get_body_type` shall fail and return a non-zero value. ]*/
4347 TEST_FUNCTION(message_get_body_type_with_NULL_message_fails)
4348 {
4349 // arrange
4350 int result;
4351 MESSAGE_HANDLE message = message_create();
4352 MESSAGE_BODY_TYPE body_type;
4353 umock_c_reset_all_calls();
4354
4355 (void)message_add_body_amqp_sequence(message, test_sequence_1);
4356 umock_c_reset_all_calls();
4357
4358 // act
4359 result = message_get_body_type(NULL, &body_type);
4360
4361 // assert
4362 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4363 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4364
4365 // cleanup
4366 message_destroy(message);
4367 }
4368
4369 /* Tests_SRS_MESSAGE_01_128: [ If no body has been set on the message, `body_type` shall be `MESSAGE_BODY_TYPE_NONE`. ]*/
4370 TEST_FUNCTION(message_get_body_type_when_no_body_was_set_yields_MESSAGE_BODY_TYPE_NONE)
4371 {
4372 // arrange
4373 int result;
4374 MESSAGE_HANDLE message = message_create();
4375 MESSAGE_BODY_TYPE body_type;
4376 umock_c_reset_all_calls();
4377
4378 // act
4379 result = message_get_body_type(message, &body_type);
4380
4381 // assert
4382 ASSERT_ARE_EQUAL(int, 0, result);
4383 ASSERT_ARE_EQUAL(MESSAGE_BODY_TYPE, MESSAGE_BODY_TYPE_NONE, body_type);
4384 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4385
4386 // cleanup
4387 message_destroy(message);
4388 }
4389
4390 /* message_set_message_format */
4391
4392 /* Tests_SRS_MESSAGE_01_129: [ `message_set_message_format` shall set the message format for the message identified by `message`. ]*/
4393 /* Tests_SRS_MESSAGE_01_130: [ On success, `message_set_message_format` shall return 0. ]*/
4394 TEST_FUNCTION(message_set_message_format_sets_the_message_format)
4395 {
4396 // arrange
4397 int result;
4398 MESSAGE_HANDLE message = message_create();
4399 umock_c_reset_all_calls();
4400
4401 // act
4402 result = message_set_message_format(message, 0);
4403
4404 // assert
4405 ASSERT_ARE_EQUAL(int, 0, result);
4406 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4407
4408 // cleanup
4409 message_destroy(message);
4410 }
4411
4412 /* Tests_SRS_MESSAGE_01_129: [ `message_set_message_format` shall set the message format for the message identified by `message`. ]*/
4413 /* Tests_SRS_MESSAGE_01_130: [ On success, `message_set_message_format` shall return 0. ]*/
4414 TEST_FUNCTION(message_set_message_format_with_0x42_sets_the_message_format)
4415 {
4416 // arrange
4417 int result;
4418 MESSAGE_HANDLE message = message_create();
4419 umock_c_reset_all_calls();
4420
4421 // act
4422 result = message_set_message_format(message, 0x42);
4423
4424 // assert
4425 ASSERT_ARE_EQUAL(int, 0, result);
4426 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4427
4428 // cleanup
4429 message_destroy(message);
4430 }
4431
4432 /* Tests_SRS_MESSAGE_01_131: [ If `message` is NULL, `message_set_message_format` shall fail and return a non-zero value. ]*/
4433 TEST_FUNCTION(message_set_message_format_with_NULL_message_fails)
4434 {
4435 // arrange
4436 int result;
4437
4438 // act
4439 result = message_set_message_format(NULL, 0);
4440
4441 // assert
4442 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4443 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4444 }
4445
4446 /* message_get_message_format */
4447
4448 /* Tests_SRS_MESSAGE_01_132: [ `message_get_message_format` shall get the message format for the message identified by `message` and return it in the `message_fomrat` argument. ]*/
4449 /* Tests_SRS_MESSAGE_01_133: [ On success, `message_get_message_format` shall return 0. ]*/
4450 TEST_FUNCTION(message_get_message_format_gets_the_previously_set_message_format)
4451 {
4452 // arrange
4453 int result;
4454 uint32_t read_message_format;
4455 MESSAGE_HANDLE message = message_create();
4456 (void)message_set_message_format(message, 0x42);
4457 umock_c_reset_all_calls();
4458
4459 // act
4460 result = message_get_message_format(message, &read_message_format);
4461
4462 // assert
4463 ASSERT_ARE_EQUAL(int, 0, result);
4464 ASSERT_ARE_EQUAL(uint32_t, 0x42, read_message_format);
4465 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4466
4467 // cleanup
4468 message_destroy(message);
4469 }
4470
4471 /* Tests_SRS_MESSAGE_01_134: [ If `message` or `message_format` is NULL, `message_get_message_format` shall fail and return a non-zero value. ]*/
4472 TEST_FUNCTION(message_get_message_format_with_NULL_message_format_fails)
4473 {
4474 // arrange
4475 int result;
4476 MESSAGE_HANDLE message = message_create();
4477 (void)message_set_message_format(message, 0x42);
4478 umock_c_reset_all_calls();
4479
4480 // act
4481 result = message_get_message_format(message, NULL);
4482
4483 // assert
4484 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4485 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4486
4487 // cleanup
4488 message_destroy(message);
4489 }
4490
4491 /* Tests_SRS_MESSAGE_01_134: [ If `message` or `message_format` is NULL, `message_get_message_format` shall fail and return a non-zero value. ]*/
4492 TEST_FUNCTION(message_get_message_format_with_NULL_message_fails)
4493 {
4494 // arrange
4495 int result;
4496 uint32_t read_message_format;
4497
4498 // act
4499 result = message_get_message_format(NULL, &read_message_format);
4500
4501 // assert
4502 ASSERT_ARE_NOT_EQUAL(int, 0, result);
4503 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4504 }
4505
4506 /* Tests_SRS_MESSAGE_01_135: [ By default a message on which `message_set_message_format` was not called shall have message format set to 0. ]*/
4507 TEST_FUNCTION(message_get_message_format_without_any_Set_shall_return_the_default_of_0)
4508 {
4509 // arrange
4510 int result;
4511 uint32_t read_message_format;
4512 MESSAGE_HANDLE message = message_create();
4513 umock_c_reset_all_calls();
4514
4515 // act
4516 result = message_get_message_format(message, &read_message_format);
4517
4518 // assert
4519 ASSERT_ARE_EQUAL(int, 0, result);
4520 ASSERT_ARE_EQUAL(uint32_t, 0, read_message_format);
4521 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
4522
4523 // cleanup
4524 message_destroy(message);
4525 }
4526
4527 END_TEST_SUITE(message_ut)