1 /*
2 * FreeRTOS+TCP <DEVELOPMENT BRANCH>
3 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * http://aws.amazon.com/freertos
25 * http://www.FreeRTOS.org
26 */
27
28
29 /* Include Unity header */
30 #include "unity.h"
31
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36
37 #include "mock_task.h"
38 #include "mock_list.h"
39
40 /* This must come after list.h is included (in this case, indirectly
41 * by mock_list.h). */
42 #include "mock_Sockets_list_macros.h"
43 #include "mock_queue.h"
44 #include "mock_event_groups.h"
45 #include "mock_portable.h"
46
47 #include "mock_FreeRTOS_IP.h"
48 #include "mock_FreeRTOS_IP_Private.h"
49 #include "mock_NetworkBufferManagement.h"
50 #include "mock_FreeRTOS_Stream_Buffer.h"
51
52 #include "FreeRTOS_Sockets.h"
53
54 #include "FreeRTOS_Sockets_stubs.c"
55 #include "catch_assert.h"
56
57 #include "FreeRTOSIPConfig.h"
58
59 /* =========================== EXTERN VARIABLES =========================== */
60
61 BaseType_t prvTCPSendLoop( FreeRTOS_Socket_t * pxSocket,
62 const void * pvBuffer,
63 size_t uxDataLength,
64 BaseType_t xFlags );
65
66 extern List_t xBoundTCPSocketsList;
67
68 /* 2001::1 */
69 static IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
70
71 /* ============================== Test Cases ============================== */
72
73 /**
74 * @brief Invalid parameters.
75 */
test_FreeRTOS_accept_InvalidParams(void)76 void test_FreeRTOS_accept_InvalidParams( void )
77 {
78 FreeRTOS_Socket_t xServerSocket, * pxReturn;
79 struct freertos_sockaddr xAddress;
80 socklen_t xAddressLength;
81
82 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
83
84 /* Invalid Protocol */
85 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
86 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
87 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, pxReturn );
88
89 /* NULL socket. */
90 pxReturn = FreeRTOS_accept( NULL, &xAddress, &xAddressLength );
91 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, pxReturn );
92
93 /* Unbound Socket */
94 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
95 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
96 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
97 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, pxReturn );
98
99 /* Socket is not in listen mode. */
100 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
101 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
102 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN + 1;
103 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
104 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, pxReturn );
105 }
106
107 /**
108 * @brief Client socket is already taken.
109 */
test_FreeRTOS_accept_ClientSocketTaken(void)110 void test_FreeRTOS_accept_ClientSocketTaken( void )
111 {
112 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
113 struct freertos_sockaddr xAddress;
114 socklen_t xAddressLength;
115
116 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
117 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
118
119 /* Invalid Protocol */
120 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
121 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
122 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
123
124 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
125
126 vTaskSuspendAll_Expect();
127 xTaskResumeAll_ExpectAndReturn( pdFALSE );
128
129 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
130 TEST_ASSERT_EQUAL( NULL, pxReturn );
131 TEST_ASSERT_EQUAL( NULL, xServerSocket.u.xTCP.pxPeerSocket );
132 }
133
134 /**
135 * @brief Peer socket is NULL.
136 */
test_FreeRTOS_accept_PeerSocketNULL(void)137 void test_FreeRTOS_accept_PeerSocketNULL( void )
138 {
139 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
140 struct freertos_sockaddr xAddress;
141 socklen_t xAddressLength;
142
143 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
144 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
145
146 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
147 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
148 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
149
150 xServerSocket.u.xTCP.pxPeerSocket = NULL;
151
152 vTaskSuspendAll_Expect();
153 xTaskResumeAll_ExpectAndReturn( pdFALSE );
154
155 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
156 TEST_ASSERT_EQUAL( NULL, pxReturn );
157 TEST_ASSERT_EQUAL( NULL, xServerSocket.u.xTCP.pxPeerSocket );
158 }
159
160 /**
161 * @brief Cannot reuse the socket.
162 */
test_FreeRTOS_accept_NotReuseSocket(void)163 void test_FreeRTOS_accept_NotReuseSocket( void )
164 {
165 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
166 struct freertos_sockaddr xAddress;
167 socklen_t xAddressLength = 0;
168
169 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
170 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
171 memset( &xAddress, 0, sizeof( xAddress ) );
172
173 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
174 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
175 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
176
177 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
178 xPeerSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
179 xPeerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = 0xAABBCCDD;
180 xPeerSocket.u.xTCP.usRemotePort = 0x1234;
181
182 vTaskSuspendAll_Expect();
183 xTaskResumeAll_ExpectAndReturn( pdFALSE );
184
185 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
186
187 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
188 TEST_ASSERT_EQUAL( &xPeerSocket, pxReturn );
189 TEST_ASSERT_EQUAL( NULL, xServerSocket.u.xTCP.pxPeerSocket );
190 TEST_ASSERT_EQUAL( pdFALSE, xPeerSocket.u.xTCP.bits.bPassAccept );
191 TEST_ASSERT_EQUAL( FreeRTOS_ntohl( xPeerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 ), xAddress.sin_address.ulIP_IPv4 );
192 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xPeerSocket.u.xTCP.usRemotePort ), xAddress.sin_port );
193 TEST_ASSERT_EQUAL( sizeof( xAddress ), xAddressLength );
194 }
195
196 /**
197 * @brief Can reuse socket.
198 */
test_FreeRTOS_accept_ReuseSocket(void)199 void test_FreeRTOS_accept_ReuseSocket( void )
200 {
201 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
202 struct freertos_sockaddr xAddress;
203 socklen_t xAddressLength = 0;
204
205 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
206 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
207 memset( &xAddress, 0, sizeof( xAddress ) );
208
209 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
210 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
211 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
212 xServerSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
213 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
214 xServerSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
215 xServerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = 0xAABBCCDD;
216 xServerSocket.u.xTCP.usRemotePort = 0x1234;
217
218 vTaskSuspendAll_Expect();
219 xTaskResumeAll_ExpectAndReturn( pdFALSE );
220
221 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
222 TEST_ASSERT_EQUAL( &xServerSocket, pxReturn );
223 TEST_ASSERT_EQUAL( pdFALSE, xServerSocket.u.xTCP.bits.bPassAccept );
224 TEST_ASSERT_EQUAL( FreeRTOS_ntohl( xServerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 ), xAddress.sin_address.ulIP_IPv4 );
225 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xServerSocket.u.xTCP.usRemotePort ), xAddress.sin_port );
226 TEST_ASSERT_EQUAL( sizeof( xAddress ), xAddressLength );
227 }
228
229 /**
230 * @brief Accept while passing NULL in address.
231 */
test_FreeRTOS_accept_ReuseSocket_NULLAddress(void)232 void test_FreeRTOS_accept_ReuseSocket_NULLAddress( void )
233 {
234 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
235 struct freertos_sockaddr xAddress;
236 socklen_t xAddressLength = 0;
237
238 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
239 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
240 memset( &xAddress, 0, sizeof( xAddress ) );
241
242 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
243 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
244 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
245 xServerSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
246 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
247 xServerSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
248 xServerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = 0xAABBCCDD;
249 xServerSocket.u.xTCP.usRemotePort = 0x1234;
250
251 vTaskSuspendAll_Expect();
252 xTaskResumeAll_ExpectAndReturn( pdFALSE );
253
254 pxReturn = FreeRTOS_accept( &xServerSocket, NULL, NULL );
255 TEST_ASSERT_EQUAL( &xServerSocket, pxReturn );
256 TEST_ASSERT_EQUAL( pdFALSE, xServerSocket.u.xTCP.bits.bPassAccept );
257 }
258
259 /**
260 * @brief Can reuse socket. Timeout happens.
261 */
test_FreeRTOS_accept_ReuseSocket_Timeout(void)262 void test_FreeRTOS_accept_ReuseSocket_Timeout( void )
263 {
264 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
265 struct freertos_sockaddr xAddress;
266 socklen_t xAddressLength = 0;
267
268 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
269 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
270 memset( &xAddress, 0, sizeof( xAddress ) );
271
272 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
273
274 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
275 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
276 xServerSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
277 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
278 xServerSocket.u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
279 xServerSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = 0xAABBCCDD;
280 xServerSocket.u.xTCP.usRemotePort = 0x1234;
281 xServerSocket.xReceiveBlockTime = 0xAA;
282
283 vTaskSuspendAll_Expect();
284 xTaskResumeAll_ExpectAndReturn( pdFALSE );
285
286 vTaskSetTimeOutState_ExpectAnyArgs();
287
288 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
289
290 xEventGroupWaitBits_ExpectAndReturn( xServerSocket.xEventGroup, eSOCKET_ACCEPT, pdTRUE, pdFALSE, 0xAA, pdFALSE );
291
292 vTaskSuspendAll_Expect();
293 xTaskResumeAll_ExpectAndReturn( pdFALSE );
294
295 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
296
297 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
298 TEST_ASSERT_EQUAL( NULL, pxReturn );
299 TEST_ASSERT_EQUAL( pdFALSE, xServerSocket.u.xTCP.bits.bPassAccept );
300 }
301
302 /**
303 * @brief Can reuse IPv6 socket.
304 */
test_FreeRTOS_accept_ReuseIPv6Socket(void)305 void test_FreeRTOS_accept_ReuseIPv6Socket( void )
306 {
307 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
308 struct freertos_sockaddr xAddress;
309 socklen_t xAddressLength = 0;
310
311 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
312 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
313 memset( &xAddress, 0, sizeof( xAddress ) );
314
315 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
316 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
317 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
318 xServerSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
319 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
320 xServerSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
321 xServerSocket.u.xTCP.usRemotePort = 0x1234;
322 xServerSocket.bits.bIsIPv6 = pdTRUE;
323 memcpy( xServerSocket.u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
324
325 vTaskSuspendAll_Expect();
326 xTaskResumeAll_ExpectAndReturn( pdFALSE );
327
328 pxReturn = FreeRTOS_accept( &xServerSocket, &xAddress, &xAddressLength );
329 TEST_ASSERT_EQUAL( &xServerSocket, pxReturn );
330 TEST_ASSERT_EQUAL( pdFALSE, xServerSocket.u.xTCP.bits.bPassAccept );
331 TEST_ASSERT_EQUAL_MEMORY( xAddress.sin_address.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
332 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xServerSocket.u.xTCP.usRemotePort ), xAddress.sin_port );
333 TEST_ASSERT_EQUAL( sizeof( xAddress ), xAddressLength );
334 }
335
336 /**
337 * @brief Can reuse IPv6 socket.
338 */
test_FreeRTOS_accept_ReuseIPv6Socket_NullAddress(void)339 void test_FreeRTOS_accept_ReuseIPv6Socket_NullAddress( void )
340 {
341 FreeRTOS_Socket_t xServerSocket, * pxReturn, xPeerSocket;
342 socklen_t xAddressLength = 0;
343
344 memset( &xServerSocket, 0, sizeof( xServerSocket ) );
345 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
346
347 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
348 xServerSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
349 xServerSocket.u.xTCP.eTCPState = eTCP_LISTEN;
350 xServerSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
351 xServerSocket.u.xTCP.pxPeerSocket = &xPeerSocket;
352 xServerSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
353 xServerSocket.u.xTCP.usRemotePort = 0x1234;
354 xServerSocket.bits.bIsIPv6 = pdTRUE;
355 memcpy( xServerSocket.u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
356
357 vTaskSuspendAll_Expect();
358 xTaskResumeAll_ExpectAndReturn( pdFALSE );
359
360 pxReturn = FreeRTOS_accept( &xServerSocket, NULL, &xAddressLength );
361 TEST_ASSERT_EQUAL( &xServerSocket, pxReturn );
362 TEST_ASSERT_EQUAL( pdFALSE, xServerSocket.u.xTCP.bits.bPassAccept );
363 }
364
365 /**
366 * @brief Invalid values.
367 */
test_FreeRTOS_recv_InvalidValues(void)368 void test_FreeRTOS_recv_InvalidValues( void )
369 {
370 BaseType_t xReturn;
371 FreeRTOS_Socket_t xSocket;
372 uint8_t pvBuffer[ 1500 ];
373 size_t uxBufferLength = 1500;
374 BaseType_t xFlags = 0;
375
376 memset( &xSocket, 0, sizeof( xSocket ) );
377
378 /* Invalid Protocol */
379 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
380 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
381 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
382
383 /* NULL socket. */
384 xReturn = FreeRTOS_recv( NULL, pvBuffer, uxBufferLength, xFlags );
385 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
386
387 /* Unbound Socket */
388 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
389 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
390 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
391 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
392
393 xFlags = FREERTOS_ZERO_COPY;
394 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
395 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
396 xReturn = FreeRTOS_recv( &xSocket, NULL, uxBufferLength, xFlags );
397 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
398 }
399
400 /**
401 * @brief Not connected socket and there is no memory in the system.
402 */
test_FreeRTOS_recv_NotConnectedAndNoMemory(void)403 void test_FreeRTOS_recv_NotConnectedAndNoMemory( void )
404 {
405 BaseType_t xReturn;
406 FreeRTOS_Socket_t xSocket;
407 uint8_t pvBuffer[ 1500 ];
408 size_t uxBufferLength = 1500;
409 BaseType_t xFlags = 0;
410
411 memset( &xSocket, 0, sizeof( xSocket ) );
412
413 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
414 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
415 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
416 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xReturn );
417
418 memset( &xSocket, 0, sizeof( xSocket ) );
419
420 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
421 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
422 xSocket.u.xTCP.bits.bMallocError = pdTRUE_UNSIGNED;
423 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
424 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOMEM, xReturn );
425 }
426
427 /**
428 * @brief No wait in an established connection.
429 */
test_FreeRTOS_recv_EstablishedConnection_NoWait(void)430 void test_FreeRTOS_recv_EstablishedConnection_NoWait( void )
431 {
432 BaseType_t xReturn;
433 FreeRTOS_Socket_t xSocket;
434 uint8_t pvBuffer[ 1500 ];
435 size_t uxBufferLength = 1500;
436 BaseType_t xFlags = 0;
437
438 memset( &xSocket, 0, sizeof( xSocket ) );
439
440 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
441 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
442 xSocket.u.xTCP.eTCPState = eESTABLISHED;
443
444 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_INTR, pdTRUE, pdFALSE, 0, 0 );
445
446 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
447
448 TEST_ASSERT_EQUAL( 0, xReturn );
449 }
450
451 /**
452 * @brief Timeout occurs.
453 */
test_FreeRTOS_recv_TimeOut(void)454 void test_FreeRTOS_recv_TimeOut( void )
455 {
456 BaseType_t xReturn;
457 FreeRTOS_Socket_t xSocket;
458 uint8_t pvBuffer[ 1500 ];
459 size_t uxBufferLength = 1500;
460 BaseType_t xFlags = 0;
461
462 memset( &xSocket, 0, sizeof( xSocket ) );
463
464 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
465 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
466 xSocket.u.xTCP.eTCPState = eESTABLISHED;
467 xSocket.xReceiveBlockTime = 0xAA;
468
469 vTaskSetTimeOutState_ExpectAnyArgs();
470
471 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
472
473 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
474
475 TEST_ASSERT_EQUAL( 0, xReturn );
476 }
477
478 /**
479 * @brief Receive interrupted.
480 */
test_FreeRTOS_recv_Interrupted(void)481 void test_FreeRTOS_recv_Interrupted( void )
482 {
483 BaseType_t xReturn;
484 FreeRTOS_Socket_t xSocket;
485 uint8_t pvBuffer[ 1500 ];
486 size_t uxBufferLength = 1500;
487 BaseType_t xFlags = 0;
488
489 memset( &xSocket, 0, sizeof( xSocket ) );
490
491 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
492 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
493 xSocket.u.xTCP.eTCPState = eESTABLISHED;
494 xSocket.xReceiveBlockTime = 0xAA;
495
496 vTaskSetTimeOutState_ExpectAnyArgs();
497
498 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
499
500 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE | ( EventBits_t ) eSOCKET_CLOSED | ( EventBits_t ) eSOCKET_INTR, pdTRUE, pdFALSE, 0xAA, eSOCKET_INTR );
501
502 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
503
504 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINTR, xReturn );
505 }
506
507 /**
508 * @brief Receive interrupted.
509 */
test_FreeRTOS_recv_Interrupted1(void)510 void test_FreeRTOS_recv_Interrupted1( void )
511 {
512 BaseType_t xReturn;
513 FreeRTOS_Socket_t xSocket;
514 uint8_t pvBuffer[ 1500 ];
515 size_t uxBufferLength = 1500;
516 BaseType_t xFlags = 0;
517
518 memset( &xSocket, 0, sizeof( xSocket ) );
519
520 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
521 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
522 xSocket.u.xTCP.eTCPState = eESTABLISHED;
523 xSocket.xReceiveBlockTime = 0xAA;
524
525 vTaskSetTimeOutState_ExpectAnyArgs();
526
527 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
528
529 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE | ( EventBits_t ) eSOCKET_CLOSED | ( EventBits_t ) eSOCKET_INTR, pdTRUE, pdFALSE, 0xAA, eSOCKET_RECEIVE | eSOCKET_CLOSED | eSOCKET_INTR );
530
531 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE | eSOCKET_CLOSED, 0 );
532
533 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
534
535 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINTR, xReturn );
536 }
537
538 /**
539 * @brief Receive stream is NULl for the socket.
540 */
test_FreeRTOS_recv_RxStreamNULL(void)541 void test_FreeRTOS_recv_RxStreamNULL( void )
542 {
543 BaseType_t xReturn;
544 FreeRTOS_Socket_t xSocket;
545 uint8_t pvBuffer[ 1500 ];
546 size_t uxBufferLength = 1500;
547 BaseType_t xFlags = 0;
548
549 memset( &xSocket, 0, sizeof( xSocket ) );
550
551 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
552 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
553 xSocket.u.xTCP.eTCPState = eESTABLISHED;
554 xSocket.xReceiveBlockTime = 0xAA;
555
556 vTaskSetTimeOutState_ExpectAnyArgs();
557
558 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
559
560 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE | ( EventBits_t ) eSOCKET_CLOSED | ( EventBits_t ) eSOCKET_INTR, pdTRUE, pdFALSE, 0xAA, 0 );
561
562 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
563
564 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
565
566 TEST_ASSERT_EQUAL( 0, xReturn );
567 }
568
569 /**
570 * @brief 12 bytes are present in the Buffer when receive is called.
571 */
test_FreeRTOS_recv_12BytesAlreadyInBuffer(void)572 void test_FreeRTOS_recv_12BytesAlreadyInBuffer( void )
573 {
574 BaseType_t xReturn;
575 FreeRTOS_Socket_t xSocket;
576 uint8_t pvBuffer[ 1500 ];
577 size_t uxBufferLength = 1500;
578 BaseType_t xFlags = 0;
579
580 memset( &xSocket, 0, sizeof( xSocket ) );
581
582 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
583 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
584 xSocket.u.xTCP.eTCPState = eESTABLISHED;
585 xSocket.xReceiveBlockTime = 0xAA;
586 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
587
588 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
589
590 uxStreamBufferGet_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0U, pvBuffer, ( size_t ) uxBufferLength, 0, 12 );
591
592 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
593
594 TEST_ASSERT_EQUAL( 12, xReturn );
595 }
596
597 /**
598 * @brief Low water mark reached when receive is called.
599 */
test_FreeRTOS_recv_LowWaterReached(void)600 void test_FreeRTOS_recv_LowWaterReached( void )
601 {
602 BaseType_t xReturn;
603 FreeRTOS_Socket_t xSocket;
604 uint8_t pvBuffer[ 1500 ];
605 size_t uxBufferLength = 1500;
606 BaseType_t xFlags = 0;
607
608 memset( &xSocket, 0, sizeof( xSocket ) );
609
610 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
611 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
612 xSocket.u.xTCP.eTCPState = eESTABLISHED;
613 xSocket.xReceiveBlockTime = 0xAA;
614 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
615 xSocket.u.xTCP.bits.bLowWater = pdTRUE_UNSIGNED;
616
617 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
618
619 uxStreamBufferGet_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0U, pvBuffer, ( size_t ) uxBufferLength, 0, 12 );
620
621 uxStreamBufferFrontSpace_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
622
623 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdTRUE );
624
625 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
626
627 TEST_ASSERT_EQUAL( 12, xReturn );
628 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bLowWater );
629 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bWinChange );
630 TEST_ASSERT_EQUAL( 1U, xSocket.u.xTCP.usTimeout );
631 }
632
633 /**
634 * @brief Low water mark reached when receive is called.
635 */
test_FreeRTOS_recv_LowWaterReached2(void)636 void test_FreeRTOS_recv_LowWaterReached2( void )
637 {
638 BaseType_t xReturn;
639 FreeRTOS_Socket_t xSocket;
640 uint8_t pvBuffer[ 1500 ];
641 size_t uxBufferLength = 1500;
642 BaseType_t xFlags = 0;
643
644 memset( &xSocket, 0, sizeof( xSocket ) );
645
646 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
647 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
648 xSocket.u.xTCP.eTCPState = eESTABLISHED;
649 xSocket.xReceiveBlockTime = 0xAA;
650 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
651 xSocket.u.xTCP.bits.bLowWater = pdTRUE_UNSIGNED;
652 xSocket.u.xTCP.uxEnoughSpace = 13;
653
654 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
655
656 uxStreamBufferGet_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0U, pvBuffer, ( size_t ) uxBufferLength, 0, 12 );
657
658 uxStreamBufferFrontSpace_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
659
660 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
661
662 TEST_ASSERT_EQUAL( 12, xReturn );
663 }
664
665 /**
666 * @brief 12 bytes arrive to the socket after a call to receive is made.
667 */
test_FreeRTOS_recv_12BytesArriveLater(void)668 void test_FreeRTOS_recv_12BytesArriveLater( void )
669 {
670 BaseType_t xReturn;
671 FreeRTOS_Socket_t xSocket;
672 uint8_t pvBuffer[ 1500 ];
673 size_t uxBufferLength = 1500;
674 BaseType_t xFlags = FREERTOS_ZERO_COPY;
675
676 memset( &xSocket, 0, sizeof( xSocket ) );
677
678 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
679 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
680 xSocket.u.xTCP.eTCPState = eESTABLISHED;
681 xSocket.xReceiveBlockTime = 0xAA;
682 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
683
684 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0 );
685
686 vTaskSetTimeOutState_ExpectAnyArgs();
687
688 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
689
690 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE | ( EventBits_t ) eSOCKET_CLOSED | ( EventBits_t ) eSOCKET_INTR, pdTRUE, pdFALSE, 0xAA, 0 );
691
692 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 12 );
693
694 uxStreamBufferGetPtr_ExpectAndReturn( xSocket.u.xTCP.rxStream, ( uint8_t ** ) pvBuffer, 12 );
695
696 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
697
698 TEST_ASSERT_EQUAL( 12, xReturn );
699 }
700
701 /**
702 * @brief 12 bytes arrive to the socket after a call to receive is made and a timeout occurs.
703 */
test_FreeRTOS_recv_12BytesArriveLater_Timeout(void)704 void test_FreeRTOS_recv_12BytesArriveLater_Timeout( void )
705 {
706 BaseType_t xReturn;
707 FreeRTOS_Socket_t xSocket;
708 uint8_t pvBuffer[ 1500 ];
709 size_t uxBufferLength = 1500;
710 BaseType_t xFlags = FREERTOS_ZERO_COPY | FREERTOS_MSG_DONTWAIT;
711
712 memset( &xSocket, 0, sizeof( xSocket ) );
713
714 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
715 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
716 xSocket.u.xTCP.eTCPState = eESTABLISHED;
717 xSocket.xReceiveBlockTime = 0xAA;
718 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
719
720 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0 );
721
722 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
723
724 TEST_ASSERT_EQUAL( 0, xReturn );
725 }
726
727 /**
728 * @brief Socket is closing in receive procedure.
729 */
test_FreeRTOS_recv_SocketClosing(void)730 void test_FreeRTOS_recv_SocketClosing( void )
731 {
732 BaseType_t xReturn;
733 FreeRTOS_Socket_t xSocket;
734 uint8_t pvBuffer[ 1500 ];
735 size_t uxBufferLength = 1500;
736 BaseType_t xFlags = FREERTOS_ZERO_COPY;
737
738 memset( &xSocket, 0, sizeof( xSocket ) );
739
740 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
741 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
742 xSocket.u.xTCP.eTCPState = eCLOSING;
743 xSocket.xReceiveBlockTime = 0xAA;
744 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
745
746 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0 );
747
748 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
749
750 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xReturn );
751 }
752
753 /**
754 * @brief Socket is in eClise_Wait in receive procedure.
755 */
test_FreeRTOS_recv_SocketCloseWait(void)756 void test_FreeRTOS_recv_SocketCloseWait( void )
757 {
758 BaseType_t xReturn;
759 FreeRTOS_Socket_t xSocket;
760 uint8_t pvBuffer[ 1500 ];
761 size_t uxBufferLength = 1500;
762 BaseType_t xFlags = FREERTOS_ZERO_COPY;
763
764 memset( &xSocket, 0, sizeof( xSocket ) );
765
766 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
767 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
768 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT;
769 xSocket.xReceiveBlockTime = 0xAA;
770 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) pvBuffer;
771
772 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.rxStream, 0 );
773
774 xReturn = FreeRTOS_recv( &xSocket, pvBuffer, uxBufferLength, xFlags );
775
776 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xReturn );
777 }
778
779 /**
780 * @brief Invalid parameters passed to the function.
781 */
test_FreeRTOS_get_tx_head_InvalidParams(void)782 void test_FreeRTOS_get_tx_head_InvalidParams( void )
783 {
784 uint8_t * pucReturn;
785 FreeRTOS_Socket_t xSocket;
786 BaseType_t xLength;
787
788 memset( &xSocket, 0, sizeof( xSocket ) );
789
790 /* Invalid Protocol. */
791 pucReturn = FreeRTOS_get_tx_head( &xSocket, &xLength );
792 TEST_ASSERT_EQUAL( NULL, pucReturn );
793
794 /* NULL socket. */
795 pucReturn = FreeRTOS_get_tx_head( NULL, &xLength );
796 TEST_ASSERT_EQUAL( NULL, pucReturn );
797
798 /* NULL stream. */
799 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
800 pucReturn = FreeRTOS_get_tx_head( &xSocket, &xLength );
801 TEST_ASSERT_EQUAL( NULL, pucReturn );
802 }
803
804 /**
805 * @brief All fields of the socket are NULL.
806 */
test_FreeRTOS_get_tx_head_AllNULL(void)807 void test_FreeRTOS_get_tx_head_AllNULL( void )
808 {
809 uint8_t * pucReturn;
810 FreeRTOS_Socket_t xSocket;
811 BaseType_t xLength;
812 uint8_t ucStream[ ipconfigTCP_MSS ];
813
814 memset( &xSocket, 0, sizeof( xSocket ) );
815 memset( ucStream, 0, ipconfigTCP_MSS );
816
817 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
818 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
819
820 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0 );
821
822 pucReturn = FreeRTOS_get_tx_head( &xSocket, &xLength );
823 TEST_ASSERT_EQUAL_PTR( ( ( StreamBuffer_t * ) ucStream )->ucArray, pucReturn );
824 TEST_ASSERT_EQUAL( 0, xLength );
825 }
826
827 /**
828 * @brief Less space in the head than total length.
829 */
test_FreeRTOS_get_tx_head_LessSpace(void)830 void test_FreeRTOS_get_tx_head_LessSpace( void )
831 {
832 uint8_t * pucReturn;
833 FreeRTOS_Socket_t xSocket;
834 BaseType_t xLength;
835 uint8_t ucStream[ ipconfigTCP_MSS ];
836
837 memset( &xSocket, 0, sizeof( xSocket ) );
838 memset( ucStream, 0, ipconfigTCP_MSS );
839
840 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
841 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
842
843 ( ( StreamBuffer_t * ) ucStream )->LENGTH = 20;
844 ( ( StreamBuffer_t * ) ucStream )->uxHead = 10;
845
846 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10 );
847
848 pucReturn = FreeRTOS_get_tx_head( &xSocket, &xLength );
849 TEST_ASSERT_EQUAL_PTR( &( ( ( StreamBuffer_t * ) ucStream )->ucArray[ 10 ] ), pucReturn );
850 TEST_ASSERT_EQUAL( 10, xLength );
851 }
852
853 /**
854 * @brief More space in the head than total length.
855 */
test_FreeRTOS_get_tx_head_MoreSpace(void)856 void test_FreeRTOS_get_tx_head_MoreSpace( void )
857 {
858 uint8_t * pucReturn;
859 FreeRTOS_Socket_t xSocket;
860 BaseType_t xLength;
861 uint8_t ucStream[ ipconfigTCP_MSS ];
862
863 memset( &xSocket, 0, sizeof( xSocket ) );
864 memset( ucStream, 0, ipconfigTCP_MSS );
865
866 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
867 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
868
869 ( ( StreamBuffer_t * ) ucStream )->LENGTH = 200;
870 ( ( StreamBuffer_t * ) ucStream )->uxHead = 10;
871
872 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10 );
873
874 pucReturn = FreeRTOS_get_tx_head( &xSocket, &xLength );
875 TEST_ASSERT_EQUAL_PTR( &( ( ( StreamBuffer_t * ) ucStream )->ucArray[ 10 ] ), pucReturn );
876 TEST_ASSERT_EQUAL( 10, xLength );
877 }
878
879 /**
880 * @brief Invalid inputs to the function.
881 */
test_FreeRTOS_send_InvalidInput(void)882 void test_FreeRTOS_send_InvalidInput( void )
883 {
884 BaseType_t xReturn;
885 FreeRTOS_Socket_t xSocket;
886 uint8_t pvBuffer[ ipconfigTCP_MSS ];
887 size_t uxDataLength;
888 BaseType_t xFlags;
889 StreamBuffer_t xLocalStreamBuffer;
890
891 memset( &xSocket, 0, sizeof( xSocket ) );
892 memset( pvBuffer, 0, ipconfigTCP_MSS );
893
894 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
895 xSocket.u.xTCP.eTCPState = eESTABLISHED;
896 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
897 uxDataLength = 0;
898 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
899 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
900 TEST_ASSERT_EQUAL( 0, xReturn );
901
902 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
903 xSocket.u.xTCP.eTCPState = eESTABLISHED;
904 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
905 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
906 uxDataLength = 100;
907 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
908 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 0 );
909 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
910 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
911 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOSPC, xReturn );
912
913 /* Socket is not connected any more. */
914 xSocket.u.xTCP.eTCPState = eESTABLISHED + 1;
915 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
916 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
917
918 uxDataLength = 100;
919 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
920 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 0 );
921 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
922 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
923 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xReturn );
924 }
925
926 /**
927 * @brief There is exact amount of space in stream buffer as the length of data we want to send.
928 */
test_FreeRTOS_send_ExactSpaceInStreamBuffer(void)929 void test_FreeRTOS_send_ExactSpaceInStreamBuffer( void )
930 {
931 BaseType_t xReturn;
932 FreeRTOS_Socket_t xSocket;
933 uint8_t pvBuffer[ ipconfigTCP_MSS ];
934 size_t uxDataLength;
935 BaseType_t xFlags;
936 StreamBuffer_t xLocalStreamBuffer;
937
938 /* 1. Last set of bytes. */
939 memset( &xSocket, 0, sizeof( xSocket ) );
940 memset( pvBuffer, 0, ipconfigTCP_MSS );
941
942 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
943 xSocket.u.xTCP.eTCPState = eESTABLISHED;
944 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
945 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
946 xSocket.u.xTCP.bits.bCloseAfterSend = pdTRUE_UNSIGNED;
947
948 uxDataLength = 100;
949 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
950 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength );
951 vTaskSuspendAll_Expect();
952 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength, uxDataLength );
953 xTaskResumeAll_ExpectAndReturn( pdFALSE );
954 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
955 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
956 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
957
958 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
959
960 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
961 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bCloseRequested );
962
963
964 /* 2. Not last set of bytes. */
965 xSocket.u.xTCP.bits.bCloseAfterSend = pdFALSE_UNSIGNED;
966 xSocket.u.xTCP.bits.bCloseRequested = pdFALSE;
967
968 uxDataLength = 100;
969 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
970 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength );
971 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength, uxDataLength );
972 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
973 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
974 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
975 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
976
977 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
978 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bCloseRequested );
979 }
980
981 /**
982 * @brief There is more space in stream buffer than the length of data we want to send.
983 */
test_FreeRTOS_send_MoreSpaceInStreamBuffer(void)984 void test_FreeRTOS_send_MoreSpaceInStreamBuffer( void )
985 {
986 BaseType_t xReturn;
987 FreeRTOS_Socket_t xSocket;
988 uint8_t pvBuffer[ ipconfigTCP_MSS ];
989 size_t uxDataLength;
990 BaseType_t xFlags;
991 StreamBuffer_t xLocalStreamBuffer;
992
993 memset( &xSocket, 0, sizeof( xSocket ) );
994 memset( pvBuffer, 0, ipconfigTCP_MSS );
995
996 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
997 xSocket.u.xTCP.eTCPState = eESTABLISHED;
998 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
999 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1000 xSocket.u.xTCP.bits.bCloseAfterSend = pdTRUE_UNSIGNED;
1001
1002 uxDataLength = 100;
1003 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1004 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength + 20 );
1005 vTaskSuspendAll_Expect();
1006 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength, uxDataLength );
1007 xTaskResumeAll_ExpectAndReturn( pdFALSE );
1008 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1009 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
1010 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1011 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1012
1013 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
1014 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bCloseRequested );
1015 }
1016
1017 /**
1018 * @brief There is less space in stream buffer than the length of data we want to send, also a timeout happens.
1019 */
test_FreeRTOS_send_LessSpaceInStreamBuffer_Timeout(void)1020 void test_FreeRTOS_send_LessSpaceInStreamBuffer_Timeout( void )
1021 {
1022 BaseType_t xReturn;
1023 FreeRTOS_Socket_t xSocket;
1024 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1025 size_t uxDataLength;
1026 BaseType_t xFlags = 0;
1027 StreamBuffer_t xLocalStreamBuffer;
1028
1029 memset( &xSocket, 0, sizeof( xSocket ) );
1030 memset( pvBuffer, 0, ipconfigTCP_MSS );
1031
1032 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1033 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1034 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1035 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1036 xSocket.u.xTCP.bits.bCloseAfterSend = pdTRUE_UNSIGNED;
1037 xSocket.xSendBlockTime = 100;
1038
1039 uxDataLength = 100;
1040 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1041 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength - 20 );
1042 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength - 20, uxDataLength - 20 );
1043 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1044 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1045 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1046 vTaskSetTimeOutState_ExpectAnyArgs();
1047 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_SEND | eSOCKET_CLOSED, pdTRUE, pdFALSE, 100, pdFALSE );
1048 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1049
1050 /* Second Iteration. No space still. */
1051 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 0 );
1052
1053 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
1054
1055 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1056
1057 TEST_ASSERT_EQUAL( uxDataLength - 20, xReturn );
1058 }
1059
1060 /**
1061 * @brief There is less space in stream buffer than the length of data we want to send. However,
1062 * over time, space becomes available.
1063 */
test_FreeRTOS_send_LessSpaceInStreamBuffer_EventuallySpaceAvailable(void)1064 void test_FreeRTOS_send_LessSpaceInStreamBuffer_EventuallySpaceAvailable( void )
1065 {
1066 BaseType_t xReturn;
1067 FreeRTOS_Socket_t xSocket;
1068 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1069 size_t uxDataLength;
1070 BaseType_t xFlags = 0;
1071 StreamBuffer_t xLocalStreamBuffer;
1072
1073 memset( &xSocket, 0, sizeof( xSocket ) );
1074 memset( pvBuffer, 0, ipconfigTCP_MSS );
1075
1076 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1077 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1078 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1079 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1080 xSocket.xSendBlockTime = 100;
1081
1082 uxDataLength = 100;
1083 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1084 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength - 20 );
1085 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength - 20, uxDataLength - 20 );
1086 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1087 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1088 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1089 vTaskSetTimeOutState_ExpectAnyArgs();
1090 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_SEND | eSOCKET_CLOSED, pdTRUE, pdFALSE, 100, pdFALSE );
1091 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1092
1093 /* Second Iteration. */
1094 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 20 );
1095 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, &pvBuffer[ 80 ], 20, 20 );
1096 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1097 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1098 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
1099
1100 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1101
1102 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
1103 }
1104
1105 /**
1106 * @brief There is no space in stream buffer for multiple iterations.
1107 */
test_FreeRTOS_send_MultipleIterationsAndNoSuccess(void)1108 void test_FreeRTOS_send_MultipleIterationsAndNoSuccess( void )
1109 {
1110 BaseType_t xReturn;
1111 FreeRTOS_Socket_t xSocket;
1112 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1113 size_t uxDataLength;
1114 BaseType_t xFlags = 0;
1115 StreamBuffer_t xLocalStreamBuffer;
1116
1117 memset( &xSocket, 0, sizeof( xSocket ) );
1118 memset( pvBuffer, 0, ipconfigTCP_MSS );
1119
1120 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1121 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1122 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1123 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1124 xSocket.xSendBlockTime = 100;
1125
1126 uxDataLength = 100;
1127 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1128 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength - 20 );
1129 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength - 20, uxDataLength - 20 );
1130 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1131 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1132 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1133 vTaskSetTimeOutState_ExpectAnyArgs();
1134 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_SEND | eSOCKET_CLOSED, pdTRUE, pdFALSE, 100, pdFALSE );
1135 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1136
1137 /* Second Iteration. */
1138 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 10 );
1139 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, &pvBuffer[ 80 ], 10, 10 );
1140 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1141 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1142
1143 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
1144
1145 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_SEND | eSOCKET_CLOSED, pdTRUE, pdFALSE, 100, pdFALSE );
1146 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1147
1148 /* Third iteration. No space still. */
1149 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, 0 );
1150
1151 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
1152
1153 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1154
1155 TEST_ASSERT_EQUAL( uxDataLength - 10, xReturn );
1156 }
1157
1158 /*
1159 * @brief While waiting for space, the socket gets disconnected.
1160 */
test_FreeRTOS_send_DisconnectionOccursDuringWait(void)1161 void test_FreeRTOS_send_DisconnectionOccursDuringWait( void )
1162 {
1163 BaseType_t xReturn;
1164 FreeRTOS_Socket_t xSocket;
1165 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1166 size_t uxDataLength;
1167 BaseType_t xFlags = 0;
1168 StreamBuffer_t xLocalStreamBuffer;
1169
1170 memset( &xSocket, 0, sizeof( xSocket ) );
1171 memset( pvBuffer, 0, ipconfigTCP_MSS );
1172
1173 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1174 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1175 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1176 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1177 xSocket.xSendBlockTime = 100;
1178
1179 uxDataLength = 100;
1180 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1181 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength - 20 );
1182 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength - 20, uxDataLength - 20 );
1183 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1184 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1185 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1186 vTaskSetTimeOutState_ExpectAnyArgs();
1187 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_SEND | eSOCKET_CLOSED, pdTRUE, pdFALSE, 100, pdFALSE );
1188
1189 /* Let `socketSOCKET_IS_BOUND()` return false, so that prvTCPSendCheck()
1190 * returns en error, so that the loop is stopped. */
1191 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
1192
1193 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1194
1195 TEST_ASSERT_EQUAL( uxDataLength - 20, xReturn );
1196 }
1197
1198 /*
1199 * @brief IP task is calling send function with a NULL buffer. Also there are 20 bytes worth of space
1200 * less in the stream buffer as the data length.
1201 */
test_FreeRTOS_send_IPTaskWithNULLBuffer(void)1202 void test_FreeRTOS_send_IPTaskWithNULLBuffer( void )
1203 {
1204 BaseType_t xReturn;
1205 FreeRTOS_Socket_t xSocket;
1206 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1207 size_t uxDataLength;
1208 BaseType_t xFlags = 0;
1209 StreamBuffer_t xLocalStreamBuffer;
1210
1211 memset( &xSocket, 0, sizeof( xSocket ) );
1212 memset( pvBuffer, 0, ipconfigTCP_MSS );
1213
1214 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1215 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1216 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1217 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1218 xSocket.xSendBlockTime = 100;
1219
1220 uxDataLength = 100;
1221
1222 xReturn = FreeRTOS_send( &xSocket, NULL, uxDataLength, xFlags );
1223
1224 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1225 }
1226
1227 /**
1228 * @brief Send called with a don't wait flag when there is space in buffer.
1229 */
test_FreeRTOS_send_DontWaitFlag(void)1230 void test_FreeRTOS_send_DontWaitFlag( void )
1231 {
1232 BaseType_t xReturn;
1233 FreeRTOS_Socket_t xSocket;
1234 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1235 size_t uxDataLength;
1236 BaseType_t xFlags = FREERTOS_MSG_DONTWAIT;
1237 StreamBuffer_t xLocalStreamBuffer;
1238
1239 memset( &xSocket, 0, sizeof( xSocket ) );
1240 memset( pvBuffer, 0, ipconfigTCP_MSS );
1241
1242 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1243 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1244 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1245 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1246 xSocket.xSendBlockTime = 100;
1247
1248 uxDataLength = 100;
1249 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1250 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength - 20 );
1251 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength - 20, uxDataLength - 20 );
1252 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1253 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1254 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1255
1256 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1257
1258 TEST_ASSERT_EQUAL( uxDataLength - 20, xReturn );
1259 }
1260
1261 /**
1262 * @brief FreeRTOS_send is called from IP task.
1263 */
test_FreeRTOS_send_ExactSpaceInStreamBufferInIPTask(void)1264 void test_FreeRTOS_send_ExactSpaceInStreamBufferInIPTask( void )
1265 {
1266 BaseType_t xReturn;
1267 FreeRTOS_Socket_t xSocket;
1268 uint8_t pvBuffer[ ipconfigTCP_MSS ];
1269 size_t uxDataLength;
1270 BaseType_t xFlags;
1271 StreamBuffer_t xLocalStreamBuffer;
1272
1273 /* 1. Last set of bytes. */
1274 memset( &xSocket, 0, sizeof( xSocket ) );
1275 memset( pvBuffer, 0, ipconfigTCP_MSS );
1276
1277 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1278 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1279 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
1280 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
1281 xSocket.u.xTCP.bits.bCloseAfterSend = pdTRUE_UNSIGNED;
1282
1283 uxDataLength = 100;
1284 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1285 uxStreamBufferGetSpace_ExpectAndReturn( xSocket.u.xTCP.txStream, uxDataLength );
1286 vTaskSuspendAll_Expect();
1287 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, pvBuffer, uxDataLength, uxDataLength );
1288 xTaskResumeAll_ExpectAndReturn( pdFALSE );
1289 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1290 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1291
1292 xReturn = FreeRTOS_send( &xSocket, pvBuffer, uxDataLength, xFlags );
1293
1294 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
1295 }
1296
1297 /**
1298 * @brief Invalid values passed to listen.
1299 */
test_FreeRTOS_listen_InvalidValues(void)1300 void test_FreeRTOS_listen_InvalidValues( void )
1301 {
1302 BaseType_t xReturn;
1303 FreeRTOS_Socket_t xSocket;
1304 BaseType_t xBacklog;
1305
1306 memset( &xSocket, 0, sizeof( xSocket ) );
1307
1308 /* Invalid Protocol. */
1309 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1310 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1311 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1312
1313 /* Unbound. */
1314 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
1315 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1316 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1317
1318 /* NULL socket. */
1319 xReturn = FreeRTOS_listen( NULL, xBacklog );
1320 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1321
1322 /* Invalid state. */
1323 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1324 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1325 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1326 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1327 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1328 }
1329
1330 /**
1331 * @brief Listen call successful.
1332 */
test_FreeRTOS_listen_Success(void)1333 void test_FreeRTOS_listen_Success( void )
1334 {
1335 BaseType_t xReturn;
1336 FreeRTOS_Socket_t xSocket;
1337 BaseType_t xBacklog = 0;
1338
1339 memset( &xSocket, 0, sizeof( xSocket ) );
1340 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1341 xSocket.u.xTCP.eTCPState = eCLOSED;
1342 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1343
1344 FreeRTOS_min_int32_ExpectAndReturn( ( int32_t ) 0xffff, ( int32_t ) xBacklog, xBacklog );
1345
1346 vTCPStateChange_Expect( &xSocket, eTCP_LISTEN );
1347
1348 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1349 TEST_ASSERT_EQUAL( 0, xReturn );
1350
1351 memset( &xSocket, 0, sizeof( xSocket ) );
1352 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1353 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT;
1354 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1355
1356 FreeRTOS_min_int32_ExpectAndReturn( ( int32_t ) 0xffff, ( int32_t ) xBacklog, xBacklog );
1357
1358 vTCPStateChange_Expect( &xSocket, eTCP_LISTEN );
1359
1360 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1361 TEST_ASSERT_EQUAL( 0, xReturn );
1362 }
1363
1364 /**
1365 * @brief Listen call successful when socket is set to be reused.
1366 */
test_FreeRTOS_listen_Success_WithReuseSocket(void)1367 void test_FreeRTOS_listen_Success_WithReuseSocket( void )
1368 {
1369 BaseType_t xReturn;
1370 FreeRTOS_Socket_t xSocket;
1371 BaseType_t xBacklog = 0;
1372
1373 memset( &xSocket, 0, sizeof( xSocket ) );
1374 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1375 xSocket.u.xTCP.eTCPState = eCLOSED;
1376 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1377
1378 memset( xSocket.u.xTCP.xPacket.u.ucLastPacket, 0xFF, sizeof( xSocket.u.xTCP.xPacket.u.ucLastPacket ) );
1379 memset( &xSocket.u.xTCP.xTCPWindow, 0xFF, sizeof( xSocket.u.xTCP.xTCPWindow ) );
1380 memset( &xSocket.u.xTCP.bits, 0xFF, sizeof( xSocket.u.xTCP.bits ) );
1381
1382 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
1383
1384 FreeRTOS_min_int32_ExpectAndReturn( ( int32_t ) 0xffff, ( int32_t ) xBacklog, xBacklog );
1385
1386 vTCPStateChange_Expect( &xSocket, eTCP_LISTEN );
1387
1388 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1389 TEST_ASSERT_EQUAL( 0, xReturn );
1390 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bReuseSocket );
1391 TEST_ASSERT_EACH_EQUAL_UINT8( 0, xSocket.u.xTCP.xPacket.u.ucLastPacket, sizeof( xSocket.u.xTCP.xPacket.u.ucLastPacket ) );
1392 TEST_ASSERT_EACH_EQUAL_UINT8( 0, &xSocket.u.xTCP.xTCPWindow, sizeof( xSocket.u.xTCP.xTCPWindow ) );
1393 }
1394
1395 /**
1396 * @brief Listen call successful when socket is set to be reused and the streams are non NULL.
1397 */
test_FreeRTOS_listen_Success_WithReuseSocket_StreamsNonNULL(void)1398 void test_FreeRTOS_listen_Success_WithReuseSocket_StreamsNonNULL( void )
1399 {
1400 BaseType_t xReturn;
1401 FreeRTOS_Socket_t xSocket;
1402 BaseType_t xBacklog = 0;
1403
1404 memset( &xSocket, 0, sizeof( xSocket ) );
1405 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1406 xSocket.u.xTCP.eTCPState = eCLOSED;
1407 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1408
1409 memset( xSocket.u.xTCP.xPacket.u.ucLastPacket, 0xFF, sizeof( xSocket.u.xTCP.xPacket.u.ucLastPacket ) );
1410 memset( &xSocket.u.xTCP.xTCPWindow, 0xFF, sizeof( xSocket.u.xTCP.xTCPWindow ) );
1411 memset( &xSocket.u.xTCP.bits, 0xFF, sizeof( xSocket.u.xTCP.bits ) );
1412
1413 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
1414 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) &xReturn;
1415 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) &xReturn;
1416
1417 FreeRTOS_min_int32_ExpectAndReturn( ( int32_t ) 0xffff, ( int32_t ) xBacklog, xBacklog );
1418
1419 vStreamBufferClear_Expect( xSocket.u.xTCP.rxStream );
1420 vStreamBufferClear_Expect( xSocket.u.xTCP.txStream );
1421
1422 vTCPStateChange_Expect( &xSocket, eTCP_LISTEN );
1423
1424 xReturn = FreeRTOS_listen( &xSocket, xBacklog );
1425 TEST_ASSERT_EQUAL( 0, xReturn );
1426 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bReuseSocket );
1427 TEST_ASSERT_EACH_EQUAL_UINT8( 0, xSocket.u.xTCP.xPacket.u.ucLastPacket, sizeof( xSocket.u.xTCP.xPacket.u.ucLastPacket ) );
1428 TEST_ASSERT_EACH_EQUAL_UINT8( 0, &xSocket.u.xTCP.xTCPWindow, sizeof( xSocket.u.xTCP.xTCPWindow ) );
1429 }
1430
1431 /**
1432 * @brief Invalid values passed to shutdown.
1433 */
test_FreeRTOS_shutdown_Invalid(void)1434 void test_FreeRTOS_shutdown_Invalid( void )
1435 {
1436 BaseType_t xReturn;
1437 FreeRTOS_Socket_t xSocket;
1438 BaseType_t xHow;
1439
1440 memset( &xSocket, 0, sizeof( xSocket ) );
1441
1442 /* Invalid Protocol. */
1443 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1444 xReturn = FreeRTOS_shutdown( &xSocket, xHow );
1445 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1446
1447 /* Unbound. */
1448 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
1449 xReturn = FreeRTOS_shutdown( &xSocket, xHow );
1450 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1451
1452 /* NULL socket. */
1453 xReturn = FreeRTOS_shutdown( NULL, xHow );
1454 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EOPNOTSUPP, xReturn );
1455
1456 /* Invalid state. */
1457 for( int i = 0; i < 255; i++ )
1458 {
1459 if( i != eESTABLISHED )
1460 {
1461 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1462 xSocket.u.xTCP.eTCPState = i;
1463 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1464 xReturn = FreeRTOS_shutdown( &xSocket, xHow );
1465 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xReturn );
1466 }
1467 }
1468 }
1469
1470 /**
1471 * @brief Call to shutdown successful.
1472 */
test_FreeRTOS_shutdown_Success(void)1473 void test_FreeRTOS_shutdown_Success( void )
1474 {
1475 BaseType_t xReturn;
1476 FreeRTOS_Socket_t xSocket;
1477 BaseType_t xHow;
1478
1479 memset( &xSocket, 0, sizeof( xSocket ) );
1480
1481 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1482 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1483 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
1484 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFALSE );
1485
1486 xReturn = FreeRTOS_shutdown( &xSocket, xHow );
1487
1488 TEST_ASSERT_EQUAL( 0, xReturn );
1489 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bUserShutdown );
1490 TEST_ASSERT_EQUAL( 1U, xSocket.u.xTCP.usTimeout );
1491 }
1492
1493 /**
1494 * @brief Invalid inputs.
1495 */
test_FreeRTOS_get_rx_buf_InvalidInput(void)1496 void test_FreeRTOS_get_rx_buf_InvalidInput( void )
1497 {
1498 const struct xSTREAM_BUFFER * pxReturn;
1499 FreeRTOS_Socket_t xSocket;
1500
1501 memset( &xSocket, 0, sizeof( xSocket ) );
1502
1503 /* Invalid Protocol. */
1504 pxReturn = FreeRTOS_get_rx_buf( &xSocket );
1505 TEST_ASSERT_EQUAL( NULL, pxReturn );
1506
1507 /* NULL socket. */
1508 pxReturn = FreeRTOS_get_rx_buf( NULL );
1509 TEST_ASSERT_EQUAL( NULL, pxReturn );
1510 }
1511
1512 /**
1513 * @brief Happy path.
1514 */
test_FreeRTOS_get_rx_buf_ValidInput(void)1515 void test_FreeRTOS_get_rx_buf_ValidInput( void )
1516 {
1517 const struct xSTREAM_BUFFER * pxReturn;
1518 struct xSTREAM_BUFFER xStream;
1519 FreeRTOS_Socket_t xSocket;
1520
1521 memset( &xSocket, 0, sizeof( xSocket ) );
1522
1523 /* NULL socket. */
1524 xSocket.u.xTCP.rxStream = &xStream;
1525 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1526
1527 pxReturn = FreeRTOS_get_rx_buf( &xSocket );
1528 TEST_ASSERT_EQUAL( &xStream, pxReturn );
1529 }
1530
1531
1532 /**
1533 * @brief Invalid protocol passed to the function.
1534 */
test_FreeRTOS_tx_space_InvalidProtocol(void)1535 void test_FreeRTOS_tx_space_InvalidProtocol( void )
1536 {
1537 BaseType_t xReturn;
1538 FreeRTOS_Socket_t xSocket;
1539
1540 memset( &xSocket, 0, sizeof( xSocket ) );
1541
1542 xReturn = FreeRTOS_tx_space( &xSocket );
1543 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1544 }
1545
1546 /**
1547 * @brief The stream is NULL in this case.
1548 */
test_FreeRTOS_tx_space_NULLStream(void)1549 void test_FreeRTOS_tx_space_NULLStream( void )
1550 {
1551 BaseType_t xReturn;
1552 FreeRTOS_Socket_t xSocket;
1553
1554 memset( &xSocket, 0, sizeof( xSocket ) );
1555
1556 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1557 xSocket.u.xTCP.uxTxStreamSize = 0xBB;
1558 xReturn = FreeRTOS_tx_space( &xSocket );
1559 TEST_ASSERT_EQUAL( 0xBB, xReturn );
1560 }
1561
1562 /**
1563 * @brief Stream is valid. Happy path.
1564 */
test_FreeRTOS_tx_space_ValidStream(void)1565 void test_FreeRTOS_tx_space_ValidStream( void )
1566 {
1567 BaseType_t xReturn;
1568 FreeRTOS_Socket_t xSocket;
1569 uint8_t ucStream[ 20 ];
1570
1571 memset( &xSocket, 0, sizeof( xSocket ) );
1572
1573 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1574 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
1575
1576 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0xABCD );
1577
1578 xReturn = FreeRTOS_tx_space( &xSocket );
1579 TEST_ASSERT_EQUAL( 0xABCD, xReturn );
1580 }
1581
1582 /**
1583 * @brief All combination of inputs. See below comments.
1584 */
test_FreeRTOS_tx_size(void)1585 void test_FreeRTOS_tx_size( void )
1586 {
1587 BaseType_t xReturn;
1588 FreeRTOS_Socket_t xSocket;
1589 uint8_t ucStream[ 20 ];
1590
1591 memset( &xSocket, 0, sizeof( xSocket ) );
1592
1593 /* Invalid Protocol. */
1594 xReturn = FreeRTOS_tx_size( &xSocket );
1595 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1596
1597 /* Valid Protocol. Stream NULL. */
1598 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1599 xReturn = FreeRTOS_tx_size( &xSocket );
1600 TEST_ASSERT_EQUAL( 0, xReturn );
1601
1602 /* Valid Protocol. Stream non-NULL. */
1603 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1604 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
1605 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0x345 );
1606 xReturn = FreeRTOS_tx_size( &xSocket );
1607 TEST_ASSERT_EQUAL( 0x345, xReturn );
1608 }
1609
1610 /**
1611 * @brief All combination of inputs. See below comments.
1612 */
test_FreeRTOS_issocketconnected(void)1613 void test_FreeRTOS_issocketconnected( void )
1614 {
1615 BaseType_t xReturn;
1616 FreeRTOS_Socket_t xSocket;
1617
1618 memset( &xSocket, 0, sizeof( xSocket ) );
1619
1620 /* Invalid Protocol. */
1621 xReturn = FreeRTOS_issocketconnected( &xSocket );
1622 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1623
1624 /* Valid Protocol. Invalid State. */
1625 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1626 xSocket.u.xTCP.eTCPState = eESTABLISHED - 1;
1627 xReturn = FreeRTOS_issocketconnected( &xSocket );
1628 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
1629
1630 /* Valid Protocol. Invalid State. */
1631 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1632 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT;
1633 xReturn = FreeRTOS_issocketconnected( &xSocket );
1634 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
1635
1636 /* Valid Protocol. Valid State. */
1637 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1638 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT - 1;
1639 xReturn = FreeRTOS_issocketconnected( &xSocket );
1640 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
1641 }
1642
1643
1644 /**
1645 * @brief All combination of inputs. See below comments.
1646 */
test_FreeRTOS_mss(void)1647 void test_FreeRTOS_mss( void )
1648 {
1649 BaseType_t xReturn;
1650 FreeRTOS_Socket_t xSocket;
1651
1652 memset( &xSocket, 0, sizeof( xSocket ) );
1653
1654 /* Invalid Protocol. */
1655 xReturn = FreeRTOS_mss( &xSocket );
1656 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1657
1658 /* Valid Protocol. Invalid State. */
1659 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1660 xSocket.u.xTCP.usMSS = 0xFD;
1661 xReturn = FreeRTOS_mss( &xSocket );
1662 TEST_ASSERT_EQUAL( 0xFD, xReturn );
1663 }
1664
1665 /**
1666 * @brief All combination of inputs. See below comments.
1667 */
test_FreeRTOS_connstatus(void)1668 void test_FreeRTOS_connstatus( void )
1669 {
1670 BaseType_t xReturn;
1671 FreeRTOS_Socket_t xSocket;
1672
1673 memset( &xSocket, 0, sizeof( xSocket ) );
1674
1675 /* Invalid Protocol. */
1676 xReturn = FreeRTOS_connstatus( &xSocket );
1677 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1678
1679 /* Valid Protocol. Invalid State. */
1680 for( uint8_t i = 0; i < 125; i++ )
1681 {
1682 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1683 xSocket.u.xTCP.eTCPState = i;
1684 xReturn = FreeRTOS_connstatus( &xSocket );
1685 TEST_ASSERT_EQUAL( i, xReturn );
1686 }
1687 }
1688
1689 /**
1690 * @brief All combination of inputs. See below comments.
1691 */
test_FreeRTOS_rx_size(void)1692 void test_FreeRTOS_rx_size( void )
1693 {
1694 BaseType_t xReturn;
1695 FreeRTOS_Socket_t xSocket;
1696 uint8_t ucStream[ 20 ];
1697
1698 memset( &xSocket, 0, sizeof( xSocket ) );
1699
1700 /* Invalid Protocol. */
1701 xReturn = FreeRTOS_rx_size( &xSocket );
1702 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1703
1704 /* Valid Protocol. Stream NULL. */
1705 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1706 xReturn = FreeRTOS_rx_size( &xSocket );
1707 TEST_ASSERT_EQUAL( 0, xReturn );
1708
1709 /* Valid Protocol. Stream non-NULL. */
1710 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1711 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) ucStream;
1712 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0xAB );
1713 xReturn = FreeRTOS_rx_size( &xSocket );
1714 TEST_ASSERT_EQUAL( 0xAB, xReturn );
1715 }
1716
1717 /**
1718 * @brief Send zero byte via prvTCPSendLoop.
1719 */
test_prvTCPSendLoop_ZeroByte()1720 void test_prvTCPSendLoop_ZeroByte()
1721 {
1722 BaseType_t xReturn;
1723 FreeRTOS_Socket_t xSocket;
1724 uint8_t pvBuffer[ 10 ];
1725 BaseType_t xFlags = 0;
1726
1727 memset( &xSocket, 0, sizeof( xSocket ) );
1728
1729 uxStreamBufferGetSpace_IgnoreAndReturn( 0 );
1730
1731 xReturn = prvTCPSendLoop( &xSocket, pvBuffer, 0, xFlags );
1732
1733 TEST_ASSERT_EQUAL( 0, xReturn );
1734 }
1735
1736 /**
1737 * @brief Send NULL buffer via prvTCPSendLoop.
1738 */
test_prvTCPSendLoop_NullBuffer()1739 void test_prvTCPSendLoop_NullBuffer()
1740 {
1741 BaseType_t xReturn;
1742 FreeRTOS_Socket_t xSocket;
1743 BaseType_t xFlags = 0;
1744 size_t uxDataLength = 100;
1745
1746 memset( &xSocket, 0, sizeof( xSocket ) );
1747
1748 uxStreamBufferGetSpace_IgnoreAndReturn( 100 );
1749 uxStreamBufferAdd_ExpectAndReturn( xSocket.u.xTCP.txStream, 0U, NULL, uxDataLength, uxDataLength );
1750 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1751
1752 xReturn = prvTCPSendLoop( &xSocket, NULL, uxDataLength, xFlags );
1753
1754 TEST_ASSERT_EQUAL( uxDataLength, xReturn );
1755 }
1756
