Debian Codegraph @

src/vendor/azure-uamqp-c/tests/session_ut/session_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 <cstdint>
7 #else
8 #include <stdlib.h>
9 #include <stdint.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/umocktypes_charptr.h"
16
17 static void* my_gballoc_malloc(size_t size)
18 {
19 return malloc(size);
20 }
21
22 static void* my_gballoc_calloc(size_t nmemb, size_t size)
23 {
24 return calloc(nmemb, size);
25 }
26
27 static void* my_gballoc_realloc(void* ptr, size_t size)
28 {
29 return realloc(ptr, size);
30 }
31
32 static void my_gballoc_free(void* ptr)
33 {
34 free(ptr);
35 }
36
37 #define ENABLE_MOCKS
38
39 #include "azure_c_shared_utility/gballoc.h"
40 #include "azure_c_shared_utility/xio.h"
41 #include "azure_uamqp_c/amqp_definitions.h"
42 #include "azure_uamqp_c/connection.h"
43
44 #undef ENABLE_MOCKS
45
46 #include "azure_uamqp_c/session.h"
47
48 #define TEST_ENDPOINT_HANDLE (ENDPOINT_HANDLE)0x4242
49 #define TEST_DESCRIBED_AMQP_VALUE (AMQP_VALUE)0x4247
50 #define TEST_LIST_ITEM_AMQP_VALUE (AMQP_VALUE)0x4246
51 #define TEST_DESCRIPTOR_AMQP_VALUE (AMQP_VALUE)0x4245
52 #define TEST_CONNECTION_HANDLE (CONNECTION_HANDLE)0x4248
53 #define TEST_DELIVERY_QUEUE_HANDLE (DELIVERY_QUEUE_HANDLE)0x4249
54 #define TEST_CONTEXT (void*)0x4444
55 #define TEST_ATTACH_PERFORMATIVE (AMQP_VALUE)0x5000
56 #define TEST_BEGIN_PERFORMATIVE (AMQP_VALUE)0x5001
57
58 static TRANSFER_HANDLE test_transfer_handle = (TRANSFER_HANDLE)0x6001;
59 static ON_ENDPOINT_FRAME_RECEIVED saved_frame_received_callback;
60 static ON_CONNECTION_STATE_CHANGED saved_connection_state_changed_callback;
61 static void* saved_callback_context;
62 static uint32_t some_remote_max_frame_size = 512;
63
64 static uint64_t performative_ulong;
65
66 MOCK_FUNCTION_WITH_CODE(, void, test_frame_received_callback, void*, context, AMQP_VALUE, performative, uint32_t, frame_payload_size, const unsigned char*, payload_bytes)
67 MOCK_FUNCTION_END();
68 MOCK_FUNCTION_WITH_CODE(, void, test_on_session_state_changed, void*, context, SESSION_STATE, new_session_state, SESSION_STATE, previous_session_state)
69 MOCK_FUNCTION_END();
70 MOCK_FUNCTION_WITH_CODE(, void, test_on_flow_on, void*, context)
71 MOCK_FUNCTION_END();
72 MOCK_FUNCTION_WITH_CODE(, void, test_on_send_complete, void*, context, IO_SEND_RESULT, send_result)
73 MOCK_FUNCTION_END();
74
75 static int my_amqpvalue_get_ulong(AMQP_VALUE value, uint64_t* ulong_value)
76 {
77 (void)value;
78 *ulong_value = performative_ulong;
79 return 0;
80 }
81
82 static int my_connection_start_endpoint(ENDPOINT_HANDLE endpoint, ON_ENDPOINT_FRAME_RECEIVED frame_received_callback, ON_CONNECTION_STATE_CHANGED on_connection_state_changed, void* context)
83 {
84 (void)endpoint;
85 saved_frame_received_callback = frame_received_callback;
86 saved_connection_state_changed_callback = on_connection_state_changed;
87 saved_callback_context = context;
88 return 0;
89 }
90
91 static TEST_MUTEX_HANDLE g_testByTest;
92
93 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
94
95 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
96 {
97 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
98 }
99
100 BEGIN_TEST_SUITE(session_ut)
101
102 TEST_SUITE_INITIALIZE(suite_init)
103 {
104 int result;
105
106 g_testByTest = TEST_MUTEX_CREATE();
107 ASSERT_IS_NOT_NULL(g_testByTest);
108
109 umock_c_init(on_umock_c_error);
110
111 result = umocktypes_charptr_register_types();
112 ASSERT_ARE_EQUAL(int, 0, result);
113
114 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
115 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
116 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
117 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
118 REGISTER_GLOBAL_MOCK_HOOK(amqpvalue_get_ulong, my_amqpvalue_get_ulong);
119 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_uint, 0);
120 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_inplace_descriptor, TEST_DESCRIPTOR_AMQP_VALUE);
121 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_string, 0);
122 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_list_item, TEST_LIST_ITEM_AMQP_VALUE);
123 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_inplace_described_value, TEST_DESCRIBED_AMQP_VALUE);
124 REGISTER_GLOBAL_MOCK_RETURN(amqpvalue_get_encoded_size, 0);
125 REGISTER_GLOBAL_MOCK_RETURN(connection_open, 0);
126 REGISTER_GLOBAL_MOCK_RETURN(connection_close, 0);
127 REGISTER_GLOBAL_MOCK_RETURN(connection_create_endpoint, TEST_ENDPOINT_HANDLE);
128 REGISTER_GLOBAL_MOCK_RETURN(connection_endpoint_get_incoming_channel, 0);
129 REGISTER_GLOBAL_MOCK_RETURN(connection_encode_frame, 0);
130 REGISTER_GLOBAL_MOCK_RETURN(connection_get_remote_max_frame_size, 0);
131 REGISTER_GLOBAL_MOCK_HOOK(connection_start_endpoint, my_connection_start_endpoint);
132
133 REGISTER_UMOCK_ALIAS_TYPE(SESSION_HANDLE, void*);
134 REGISTER_UMOCK_ALIAS_TYPE(CONNECTION_HANDLE, void*);
135 REGISTER_UMOCK_ALIAS_TYPE(ENDPOINT_HANDLE, void*);
136 }
137
138 TEST_SUITE_CLEANUP(suite_cleanup)
139 {
140 umock_c_deinit();
141
142 TEST_MUTEX_DESTROY(g_testByTest);
143 }
144
145 TEST_FUNCTION_INITIALIZE(method_init)
146 {
147 if (TEST_MUTEX_ACQUIRE(g_testByTest))
148 {
149 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
150 }
151
152 umock_c_reset_all_calls();
153 }
154
155 TEST_FUNCTION_CLEANUP(method_cleanup)
156 {
157 TEST_MUTEX_RELEASE(g_testByTest);
158 }
159
160 /* session_create */
161
162 /* Tests_S_R_S_SESSION_01_030: [session_create shall create a new session instance and return a non-NULL handle to it.] */
163 /* Tests_S_R_S_SESSION_01_032: [session_create shall create a new session endpoint by calling connection_create_endpoint.] */
164 TEST_FUNCTION(session_create_with_valid_args_succeeds)
165 {
166 // arrange
167 SESSION_HANDLE session;
168 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
169 STRICT_EXPECTED_CALL(connection_create_endpoint(TEST_CONNECTION_HANDLE));
170
171 // act
172 session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
173
174 // assert
175 ASSERT_IS_NOT_NULL(session);
176 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
177
178 // cleanup
179 session_destroy(session);
180 }
181
182 /* Tests_S_R_S_SESSION_01_030: [session_create shall create a new session instance and return a non-NULL handle to it.] */
183 /* Tests_S_R_S_SESSION_01_032: [session_create shall create a new session endpoint by calling connection_create_endpoint.] */
184 TEST_FUNCTION(session_create_twice_on_the_same_connection_works)
185 {
186 // arrange
187 SESSION_HANDLE session1;
188 SESSION_HANDLE session2;
189 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
190 STRICT_EXPECTED_CALL(connection_create_endpoint(TEST_CONNECTION_HANDLE));
191 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
192 STRICT_EXPECTED_CALL(connection_create_endpoint(TEST_CONNECTION_HANDLE));
193
194 // act
195 session1 = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
196 session2 = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
197
198 // assert
199 ASSERT_IS_NOT_NULL(session1);
200 ASSERT_IS_NOT_NULL(session2);
201 ASSERT_ARE_NOT_EQUAL(void_ptr, session1, session2);
202 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
203
204 // cleanup
205 session_destroy(session1);
206 session_destroy(session2);
207 }
208
209 /* Tests_S_R_S_SESSION_01_031: [If connection is NULL, session_create shall fail and return NULL.] */
210 TEST_FUNCTION(session_create_with_NULL_connection_fails)
211 {
212 // arrange
213
214 // act
215 SESSION_HANDLE session = session_create(NULL, NULL, NULL);
216
217 // assert
218 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
219 ASSERT_IS_NULL(session);
220 }
221
222 /* Tests_S_R_S_SESSION_01_042: [If allocating memory for the session fails, session_create shall fail and return NULL.] */
223 TEST_FUNCTION(when_allocating_memory_for_the_session_fails_session_create_fails)
224 {
225 // arrange
226 SESSION_HANDLE session;
227 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
228 .SetReturn(NULL);
229
230 // act
231 session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
232
233 // assert
234 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
235 ASSERT_IS_NULL(session);
236 }
237
238 /* Tests_S_R_S_SESSION_01_033: [If connection_create_endpoint fails, session_create shall fail and return NULL.] */
239 TEST_FUNCTION(when_connection_create_endpoint_fails_session_create_fails)
240 {
241 // arrange
242 SESSION_HANDLE session;
243 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
244 STRICT_EXPECTED_CALL(connection_create_endpoint(TEST_CONNECTION_HANDLE))
245 .SetReturn(NULL);
246 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
247
248 // act
249 session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
250
251 // assert
252 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
253 ASSERT_IS_NULL(session);
254 }
255
256 /* session_destroy */
257
258 /* Tests_S_R_S_SESSION_01_034: [session_destroy shall free all resources allocated by session_create.] */
259 /* Tests_S_R_S_SESSION_01_035: [The endpoint created in session_create shall be freed by calling connection_destroy_endpoint.] */
260 TEST_FUNCTION(when_session_destroy_is_called_then_the_underlying_endpoint_is_freed)
261 {
262 // arrange
263 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
264 umock_c_reset_all_calls();
265
266 STRICT_EXPECTED_CALL(connection_destroy_endpoint(TEST_ENDPOINT_HANDLE));
267 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
268
269 // act
270 session_destroy(session);
271
272 // assert
273 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
274 }
275
276 /* Tests_S_R_S_SESSION_01_036: [If session is NULL, session_destroy shall do nothing.] */
277 TEST_FUNCTION(session_destroy_with_NULL_session_does_nothing)
278 {
279 // arrange
280
281 // act
282 session_destroy(NULL);
283
284 // assert
285 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
286 }
287
288 /* session_create_link_endpoint */
289
290 /* Tests_S_R_S_SESSION_01_043: [session_create_link_endpoint shall create a link endpoint associated with a given session and return a non-NULL handle to it.] */
291 /* Tests_S_R_S_SESSION_01_046: [An unused handle shall be assigned to the link endpoint.] */
292 TEST_FUNCTION(session_create_link_endpoint_creates_a_link_endpoint)
293 {
294 // arrange
295 LINK_ENDPOINT_HANDLE link_endpoint;
296 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
297 umock_c_reset_all_calls();
298
299 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
300 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
301 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
302
303 // act
304 link_endpoint = session_create_link_endpoint(session, "1");
305
306 // assert
307 ASSERT_IS_NOT_NULL(link_endpoint);
308 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
309
310 // cleanup
311 session_destroy_link_endpoint(link_endpoint);
312 session_destroy(session);
313 }
314
315 /* Tests_S_R_S_SESSION_01_044: [If session, name or frame_received_callback is NULL, session_create_link_endpoint shall fail and return NULL.] */
316 TEST_FUNCTION(session_create_with_NULL_session_fails)
317 {
318 // arrange
319
320 // act
321 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(NULL, "1");
322
323 // assert
324 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
325 ASSERT_IS_NULL(link_endpoint);
326 }
327
328 /* Tests_S_R_S_SESSION_01_044: [If session, name or frame_received_callback is NULL, session_create_link_endpoint shall fail and return NULL.] */
329 TEST_FUNCTION(session_create_with_NULL_name_fails)
330 {
331 // arrange
332 LINK_ENDPOINT_HANDLE link_endpoint;
333 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
334 umock_c_reset_all_calls();
335
336 // act
337 link_endpoint = session_create_link_endpoint(session, NULL);
338
339 // assert
340 ASSERT_IS_NULL(link_endpoint);
341 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
342
343 // cleanup
344 session_destroy(session);
345 }
346
347 /* Tests_S_R_S_SESSION_01_045: [If allocating memory for the link endpoint fails, session_create_link_endpoint shall fail and return NULL.] */
348 TEST_FUNCTION(when_allocating_memory_for_the_link_endpoint_fails_then_session_create_link_endpoint_fails)
349 {
350 // arrange
351 LINK_ENDPOINT_HANDLE link_endpoint;
352 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
353 umock_c_reset_all_calls();
354
355 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
356 .SetReturn(NULL);
357
358 // act
359 link_endpoint = session_create_link_endpoint(session, "1");
360
361 // assert
362 ASSERT_IS_NULL(link_endpoint);
363 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
364
365 // cleanup
366 session_destroy(session);
367 }
368
369 /* Tests_S_R_S_SESSION_01_045: [If allocating memory for the link endpoint fails, session_create_link_endpoint shall fail and return NULL.] */
370 TEST_FUNCTION(when_allocating_the_link_name_fails_then_session_create_link_endpoint_fails)
371 {
372 // arrange
373 LINK_ENDPOINT_HANDLE link_endpoint;
374 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
375 umock_c_reset_all_calls();
376
377 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
378 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
379 .SetReturn(NULL);
380 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
381
382 // act
383 link_endpoint = session_create_link_endpoint(session, "1");
384
385 // assert
386 ASSERT_IS_NULL(link_endpoint);
387 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
388
389 // cleanup
390 session_destroy(session);
391 }
392
393 /* Tests_S_R_S_SESSION_01_045: [If allocating memory for the link endpoint fails, session_create_link_endpoint shall fail and return NULL.] */
394 TEST_FUNCTION(when_reallocating_the_endpoint_array_for_the_link_endpoint_fails_then_session_create_link_endpoint_fails)
395 {
396 // arrange
397 LINK_ENDPOINT_HANDLE link_endpoint;
398 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
399 umock_c_reset_all_calls();
400
401 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG));
402 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
403 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG))
404 .SetReturn(NULL);
405 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
406 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
407
408 // act
409 link_endpoint = session_create_link_endpoint(session, "1");
410
411 // assert
412 ASSERT_IS_NULL(link_endpoint);
413 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
414
415 // cleanup
416 session_destroy(session);
417 }
418
419 /* session_destroy_link_endpoint */
420
421 /* Tests_S_R_S_SESSION_01_050: [If link_endpoint is NULL, session_destroy_link_endpoint shall do nothing.] */
422 TEST_FUNCTION(session_destroy_link_endpoint_with_NULL_handle_does_nothing)
423 {
424 // arrange
425
426 // act
427 session_destroy_link_endpoint(NULL);
428
429 // assert
430 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
431 }
432
433 #if 0
434 /* Tests_S_R_S_SESSION_01_049: [session_destroy_link_endpoint shall detach the associated endpoint, but not free the resources of the endpoint.] */
435 TEST_FUNCTION(session_destroy_link_endpoint_frees_the_resources)
436 {
437 // arrange
438 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
439 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1");
440 umock_c_reset_all_calls();
441
442 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
443 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
444 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
445
446 // act
447 session_destroy_link_endpoint(link_endpoint);
448
449 // assert
450 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
451
452 // cleanup
453 session_destroy(session);
454 }
455
456 /* Tests_S_R_S_SESSION_01_049: [session_destroy_link_endpoint shall free all resources associated with the endpoint.] */
457 TEST_FUNCTION(session_destroy_link_endpoint_when_2_endpoints_are_there_frees_the_resources)
458 {
459 // arrange
460 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
461 LINK_ENDPOINT_HANDLE link_endpoint1 = session_create_link_endpoint(session, "1");
462 LINK_ENDPOINT_HANDLE link_endpoint2 = session_create_link_endpoint(session, "1");
463 umock_c_reset_all_calls();
464
465 STRICT_EXPECTED_CALL(gballoc_realloc(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
466 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
467 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
468
469 // act
470 session_destroy_link_endpoint(link_endpoint1);
471
472 // assert
473 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
474
475 // cleanup
476 session_destroy_link_endpoint(link_endpoint2);
477 session_destroy(session);
478 }
479
480 /* session_send_transfer */
481
482 /* Tests_S_R_S_SESSION_01_051: [session_send_transfer shall send a transfer frame with the performative indicated in the transfer argument.] */
483 /* Tests_S_R_S_SESSION_01_053: [On success, session_send_transfer shall return 0.] */
484 /* Tests_S_R_S_SESSION_01_055: [The encoding of the frame shall be done by calling connection_encode_frame and passing as arguments: the connection handle associated with the session, the transfer performative and the payload chunks passed to session_send_transfer.] */
485 /* Tests_S_R_S_SESSION_01_057: [The delivery ids shall be assigned starting at 0.] */
486 TEST_FUNCTION(session_transfer_sends_the_frame_to_the_connection)
487 {
488 // arrange
489 int result;
490 delivery_number delivery_id;
491 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
492 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
493 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
494 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
495 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
496 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
497 umock_c_reset_all_calls();
498
499 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
500 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
501 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
502 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
503 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242));
504 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
505
506 // act
507 result = session_send_transfer(link_endpoint, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
508
509 // assert
510 ASSERT_ARE_EQUAL(int, 0, result);
511 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
512
513 // cleanup
514 session_destroy_link_endpoint(link_endpoint);
515 session_destroy(session);
516 }
517 #endif
518
519 /* Tests_S_R_S_SESSION_01_054: [If link_endpoint or transfer is NULL, session_send_transfer shall fail and return a non-zero value.] */
520 TEST_FUNCTION(session_transfer_with_NULL_transfer_fails)
521 {
522 // arrange
523 int result;
524 delivery_number delivery_id;
525 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
526 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1");
527 umock_c_reset_all_calls();
528
529 // act
530 result = session_send_transfer(link_endpoint, NULL, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
531
532 // assert
533 ASSERT_ARE_NOT_EQUAL(int, 0, result);
534 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
535
536 // cleanup
537 session_destroy_link_endpoint(link_endpoint);
538 session_destroy(session);
539 }
540
541 /* Tests_S_R_S_SESSION_01_054: [If link_endpoint or transfer is NULL, session_send_transfer shall fail and return a non-zero value.] */
542 TEST_FUNCTION(session_transfer_with_NULL_link_endpoint_fails)
543 {
544 // arrange
545
546 // act
547 delivery_number delivery_id;
548 int result = session_send_transfer(NULL, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
549
550 // assert
551 ASSERT_ARE_NOT_EQUAL(int, 0, result);
552 }
553
554 #if 0
555 /* Tests_S_R_S_SESSION_01_058: [When any other error occurs, session_send_transfer shall fail and return a non-zero value.] */
556 TEST_FUNCTION(when_transfer_set_delivery_id_fails_then_session_transfer_fails)
557 {
558 // arrange
559 int result;
560 delivery_number delivery_id;
561 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
562 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
563 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
564 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
565 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
566 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
567 umock_c_reset_all_calls();
568
569 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0))
570 .SetReturn(1);
571
572 // act
573 result = session_send_transfer(link_endpoint, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
574
575 // assert
576 ASSERT_ARE_NOT_EQUAL(int, 0, result);
577 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
578
579 // cleanup
580 session_destroy_link_endpoint(link_endpoint);
581 session_destroy(session);
582 }
583
584 /* Tests_S_R_S_SESSION_01_058: [When any other error occurs, session_send_transfer shall fail and return a non-zero value.] */
585 TEST_FUNCTION(when_amqpvalue_create_transfer_fails_then_session_transfer_fails)
586 {
587 // arrange
588 int result;
589 delivery_number delivery_id;
590 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
591 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
592 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
593 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
594 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
595 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
596 umock_c_reset_all_calls();
597
598 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
599 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
600 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
601 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle))
602 .SetReturn(NULL);
603
604 // act
605 result = session_send_transfer(link_endpoint, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
606
607 // assert
608 ASSERT_ARE_NOT_EQUAL(int, 0, result);
609 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
610
611 // cleanup
612 session_destroy_link_endpoint(link_endpoint);
613 session_destroy(session);
614 }
615
616 /* Tests_S_R_S_SESSION_01_056: [If connection_encode_frame fails then session_send_transfer shall fail and return a non-zero value.] */
617 TEST_FUNCTION(when_connection_encode_frame_fails_then_session_transfer_fails)
618 {
619 // arrange
620 int result;
621 delivery_number delivery_id;
622 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
623 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
624 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
625 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
626 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
627 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
628 umock_c_reset_all_calls();
629
630 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
631 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
632 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
633 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
634 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242))
635 .SetReturn(1);
636 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
637
638 // act
639 result = session_send_transfer(link_endpoint, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
640
641 // assert
642 ASSERT_ARE_NOT_EQUAL(int, 0, result);
643 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
644
645 // cleanup
646 session_destroy_link_endpoint(link_endpoint);
647 session_destroy(session);
648 }
649 #endif
650
651 /* Tests_S_R_S_SESSION_01_059: [When session_send_transfer is called while the session is not in the MAPPED state, session_send_transfer shall fail and return a non-zero value.] */
652 TEST_FUNCTION(when_session_is_not_MAPPED_the_transfer_fails)
653 {
654 // arrange
655 int result;
656 delivery_number delivery_id;
657 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
658 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1");
659 umock_c_reset_all_calls();
660
661 // act
662 result = session_send_transfer(link_endpoint, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
663
664 // assert
665 ASSERT_ARE_NOT_EQUAL(int, 0, result);
666 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
667
668 // cleanup
669 session_destroy_link_endpoint(link_endpoint);
670 session_destroy(session);
671 }
672
673 /* on_connection_state_changed */
674
675 #if 0
676 /* Tests_S_R_S_SESSION_01_060: [If the previous connection state is not OPENED and the new connection state is OPENED, the BEGIN frame shall be sent out and the state shall be switched to BEGIN_SENT.] */
677 TEST_FUNCTION(connection_state_changed_callback_with_OPENED_triggers_sending_the_BEGIN_frame)
678 {
679 // arrange
680 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
681 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
682 umock_c_reset_all_calls();
683
684 STRICT_EXPECTED_CALL(definition_mocks, begin_create(0, 1, 1));
685 STRICT_EXPECTED_CALL(definition_mocks, begin_set_handle_max(test_begin_handle, 4294967295));
686 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_begin(test_begin_handle));
687 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_begin_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242));
688 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_begin_amqp_value));
689 STRICT_EXPECTED_CALL(definition_mocks, begin_destroy(test_begin_handle));
690
691 STRICT_EXPECTED_CALL(test_on_session_state_changed(NULL, SESSION_STATE_BEGIN_SENT, SESSION_STATE_UNMAPPED));
692
693 // act
694 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
695
696 // assert
697 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
698
699 // cleanup
700 session_destroy_link_endpoint(link_endpoint);
701 session_destroy(session);
702 }
703
704 /* Tests_S_R_S_SESSION_01_060: [If the previous connection state is not OPENED and the new connection state is OPENED, the BEGIN frame shall be sent out and the state shall be switched to BEGIN_SENT.] */
705 TEST_FUNCTION(connection_state_changed_callback_and_new_state_is_not_OPENED_does_not_trigger_sending_the_BEGIN_frame)
706 {
707 // arrange
708 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
709 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
710 umock_c_reset_all_calls();
711
712 // act
713 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPEN_SENT, CONNECTION_STATE_START);
714
715 // assert
716 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
717
718 // cleanup
719 session_destroy_link_endpoint(link_endpoint);
720 session_destroy(session);
721 }
722
723 /* Tests_S_R_S_SESSION_01_060: [If the previous connection state is not OPENED and the new connection state is OPENED, the BEGIN frame shall be sent out and the state shall be switched to BEGIN_SENT.] */
724 TEST_FUNCTION(connection_state_changed_callback_and_from_OPENED_to_OPENED_does_not_trigger_sending_the_BEGIN_frame)
725 {
726 // arrange
727 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
728 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
729 umock_c_reset_all_calls();
730
731 // act
732 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPENED);
733
734 // assert
735 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
736
737 // cleanup
738 session_destroy_link_endpoint(link_endpoint);
739 session_destroy(session);
740 }
741
742 /* Tests_S_R_S_SESSION_01_060: [If the previous connection state is not OPENED and the new connection state is OPENED, the BEGIN frame shall be sent out and the state shall be switched to BEGIN_SENT.] */
743 TEST_FUNCTION(connection_state_changed_callback_to_OPENED_twice_only_triggers_sending_the_BEGIN_frame_once)
744 {
745 // arrange
746 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
747 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
748 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
749 umock_c_reset_all_calls();
750
751 // act
752 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
753
754 // assert
755 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
756
757 // cleanup
758 session_destroy_link_endpoint(link_endpoint);
759 session_destroy(session);
760 }
761
762 /* Tests_-S_R_S_SESSION_01_061: [If the previous connection state is OPENED and the new connection state is not OPENED anymore, the state shall be switched to DISCARDING.] */
763 TEST_FUNCTION(connection_state_changed_callback_to_different_than_OPENED_when_in_UNMAPPED_sets_the_session_state_to_END)
764 {
765 // arrange
766 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
767 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
768 umock_c_reset_all_calls();
769
770 STRICT_EXPECTED_CALL(test_on_session_state_changed(NULL, SESSION_STATE_DISCARDING, SESSION_STATE_UNMAPPED));
771
772 // act
773 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_CLOSE_RCVD, CONNECTION_STATE_OPENED);
774
775 // assert
776 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
777
778 // cleanup
779 session_destroy_link_endpoint(link_endpoint);
780 session_destroy(session);
781 }
782
783 /* Tests_-S_R_S_SESSION_01_061: [If the previous connection state is OPENED and the new connection state is not OPENED anymore, the state shall be switched to DISCARDING.] */
784 TEST_FUNCTION(connection_state_changed_callback_to_different_than_OPENED_when_in_BEGIN_SENT_sets_the_session_state_to_END)
785 {
786 // arrange
787 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
788 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
789 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
790 umock_c_reset_all_calls();
791
792 STRICT_EXPECTED_CALL(test_on_session_state_changed(NULL, SESSION_STATE_DISCARDING, SESSION_STATE_BEGIN_SENT));
793
794 // act
795 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_CLOSE_RCVD, CONNECTION_STATE_OPENED);
796
797 // assert
798 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
799
800 // cleanup
801 session_destroy_link_endpoint(link_endpoint);
802 session_destroy(session);
803 }
804
805 /* Tests_-S_R_S_SESSION_01_061: [If the previous connection state is OPENED and the new connection state is not OPENED anymore, the state shall be switched to DISCARDING.] */
806 TEST_FUNCTION(connection_state_changed_callback_to_different_than_OPENED_when_in_MAPPED_sets_the_session_state_to_END)
807 {
808 // arrange
809 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE, NULL, NULL);
810 LINK_ENDPOINT_HANDLE link_endpoint = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
811 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
812 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
813 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
814 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
815 umock_c_reset_all_calls();
816
817 STRICT_EXPECTED_CALL(test_on_session_state_changed(NULL, SESSION_STATE_DISCARDING, SESSION_STATE_MAPPED));
818
819 // act
820 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_CLOSE_RCVD, CONNECTION_STATE_OPENED);
821
822 // assert
823 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
824
825 // cleanup
826 session_destroy_link_endpoint(link_endpoint);
827 session_destroy(session);
828 }
829
830 /* Session flow control */
831
832 /* Tests_S_R_S_SESSION_01_012: [The session endpoint assigns each outgoing transfer frame an implicit transfer-id from a session scoped sequence.] */
833 /* Tests_S_R_S_SESSION_01_027: [sending a transfer Upon sending a transfer, the sending endpoint will increment its next-outgoing-id] */
834 /* Tests_S_R_S_SESSION_01_016: [next-outgoing-id The next-outgoing-id is the transfer-id to assign to the next transfer frame.] */
835 /* Tests_S_R_S_SESSION_01_017: [The nextoutgoing-id MAY be initialized to an arbitrary value ] */
836 /* Tests_S_R_S_SESSION_01_018: [is incremented after each successive transfer according to RFC-1982 [RFC1982] serial number arithmetic.] */
837 TEST_FUNCTION(when_2_transfers_happen_on_2_different_endpoints_2_different_delivery_ids_are_assigned)
838 {
839 // arrange
840 delivery_number delivery_id0;
841 delivery_number delivery_id1;
842 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
843 LINK_ENDPOINT_HANDLE link_endpoint0 = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
844 LINK_ENDPOINT_HANDLE link_endpoint1 = session_create_link_endpoint(session, "2", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
845 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
846 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
847 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
848 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
849 umock_c_reset_all_calls();
850
851 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
852 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
853 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
854 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
855 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242));
856 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
857
858 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 1));
859 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
860 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
861 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
862 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242));
863 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
864
865 // act
866 (void)session_send_transfer(link_endpoint0, test_transfer_handle, NULL, 0, &delivery_id0, test_on_send_complete, (void*)0x4242);
867 (void)session_send_transfer(link_endpoint0, test_transfer_handle, NULL, 0, &delivery_id1, test_on_send_complete, (void*)0x4242);
868
869 // assert
870 ASSERT_ARE_EQUAL(uint32_t, 0, delivery_id0);
871 ASSERT_ARE_EQUAL(uint32_t, 1, delivery_id1);
872 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
873
874 // cleanup
875 session_destroy_link_endpoint(link_endpoint0);
876 session_destroy_link_endpoint(link_endpoint1);
877 session_destroy(session);
878 }
879
880 /* Tests_S_R_S_SESSION_01_018: [is incremented after each successive transfer according to RFC-1982 [RFC1982] serial number arithmetic.] */
881 TEST_FUNCTION(when_if_sending_the_frame_to_the_connection_fails_the_next_outgoing_id_is_not_incremented)
882 {
883 // arrange
884 delivery_number delivery_id;
885 SESSION_HANDLE session = session_create(TEST_CONNECTION_HANDLE);
886 LINK_ENDPOINT_HANDLE link_endpoint0 = session_create_link_endpoint(session, "1", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
887 LINK_ENDPOINT_HANDLE link_endpoint1 = session_create_link_endpoint(session, "2", test_frame_received_callback, test_on_session_state_changed, test_on_flow_on, NULL);
888 saved_connection_state_changed_callback(saved_callback_context, CONNECTION_STATE_OPENED, CONNECTION_STATE_OPEN_SENT);
889 STRICT_EXPECTED_CALL(amqpvalue_get_inplace_descriptor(TEST_BEGIN_PERFORMATIVE));
890 STRICT_EXPECTED_CALL(definition_mocks, is_begin_type_by_descriptor(TEST_DESCRIPTOR_AMQP_VALUE));
891 saved_frame_received_callback(saved_callback_context, TEST_BEGIN_PERFORMATIVE, 0, NULL);
892 umock_c_reset_all_calls();
893
894 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
895 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
896 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
897 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
898 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242))
899 .SetReturn(1);
900 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
901
902 STRICT_EXPECTED_CALL(definition_mocks, transfer_set_delivery_id(test_transfer_handle, 0));
903 STRICT_EXPECTED_CALL(connection_get_remote_max_frame_size(TEST_CONNECTION_HANDLE, IGNORED_PTR_ARG))
904 .CopyOutArgumentBuffer(2, &some_remote_max_frame_size, sizeof(some_remote_max_frame_size));
905 STRICT_EXPECTED_CALL(definition_mocks, amqpvalue_create_transfer(test_transfer_handle));
906 STRICT_EXPECTED_CALL(connection_encode_frame(TEST_ENDPOINT_HANDLE, test_transfer_amqp_value, NULL, 0, test_on_send_complete, (void*)0x4242));
907 STRICT_EXPECTED_CALL(amqpvalue_destroy(test_transfer_amqp_value));
908
909 // act
910 (void)session_send_transfer(link_endpoint0, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
911 (void)session_send_transfer(link_endpoint0, test_transfer_handle, NULL, 0, &delivery_id, test_on_send_complete, (void*)0x4242);
912
913 // assert
914 ASSERT_ARE_EQUAL(uint32_t, 0, delivery_id);
915 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
916
917 // cleanup
918 session_destroy_link_endpoint(link_endpoint0);
919 session_destroy_link_endpoint(link_endpoint1);
920 session_destroy(session);
921 }
922 #endif
923
924 END_TEST_SUITE(session_ut)