Debian Codegraph @

src/vendor/azure-uamqp-c/tests/link_ut/link_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 <cstdio>
7 #include <cstdint>
8 #else
9 #include <stdlib.h>
10 #include <string.h>
11 #include <stdint.h>
12 #include <stdbool.h>
13 #endif
14
15 #include "azure_macro_utils/macro_utils.h"
16 #include "testrunnerswitcher.h"
17 #include "umock_c/umock_c.h"
18 #include "umock_c/umock_c_negative_tests.h"
19 #include "umock_c/umocktypes_bool.h"
20 #include "umock_c/umocktypes_stdint.h"
21
22 static void* my_gballoc_malloc(size_t size)
23 {
24 return malloc(size);
25 }
26
27 static void* my_gballoc_calloc(size_t nmemb, size_t size)
28 {
29 return calloc(nmemb, size);
30 }
31
32 static void* my_gballoc_realloc(void* ptr, size_t size)
33 {
34 return realloc(ptr, size);
35 }
36
37 static void my_gballoc_free(void* ptr)
38 {
39 free(ptr);
40 }
41
42 #define ENABLE_MOCKS
43
44 #include "azure_c_shared_utility/gballoc.h"
45 #include "azure_c_shared_utility/singlylinkedlist.h"
46 #include "azure_c_shared_utility/tickcounter.h"
47 #include "azure_uamqp_c/session.h"
48 #include "azure_uamqp_c/amqpvalue.h"
49 #include "azure_uamqp_c/amqp_definitions.h"
50 #include "azure_uamqp_c/amqp_frame_codec.h"
51 #include "azure_uamqp_c/async_operation.h"
52
53 #undef ENABLE_MOCK_FILTERING_SWITCH
54 #define ENABLE_MOCK_FILTERING
55 #define please_mock_transfer_set_delivery_tag MOCK_ENABLED
56 #undef ENABLE_MOCK_FILTERING_SWITCH
57 #undef ENABLE_MOCK_FILTERING
58
59 #undef ENABLE_MOCKS
60
61 #include "azure_uamqp_c/link.h"
62
63 static SESSION_HANDLE TEST_SESSION_HANDLE = (SESSION_HANDLE)0x4000;
64 const char* TEST_LINK_NAME_1 = "test_link_name_1";
65 static TICK_COUNTER_HANDLE TEST_TICK_COUNTER_HANDLE = (TICK_COUNTER_HANDLE)0x4001;
66 static SINGLYLINKEDLIST_HANDLE TEST_SINGLYLINKEDLIST_HANDLE = (SINGLYLINKEDLIST_HANDLE)0x4002;
67 static LINK_ENDPOINT_HANDLE TEST_LINK_ENDPOINT = (LINK_ENDPOINT_HANDLE)0x4003;
68 const AMQP_VALUE TEST_LINK_SOURCE = (AMQP_VALUE)0x4004;
69 const AMQP_VALUE TEST_LINK_TARGET = (AMQP_VALUE)0x4005;
70 const AMQP_VALUE TEST_AMQP_VALUE = (AMQP_VALUE)0x4006;
71 const LIST_ITEM_HANDLE TEST_LIST_ITEM_HANDLE = (LIST_ITEM_HANDLE)0x4007;
72 const TRANSFER_HANDLE TEST_TRANSFER_HANDLE = (TRANSFER_HANDLE)0x4008;
73 #define AMQP_BATCHING_FORMAT_CODE 0x80013700
74
75 static TEST_MUTEX_HANDLE g_testByTest;
76
77 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
78
79 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
80 {
81 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
82 }
83
84 static int umocktypes_copy_bool_ptr(bool** destination, const bool* source)
85 {
86 int result;
87
88 *destination = (bool*)my_gballoc_malloc(sizeof(bool));
89 if (*destination == NULL)
90 {
91 result = MU_FAILURE;
92 }
93 else
94 {
95 *(*destination) = (*source);
96
97 result = 0;
98 }
99
100 return result;
101 }
102
103 static void umocktypes_free_bool_ptr(bool** value)
104 {
105 if (*value != NULL)
106 {
107 my_gballoc_free(*value);
108 }
109 }
110
111 static char* umocktypes_stringify_bool_ptr(const bool** value)
112 {
113 char* result;
114
115 result = (char*)my_gballoc_malloc(8);
116 if (result != NULL)
117 {
118 if (*value == NULL)
119 {
120 (void)strcpy(result, "{NULL}");
121 }
122 else if (*(*value) == true)
123 {
124 (void)strcpy(result, "{true}");
125 }
126 else
127 {
128 (void)strcpy(result, "{false}");
129 }
130 }
131
132 return result;
133 }
134
135 static int umocktypes_are_equal_bool_ptr(bool** left, bool** right)
136 {
137 int result;
138
139 if (*left == *right)
140 {
141 result = 1;
142 }
143 else
144 {
145 if (*(*left) == *(*right))
146 {
147 result = 1;
148 }
149 else
150 {
151 result = 0;
152 }
153 }
154
155 return result;
156 }
157
158
159 // bool FLOW_HANDLE functions
160
161 static int umocktypes_copy_FLOW_HANDLE(FLOW_HANDLE* destination, const FLOW_HANDLE* source)
162 {
163 int result = 0;
164
165 *(destination) = *(source);
166
167 return result;
168 }
169
170 static void umocktypes_free_FLOW_HANDLE(FLOW_HANDLE* value)
171 {
172 (void)value;
173 }
174
175 static char* umocktypes_stringify_FLOW_HANDLE(const FLOW_HANDLE* value)
176 {
177 char temp_buffer[32];
178 char* result;
179 size_t length = sprintf(temp_buffer, "%p", (void*)*value);
180 if (length < 0)
181 {
182 result = NULL;
183 }
184 else
185 {
186 result = (char*)malloc(length + 1);
187 if (result != NULL)
188 {
189 (void)memcpy(result, temp_buffer, length + 1);
190 }
191 }
192 return result;
193 }
194
195 static int umocktypes_are_equal_FLOW_HANDLE(FLOW_HANDLE* left, FLOW_HANDLE* right)
196 {
197 int result;
198
199 if (*left == *right)
200 {
201 result = 1;
202 }
203 else
204 {
205 result = 0;
206 }
207
208 return result;
209 }
210
211 // TRANSFER umock functions
212
213 static int umocktypes_copy_TRANSFER_HANDLE(TRANSFER_HANDLE* destination, const TRANSFER_HANDLE* source)
214 {
215 int result = 0;
216
217 *(destination) = *(source);
218
219 return result;
220 }
221
222 static void umocktypes_free_TRANSFER_HANDLE(TRANSFER_HANDLE* value)
223 {
224 (void)value;
225 }
226
227 static char* umocktypes_stringify_TRANSFER_HANDLE(const TRANSFER_HANDLE* value)
228 {
229 char temp_buffer[32];
230 char* result;
231 size_t length = sprintf(temp_buffer, "%p", (void*)*value);
232 if (length < 0)
233 {
234 result = NULL;
235 }
236 else
237 {
238 result = (char*)malloc(length + 1);
239 if (result != NULL)
240 {
241 (void)memcpy(result, temp_buffer, length + 1);
242 }
243 }
244 return result;
245 }
246
247 static int umocktypes_are_equal_TRANSFER_HANDLE(TRANSFER_HANDLE* left, TRANSFER_HANDLE* right)
248 {
249 int result;
250
251 if (*left == *right)
252 {
253 result = 1;
254 }
255 else
256 {
257 result = 0;
258 }
259
260 return result;
261 }
262
263 // delivery_tag mocks
264
265 static char* umock_stringify_delivery_tag(const delivery_tag* value)
266 {
267 char* result = (char*)my_gballoc_malloc(1);
268 (void)value;
269 result[0] = '\0';
270 return result;
271 }
272
273 static int umock_are_equal_delivery_tag(const delivery_tag* left, const delivery_tag* right)
274 {
275 int result;
276
277 if (left->length != right->length)
278 {
279 result = 0;
280 }
281 else
282 {
283 if (memcmp(left->bytes, right->bytes, left->length) == 0)
284 {
285 result = 1;
286 }
287 else
288 {
289 result = 0;
290 }
291 }
292
293 return result;
294 }
295
296 static int umock_copy_delivery_tag(delivery_tag* destination, const delivery_tag* source)
297 {
298 int result;
299
300 destination->bytes = (const unsigned char*)my_gballoc_malloc(source->length);
301 if (destination->bytes == NULL)
302 {
303 result = -1;
304 }
305 else
306 {
307 (void)memcpy((void*)destination->bytes, source->bytes, source->length);
308 destination->length = source->length;
309 result = 0;
310 }
311
312 return result;
313 }
314
315 static void umock_free_delivery_tag(delivery_tag* value)
316 {
317 my_gballoc_free((void*)value->bytes);
318 value->bytes = NULL;
319 value->length = 0;
320 }
321
322
323 static TRANSFER_HANDLE test_on_transfer_received_transfer;
324 static uint32_t test_on_transfer_received_payload_size;
325 static unsigned char test_on_transfer_received_payload_bytes[2048];
326 static AMQP_VALUE test_on_transfer_received(void* context, TRANSFER_HANDLE transfer, uint32_t payload_size, const unsigned char* payload_bytes)
327 {
328 (void)context;
329 test_on_transfer_received_transfer = transfer;
330 test_on_transfer_received_payload_size = payload_size;
331 memcpy(test_on_transfer_received_payload_bytes, payload_bytes, payload_size);
332
333 return (AMQP_VALUE)0x6000;
334 }
335
336 static LINK_STATE test_on_link_state_changed_new_link_state;
337 LINK_STATE test_on_link_state_changed_previous_link_state;
338 static void test_on_link_state_changed(void* context, LINK_STATE new_link_state, LINK_STATE previous_link_state)
339 {
340 (void)context;
341 test_on_link_state_changed_new_link_state = new_link_state;
342 test_on_link_state_changed_previous_link_state = previous_link_state;
343 }
344
345 static void test_on_link_flow_on(void* context)
346 {
347 (void)context;
348 }
349
350 static void on_delivery_settled(void* context, delivery_number delivery_no, LINK_DELIVERY_SETTLE_REASON reason, AMQP_VALUE delivery_state)
351 {
352 (void)context;
353 (void)delivery_no;
354 (void)reason;
355 (void)delivery_state;
356 }
357
358 static LINK_HANDLE create_link(role link_role)
359 {
360 umock_c_reset_all_calls();
361
362 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
363 STRICT_EXPECTED_CALL(amqpvalue_clone(IGNORED_PTR_ARG));
364 STRICT_EXPECTED_CALL(amqpvalue_clone(IGNORED_PTR_ARG));
365 STRICT_EXPECTED_CALL(tickcounter_create());
366 STRICT_EXPECTED_CALL(singlylinkedlist_create());
367 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
368 STRICT_EXPECTED_CALL(session_create_link_endpoint(TEST_SESSION_HANDLE, TEST_LINK_NAME_1));
369 STRICT_EXPECTED_CALL(session_set_link_endpoint_callback(TEST_LINK_ENDPOINT, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
370
371 return link_create(TEST_SESSION_HANDLE, TEST_LINK_NAME_1, link_role, TEST_LINK_SOURCE, TEST_LINK_TARGET);
372 }
373
374 // If on_session_state_changed it does the full attach, including receiving the ATTACH response.
375 static int attach_link(LINK_HANDLE link, role link_role, ON_ENDPOINT_FRAME_RECEIVED* on_frame_received, ON_SESSION_STATE_CHANGED* on_session_state_changed)
376 {
377 int result;
378
379 umock_c_reset_all_calls();
380
381 ATTACH_HANDLE attach = (ATTACH_HANDLE)0x4999;
382
383 STRICT_EXPECTED_CALL(session_begin(TEST_SESSION_HANDLE));
384
385 if (on_session_state_changed != NULL)
386 {
387 STRICT_EXPECTED_CALL(session_start_link_endpoint(TEST_LINK_ENDPOINT, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, link))
388 .CaptureArgumentValue_frame_received_callback(on_frame_received)
389 .CaptureArgumentValue_on_session_state_changed(on_session_state_changed);
390
391 result = link_attach(link, test_on_transfer_received, test_on_link_state_changed, test_on_link_flow_on, NULL);
392 }
393 else
394 {
395 ON_SESSION_STATE_CHANGED local_on_session_state_changed = NULL;
396 ON_ENDPOINT_FRAME_RECEIVED local_on_frame_received = NULL;
397 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
398 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
399 uint32_t frame_payload_size = 30;
400 const unsigned char payload_bytes[30] = { 0 };
401 uint64_t max_message_size = 123456;
402
403 STRICT_EXPECTED_CALL(session_start_link_endpoint(TEST_LINK_ENDPOINT, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, link))
404 .CaptureArgumentValue_frame_received_callback(&local_on_frame_received)
405 .CaptureArgumentValue_on_session_state_changed(&local_on_session_state_changed);
406
407 result = link_attach(link, test_on_transfer_received, test_on_link_state_changed, test_on_link_flow_on, NULL);
408
409 umock_c_reset_all_calls();
410 STRICT_EXPECTED_CALL(attach_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
411 .SetReturn(attach);
412 STRICT_EXPECTED_CALL(attach_set_snd_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
413 STRICT_EXPECTED_CALL(attach_set_rcv_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
414 STRICT_EXPECTED_CALL(attach_set_role(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
415 STRICT_EXPECTED_CALL(attach_set_source(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
416 STRICT_EXPECTED_CALL(attach_set_target(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
417
418 if (link_role == role_sender)
419 {
420 STRICT_EXPECTED_CALL(attach_set_initial_delivery_count(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
421 }
422
423 STRICT_EXPECTED_CALL(attach_set_max_message_size(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
424 STRICT_EXPECTED_CALL(session_send_attach(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
425 STRICT_EXPECTED_CALL(attach_destroy(IGNORED_PTR_ARG));
426
427 local_on_session_state_changed(link, SESSION_STATE_MAPPED, SESSION_STATE_UNMAPPED);
428 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
429
430 umock_c_reset_all_calls();
431 // ATTACH response
432 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
433 .SetReturn(descriptor);
434 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
435 .SetReturn(true);
436 STRICT_EXPECTED_CALL(amqpvalue_get_attach(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
437 STRICT_EXPECTED_CALL(attach_get_max_message_size(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
438 .CopyOutArgumentBuffer(2, &max_message_size, sizeof(max_message_size));
439 STRICT_EXPECTED_CALL(attach_destroy(IGNORED_PTR_ARG));
440
441 local_on_frame_received(link, performative, frame_payload_size, payload_bytes);
442
443 // FLOW received from remote endpoint.
444
445 if (link_role == role_sender)
446 {
447 FLOW_HANDLE flow = (FLOW_HANDLE)0x5679;
448 uint32_t link_credit = 10000;
449 delivery_number delivery_count = 0;
450
451 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
452 .SetReturn(descriptor);
453 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
454 .SetReturn(false);
455 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
456 .SetReturn(true);
457 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
458 .CopyOutArgumentBuffer(2, &flow, sizeof(flow));
459 STRICT_EXPECTED_CALL(flow_get_link_credit(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
460 .CopyOutArgumentBuffer(2, &link_credit, sizeof(link_credit))
461 .SetReturn(0);
462 STRICT_EXPECTED_CALL(flow_get_delivery_count(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
463 .CopyOutArgumentBuffer(2, &delivery_count, sizeof(delivery_count))
464 .SetReturn(0);
465 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
466
467 local_on_frame_received(link, performative, frame_payload_size, payload_bytes);
468 }
469
470 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
471
472 if (on_frame_received != NULL)
473 {
474 *on_frame_received = local_on_frame_received;
475 }
476 }
477
478 return result;
479 }
480
481 BEGIN_TEST_SUITE(link_ut)
482
483 TEST_SUITE_INITIALIZE(suite_init)
484 {
485 int result;
486
487 g_testByTest = TEST_MUTEX_CREATE();
488 ASSERT_IS_NOT_NULL(g_testByTest);
489
490 umock_c_init(on_umock_c_error);
491
492 result = umocktypes_bool_register_types();
493 ASSERT_ARE_EQUAL(int, 0, result, "Failed registering bool types");
494
495 result = umocktypes_stdint_register_types();
496 ASSERT_ARE_EQUAL(int, 0, result, "Failed registering stdint types");
497
498 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
499 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
500 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
501 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
502 REGISTER_UMOCK_ALIAS_TYPE(transfer_number, uint32_t);
503 REGISTER_UMOCK_ALIAS_TYPE(role, bool);
504 REGISTER_UMOCK_ALIAS_TYPE(delivery_number, uint32_t);
505 REGISTER_UMOCK_ALIAS_TYPE(sequence_no, uint32_t);
506 REGISTER_UMOCK_ALIAS_TYPE(handle, uint32_t);
507 REGISTER_UMOCK_ALIAS_TYPE(sender_settle_mode, uint8_t);
508 REGISTER_UMOCK_ALIAS_TYPE(receiver_settle_mode, uint8_t);
509 REGISTER_UMOCK_ALIAS_TYPE(DISPOSITION_HANDLE, void*);
510 REGISTER_UMOCK_ALIAS_TYPE(AMQP_VALUE, void*);
511 REGISTER_UMOCK_ALIAS_TYPE(TICK_COUNTER_HANDLE, void*);
512 REGISTER_UMOCK_ALIAS_TYPE(SINGLYLINKEDLIST_HANDLE, void*);
513 REGISTER_UMOCK_ALIAS_TYPE(LIST_ITEM_HANDLE, void*);
514 REGISTER_UMOCK_ALIAS_TYPE(SESSION_HANDLE, void*);
515 REGISTER_UMOCK_ALIAS_TYPE(ATTACH_HANDLE, void*);
516 REGISTER_UMOCK_ALIAS_TYPE(LINK_ENDPOINT_HANDLE, void*);
517 REGISTER_UMOCK_ALIAS_TYPE(ON_LINK_ENDPOINT_DESTROYED_CALLBACK, void*);
518 REGISTER_UMOCK_ALIAS_TYPE(ON_ENDPOINT_FRAME_RECEIVED, void*);
519 REGISTER_UMOCK_ALIAS_TYPE(ON_TRANSFER_RECEIVED, void*);
520 REGISTER_UMOCK_ALIAS_TYPE(ON_LINK_STATE_CHANGED, void*);
521 REGISTER_UMOCK_ALIAS_TYPE(ON_LINK_FLOW_ON, void*);
522 REGISTER_UMOCK_ALIAS_TYPE(ON_SESSION_STATE_CHANGED, void*);
523 REGISTER_UMOCK_ALIAS_TYPE(ON_SESSION_FLOW_ON, void*);
524 REGISTER_UMOCK_ALIAS_TYPE(ASYNC_OPERATION_CANCEL_HANDLER_FUNC, void*);
525 REGISTER_UMOCK_ALIAS_TYPE(ASYNC_OPERATION_HANDLE, void*);
526 REGISTER_UMOCK_ALIAS_TYPE(message_format, uint32_t);
527 REGISTER_UMOCK_ALIAS_TYPE(ON_SEND_COMPLETE, void*);
528 REGISTER_UMOCK_ALIAS_TYPE(SESSION_SEND_TRANSFER_RESULT, int);
529
530 REGISTER_GLOBAL_MOCK_RETURNS(tickcounter_create, TEST_TICK_COUNTER_HANDLE, NULL);
531 REGISTER_GLOBAL_MOCK_RETURNS(singlylinkedlist_create, TEST_SINGLYLINKEDLIST_HANDLE, NULL);
532 REGISTER_GLOBAL_MOCK_RETURNS(session_create_link_endpoint, TEST_LINK_ENDPOINT, NULL);
533 REGISTER_GLOBAL_MOCK_RETURNS(session_start_link_endpoint, 0, 1);
534
535 REGISTER_GLOBAL_MOCK_FAIL_RETURN(async_operation_create, NULL);
536 REGISTER_GLOBAL_MOCK_RETURNS(transfer_create, TEST_TRANSFER_HANDLE, NULL);
537 REGISTER_GLOBAL_MOCK_RETURNS(transfer_set_delivery_tag, 0, 1);
538 REGISTER_GLOBAL_MOCK_RETURNS(transfer_set_message_format, 0, 1);
539 REGISTER_GLOBAL_MOCK_RETURNS(transfer_set_settled, 0, 1);
540 REGISTER_GLOBAL_MOCK_RETURNS(amqpvalue_create_transfer, TEST_AMQP_VALUE, NULL);
541 REGISTER_GLOBAL_MOCK_RETURNS(tickcounter_get_current_ms, 0, 1);
542 REGISTER_GLOBAL_MOCK_RETURNS(singlylinkedlist_add, TEST_LIST_ITEM_HANDLE, NULL);
543 REGISTER_GLOBAL_MOCK_RETURNS(singlylinkedlist_remove, 0, 1);
544 REGISTER_GLOBAL_MOCK_RETURNS(session_send_transfer, 0, 1);
545
546 REGISTER_TYPE(FLOW_HANDLE, FLOW_HANDLE);
547 REGISTER_TYPE(TRANSFER_HANDLE, TRANSFER_HANDLE);
548 REGISTER_TYPE(bool*, bool_ptr);
549 REGISTER_TYPE(uint32_t, uint32_t);
550
551 REGISTER_UMOCK_VALUE_TYPE(delivery_tag);
552 }
553
554 TEST_SUITE_CLEANUP(suite_cleanup)
555 {
556 umock_c_deinit();
557
558 TEST_MUTEX_DESTROY(g_testByTest);
559 }
560
561 TEST_FUNCTION_INITIALIZE(test_init)
562 {
563 if (TEST_MUTEX_ACQUIRE(g_testByTest))
564 {
565 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
566 }
567
568 umock_c_reset_all_calls();
569 }
570
571 TEST_FUNCTION_CLEANUP(test_cleanup)
572 {
573 TEST_MUTEX_RELEASE(g_testByTest);
574 }
575
576 TEST_FUNCTION(link_create_succeeds)
577 {
578 // arrange
579 AMQP_VALUE link_source = TEST_LINK_SOURCE;
580 AMQP_VALUE link_target = TEST_LINK_TARGET;
581
582 umock_c_reset_all_calls();
583
584 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
585 STRICT_EXPECTED_CALL(amqpvalue_clone(IGNORED_PTR_ARG));
586 STRICT_EXPECTED_CALL(amqpvalue_clone(IGNORED_PTR_ARG));
587 STRICT_EXPECTED_CALL(tickcounter_create());
588 STRICT_EXPECTED_CALL(singlylinkedlist_create());
589 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
590 STRICT_EXPECTED_CALL(session_create_link_endpoint(TEST_SESSION_HANDLE, TEST_LINK_NAME_1));
591 STRICT_EXPECTED_CALL(session_set_link_endpoint_callback(TEST_LINK_ENDPOINT, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
592
593 // act
594 LINK_HANDLE link = link_create(TEST_SESSION_HANDLE, TEST_LINK_NAME_1, role_receiver, link_source, link_target);
595
596 // assert
597 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
598 ASSERT_IS_NOT_NULL(link);
599
600 // cleanup
601 link_destroy(link);
602 }
603
604 TEST_FUNCTION(link_attach_succeeds)
605 {
606 // arrange
607 LINK_HANDLE link = create_link(role_receiver);
608 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
609
610 umock_c_reset_all_calls();
611
612 STRICT_EXPECTED_CALL(session_begin(TEST_SESSION_HANDLE));
613 STRICT_EXPECTED_CALL(session_start_link_endpoint(TEST_LINK_ENDPOINT, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, link))
614 .CaptureArgumentValue_frame_received_callback(&on_frame_received);
615
616 // act
617 int result = link_attach(link, test_on_transfer_received, test_on_link_state_changed, test_on_link_flow_on, NULL);
618
619 // assert
620 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
621 ASSERT_ARE_EQUAL(int, 0, result);
622 ASSERT_IS_NOT_NULL(on_frame_received);
623
624 // cleanup
625 link_destroy(link);
626 }
627
628 TEST_FUNCTION(link_receiver_frame_received_succeeds)
629 {
630 // arrange
631 LINK_HANDLE link = create_link(role_receiver);
632 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
633 ON_SESSION_STATE_CHANGED on_session_state_changed = NULL;
634 int attach_result = attach_link(link, role_receiver, &on_frame_received, &on_session_state_changed);
635 ASSERT_ARE_EQUAL(int, 0, attach_result);
636
637 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
638 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
639 FLOW_HANDLE flow = (FLOW_HANDLE)0x5002;
640 uint32_t frame_payload_size = 30;
641 const unsigned char payload_bytes[30] = { 0 };
642
643 umock_c_reset_all_calls();
644 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
645 .SetReturn(descriptor);
646 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
647 .SetReturn(false);
648 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
649 .SetReturn(1);
650 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
651 .CopyOutArgumentBuffer(2, &flow, sizeof(flow));
652 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
653
654 // act
655 on_frame_received(link, performative, frame_payload_size, payload_bytes);
656
657 // assert
658 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
659
660 // cleanup
661 link_destroy(link);
662 }
663
664 TEST_FUNCTION(link_sender_frame_received_succeeds)
665 {
666 // arrange
667 LINK_HANDLE link = create_link(role_sender);
668 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
669 ON_SESSION_STATE_CHANGED on_session_state_changed = NULL;
670 int attach_result = attach_link(link, role_sender, &on_frame_received, &on_session_state_changed);
671 ASSERT_ARE_EQUAL(int, 0, attach_result);
672
673 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
674 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
675 FLOW_HANDLE flow = (FLOW_HANDLE)0x5002;
676 uint32_t frame_payload_size = 30;
677 const unsigned char payload_bytes[30] = { 0 };
678 uint32_t link_credit_value = 700;
679 uint32_t delivery_count_value = 300;
680
681 umock_c_reset_all_calls();
682 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
683 .SetReturn(descriptor);
684 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
685 .SetReturn(false);
686 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
687 .SetReturn(1);
688 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
689 .CopyOutArgumentBuffer(2, &flow, sizeof(flow));
690 STRICT_EXPECTED_CALL(flow_get_link_credit(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
691 .CopyOutArgumentBuffer(2, &link_credit_value, sizeof(link_credit_value));
692 STRICT_EXPECTED_CALL(flow_get_delivery_count(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
693 .CopyOutArgumentBuffer(2, &delivery_count_value, sizeof(delivery_count_value));
694 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
695
696 // act
697 on_frame_received(link, performative, frame_payload_size, payload_bytes);
698
699 // assert
700 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
701
702 // cleanup
703 link_destroy(link);
704 }
705
706 TEST_FUNCTION(link_receiver_frame_received_get_flow_fails_no_double_free_fails)
707 {
708 // arrange
709 LINK_HANDLE link = create_link(role_receiver);
710 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
711 ON_SESSION_STATE_CHANGED on_session_state_changed = NULL;
712 int attach_result = attach_link(link, role_receiver, &on_frame_received, &on_session_state_changed);
713 ASSERT_ARE_EQUAL(int, 0, attach_result);
714
715 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
716 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
717 FLOW_HANDLE flow = NULL;
718 uint32_t frame_payload_size = 30;
719 const unsigned char payload_bytes[30] = { 0 };
720
721 umock_c_reset_all_calls();
722 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
723 .SetReturn(descriptor);
724 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
725 .SetReturn(false);
726 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
727 .SetReturn(1);
728 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
729 .CopyOutArgumentBuffer(2, &flow, sizeof(flow))
730 .SetReturn(1);
731
732 // act
733 on_frame_received(link, performative, frame_payload_size, payload_bytes);
734
735 // assert
736 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
737
738 // cleanup
739 link_destroy(link);
740 }
741
742 TEST_FUNCTION(link_receiver_default_max_credit_succeeds)
743 {
744 // arrange
745 const int DEFAULT_LINK_CREDIT = 10000;
746
747 LINK_HANDLE link = create_link(role_receiver);
748
749 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
750 ON_SESSION_STATE_CHANGED on_session_state_changed = NULL;
751 int attach_result = attach_link(link, role_receiver, &on_frame_received, &on_session_state_changed);
752 ASSERT_ARE_EQUAL(int, 0, attach_result);
753
754 ATTACH_HANDLE attach = (ATTACH_HANDLE)0x4999;
755 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
756 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
757 FLOW_HANDLE flow = (FLOW_HANDLE)0x5002;
758 TRANSFER_HANDLE transfer = (TRANSFER_HANDLE)0x5003;
759 uint32_t frame_payload_size = 30;
760 const unsigned char payload_bytes[30] = { 0 };
761 bool more = false;
762 DISPOSITION_HANDLE disposition = (DISPOSITION_HANDLE)0x5005;
763
764 umock_c_reset_all_calls();
765 STRICT_EXPECTED_CALL(attach_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
766 .SetReturn(attach);
767 STRICT_EXPECTED_CALL(attach_set_snd_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
768 STRICT_EXPECTED_CALL(attach_set_rcv_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
769 STRICT_EXPECTED_CALL(attach_set_role(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
770 STRICT_EXPECTED_CALL(attach_set_source(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
771 STRICT_EXPECTED_CALL(attach_set_target(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
772
773 STRICT_EXPECTED_CALL(attach_set_max_message_size(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
774 STRICT_EXPECTED_CALL(session_send_attach(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
775 STRICT_EXPECTED_CALL(attach_destroy(IGNORED_PTR_ARG));
776
777 on_session_state_changed(link, SESSION_STATE_MAPPED, SESSION_STATE_UNMAPPED);
778 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
779
780 umock_c_reset_all_calls();
781 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
782 .SetReturn(descriptor);
783 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
784 .SetReturn(false);
785 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
786 .SetReturn(1);
787 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
788 .CopyOutArgumentBuffer(2, &flow, sizeof(flow));
789 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
790 on_frame_received(link, performative, frame_payload_size, payload_bytes);
791 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
792
793 umock_c_reset_all_calls();
794 // First transfer results in FLOW to set link credit.
795 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
796 .SetReturn(descriptor);
797 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
798 .SetReturn(false);
799 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
800 .SetReturn(false);
801 STRICT_EXPECTED_CALL(is_transfer_type_by_descriptor(IGNORED_PTR_ARG))
802 .SetReturn(true);
803 STRICT_EXPECTED_CALL(amqpvalue_get_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
804 .CopyOutArgumentBuffer(2, &transfer, sizeof(transfer));
805 // send_flow
806 STRICT_EXPECTED_CALL(flow_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
807 .SetReturn(flow);
808 STRICT_EXPECTED_CALL(flow_set_link_credit(IGNORED_PTR_ARG, DEFAULT_LINK_CREDIT));
809 STRICT_EXPECTED_CALL(flow_set_handle(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
810 STRICT_EXPECTED_CALL(flow_set_delivery_count(IGNORED_PTR_ARG, 0));
811 STRICT_EXPECTED_CALL(session_send_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
812 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
813 // continue processing TRANSFER
814 STRICT_EXPECTED_CALL(transfer_get_more(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
815 .CopyOutArgumentBuffer(2, &more, sizeof(bool));
816 STRICT_EXPECTED_CALL(transfer_get_delivery_id(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
817 STRICT_EXPECTED_CALL(disposition_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
818 .SetReturn(disposition);
819 STRICT_EXPECTED_CALL(disposition_set_last(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
820 STRICT_EXPECTED_CALL(disposition_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
821 STRICT_EXPECTED_CALL(disposition_set_state(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
822 STRICT_EXPECTED_CALL(session_send_disposition(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
823 STRICT_EXPECTED_CALL(disposition_destroy(IGNORED_PTR_ARG));
824 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
825 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
826
827 // act
828 on_frame_received(link, performative, frame_payload_size, payload_bytes);
829
830 // assert
831 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
832
833 // cleanup
834 link_destroy(link);
835 }
836
837 TEST_FUNCTION(link_receiver_link_credit_replenish_succeeds)
838 {
839 // arrange
840 LINK_HANDLE link = create_link(role_receiver);
841 ASSERT_ARE_EQUAL(int, 0, link_set_max_link_credit(link, 5));
842
843 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
844 ON_SESSION_STATE_CHANGED on_session_state_changed = NULL;
845 int attach_result = attach_link(link, role_receiver, &on_frame_received, &on_session_state_changed);
846 ASSERT_ARE_EQUAL(int, 0, attach_result);
847
848 ATTACH_HANDLE attach = (ATTACH_HANDLE)0x4999;
849 AMQP_VALUE performative = (AMQP_VALUE)0x5000;
850 AMQP_VALUE descriptor = (AMQP_VALUE)0x5001;
851 FLOW_HANDLE flow = (FLOW_HANDLE)0x5002;
852 TRANSFER_HANDLE transfer = (TRANSFER_HANDLE)0x5003;
853 uint32_t frame_payload_size = 30;
854 const unsigned char payload_bytes[30] = { 0 };
855 bool more = false;
856 DISPOSITION_HANDLE disposition = (DISPOSITION_HANDLE)0x5005;
857
858 umock_c_reset_all_calls();
859 STRICT_EXPECTED_CALL(attach_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
860 .SetReturn(attach);
861 STRICT_EXPECTED_CALL(attach_set_snd_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
862 STRICT_EXPECTED_CALL(attach_set_rcv_settle_mode(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
863 STRICT_EXPECTED_CALL(attach_set_role(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
864 STRICT_EXPECTED_CALL(attach_set_source(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
865 STRICT_EXPECTED_CALL(attach_set_target(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
866
867 STRICT_EXPECTED_CALL(attach_set_max_message_size(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
868 STRICT_EXPECTED_CALL(session_send_attach(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
869 STRICT_EXPECTED_CALL(attach_destroy(IGNORED_PTR_ARG));
870
871 on_session_state_changed(link, SESSION_STATE_MAPPED, SESSION_STATE_UNMAPPED);
872 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
873
874 umock_c_reset_all_calls();
875 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
876 .SetReturn(descriptor);
877 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
878 .SetReturn(false);
879 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
880 .SetReturn(1);
881 STRICT_EXPECTED_CALL(amqpvalue_get_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
882 .CopyOutArgumentBuffer(2, &flow, sizeof(flow));
883 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
884 on_frame_received(link, performative, frame_payload_size, payload_bytes);
885 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
886
887 umock_c_reset_all_calls();
888 // First transfer results in FLOW to set link credit.
889 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
890 .SetReturn(descriptor);
891 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
892 .SetReturn(false);
893 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
894 .SetReturn(false);
895 STRICT_EXPECTED_CALL(is_transfer_type_by_descriptor(IGNORED_PTR_ARG))
896 .SetReturn(true);
897 STRICT_EXPECTED_CALL(amqpvalue_get_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
898 .CopyOutArgumentBuffer(2, &transfer, sizeof(transfer));
899 // send_flow
900 STRICT_EXPECTED_CALL(flow_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
901 .SetReturn(flow);
902 STRICT_EXPECTED_CALL(flow_set_link_credit(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
903 STRICT_EXPECTED_CALL(flow_set_handle(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
904 STRICT_EXPECTED_CALL(flow_set_delivery_count(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
905 STRICT_EXPECTED_CALL(session_send_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
906 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
907 // continue processing TRANSFER
908 STRICT_EXPECTED_CALL(transfer_get_more(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
909 .CopyOutArgumentBuffer(2, &more, sizeof(bool));
910 STRICT_EXPECTED_CALL(transfer_get_delivery_id(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
911 STRICT_EXPECTED_CALL(disposition_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
912 .SetReturn(disposition);
913 STRICT_EXPECTED_CALL(disposition_set_last(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
914 STRICT_EXPECTED_CALL(disposition_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
915 STRICT_EXPECTED_CALL(disposition_set_state(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
916 STRICT_EXPECTED_CALL(session_send_disposition(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
917 STRICT_EXPECTED_CALL(disposition_destroy(IGNORED_PTR_ARG));
918 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
919 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
920 on_frame_received(link, performative, frame_payload_size, payload_bytes);
921 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
922
923 umock_c_reset_all_calls();
924
925 // act
926 // First 3 transfers result in no FLOW.
927 for (int i = 0; i < 3; i++)
928 {
929 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
930 .SetReturn(descriptor);
931 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
932 .SetReturn(false);
933 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
934 .SetReturn(false);
935 STRICT_EXPECTED_CALL(is_transfer_type_by_descriptor(IGNORED_PTR_ARG))
936 .SetReturn(true);
937 STRICT_EXPECTED_CALL(amqpvalue_get_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
938 .CopyOutArgumentBuffer(2, &transfer, sizeof(transfer));
939 STRICT_EXPECTED_CALL(transfer_get_more(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
940 .CopyOutArgumentBuffer(2, &more, sizeof(bool));
941 STRICT_EXPECTED_CALL(transfer_get_delivery_id(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
942 STRICT_EXPECTED_CALL(disposition_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
943 .SetReturn(disposition);
944 STRICT_EXPECTED_CALL(disposition_set_last(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
945 STRICT_EXPECTED_CALL(disposition_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
946 STRICT_EXPECTED_CALL(disposition_set_state(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
947 STRICT_EXPECTED_CALL(session_send_disposition(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
948 STRICT_EXPECTED_CALL(disposition_destroy(IGNORED_PTR_ARG));
949 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
950 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
951 on_frame_received(link, performative, frame_payload_size, payload_bytes);
952 }
953
954 // And 4th does result in FLOW.
955 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(performative))
956 .SetReturn(descriptor);
957 STRICT_EXPECTED_CALL(is_attach_type_by_descriptor(IGNORED_PTR_ARG))
958 .SetReturn(false);
959 STRICT_EXPECTED_CALL(is_flow_type_by_descriptor(IGNORED_PTR_ARG))
960 .SetReturn(false);
961 STRICT_EXPECTED_CALL(is_transfer_type_by_descriptor(IGNORED_PTR_ARG))
962 .SetReturn(true);
963 STRICT_EXPECTED_CALL(amqpvalue_get_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
964 .CopyOutArgumentBuffer(2, &transfer, sizeof(transfer));
965 // send_flow
966 STRICT_EXPECTED_CALL(flow_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG, IGNORED_NUM_ARG))
967 .SetReturn(flow);
968 STRICT_EXPECTED_CALL(flow_set_link_credit(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
969 STRICT_EXPECTED_CALL(flow_set_handle(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
970 STRICT_EXPECTED_CALL(flow_set_delivery_count(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
971 STRICT_EXPECTED_CALL(session_send_flow(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
972 STRICT_EXPECTED_CALL(flow_destroy(IGNORED_PTR_ARG));
973 // continue processing TRANSFER
974 STRICT_EXPECTED_CALL(transfer_get_more(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
975 .CopyOutArgumentBuffer(2, &more, sizeof(bool));
976 STRICT_EXPECTED_CALL(transfer_get_delivery_id(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
977 STRICT_EXPECTED_CALL(disposition_create(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
978 .SetReturn(disposition);
979 STRICT_EXPECTED_CALL(disposition_set_last(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
980 STRICT_EXPECTED_CALL(disposition_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
981 STRICT_EXPECTED_CALL(disposition_set_state(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
982 STRICT_EXPECTED_CALL(session_send_disposition(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
983 STRICT_EXPECTED_CALL(disposition_destroy(IGNORED_PTR_ARG));
984 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
985 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
986 on_frame_received(link, performative, frame_payload_size, payload_bytes);
987
988 // assert
989 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
990
991 // cleanup
992 link_destroy(link);
993 }
994
995 TEST_FUNCTION(link_transfer_async_success)
996 {
997 // arrange
998 LINK_HANDLE link = create_link(role_sender);
999
1000 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
1001 LINK_TRANSFER_RESULT link_transfer_error;
1002 tickcounter_ms_t send_timeout = 1000;
1003 uint8_t data_bytes[16];
1004 PAYLOAD payload;
1005 payload.bytes = (const unsigned char*)data_bytes;
1006 payload.length = 0;
1007 const size_t message_count = 1;
1008 uint8_t async_op_result[128];
1009 unsigned char delivery_tag_bytes[10];
1010 delivery_tag moot_delivery_tag;
1011 moot_delivery_tag.bytes = delivery_tag_bytes;
1012 moot_delivery_tag.length = sizeof(delivery_tag_bytes);
1013
1014 int attach_result = attach_link(link, role_sender, &on_frame_received, NULL);
1015 ASSERT_ARE_EQUAL(int, 0, attach_result);
1016
1017 umock_c_reset_all_calls();
1018 STRICT_EXPECTED_CALL(async_operation_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
1019 .SetReturn((ASYNC_OPERATION_HANDLE)async_op_result);
1020 STRICT_EXPECTED_CALL(transfer_create(IGNORED_NUM_ARG));
1021 STRICT_EXPECTED_CALL(transfer_set_delivery_tag(IGNORED_PTR_ARG, moot_delivery_tag))
1022 .IgnoreArgument_delivery_tag_value(); // Important for making umock-c work with custom value arguments.
1023 STRICT_EXPECTED_CALL(transfer_set_message_format(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1024 STRICT_EXPECTED_CALL(transfer_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1025 STRICT_EXPECTED_CALL(amqpvalue_create_transfer(IGNORED_PTR_ARG));
1026 STRICT_EXPECTED_CALL(tickcounter_get_current_ms(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1027 STRICT_EXPECTED_CALL(singlylinkedlist_add(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1028 STRICT_EXPECTED_CALL(session_send_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1029 .SetReturn(SESSION_SEND_TRANSFER_OK);
1030 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
1031 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
1032
1033 // act
1034 ASYNC_OPERATION_HANDLE async_result = link_transfer_async(link, AMQP_BATCHING_FORMAT_CODE, &payload, message_count, on_delivery_settled, NULL, &link_transfer_error, send_timeout);
1035
1036 // assert
1037 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1038 ASSERT_IS_NOT_NULL(async_result);
1039
1040 // cleanup
1041 link_destroy(link);
1042 }
1043
1044 TEST_FUNCTION(link_transfer_async_SESSION_SEND_TRANSFER_ERROR_fails)
1045 {
1046 // arrange
1047 LINK_HANDLE link = create_link(role_sender);
1048
1049 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
1050 LINK_TRANSFER_RESULT link_transfer_error;
1051 tickcounter_ms_t send_timeout = 1000;
1052 uint8_t data_bytes[16];
1053 PAYLOAD payload;
1054 payload.bytes = (const unsigned char*)data_bytes;
1055 payload.length = 0;
1056 const size_t message_count = 1;
1057 uint8_t async_op_result[128];
1058 unsigned char delivery_tag_bytes[10];
1059 delivery_tag moot_delivery_tag;
1060 moot_delivery_tag.bytes = delivery_tag_bytes;
1061 moot_delivery_tag.length = sizeof(delivery_tag_bytes);
1062
1063 int attach_result = attach_link(link, role_sender, &on_frame_received, NULL);
1064 ASSERT_ARE_EQUAL(int, 0, attach_result);
1065
1066 umock_c_reset_all_calls();
1067 STRICT_EXPECTED_CALL(async_operation_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
1068 .SetReturn((ASYNC_OPERATION_HANDLE)async_op_result);
1069 STRICT_EXPECTED_CALL(transfer_create(IGNORED_NUM_ARG));
1070 STRICT_EXPECTED_CALL(transfer_set_delivery_tag(IGNORED_PTR_ARG, moot_delivery_tag))
1071 .IgnoreArgument_delivery_tag_value(); // Important for making umock-c work with custom value arguments.
1072 STRICT_EXPECTED_CALL(transfer_set_message_format(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1073 STRICT_EXPECTED_CALL(transfer_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1074 STRICT_EXPECTED_CALL(amqpvalue_create_transfer(IGNORED_PTR_ARG));
1075 STRICT_EXPECTED_CALL(tickcounter_get_current_ms(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1076 STRICT_EXPECTED_CALL(singlylinkedlist_add(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1077 STRICT_EXPECTED_CALL(session_send_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1078 .SetReturn(SESSION_SEND_TRANSFER_ERROR);
1079 STRICT_EXPECTED_CALL(singlylinkedlist_remove(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1080 STRICT_EXPECTED_CALL(async_operation_destroy(IGNORED_PTR_ARG));
1081 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
1082 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
1083
1084 // act
1085 ASYNC_OPERATION_HANDLE async_result = link_transfer_async(link, AMQP_BATCHING_FORMAT_CODE, &payload, message_count, on_delivery_settled, NULL, &link_transfer_error, send_timeout);
1086
1087 // assert
1088 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1089 ASSERT_IS_NULL(async_result);
1090
1091 // cleanup
1092 link_destroy(link);
1093 }
1094
1095 TEST_FUNCTION(link_transfer_async_SESSION_SEND_TRANSFER_BUSY_fails)
1096 {
1097 // arrange
1098 LINK_HANDLE link = create_link(role_sender);
1099
1100 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
1101 LINK_TRANSFER_RESULT link_transfer_error;
1102 tickcounter_ms_t send_timeout = 1000;
1103 uint8_t data_bytes[16];
1104 PAYLOAD payload;
1105 payload.bytes = (const unsigned char*)data_bytes;
1106 payload.length = 0;
1107 const size_t message_count = 1;
1108 uint8_t async_op_result[128];
1109 unsigned char delivery_tag_bytes[10];
1110 delivery_tag moot_delivery_tag;
1111 moot_delivery_tag.bytes = delivery_tag_bytes;
1112 moot_delivery_tag.length = sizeof(delivery_tag_bytes);
1113
1114 int attach_result = attach_link(link, role_sender, &on_frame_received, NULL);
1115 ASSERT_ARE_EQUAL(int, 0, attach_result);
1116
1117 umock_c_reset_all_calls();
1118 STRICT_EXPECTED_CALL(async_operation_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
1119 .SetReturn((ASYNC_OPERATION_HANDLE)async_op_result);
1120 STRICT_EXPECTED_CALL(transfer_create(IGNORED_NUM_ARG));
1121 STRICT_EXPECTED_CALL(transfer_set_delivery_tag(IGNORED_PTR_ARG, moot_delivery_tag))
1122 .IgnoreArgument_delivery_tag_value(); // Important for making umock-c work with custom value arguments.
1123 STRICT_EXPECTED_CALL(transfer_set_message_format(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1124 STRICT_EXPECTED_CALL(transfer_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1125 STRICT_EXPECTED_CALL(amqpvalue_create_transfer(IGNORED_PTR_ARG));
1126 STRICT_EXPECTED_CALL(tickcounter_get_current_ms(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1127 STRICT_EXPECTED_CALL(singlylinkedlist_add(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1128 STRICT_EXPECTED_CALL(session_send_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1129 .SetReturn(SESSION_SEND_TRANSFER_BUSY);
1130 STRICT_EXPECTED_CALL(singlylinkedlist_remove(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1131 STRICT_EXPECTED_CALL(async_operation_destroy(IGNORED_PTR_ARG));
1132 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
1133 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
1134
1135 // act
1136 ASYNC_OPERATION_HANDLE async_result = link_transfer_async(link, AMQP_BATCHING_FORMAT_CODE, &payload, message_count, on_delivery_settled, NULL, &link_transfer_error, send_timeout);
1137
1138 // assert
1139 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1140 ASSERT_IS_NULL(async_result);
1141
1142 // cleanup
1143 link_destroy(link);
1144 }
1145
1146 // If `session_send_transfer` fails internally, depending on the point where it fails `remove_all_pending_deliveries` might be called,
1147 // causing the ASYNC_OPERATION_HANDLE/DELIVERY_INSTANCE variable `result` to be removed from `link->pending_deliveries` and destroyed.
1148 // Then when `session_send_transfer` returns, in such cases `singlylinkedlist_remove` will fail and `async_operation_destroy` should not be called (to avoid a double-free).
1149 TEST_FUNCTION(link_transfer_async_SESSION_SEND_TRANSFER_ERROR_result_already_destroyed_fails)
1150 {
1151 // arrange
1152 LINK_HANDLE link = create_link(role_sender);
1153
1154 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
1155 LINK_TRANSFER_RESULT link_transfer_error;
1156 tickcounter_ms_t send_timeout = 1000;
1157 uint8_t data_bytes[16];
1158 PAYLOAD payload;
1159 payload.bytes = (const unsigned char*)data_bytes;
1160 payload.length = 0;
1161 const size_t message_count = 1;
1162 uint8_t async_op_result[128];
1163 unsigned char delivery_tag_bytes[10];
1164 delivery_tag moot_delivery_tag;
1165 moot_delivery_tag.bytes = delivery_tag_bytes;
1166 moot_delivery_tag.length = sizeof(delivery_tag_bytes);
1167
1168 int attach_result = attach_link(link, role_sender, &on_frame_received, NULL);
1169 ASSERT_ARE_EQUAL(int, 0, attach_result);
1170
1171 umock_c_reset_all_calls();
1172 STRICT_EXPECTED_CALL(async_operation_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
1173 .SetReturn((ASYNC_OPERATION_HANDLE)async_op_result);
1174 STRICT_EXPECTED_CALL(transfer_create(IGNORED_NUM_ARG));
1175 STRICT_EXPECTED_CALL(transfer_set_delivery_tag(IGNORED_PTR_ARG, moot_delivery_tag))
1176 .IgnoreArgument_delivery_tag_value(); // Important for making umock-c work with custom value arguments.
1177 STRICT_EXPECTED_CALL(transfer_set_message_format(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1178 STRICT_EXPECTED_CALL(transfer_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1179 STRICT_EXPECTED_CALL(amqpvalue_create_transfer(IGNORED_PTR_ARG));
1180 STRICT_EXPECTED_CALL(tickcounter_get_current_ms(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1181 STRICT_EXPECTED_CALL(singlylinkedlist_add(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1182 STRICT_EXPECTED_CALL(session_send_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1183 .SetReturn(SESSION_SEND_TRANSFER_ERROR);
1184 STRICT_EXPECTED_CALL(singlylinkedlist_remove(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1185 .SetReturn(1); // result has already been removed from link->pending_deliveries.
1186 // Do not expect async_operation_destroy!
1187 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
1188 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
1189
1190 // act
1191 ASYNC_OPERATION_HANDLE async_result = link_transfer_async(link, AMQP_BATCHING_FORMAT_CODE, &payload, message_count, on_delivery_settled, NULL, &link_transfer_error, send_timeout);
1192
1193 // assert
1194 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1195 ASSERT_IS_NULL(async_result);
1196
1197 // cleanup
1198 link_destroy(link);
1199 }
1200
1201 // If `session_send_transfer` fails internally, depending on the point where it fails `remove_all_pending_deliveries` might be called,
1202 // causing the ASYNC_OPERATION_HANDLE/DELIVERY_INSTANCE variable `result` to be removed from `link->pending_deliveries` and destroyed.
1203 // Then when `session_send_transfer` returns, in such cases `singlylinkedlist_remove` will fail and `async_operation_destroy` should not be called (to avoid a double-free).
1204 TEST_FUNCTION(link_transfer_async_SESSION_SEND_TRANSFER_BUSY_result_already_destroyed_fails)
1205 {
1206 // arrange
1207 LINK_HANDLE link = create_link(role_sender);
1208
1209 ON_ENDPOINT_FRAME_RECEIVED on_frame_received = NULL;
1210 LINK_TRANSFER_RESULT link_transfer_error;
1211 tickcounter_ms_t send_timeout = 1000;
1212 uint8_t data_bytes[16];
1213 PAYLOAD payload;
1214 payload.bytes = (const unsigned char*)data_bytes;
1215 payload.length = 0;
1216 const size_t message_count = 1;
1217 uint8_t async_op_result[128];
1218 unsigned char delivery_tag_bytes[10];
1219 delivery_tag moot_delivery_tag;
1220 moot_delivery_tag.bytes = delivery_tag_bytes;
1221 moot_delivery_tag.length = sizeof(delivery_tag_bytes);
1222
1223 int attach_result = attach_link(link, role_sender, &on_frame_received, NULL);
1224 ASSERT_ARE_EQUAL(int, 0, attach_result);
1225
1226 umock_c_reset_all_calls();
1227 STRICT_EXPECTED_CALL(async_operation_create(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
1228 .SetReturn((ASYNC_OPERATION_HANDLE)async_op_result);
1229 STRICT_EXPECTED_CALL(transfer_create(IGNORED_NUM_ARG));
1230 STRICT_EXPECTED_CALL(transfer_set_delivery_tag(IGNORED_PTR_ARG, moot_delivery_tag))
1231 .IgnoreArgument_delivery_tag_value(); // Important for making umock-c work with custom value arguments.
1232 STRICT_EXPECTED_CALL(transfer_set_message_format(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1233 STRICT_EXPECTED_CALL(transfer_set_settled(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
1234 STRICT_EXPECTED_CALL(amqpvalue_create_transfer(IGNORED_PTR_ARG));
1235 STRICT_EXPECTED_CALL(tickcounter_get_current_ms(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1236 STRICT_EXPECTED_CALL(singlylinkedlist_add(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
1237 STRICT_EXPECTED_CALL(session_send_transfer(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1238 .SetReturn(SESSION_SEND_TRANSFER_BUSY);
1239 STRICT_EXPECTED_CALL(singlylinkedlist_remove(IGNORED_PTR_ARG, IGNORED_PTR_ARG))
1240 .SetReturn(1); // result has already been removed from link->pending_deliveries.
1241 // Do not expect async_operation_destroy!
1242 STRICT_EXPECTED_CALL(amqpvalue_destroy(IGNORED_PTR_ARG));
1243 STRICT_EXPECTED_CALL(transfer_destroy(IGNORED_PTR_ARG));
1244
1245 // act
1246 ASYNC_OPERATION_HANDLE async_result = link_transfer_async(link, AMQP_BATCHING_FORMAT_CODE, &payload, message_count, on_delivery_settled, NULL, &link_transfer_error, send_timeout);
1247
1248 // assert
1249 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1250 ASSERT_IS_NULL(async_result);
1251
1252 // cleanup
1253 link_destroy(link);
1254 }
1255
1256 END_TEST_SUITE(link_ut)