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 #include "mock_FreeRTOS_TCP_WIN.h"
52 #include "mock_FreeRTOS_Routing.h"
53 #include "mock_FreeRTOS_IPv6_Sockets.h"
54
55 #include "FreeRTOS_Sockets.h"
56
57
58 #include "FreeRTOS_Sockets_stubs.c"
59 #include "catch_assert.h"
60
61 #include "FreeRTOSIPConfig.h"
62
63 /* =========================== EXTERN VARIABLES =========================== */
64
65 void prvFindSelectedSocket( SocketSelect_t * pxSocketSet );
66
67 BaseType_t prvDetermineSocketSize( BaseType_t xDomain,
68 BaseType_t xType,
69 BaseType_t xProtocol,
70 size_t * pxSocketSize );
71
72 BaseType_t prvMakeSureSocketIsBound( FreeRTOS_Socket_t * pxSocket );
73
74 void prvTCPSetSocketCount( FreeRTOS_Socket_t const * pxSocketToDelete );
75
76 BaseType_t prvSockopt_so_buffer( FreeRTOS_Socket_t * pxSocket,
77 int32_t lOptionName,
78 const void * pvOptionValue );
79 uint16_t prvGetPrivatePortNumber( BaseType_t xProtocol );
80
81 const ListItem_t * pxListFindListItemWithValue( const List_t * pxList,
82 TickType_t xWantedItemValue );
83
84 BaseType_t prvTCPConnectStart( FreeRTOS_Socket_t * pxSocket,
85 struct freertos_sockaddr const * pxAddress );
86
87 int32_t prvTCPSendCheck( FreeRTOS_Socket_t * pxSocket,
88 size_t uxDataLength );
89
90 StreamBuffer_t * prvTCPCreateStream( FreeRTOS_Socket_t * pxSocket,
91 BaseType_t xIsInputStream );
92
93 BaseType_t prvValidSocket( const FreeRTOS_Socket_t * pxSocket,
94 BaseType_t xProtocol,
95 BaseType_t xIsBound );
96
97 BaseType_t bMayConnect( FreeRTOS_Socket_t const * pxSocket );
98
99 extern List_t xBoundUDPSocketsList;
100 extern List_t xBoundTCPSocketsList;
101
102 static IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
103
104 /* ============================== Test Cases ============================== */
105
106 /**
107 * @brief Sending to IP-task fails.
108 */
test_prvFindSelectedSocket_SendFail(void)109 void test_prvFindSelectedSocket_SendFail( void )
110 {
111 SocketSelect_t xSocketSet;
112
113 xEventGroupClearBits_ExpectAndReturn( xSocketSet.xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdFALSE );
114
115 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
116
117 prvFindSelectedSocket( &xSocketSet );
118 }
119
120 /**
121 * @brief Sending to IP-task is successful.
122 */
test_prvFindSelectedSocket_SendSuccess(void)123 void test_prvFindSelectedSocket_SendSuccess( void )
124 {
125 SocketSelect_t xSocketSet;
126
127 xEventGroupClearBits_ExpectAndReturn( xSocketSet.xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdFALSE );
128
129 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
130
131 xEventGroupWaitBits_ExpectAndReturn( xSocketSet.xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdTRUE, pdFALSE, portMAX_DELAY, pdTRUE );
132
133 prvFindSelectedSocket( &xSocketSet );
134 }
135
136 /**
137 * @brief Invalid or NULL socket test.
138 */
test_prvValidSocket_InvalidOrNULLSocket(void)139 void test_prvValidSocket_InvalidOrNULLSocket( void )
140 {
141 BaseType_t xReturn;
142 FreeRTOS_Socket_t * pxSocket = ( FreeRTOS_Socket_t * ) FREERTOS_INVALID_SOCKET;
143 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP, xIsBound = pdFALSE;
144
145 xReturn = prvValidSocket( NULL, xProtocol, xIsBound );
146
147 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
148
149 xReturn = prvValidSocket( pxSocket, xProtocol, xIsBound );
150
151 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
152 }
153
154 /**
155 * @brief Socket bound variable set, but the socket is not actually bound.
156 */
test_prvValidSocket_SocketBoundSetButNotBound(void)157 void test_prvValidSocket_SocketBoundSetButNotBound( void )
158 {
159 BaseType_t xReturn;
160 FreeRTOS_Socket_t xSocket;
161 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP, xIsBound = pdTRUE;
162
163 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
164
165 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
166
167 xReturn = prvValidSocket( &xSocket, xProtocol, xIsBound );
168
169 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
170 }
171
172 /**
173 * @brief Socket bound variable reset, but the socket is actually bound.
174 */
test_prvValidSocket_SocketBoundResetButBound(void)175 void test_prvValidSocket_SocketBoundResetButBound( void )
176 {
177 BaseType_t xReturn;
178 FreeRTOS_Socket_t xSocket;
179 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP, xIsBound = pdFALSE;
180
181 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
182
183 xSocket.ucProtocol = xProtocol;
184
185 xReturn = prvValidSocket( &xSocket, xProtocol, xIsBound );
186
187 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
188 }
189
190 /**
191 * @brief Invalid protocol present in the socket structure.
192 */
test_prvValidSocket_InvalidProtocol(void)193 void test_prvValidSocket_InvalidProtocol( void )
194 {
195 BaseType_t xReturn;
196 FreeRTOS_Socket_t xSocket;
197 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP, xIsBound = pdTRUE;
198
199 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
200
201 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), ( struct xLIST * ) ( uintptr_t ) 0x11223344 );
202
203 xSocket.ucProtocol = xProtocol + 1;
204
205 xReturn = prvValidSocket( &xSocket, xProtocol, xIsBound );
206
207 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
208 }
209
210 /**
211 * @brief This function is a wrapper expected to call only the initialisation functions for the bound sockets lists.
212 */
test_vNetworkSocketsInit(void)213 void test_vNetworkSocketsInit( void )
214 {
215 vListInitialise_Expect( &xBoundUDPSocketsList );
216 vListInitialise_Expect( &xBoundTCPSocketsList );
217
218 vNetworkSocketsInit();
219 }
220
221 /**
222 * @brief Test case when IP-Task is not initialised.
223 */
test_prvDetermineSocketSize_IPTaskNotInit(void)224 void test_prvDetermineSocketSize_IPTaskNotInit( void )
225 {
226 BaseType_t xReturn;
227 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
228 size_t xSocketSize;
229
230 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
231
232 xReturn = prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize );
233
234 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
235 }
236
237 /**
238 * @brief Assertion when the domain is anything except FREERTOS_AF_INET.
239 */
test_prvDetermineSocketSize_CatchAssert(void)240 void test_prvDetermineSocketSize_CatchAssert( void )
241 {
242 BaseType_t xDomain = FREERTOS_AF_INET + 1, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
243 size_t xSocketSize;
244
245 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
246
247 /* Assertion when the domain is anything except FREERTOS_AF_INET. */
248 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
249 }
250
251 /**
252 * @brief Assertion that the UDP socket list must be initialized.
253 */
test_prvDetermineSocketSize_CatchAssert2(void)254 void test_prvDetermineSocketSize_CatchAssert2( void )
255 {
256 BaseType_t xReturn;
257 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
258 size_t xSocketSize;
259
260 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
261
262 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdFALSE );
263
264 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
265
266 /* Assertion that the UDP socket list must be initialized. */
267 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
268 }
269
270 /**
271 * @brief Assertion that the TCP socket list must be initialized.
272 */
test_prvDetermineSocketSize_CatchAssert3(void)273 void test_prvDetermineSocketSize_CatchAssert3( void )
274 {
275 BaseType_t xReturn;
276 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
277 size_t xSocketSize;
278
279 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
280
281 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
282
283 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdFALSE );
284
285 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
286 memset( &xBoundTCPSocketsList, 0, sizeof( xBoundTCPSocketsList ) );
287
288 xBoundUDPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
289
290 /* Assertion that the TCP socket list must be initialized. */
291 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
292 }
293
294 /**
295 * @brief Assertion that the protocol must be either TCP or UDP.
296 */
test_prvDetermineSocketSize_CatchAssert4(void)297 void test_prvDetermineSocketSize_CatchAssert4( void )
298 {
299 BaseType_t xReturn;
300 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = ~( FREERTOS_IPPROTO_UDP | FREERTOS_IPPROTO_TCP );
301 size_t xSocketSize;
302
303 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
304
305 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
306
307 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
308
309 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
310 memset( &xBoundTCPSocketsList, 0, sizeof( xBoundTCPSocketsList ) );
311
312 xBoundUDPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
313 xBoundTCPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
314
315 /* Assertion that the protocol must be either TCP or UDP. */
316 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
317 }
318
319 /**
320 * @brief Assertion that the protocol type and the socket type must match.
321 */
test_prvDetermineSocketSize_CatchAssert5(void)322 void test_prvDetermineSocketSize_CatchAssert5( void )
323 {
324 BaseType_t xReturn;
325 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM + 1, xProtocol = FREERTOS_IPPROTO_UDP;
326 size_t xSocketSize;
327
328 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
329
330 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
331
332 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
333
334 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
335 memset( &xBoundTCPSocketsList, 0, sizeof( xBoundTCPSocketsList ) );
336
337 xBoundUDPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
338 xBoundTCPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
339
340 /* Assertion that the protocol type and the socket type must match. */
341 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
342 }
343
344 /**
345 * @brief Happy path with UDP socket size being determined.
346 */
test_prvDetermineSocketSize_UDPSocket(void)347 void test_prvDetermineSocketSize_UDPSocket( void )
348 {
349 BaseType_t xReturn;
350 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
351 size_t xSocketSize;
352 FreeRTOS_Socket_t const * pxSocket = NULL;
353
354 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
355
356 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
357 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
358
359 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
360 memset( &xBoundTCPSocketsList, 0, sizeof( xBoundTCPSocketsList ) );
361
362 xBoundUDPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
363 xBoundTCPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
364
365 xReturn = prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize );
366
367 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
368 TEST_ASSERT_EQUAL( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xUDP ), xSocketSize );
369 }
370
371 /**
372 * @brief Assertion that the protocol type and the socket type must match.
373 */
test_prvDetermineSocketSize_CatchAssert6(void)374 void test_prvDetermineSocketSize_CatchAssert6( void )
375 {
376 BaseType_t xReturn;
377 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_TCP;
378 size_t xSocketSize;
379 FreeRTOS_Socket_t const * pxSocket = NULL;
380
381 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
382
383 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
384 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
385
386 memset( &xBoundUDPSocketsList, 0, sizeof( xBoundUDPSocketsList ) );
387 memset( &xBoundTCPSocketsList, 0, sizeof( xBoundTCPSocketsList ) );
388
389 xBoundUDPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
390 xBoundTCPSocketsList.xListEnd.xItemValue = portMAX_DELAY;
391
392 /* Assertion that the protocol type and the socket type must match. */
393 catch_assert( prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize ) );
394 }
395
396 /**
397 * @brief Happy path with TCP socket size being determined.
398 */
test_prvDetermineSocketSize_TCPSocket(void)399 void test_prvDetermineSocketSize_TCPSocket( void )
400 {
401 BaseType_t xReturn;
402 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
403 size_t xSocketSize;
404 FreeRTOS_Socket_t const * pxSocket = NULL;
405
406 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
407
408 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
409 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
410
411 xReturn = prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize );
412
413 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
414 TEST_ASSERT_EQUAL( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), xSocketSize );
415 }
416
417 /**
418 * @brief Happy path with TCPv6 socket size being determined.
419 */
test_prvDetermineSocketSize_TCPv6Socket(void)420 void test_prvDetermineSocketSize_TCPv6Socket( void )
421 {
422 BaseType_t xReturn;
423 BaseType_t xDomain = FREERTOS_AF_INET6, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
424 size_t xSocketSize;
425 FreeRTOS_Socket_t const * pxSocket = NULL;
426
427 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
428
429 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
430 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
431
432 xReturn = prvDetermineSocketSize( xDomain, xType, xProtocol, &xSocketSize );
433
434 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
435 TEST_ASSERT_EQUAL( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), xSocketSize );
436 }
437
438 /**
439 * @brief Test for NULL Socket.
440 */
test_prvMakeSureSocketIsBound_NULLSocket(void)441 void test_prvMakeSureSocketIsBound_NULLSocket( void )
442 {
443 BaseType_t xResult;
444
445 xResult = prvMakeSureSocketIsBound( NULL );
446
447 TEST_ASSERT_EQUAL( pdFALSE, xResult );
448 }
449
450 /**
451 * @brief Incompatible protocol.
452 */
test_prvMakeSureSocketIsBound_TCPProtocol(void)453 void test_prvMakeSureSocketIsBound_TCPProtocol( void )
454 {
455 BaseType_t xResult;
456 FreeRTOS_Socket_t xSocket;
457
458 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
459
460 xResult = prvMakeSureSocketIsBound( &xSocket );
461
462 TEST_ASSERT_EQUAL( pdFALSE, xResult );
463 }
464
465 /**
466 * @brief Socket is already bound.
467 */
test_prvMakeSureSocketIsBound_SocketAlreadyBound(void)468 void test_prvMakeSureSocketIsBound_SocketAlreadyBound( void )
469 {
470 BaseType_t xResult;
471 FreeRTOS_Socket_t xSocket;
472
473 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
474
475 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), ( struct xLIST * ) ( uintptr_t ) 0x11223344 );
476
477 xResult = prvMakeSureSocketIsBound( &xSocket );
478
479 TEST_ASSERT_EQUAL( pdTRUE, xResult );
480 }
481
482 /**
483 * @brief Socket is not bound but attempt of binding fails.
484 */
test_prvMakeSureSocketIsBound_SocketNotBound_BindingFails(void)485 void test_prvMakeSureSocketIsBound_SocketNotBound_BindingFails( void )
486 {
487 BaseType_t xResult;
488 FreeRTOS_Socket_t xSocket;
489
490 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
491
492 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
493
494 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
495
496 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
497
498 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
499
500 xResult = prvMakeSureSocketIsBound( &xSocket );
501
502 TEST_ASSERT_EQUAL( pdFALSE, xResult );
503 }
504
505 /**
506 * @brief Socket is not bound and binding is successful.
507 */
test_prvMakeSureSocketIsBound_SocketNotBound_BindingSuccess(void)508 void test_prvMakeSureSocketIsBound_SocketNotBound_BindingSuccess( void )
509 {
510 BaseType_t xResult;
511 FreeRTOS_Socket_t xSocket;
512
513 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
514
515 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
516
517 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
518
519 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
520
521 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
522
523 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, ( EventBits_t ) eSOCKET_BOUND, pdTRUE, pdFALSE, portMAX_DELAY, pdTRUE );
524
525 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), ( struct xLIST * ) ( uintptr_t ) 0x11223344 );
526
527 xResult = prvMakeSureSocketIsBound( &xSocket );
528
529 TEST_ASSERT_EQUAL( pdTRUE, xResult );
530 }
531
532 /**
533 * @brief Trying to bind a NULL socket.
534 */
test_vSocketBind_CatchAssert1(void)535 void test_vSocketBind_CatchAssert1( void )
536 {
537 BaseType_t xReturn;
538 struct freertos_sockaddr xBindAddress;
539 size_t uxAddressLength = 0;
540 BaseType_t xInternal = 0;
541
542 catch_assert( vSocketBind( NULL, &xBindAddress, uxAddressLength, xInternal ) );
543 }
544
545 /**
546 * @brief Trying to bind an invalid socket.
547 */
test_vSocketBind_CatchAssert2(void)548 void test_vSocketBind_CatchAssert2( void )
549 {
550 BaseType_t xReturn;
551 FreeRTOS_Socket_t xSocket;
552 struct freertos_sockaddr xBindAddress;
553 size_t uxAddressLength;
554 BaseType_t xInternal;
555
556 catch_assert( vSocketBind( FREERTOS_INVALID_SOCKET, &xBindAddress, uxAddressLength, xInternal ) );
557 }
558
559 /**
560 * @brief Binding successful.
561 */
test_vSocketBind_TCP(void)562 void test_vSocketBind_TCP( void )
563 {
564 BaseType_t xReturn;
565 FreeRTOS_Socket_t xSocket;
566 struct freertos_sockaddr xBindAddress;
567 size_t uxAddressLength;
568 BaseType_t xInternal = pdFALSE;
569
570 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
571 memset( &xSocket, 0, sizeof( xSocket ) );
572
573 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
574
575 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
576
577 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
578
579 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
580
581 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
582 vListInsertEnd_IgnoreArg_pxList();
583
584
585
586 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
587
588 TEST_ASSERT_EQUAL( 0, xReturn );
589 }
590
591 /**
592 * @brief Address passed is NULL.
593 */
test_vSocketBind_TCPNULLAddress(void)594 void test_vSocketBind_TCPNULLAddress( void )
595 {
596 BaseType_t xReturn;
597 FreeRTOS_Socket_t xSocket;
598 struct freertos_sockaddr xBindAddress;
599 size_t uxAddressLength;
600 BaseType_t xInternal = pdFALSE;
601
602 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
603 memset( &xSocket, 0, sizeof( xSocket ) );
604
605 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
606
607 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdFALSE );
608 xReturn = vSocketBind( &xSocket, NULL, uxAddressLength, xInternal );
609
610 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EADDRNOTAVAIL, xReturn );
611 }
612
613 /**
614 * @brief Random number generator fails to get a random port number.
615 */
test_vSocketBind_RNGFails(void)616 void test_vSocketBind_RNGFails( void )
617 {
618 BaseType_t xReturn;
619 FreeRTOS_Socket_t xSocket;
620 struct freertos_sockaddr xBindAddress;
621 size_t uxAddressLength;
622 BaseType_t xInternal = pdFALSE;
623
624 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
625 memset( &xSocket, 0, sizeof( xSocket ) );
626
627 xBindAddress.sin_port = 0;
628
629 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
630
631 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdFALSE );
632
633 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
634
635 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EADDRNOTAVAIL, xReturn );
636 }
637
638 /**
639 * @brief Binding the socket to a given port number.
640 */
test_vSocketBind_NonZeroPortNumber(void)641 void test_vSocketBind_NonZeroPortNumber( void )
642 {
643 BaseType_t xReturn;
644 FreeRTOS_Socket_t xSocket;
645 struct freertos_sockaddr xBindAddress;
646 size_t uxAddressLength;
647 BaseType_t xInternal = pdFALSE;
648
649 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
650 memset( &xSocket, 0, sizeof( xSocket ) );
651
652 xBindAddress.sin_port = 0x12;
653
654 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
655
656 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
657
658 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
659
660 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
661
662 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
663 vListInsertEnd_IgnoreArg_pxList();
664
665 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
666
667 TEST_ASSERT_EQUAL( 0, xReturn );
668 }
669
670 /**
671 * @brief NULL item returned.
672 */
test_vSocketBind_GotNULLItem(void)673 void test_vSocketBind_GotNULLItem( void )
674 {
675 BaseType_t xReturn;
676 FreeRTOS_Socket_t xSocket;
677 struct freertos_sockaddr xBindAddress;
678 size_t uxAddressLength;
679 BaseType_t xInternal = pdTRUE;
680 ListItem_t xLocalList;
681 ListItem_t * xListStart = NULL;
682
683 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
684 memset( &xSocket, 0, sizeof( xSocket ) );
685
686 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
687
688 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
689
690 listGET_NEXT_ExpectAnyArgsAndReturn( xListStart );
691
692 listGET_LIST_ITEM_VALUE_ExpectAndReturn( xListStart, 0 );
693
694 listGET_NEXT_ExpectAnyArgsAndReturn( xListStart );
695
696 listGET_LIST_ITEM_VALUE_ExpectAndReturn( xListStart, xBindAddress.sin_port );
697
698 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
699
700 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
701
702 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
703 vListInsertEnd_IgnoreArg_pxList();
704
705 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
706
707 TEST_ASSERT_EQUAL( 0, xReturn );
708 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xBindAddress.sin_port ), xSocket.usLocalPort );
709 }
710
711 /**
712 * @brief Got a non-NULL list.
713 */
test_vSocketBind_GotANonNULLValue(void)714 void test_vSocketBind_GotANonNULLValue( void )
715 {
716 BaseType_t xReturn;
717 FreeRTOS_Socket_t xSocket;
718 struct freertos_sockaddr xBindAddress;
719 size_t uxAddressLength;
720 BaseType_t xInternal = pdTRUE;
721 ListItem_t xLocalList;
722 ListItem_t * xListStart = &xLocalList;
723
724 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
725 memset( &xSocket, 0, sizeof( xSocket ) );
726
727 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
728
729 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
730
731 listGET_NEXT_ExpectAnyArgsAndReturn( xListStart );
732
733 listGET_LIST_ITEM_VALUE_ExpectAndReturn( xListStart, 0 );
734
735 listGET_NEXT_ExpectAnyArgsAndReturn( xListStart );
736
737 listGET_LIST_ITEM_VALUE_ExpectAndReturn( xListStart, xBindAddress.sin_port );
738
739 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
740
741 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EADDRINUSE, xReturn );
742 TEST_ASSERT_EQUAL( 0, xSocket.usLocalPort );
743 }
744
745 /**
746 * @brief TCP socket bind happy path.
747 */
test_vSocketBind_TCPGotAProperValue(void)748 void test_vSocketBind_TCPGotAProperValue( void )
749 {
750 BaseType_t xReturn;
751 FreeRTOS_Socket_t xSocket;
752 struct freertos_sockaddr xBindAddress;
753 size_t uxAddressLength;
754 BaseType_t xInternal = pdTRUE;
755 ListItem_t xLocalList;
756 ListItem_t * xListStart = &xLocalList;
757
758 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
759 memset( &xSocket, 0, sizeof( xSocket ) );
760
761 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
762
763 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
764
765 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
766
767 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
768 vListInsertEnd_IgnoreArg_pxList();
769
770 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
771
772 TEST_ASSERT_EQUAL( 0, xReturn );
773 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xBindAddress.sin_port ), xSocket.usLocalPort );
774 }
775
776 /**
777 * @brief TCP trying to bind to port 0.
778 */
test_vSocketBind_TCPGotAProperValuePortZero(void)779 void test_vSocketBind_TCPGotAProperValuePortZero( void )
780 {
781 BaseType_t xReturn;
782 FreeRTOS_Socket_t xSocket;
783 struct freertos_sockaddr xBindAddress;
784 size_t uxAddressLength;
785 BaseType_t xInternal = pdTRUE;
786 MiniListItem_t xLocalList;
787
788 xBoundTCPSocketsList.xListEnd = xLocalList;
789
790 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
791 memset( &xSocket, 0, sizeof( xSocket ) );
792
793 xBindAddress.sin_port = 0;
794
795 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
796
797 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
798
799 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
800
801 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
802
803 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), FreeRTOS_htons( 1024 ) );
804
805 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
806
807 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
808 vListInsertEnd_IgnoreArg_pxList();
809
810 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
811
812 TEST_ASSERT_EQUAL( 0, xReturn );
813 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xBindAddress.sin_port ), xSocket.usLocalPort );
814 }
815
816 /**
817 * @brief TCPv6 socket bind happy path.
818 */
test_vSocketBind_TCPv6GotAProperValue(void)819 void test_vSocketBind_TCPv6GotAProperValue( void )
820 {
821 BaseType_t xReturn;
822 FreeRTOS_Socket_t xSocket;
823 struct freertos_sockaddr xBindAddress;
824 size_t uxAddressLength;
825 BaseType_t xInternal = pdTRUE;
826 ListItem_t xLocalList;
827 ListItem_t * xListStart = &xLocalList;
828 IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } }; /* 2001::1 */
829 NetworkEndPoint_t xEndPoint;
830
831 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
832 memset( &xSocket, 0, sizeof( xSocket ) );
833 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
834
835 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
836
837 xEndPoint.bits.bIPv6 = pdTRUE;
838 memcpy( xEndPoint.ipv6_settings.xIPAddress.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
839
840 xBindAddress.sin_family = FREERTOS_AF_INET6;
841 memcpy( xBindAddress.sin_address.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
842
843 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
844
845 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
846 vListInsertEnd_IgnoreArg_pxList();
847
848 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
849
850 TEST_ASSERT_EQUAL( 0, xReturn );
851 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xBindAddress.sin_port ), xSocket.usLocalPort );
852 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, xSocket.xLocalAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
853 }
854
855 /**
856 * @brief TCP socket bind with FREERTOS_INADDR_ANY.
857 */
test_vSocketBind_TCPBindAnyAddress(void)858 void test_vSocketBind_TCPBindAnyAddress( void )
859 {
860 BaseType_t xReturn;
861 FreeRTOS_Socket_t xSocket;
862 struct freertos_sockaddr xBindAddress;
863 size_t uxAddressLength;
864 BaseType_t xInternal = pdTRUE;
865 ListItem_t xLocalList;
866 ListItem_t * xListStart = &xLocalList;
867 IPv6_Address_t xIPv6Address;
868
869 memset( &xBindAddress, 0xFC, sizeof( xBindAddress ) );
870 memset( &xSocket, 0, sizeof( xSocket ) );
871 memset( &xIPv6Address, 0, sizeof( xIPv6Address ) );
872
873 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
874
875 xBindAddress.sin_family = FREERTOS_AF_INET4;
876 xBindAddress.sin_address.ulIP_IPv4 = FREERTOS_INADDR_ANY;
877
878 listSET_LIST_ITEM_VALUE_Expect( &( xSocket.xBoundSocketListItem ), xBindAddress.sin_port );
879
880 vListInsertEnd_Expect( NULL, &( xSocket.xBoundSocketListItem ) );
881 vListInsertEnd_IgnoreArg_pxList();
882
883 xReturn = vSocketBind( &xSocket, &xBindAddress, uxAddressLength, xInternal );
884
885 TEST_ASSERT_EQUAL( 0, xReturn );
886 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( xBindAddress.sin_port ), xSocket.usLocalPort );
887 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, xSocket.xLocalAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
888 }
889
890 /**
891 * @brief Closing unbound socket with unknown protocol.
892 */
test_vSocketClose_UnknownProtocol_NotBound(void)893 void test_vSocketClose_UnknownProtocol_NotBound( void )
894 {
895 FreeRTOS_Socket_t xSocket;
896 void * pvReturn;
897
898 memset( &xSocket, 0xAB, sizeof( xSocket ) );
899
900 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
901
902 vEventGroupDelete_Expect( xSocket.xEventGroup );
903
904 vPortFree_Expect( &xSocket );
905
906 pvReturn = vSocketClose( &xSocket );
907
908 TEST_ASSERT_EQUAL( NULL, pvReturn );
909 }
910
911 /**
912 * @brief Closing unbound socket having a NULL event group with unknown protocol.
913 */
test_vSocketClose_UnknownProtocol_NotBound_EventGroupNULL(void)914 void test_vSocketClose_UnknownProtocol_NotBound_EventGroupNULL( void )
915 {
916 FreeRTOS_Socket_t xSocket;
917 void * pvReturn;
918
919 memset( &xSocket, 0xAB, sizeof( xSocket ) );
920
921 xSocket.xEventGroup = NULL;
922
923 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
924
925 vPortFree_Expect( &xSocket );
926
927 pvReturn = vSocketClose( &xSocket );
928
929 TEST_ASSERT_EQUAL( NULL, pvReturn );
930 }
931
932 /**
933 * @brief Closing a TCP socket which has every object assigned.
934 */
test_vSocketClose_TCP_EverythingNonNULL(void)935 void test_vSocketClose_TCP_EverythingNonNULL( void )
936 {
937 FreeRTOS_Socket_t xSocket;
938 void * pvReturn;
939 ListItem_t xLocalList;
940
941 memset( &xSocket, 0xAB, sizeof( xSocket ) );
942
943 xSocket.xEventGroup = NULL;
944 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
945
946 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
947
948 vTCPWindowDestroy_Expect( &( xSocket.u.xTCP.xTCPWindow ) );
949
950 vPortFree_Expect( xSocket.u.xTCP.rxStream );
951
952 vPortFree_Expect( xSocket.u.xTCP.txStream );
953
954 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
955
956 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
957
958 vPortFree_Expect( &xSocket );
959
960 pvReturn = vSocketClose( &xSocket );
961
962 TEST_ASSERT_EQUAL( NULL, pvReturn );
963 }
964
965 /**
966 * @brief TCP socket being closed where there is still a pointer to last acknowledged packet.
967 */
test_vSocketClose_TCP_LastAckMessageNonNULL(void)968 void test_vSocketClose_TCP_LastAckMessageNonNULL( void )
969 {
970 FreeRTOS_Socket_t xSocket;
971 void * pvReturn;
972 ListItem_t xLocalList;
973
974 memset( &xSocket, 0xAB, sizeof( xSocket ) );
975
976 xSocket.xEventGroup = NULL;
977 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
978
979 xSocket.u.xTCP.pxAckMessage = NULL;
980
981 vTCPWindowDestroy_Expect( &( xSocket.u.xTCP.xTCPWindow ) );
982
983 vPortFree_Expect( xSocket.u.xTCP.rxStream );
984
985 vPortFree_Expect( xSocket.u.xTCP.txStream );
986
987 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
988
989 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
990
991 vPortFree_Expect( &xSocket );
992
993 pvReturn = vSocketClose( &xSocket );
994
995 TEST_ASSERT_EQUAL( NULL, pvReturn );
996 }
997
998 /**
999 * @brief Closing a socket with streams non-NULL.
1000 */
test_vSocketClose_TCP_AllFieldsNonNULL(void)1001 void test_vSocketClose_TCP_AllFieldsNonNULL( void )
1002 {
1003 FreeRTOS_Socket_t xSocket;
1004 void * pvReturn;
1005 ListItem_t xLocalList;
1006
1007 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1008
1009 xSocket.xEventGroup = NULL;
1010 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1011
1012 xSocket.u.xTCP.pxAckMessage = NULL;
1013 xSocket.u.xTCP.rxStream = NULL;
1014 xSocket.u.xTCP.txStream = NULL;
1015
1016 vTCPWindowDestroy_Expect( &( xSocket.u.xTCP.xTCPWindow ) );
1017
1018 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1019
1020 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), ( struct xLIST * ) 0x12345678 );
1021
1022 uxListRemove_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), 0 );
1023
1024 vPortFree_Expect( &xSocket );
1025
1026 pvReturn = vSocketClose( &xSocket );
1027
1028 TEST_ASSERT_EQUAL( NULL, pvReturn );
1029 }
1030
1031 /**
1032 * @brief Closing a UDP socket which doesn't have any waiting packets.
1033 */
test_vSocketClose_UDP_NoWaitingPackets(void)1034 void test_vSocketClose_UDP_NoWaitingPackets( void )
1035 {
1036 FreeRTOS_Socket_t xSocket;
1037 void * pvReturn;
1038 ListItem_t xLocalList;
1039
1040 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1041
1042 xSocket.xEventGroup = NULL;
1043 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
1044
1045 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
1046
1047 listCURRENT_LIST_LENGTH_ExpectAndReturn( &( xSocket.u.xUDP.xWaitingPacketsList ), 0 );
1048
1049 vPortFree_Expect( &xSocket );
1050
1051 pvReturn = vSocketClose( &xSocket );
1052
1053 TEST_ASSERT_EQUAL( NULL, pvReturn );
1054 }
1055
1056 /**
1057 * @brief Closing a UDP socket which has some waiting packets.
1058 */
test_vSocketClose_UDP_SomeWaitingPackets(void)1059 void test_vSocketClose_UDP_SomeWaitingPackets( void )
1060 {
1061 FreeRTOS_Socket_t xSocket;
1062 void * pvReturn;
1063 ListItem_t xLocalList;
1064 NetworkBufferDescriptor_t xNetworkBuffer;
1065
1066 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1067
1068 xSocket.xEventGroup = NULL;
1069 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
1070
1071 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
1072
1073 listCURRENT_LIST_LENGTH_ExpectAndReturn( &( xSocket.u.xUDP.xWaitingPacketsList ), 5 );
1074
1075 for( int i = 0; i < 5; i++ )
1076 {
1077 listGET_OWNER_OF_HEAD_ENTRY_ExpectAndReturn( &( xSocket.u.xUDP.xWaitingPacketsList ), &xNetworkBuffer );
1078
1079 uxListRemove_ExpectAndReturn( &( xNetworkBuffer.xBufferListItem ), pdPASS );
1080
1081 vReleaseNetworkBufferAndDescriptor_Expect( &xNetworkBuffer );
1082
1083 listCURRENT_LIST_LENGTH_ExpectAndReturn( &( xSocket.u.xUDP.xWaitingPacketsList ), 4 - i );
1084 }
1085
1086 vPortFree_Expect( &xSocket );
1087
1088 pvReturn = vSocketClose( &xSocket );
1089
1090 TEST_ASSERT_EQUAL( NULL, pvReturn );
1091 }
1092
1093 /**
1094 * @brief Set children count of a listening socket which does not have any.
1095 */
test_prvTCPSetSocketCount_ListeningSocketNoChildren(void)1096 void test_prvTCPSetSocketCount_ListeningSocketNoChildren( void )
1097 {
1098 FreeRTOS_Socket_t xSocketToDelete;
1099
1100 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1101
1102 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1103 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1104
1105 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1106
1107 prvTCPSetSocketCount( &xSocketToDelete );
1108 }
1109
1110 /**
1111 * @brief Set children count of a listening socket which has non-zero children.
1112 */
test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren1(void)1113 void test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren1( void )
1114 {
1115 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1116 ListItem_t xIterator;
1117
1118 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1119 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1120
1121 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1122 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1123
1124 xChildSocket.u.xTCP.eTCPState = eTCP_LISTEN;
1125
1126 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1127
1128 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1129
1130 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1131
1132 prvTCPSetSocketCount( &xSocketToDelete );
1133 }
1134
1135 /**
1136 * @brief Set children count of a listening socket which has non-zero children.
1137 */
test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren2(void)1138 void test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren2( void )
1139 {
1140 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1141 ListItem_t xIterator;
1142 uint16_t usLocalPort = 0x1234;
1143
1144 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1145 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1146
1147 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1148 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1149 xSocketToDelete.usLocalPort = usLocalPort;
1150
1151 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1152 xChildSocket.usLocalPort = usLocalPort + 1;
1153
1154 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1155
1156 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1157
1158 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1159
1160 prvTCPSetSocketCount( &xSocketToDelete );
1161 }
1162
1163 /**
1164 * @brief Set children count of a listening socket which has non-zero children.
1165 */
test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren3(void)1166 void test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren3( void )
1167 {
1168 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1169 ListItem_t xIterator;
1170 uint16_t usLocalPort = 0x1234;
1171
1172 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1173 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1174
1175 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1176 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1177 xSocketToDelete.usLocalPort = usLocalPort;
1178
1179 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1180 xChildSocket.usLocalPort = usLocalPort;
1181 xChildSocket.u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;
1182 xChildSocket.u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
1183
1184 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1185
1186 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1187
1188 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1189
1190 prvTCPSetSocketCount( &xSocketToDelete );
1191 }
1192
1193 /**
1194 * @brief Set children count of a listening socket which has non-zero children.
1195 */
test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren4(void)1196 void test_prvTCPSetSocketCount_ListeningSocketNonZeroChildren4( void )
1197 {
1198 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1199 ListItem_t xIterator;
1200 uint16_t usLocalPort = 0x1234;
1201
1202 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1203 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1204
1205 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1206 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1207 xSocketToDelete.usLocalPort = usLocalPort;
1208
1209 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1210 xChildSocket.usLocalPort = usLocalPort;
1211 xChildSocket.u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;
1212 xChildSocket.u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
1213
1214 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1215
1216 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1217
1218 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1219
1220 prvTCPSetSocketCount( &xSocketToDelete );
1221 }
1222
1223 /**
1224 * @brief Setting the socket count happy path.
1225 */
test_prvTCPSetSocketCount_ListeningSock_HappyPath1(void)1226 void test_prvTCPSetSocketCount_ListeningSock_HappyPath1( void )
1227 {
1228 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1229 ListItem_t xIterator;
1230 uint16_t usLocalPort = 0x1234;
1231
1232 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1233 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1234
1235 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1236 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1237 xSocketToDelete.usLocalPort = usLocalPort;
1238
1239 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1240 xChildSocket.usLocalPort = usLocalPort;
1241 xChildSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1242 xChildSocket.u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
1243 xChildSocket.xEventGroup = NULL;
1244 xChildSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1245 xChildSocket.u.xTCP.pxAckMessage = NULL;
1246
1247 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1248
1249 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1250
1251 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1252
1253 vTCPWindowDestroy_Expect( &( xChildSocket.u.xTCP.xTCPWindow ) );
1254
1255 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1256
1257 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xChildSocket.xBoundSocketListItem ), NULL );
1258
1259 vPortFree_Expect( &xChildSocket );
1260
1261 prvTCPSetSocketCount( &xSocketToDelete );
1262 }
1263
1264 /**
1265 * @brief Setting the socket count happy path.
1266 */
test_prvTCPSetSocketCount_ListeningSock_HappyPath2(void)1267 void test_prvTCPSetSocketCount_ListeningSock_HappyPath2( void )
1268 {
1269 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1270 ListItem_t xIterator;
1271 uint16_t usLocalPort = 0x1234;
1272
1273 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1274 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1275
1276 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1277 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1278 xSocketToDelete.usLocalPort = usLocalPort;
1279
1280 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1281 xChildSocket.usLocalPort = usLocalPort;
1282 xChildSocket.u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;
1283 xChildSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
1284 xChildSocket.xEventGroup = NULL;
1285 xChildSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1286 xChildSocket.u.xTCP.pxAckMessage = NULL;
1287
1288 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1289
1290 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1291
1292 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1293
1294 vTCPWindowDestroy_Expect( &( xChildSocket.u.xTCP.xTCPWindow ) );
1295
1296 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1297
1298 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xChildSocket.xBoundSocketListItem ), NULL );
1299
1300 vPortFree_Expect( &xChildSocket );
1301
1302 prvTCPSetSocketCount( &xSocketToDelete );
1303 }
1304
1305 /**
1306 * @brief Setting the socket count happy path.
1307 */
test_prvTCPSetSocketCount_ListeningSock_HappyPath3(void)1308 void test_prvTCPSetSocketCount_ListeningSock_HappyPath3( void )
1309 {
1310 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1311 ListItem_t xIterator;
1312 uint16_t usLocalPort = 0x1234;
1313
1314 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1315 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1316
1317 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1318 xSocketToDelete.u.xTCP.eTCPState = eTCP_LISTEN;
1319 xSocketToDelete.usLocalPort = usLocalPort;
1320
1321 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1322 xChildSocket.usLocalPort = usLocalPort;
1323 xChildSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1324 xChildSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
1325 xChildSocket.xEventGroup = NULL;
1326 xChildSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1327 xChildSocket.u.xTCP.pxAckMessage = NULL;
1328
1329 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1330
1331 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1332
1333 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1334
1335 vTCPWindowDestroy_Expect( &( xChildSocket.u.xTCP.xTCPWindow ) );
1336
1337 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1338
1339 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xChildSocket.xBoundSocketListItem ), NULL );
1340
1341 vPortFree_Expect( &xChildSocket );
1342
1343 prvTCPSetSocketCount( &xSocketToDelete );
1344 }
1345
1346 /**
1347 * @brief Set the socket count of a non-listening socket.
1348 */
test_prvTCPSetSocketCount_NotListeningSock_1(void)1349 void test_prvTCPSetSocketCount_NotListeningSock_1( void )
1350 {
1351 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1352 ListItem_t xIterator;
1353 uint16_t usLocalPort = 0x1234;
1354
1355 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1356 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1357
1358 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1359 xSocketToDelete.u.xTCP.eTCPState = eCONNECT_SYN;
1360 xSocketToDelete.usLocalPort = usLocalPort;
1361
1362 xChildSocket.u.xTCP.eTCPState = eCONNECT_SYN;
1363 xChildSocket.u.xTCP.usChildCount = 100;
1364
1365 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1366
1367 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1368
1369 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1370
1371 prvTCPSetSocketCount( &xSocketToDelete );
1372
1373 TEST_ASSERT_EQUAL( 100, xChildSocket.u.xTCP.usChildCount );
1374 }
1375
1376 /**
1377 * @brief Set the socket count of a non-listening socket.
1378 */
test_prvTCPSetSocketCount_NotListeningSock_2(void)1379 void test_prvTCPSetSocketCount_NotListeningSock_2( void )
1380 {
1381 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1382 ListItem_t xIterator;
1383 uint16_t usLocalPort = 0x1234;
1384
1385 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1386 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1387
1388 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1389 xSocketToDelete.u.xTCP.eTCPState = eCONNECT_SYN;
1390 xSocketToDelete.usLocalPort = usLocalPort;
1391
1392 xChildSocket.u.xTCP.eTCPState = eTCP_LISTEN;
1393 xChildSocket.usLocalPort = usLocalPort + 1;
1394 xChildSocket.u.xTCP.usChildCount = 100;
1395
1396 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1397
1398 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1399
1400 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1401
1402 prvTCPSetSocketCount( &xSocketToDelete );
1403
1404 TEST_ASSERT_EQUAL( 100, xChildSocket.u.xTCP.usChildCount );
1405 }
1406
1407 /**
1408 * @brief Set the socket count of a non-listening socket.
1409 */
test_prvTCPSetSocketCount_NotListeningSock_3(void)1410 void test_prvTCPSetSocketCount_NotListeningSock_3( void )
1411 {
1412 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1413 ListItem_t xIterator;
1414 uint16_t usLocalPort = 0x1234;
1415
1416 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1417 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1418
1419 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1420 xSocketToDelete.u.xTCP.eTCPState = eCONNECT_SYN;
1421 xSocketToDelete.usLocalPort = usLocalPort;
1422
1423 xChildSocket.u.xTCP.eTCPState = eTCP_LISTEN;
1424 xChildSocket.usLocalPort = usLocalPort;
1425 xChildSocket.u.xTCP.usChildCount = 0;
1426
1427 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1428
1429 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1430
1431 listGET_NEXT_ExpectAndReturn( &( xIterator ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
1432
1433 prvTCPSetSocketCount( &xSocketToDelete );
1434
1435 TEST_ASSERT_EQUAL( 0, xChildSocket.u.xTCP.usChildCount );
1436 }
1437
1438 /**
1439 * @brief Happy path of setting socket count of a non-listening socket.
1440 */
test_prvTCPSetSocketCount_NotListeningSock_HappyPath(void)1441 void test_prvTCPSetSocketCount_NotListeningSock_HappyPath( void )
1442 {
1443 FreeRTOS_Socket_t xSocketToDelete, xChildSocket;
1444 ListItem_t xIterator;
1445 uint16_t usLocalPort = 0x1234;
1446
1447 memset( &xSocketToDelete, 0, sizeof( xSocketToDelete ) );
1448 memset( &xChildSocket, 0, sizeof( xChildSocket ) );
1449
1450 xSocketToDelete.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1451 xSocketToDelete.u.xTCP.eTCPState = eCONNECT_SYN;
1452 xSocketToDelete.usLocalPort = usLocalPort;
1453
1454 xChildSocket.u.xTCP.eTCPState = eTCP_LISTEN;
1455 xChildSocket.usLocalPort = usLocalPort;
1456 xChildSocket.u.xTCP.usChildCount = 100;
1457
1458 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &( xIterator ) );
1459
1460 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xChildSocket );
1461
1462 prvTCPSetSocketCount( &xSocketToDelete );
1463
1464 TEST_ASSERT_EQUAL( 99, xChildSocket.u.xTCP.usChildCount );
1465 }
1466
1467 /**
1468 * @brief Invalid protocol.
1469 */
test_prvSockopt_so_buffer_InvalidProtocol(void)1470 void test_prvSockopt_so_buffer_InvalidProtocol( void )
1471 {
1472 FreeRTOS_Socket_t xSocket;
1473 int32_t lOptionName;
1474 uint8_t vOptionValue[ sizeof( uintptr_t ) ];
1475 BaseType_t xReturn;
1476
1477 memset( &xSocket, 0, sizeof( xSocket ) );
1478
1479 xReturn = prvSockopt_so_buffer( &xSocket, lOptionName, vOptionValue );
1480
1481 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1482 }
1483
1484 /**
1485 * @brief Invalid option.
1486 */
test_prvSockopt_so_buffer_InvalidOption1(void)1487 void test_prvSockopt_so_buffer_InvalidOption1( void )
1488 {
1489 FreeRTOS_Socket_t xSocket;
1490 int32_t lOptionName;
1491 uint32_t vOptionValue = 0xABCD1234;
1492 BaseType_t xReturn;
1493
1494 memset( &xSocket, 0, sizeof( xSocket ) );
1495
1496 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1497
1498 lOptionName = FREERTOS_SO_SNDBUF;
1499 xSocket.u.xTCP.txStream = NULL;
1500 xSocket.u.xTCP.usMSS = 0x12;
1501
1502 FreeRTOS_round_up_ExpectAndReturn( vOptionValue, xSocket.u.xTCP.usMSS, 0xAB );
1503
1504 xReturn = prvSockopt_so_buffer( &xSocket, lOptionName, &vOptionValue );
1505
1506 TEST_ASSERT_EQUAL( 0, xReturn );
1507 TEST_ASSERT_EQUAL( 0xAB, xSocket.u.xTCP.uxTxStreamSize );
1508 }
1509
1510 /**
1511 * @brief Invalid option.
1512 */
test_prvSockopt_so_buffer_InvalidOption2(void)1513 void test_prvSockopt_so_buffer_InvalidOption2( void )
1514 {
1515 FreeRTOS_Socket_t xSocket;
1516 int32_t lOptionName;
1517 uint8_t vOptionValue[ sizeof( uintptr_t ) ];
1518 BaseType_t xReturn;
1519 StreamBuffer_t xBuffer;
1520
1521 memset( &xSocket, 0, sizeof( xSocket ) );
1522
1523 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1524
1525 lOptionName = FREERTOS_SO_SNDBUF;
1526 xSocket.u.xTCP.txStream = &xBuffer;
1527
1528 xReturn = prvSockopt_so_buffer( &xSocket, lOptionName, vOptionValue );
1529
1530 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1531 }
1532
1533 /**
1534 * @brief Invalid option.
1535 */
test_prvSockopt_so_buffer_InvalidOption3(void)1536 void test_prvSockopt_so_buffer_InvalidOption3( void )
1537 {
1538 FreeRTOS_Socket_t xSocket;
1539 int32_t lOptionName;
1540 uint32_t vOptionValue = 0xABCD1234;
1541 BaseType_t xReturn;
1542
1543 memset( &xSocket, 0, sizeof( xSocket ) );
1544
1545 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1546
1547 lOptionName = FREERTOS_SO_RCVBUF;
1548 xSocket.u.xTCP.rxStream = NULL;
1549
1550 xReturn = prvSockopt_so_buffer( &xSocket, lOptionName, &vOptionValue );
1551
1552 TEST_ASSERT_EQUAL( 0, xReturn );
1553 TEST_ASSERT_EQUAL( vOptionValue, xSocket.u.xTCP.uxRxStreamSize );
1554 }
1555
1556 /**
1557 * @brief Invalid option.
1558 */
test_prvSockopt_so_buffer_InvalidOption4(void)1559 void test_prvSockopt_so_buffer_InvalidOption4( void )
1560 {
1561 FreeRTOS_Socket_t xSocket;
1562 int32_t lOptionName;
1563 uint8_t vOptionValue[ sizeof( uintptr_t ) ];
1564 BaseType_t xReturn;
1565 StreamBuffer_t xBuffer;
1566
1567 memset( &xSocket, 0, sizeof( xSocket ) );
1568
1569 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1570
1571 lOptionName = FREERTOS_SO_RCVBUF;
1572 xSocket.u.xTCP.rxStream = &xBuffer;
1573
1574 xReturn = prvSockopt_so_buffer( &xSocket, lOptionName, vOptionValue );
1575
1576 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1577 }
1578
1579 /**
1580 * @brief Getting private port number fails as RNG fails.
1581 */
test_prvGetPrivatePortNumber_TCP_RNGFails(void)1582 void test_prvGetPrivatePortNumber_TCP_RNGFails( void )
1583 {
1584 uint16_t usReturn;
1585 BaseType_t xProtocol = FREERTOS_IPPROTO_TCP;
1586
1587 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdFALSE );
1588
1589 usReturn = prvGetPrivatePortNumber( xProtocol );
1590
1591 TEST_ASSERT_EQUAL( 0, usReturn );
1592 }
1593
1594 /**
1595 * @brief Port number not received as IP task is not ready.
1596 */
test_prvGetPrivatePortNumber_TCP_IPTaskNotReady(void)1597 void test_prvGetPrivatePortNumber_TCP_IPTaskNotReady( void )
1598 {
1599 uint16_t usReturn;
1600 BaseType_t xProtocol = FREERTOS_IPPROTO_TCP;
1601
1602 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1603
1604 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
1605
1606 usReturn = prvGetPrivatePortNumber( xProtocol );
1607
1608 TEST_ASSERT_EQUAL( 4, usReturn );
1609 }
1610
1611 /**
1612 * @brief Port number acquired success.
1613 */
test_prvGetPrivatePortNumber_TCP_Found(void)1614 void test_prvGetPrivatePortNumber_TCP_Found( void )
1615 {
1616 uint16_t usReturn;
1617 BaseType_t xProtocol = FREERTOS_IPPROTO_TCP;
1618 ListItem_t xLocalListEnd;
1619 ListItem_t xIterator;
1620
1621 xRNGStatus = pdTRUE;
1622 xRandomNumberToReturn = 1234;
1623 TickType_t xWantedItemValue = 53768;
1624
1625 xApplicationGetRandomNumber_Stub( xStubApplicationGetRandomNumber );
1626
1627 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1628
1629 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xIterator );
1630
1631 listGET_LIST_ITEM_VALUE_ExpectAndReturn( &xIterator, xWantedItemValue );
1632
1633 xApplicationGetRandomNumber_Stub( xStubApplicationGetRandomNumber );
1634
1635 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
1636
1637 usReturn = prvGetPrivatePortNumber( xProtocol );
1638
1639 TEST_ASSERT_EQUAL( xWantedItemValue, usReturn );
1640 }
1641
1642 /**
1643 * @brief Port number for UDP fails as RNG fails.
1644 */
test_prvGetPrivatePortNumber_UDP_RNGFails(void)1645 void test_prvGetPrivatePortNumber_UDP_RNGFails( void )
1646 {
1647 uint16_t usReturn;
1648 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP;
1649
1650 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdFALSE );
1651
1652 usReturn = prvGetPrivatePortNumber( xProtocol );
1653
1654 TEST_ASSERT_EQUAL( 0, usReturn );
1655 }
1656
1657 /**
1658 * @brief Don't get a port number as IP task is not ready.
1659 */
test_prvGetPrivatePortNumber_UDP_IPTaskNotReady(void)1660 void test_prvGetPrivatePortNumber_UDP_IPTaskNotReady( void )
1661 {
1662 uint16_t usReturn;
1663 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP;
1664
1665 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1666
1667 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
1668
1669 usReturn = prvGetPrivatePortNumber( xProtocol );
1670
1671 TEST_ASSERT_EQUAL( 4, usReturn );
1672 }
1673
1674 /**
1675 * @brief UDP port number found success.
1676 */
test_prvGetPrivatePortNumber_UDP_Found(void)1677 void test_prvGetPrivatePortNumber_UDP_Found( void )
1678 {
1679 uint16_t usReturn;
1680 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP;
1681 ListItem_t xLocalListEnd;
1682 ListItem_t xIterator;
1683
1684 xRNGStatus = pdTRUE;
1685 xRandomNumberToReturn = 1234;
1686 TickType_t xWantedItemValue = 53768;
1687
1688 xApplicationGetRandomNumber_Stub( xStubApplicationGetRandomNumber );
1689
1690 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1691
1692 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ), &xIterator );
1693
1694 listGET_LIST_ITEM_VALUE_ExpectAndReturn( &xIterator, xWantedItemValue );
1695
1696 xApplicationGetRandomNumber_Stub( xStubApplicationGetRandomNumber );
1697
1698 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
1699
1700 usReturn = prvGetPrivatePortNumber( xProtocol );
1701
1702 TEST_ASSERT_EQUAL( xWantedItemValue, usReturn );
1703 }
1704
1705 /**
1706 * @brief UDP port number not found after all iterations.
1707 */
test_prvGetPrivatePortNumber_UDP_NotFoundAfterAllIterations(void)1708 void test_prvGetPrivatePortNumber_UDP_NotFoundAfterAllIterations( void )
1709 {
1710 uint16_t usReturn;
1711 BaseType_t xProtocol = FREERTOS_IPPROTO_UDP;
1712 ListItem_t xLocalListEnd;
1713 ListItem_t xIterator;
1714
1715 xRNGStatus = pdTRUE;
1716 xRandomNumberToReturn = 1234;
1717 TickType_t xWantedItemValue = 53768;
1718
1719 xApplicationGetRandomNumber_Stub( xStubApplicationGetRandomNumber );
1720
1721 xIPIsNetworkTaskReady_IgnoreAndReturn( pdTRUE );
1722
1723 listGET_NEXT_IgnoreAndReturn( &xIterator );
1724
1725 listGET_LIST_ITEM_VALUE_IgnoreAndReturn( xWantedItemValue );
1726
1727 usReturn = prvGetPrivatePortNumber( xProtocol );
1728
1729 TEST_ASSERT_EQUAL( 0, usReturn );
1730 }
1731
1732 /**
1733 * @brief Finding in a NULL list.
1734 */
test_pxListFindListItemWithValue_NULLList(void)1735 void test_pxListFindListItemWithValue_NULLList( void )
1736 {
1737 const ListItem_t * pxReturn;
1738 List_t xList;
1739 TickType_t xWantedItemValue;
1740
1741 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1742
1743 pxReturn = pxListFindListItemWithValue( NULL, xWantedItemValue );
1744
1745 TEST_ASSERT_EQUAL( NULL, pxReturn );
1746 }
1747
1748 /**
1749 * @brief Finding in a list when IP task is not ready.
1750 */
test_pxListFindListItemWithValue_IPTaskNotReady(void)1751 void test_pxListFindListItemWithValue_IPTaskNotReady( void )
1752 {
1753 const ListItem_t * pxReturn;
1754 List_t xList;
1755 TickType_t xWantedItemValue;
1756
1757 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
1758
1759 pxReturn = pxListFindListItemWithValue( &xList, xWantedItemValue );
1760
1761 TEST_ASSERT_EQUAL( NULL, pxReturn );
1762 }
1763
1764 /**
1765 * @brief Finding in list when there is nothing in the list.
1766 */
test_pxListFindListItemWithValue_ListLengthZero(void)1767 void test_pxListFindListItemWithValue_ListLengthZero( void )
1768 {
1769 const ListItem_t * pxReturn;
1770 List_t xList;
1771 TickType_t xWantedItemValue;
1772
1773 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1774
1775 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xList.xListEnd ), ( ListItem_t * ) &( xList.xListEnd ) );
1776
1777 pxReturn = pxListFindListItemWithValue( &xList, xWantedItemValue );
1778
1779 TEST_ASSERT_EQUAL( NULL, pxReturn );
1780 }
1781
1782 /**
1783 * @brief Value being searched for not found.
1784 */
test_pxListFindListItemWithValue_NotFound(void)1785 void test_pxListFindListItemWithValue_NotFound( void )
1786 {
1787 const ListItem_t * pxReturn;
1788 List_t xList;
1789 ListItem_t xLocalListItem;
1790 TickType_t xWantedItemValue = 0xABAB;
1791
1792 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1793
1794 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xList.xListEnd ), ( ListItem_t * ) &( xLocalListItem ) );
1795
1796 listGET_LIST_ITEM_VALUE_ExpectAndReturn( &( xLocalListItem ), xWantedItemValue - 1 );
1797
1798 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xLocalListItem ), ( ListItem_t * ) &( xList.xListEnd ) );
1799
1800 pxReturn = pxListFindListItemWithValue( &xList, xWantedItemValue );
1801
1802 TEST_ASSERT_EQUAL( NULL, pxReturn );
1803 }
1804
1805 /**
1806 * @brief Value found.
1807 */
test_pxListFindListItemWithValue_Found(void)1808 void test_pxListFindListItemWithValue_Found( void )
1809 {
1810 const ListItem_t * pxReturn;
1811 List_t xList;
1812 ListItem_t xLocalListItem;
1813 TickType_t xWantedItemValue = 0xABAB;
1814
1815 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
1816
1817 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xList.xListEnd ), &( xLocalListItem ) );
1818
1819 listGET_LIST_ITEM_VALUE_ExpectAndReturn( &( xLocalListItem ), xWantedItemValue );
1820
1821 pxReturn = pxListFindListItemWithValue( &xList, xWantedItemValue );
1822
1823 TEST_ASSERT_EQUAL_PTR( &( xLocalListItem ), pxReturn );
1824 }
1825
1826 /**
1827 * @brief Could not find UDP socket.
1828 */
test_pxUDPSocketLookup_NotFound(void)1829 void test_pxUDPSocketLookup_NotFound( void )
1830 {
1831 FreeRTOS_Socket_t * pxReturn;
1832 UBaseType_t uxLocalPort;
1833
1834 vpxListFindListItemWithValue_NotFound();
1835
1836 pxReturn = pxUDPSocketLookup( uxLocalPort );
1837
1838 TEST_ASSERT_EQUAL( NULL, pxReturn );
1839 }
1840
1841 /**
1842 * @brief Found a NULL socket.
1843 */
test_pxUDPSocketLookup_FoundNULLSocket(void)1844 void test_pxUDPSocketLookup_FoundNULLSocket( void )
1845 {
1846 FreeRTOS_Socket_t * pxReturn;
1847 UBaseType_t uxLocalPort = 0xBCDEF;
1848 ListItem_t xListItem;
1849
1850 vpxListFindListItemWithValue_Found( &xBoundUDPSocketsList, uxLocalPort, &xListItem );
1851
1852 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xListItem, NULL );
1853
1854 catch_assert( pxUDPSocketLookup( uxLocalPort ) );
1855 }
1856
1857 /**
1858 * @brief Found a proper UDP socket.
1859 */
test_pxUDPSocketLookup_Found(void)1860 void test_pxUDPSocketLookup_Found( void )
1861 {
1862 FreeRTOS_Socket_t * pxReturn;
1863 UBaseType_t uxLocalPort = 0xBCDEF;
1864 ListItem_t xListItem;
1865 FreeRTOS_Socket_t xLocalSocket;
1866
1867 vpxListFindListItemWithValue_Found( &xBoundUDPSocketsList, uxLocalPort, &xListItem );
1868
1869 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xListItem, &xLocalSocket );
1870
1871 pxReturn = pxUDPSocketLookup( uxLocalPort );
1872
1873 TEST_ASSERT_EQUAL( &xLocalSocket, pxReturn );
1874 }
1875
1876 /**
1877 * @brief Convert ascii values to hexadecimal values.
1878 */
test_ucASCIIToHex(void)1879 void test_ucASCIIToHex( void )
1880 {
1881 uint8_t ucHex, IdealValue;
1882 char ucInput;
1883
1884 ucInput = '0';
1885 IdealValue = 0;
1886
1887 for( int i = 0; i <= 9; i++ )
1888 {
1889 ucHex = ucASCIIToHex( ucInput + i );
1890 TEST_ASSERT_EQUAL( IdealValue + i, ucHex );
1891 }
1892
1893 ucInput = 'a';
1894 IdealValue = 10;
1895
1896 for( int i = 0; i < 6; i++ )
1897 {
1898 ucHex = ucASCIIToHex( ucInput + i );
1899 TEST_ASSERT_EQUAL( IdealValue + i, ucHex );
1900 }
1901
1902 ucInput = 'A';
1903 IdealValue = 10;
1904
1905 for( int i = 0; i < 6; i++ )
1906 {
1907 ucHex = ucASCIIToHex( ucInput + i );
1908 TEST_ASSERT_EQUAL( IdealValue + i, ucHex );
1909 }
1910
1911 for( char i = 0; ; i++ )
1912 {
1913 if( !( ( ( i >= 'a' ) && ( i <= 'f' ) ) ||
1914 ( ( i >= 'A' ) && ( i <= 'F' ) ) ||
1915 ( ( i >= '0' ) && ( i <= '9' ) ) ) )
1916 {
1917 ucHex = ucASCIIToHex( i );
1918 TEST_ASSERT_EQUAL( 0xFF, ucHex );
1919 }
1920
1921 if( i == 125 )
1922 {
1923 break;
1924 }
1925 }
1926 }
1927
1928 /**
1929 * @brief All fields NULL of socket.
1930 */
test_vSocketWakeUpUser_AllNULL(void)1931 void test_vSocketWakeUpUser_AllNULL( void )
1932 {
1933 FreeRTOS_Socket_t xSocket;
1934
1935 memset( &xSocket, 0, sizeof( xSocket ) );
1936
1937 vSocketWakeUpUser( &xSocket );
1938
1939 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
1940 }
1941
1942 /**
1943 * @brief All fields are assigned of the socket.
1944 */
test_vSocketWakeUpUser_AllNonNULL(void)1945 void test_vSocketWakeUpUser_AllNonNULL( void )
1946 {
1947 FreeRTOS_Socket_t xSocket;
1948 uint8_t xLocalSemaphore[ sizeof( xSocket.pxUserSemaphore ) ];
1949 uint8_t xLocalSocketSet[ sizeof( xSocket.pxSocketSet ) ];
1950 uint8_t xLocalEventGroup[ sizeof( xSocket.xEventGroup ) ];
1951
1952 uxGlobalCallbackCount = 0;
1953 memset( &xSocket, 0, sizeof( xSocket ) );
1954
1955 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) xLocalSemaphore;
1956 xSocket.pxUserWakeCallback = vUserCallbackLocal;
1957 xSocket.pxSocketSet = ( SocketSelect_t * ) xLocalSocketSet;
1958 xSocket.xEventGroup = ( EventGroupHandle_t ) xLocalEventGroup;
1959
1960 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
1961
1962 vSocketWakeUpUser( &xSocket );
1963
1964 TEST_ASSERT_EQUAL( 1, uxGlobalCallbackCount );
1965 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
1966 }
1967
1968 /**
1969 * @brief Event bits are set for the socket.
1970 */
test_vSocketWakeUpUser_AllNonNULL_EventBitsSet(void)1971 void test_vSocketWakeUpUser_AllNonNULL_EventBitsSet( void )
1972 {
1973 FreeRTOS_Socket_t xSocket;
1974 uint8_t xLocalSemaphore[ sizeof( xSocket.pxUserSemaphore ) ];
1975 uint8_t xLocalSocketSet[ sizeof( xSocket.pxSocketSet ) ];
1976 uint8_t xLocalEventGroup[ sizeof( xSocket.xEventGroup ) ];
1977
1978 uxGlobalCallbackCount = 0;
1979 memset( &xSocket, 0, sizeof( xSocket ) );
1980
1981 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) xLocalSemaphore;
1982 xSocket.pxUserWakeCallback = vUserCallbackLocal;
1983 xSocket.pxSocketSet = ( SocketSelect_t * ) xLocalSocketSet;
1984 xSocket.xEventGroup = ( EventGroupHandle_t ) xLocalEventGroup;
1985
1986 xSocket.xEventBits = ( eSOCKET_ALL << SOCKET_EVENT_BIT_COUNT ) | eSOCKET_ALL;
1987
1988 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
1989
1990 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSOCKET_ALL & eSELECT_ALL, pdPASS );
1991 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_ALL, pdPASS );
1992
1993 vSocketWakeUpUser( &xSocket );
1994
1995 TEST_ASSERT_EQUAL( 1, uxGlobalCallbackCount );
1996 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
1997 }
1998
1999 /**
2000 * @brief Test all states of which may connect.
2001 */
test_bMayConnect(void)2002 void test_bMayConnect( void )
2003 {
2004 BaseType_t xReturn;
2005 FreeRTOS_Socket_t xSocket;
2006
2007 memset( &xSocket, 0, sizeof( xSocket ) );
2008
2009 xSocket.u.xTCP.eTCPState = eCLOSED;
2010 xReturn = bMayConnect( &xSocket );
2011 TEST_ASSERT_EQUAL( 0, xReturn );
2012
2013 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT;
2014 xReturn = bMayConnect( &xSocket );
2015 TEST_ASSERT_EQUAL( 0, xReturn );
2016
2017 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
2018 xReturn = bMayConnect( &xSocket );
2019 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINPROGRESS, xReturn );
2020
2021 xSocket.u.xTCP.eTCPState = eTCP_LISTEN;
2022 xReturn = bMayConnect( &xSocket );
2023 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2024
2025 xSocket.u.xTCP.eTCPState = eSYN_FIRST;
2026 xReturn = bMayConnect( &xSocket );
2027 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2028
2029 xSocket.u.xTCP.eTCPState = eSYN_RECEIVED;
2030 xReturn = bMayConnect( &xSocket );
2031 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2032
2033 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2034 xReturn = bMayConnect( &xSocket );
2035 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2036
2037 xSocket.u.xTCP.eTCPState = eFIN_WAIT_1;
2038 xReturn = bMayConnect( &xSocket );
2039 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2040
2041 xSocket.u.xTCP.eTCPState = eFIN_WAIT_2;
2042 xReturn = bMayConnect( &xSocket );
2043 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2044
2045 xSocket.u.xTCP.eTCPState = eCLOSING;
2046 xReturn = bMayConnect( &xSocket );
2047 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2048
2049 xSocket.u.xTCP.eTCPState = eLAST_ACK;
2050 xReturn = bMayConnect( &xSocket );
2051 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2052
2053 xSocket.u.xTCP.eTCPState = eTIME_WAIT;
2054 xReturn = bMayConnect( &xSocket );
2055 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAGAIN, xReturn );
2056 }
2057
2058 /**
2059 * @brief Try to connect to NULL address.
2060 */
test_prvTCPConnectStart_AddressNULL(void)2061 void test_prvTCPConnectStart_AddressNULL( void )
2062 {
2063 BaseType_t xReturn;
2064 FreeRTOS_Socket_t xSocket;
2065 struct freertos_sockaddr xAddress;
2066
2067 memset( &xSocket, 0, sizeof( xSocket ) );
2068 memset( &xAddress, 0, sizeof( xAddress ) );
2069
2070 xReturn = prvTCPConnectStart( &xSocket, NULL );
2071
2072 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2073 }
2074
2075 /**
2076 * @brief Trying to connect with a invalid socket.
2077 */
test_prvTCPConnectStart_InvalidSocket(void)2078 void test_prvTCPConnectStart_InvalidSocket( void )
2079 {
2080 BaseType_t xReturn;
2081 FreeRTOS_Socket_t xSocket;
2082 struct freertos_sockaddr xAddress;
2083
2084 memset( &xSocket, 0, sizeof( xSocket ) );
2085 memset( &xAddress, 0, sizeof( xAddress ) );
2086
2087 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2088
2089 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EBADF, xReturn );
2090 }
2091
2092 /**
2093 * @brief Trying to connect an already connected socket.
2094 */
test_prvTCPConnectStart_SocketAlreadyConnected(void)2095 void test_prvTCPConnectStart_SocketAlreadyConnected( void )
2096 {
2097 BaseType_t xReturn;
2098 FreeRTOS_Socket_t xSocket;
2099 struct freertos_sockaddr xAddress;
2100
2101 memset( &xSocket, 0, sizeof( xSocket ) );
2102 memset( &xAddress, 0, sizeof( xAddress ) );
2103
2104 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2105 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2106
2107 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2108
2109 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EISCONN, xReturn );
2110 }
2111
2112 /**
2113 * @brief Connecting with an unbound socket.
2114 */
test_prvTCPConnectStart_SocketNotBound_Success(void)2115 void test_prvTCPConnectStart_SocketNotBound_Success( void )
2116 {
2117 BaseType_t xReturn;
2118 FreeRTOS_Socket_t xSocket;
2119 struct freertos_sockaddr xAddress;
2120
2121 memset( &xSocket, 0, sizeof( xSocket ) );
2122 memset( &xAddress, 0, sizeof( xAddress ) );
2123
2124 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2125
2126 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2127
2128 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
2129
2130 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2131
2132 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
2133
2134 xEventGroupWaitBits_ExpectAnyArgsAndReturn( pdPASS );
2135
2136 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), &xBoundTCPSocketsList );
2137
2138 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2139
2140 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2141
2142 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2143
2144 TEST_ASSERT_EQUAL( 0, xReturn );
2145 }
2146
2147 /**
2148 * @brief Connecting with an unbound IPv6 socket.
2149 */
test_prvTCPConnectStart_IPv6SocketNotBound_Success(void)2150 void test_prvTCPConnectStart_IPv6SocketNotBound_Success( void )
2151 {
2152 BaseType_t xReturn;
2153 FreeRTOS_Socket_t xSocket;
2154 struct freertos_sockaddr xAddress;
2155
2156 memset( &xSocket, 0, sizeof( xSocket ) );
2157 memset( &xAddress, 0, sizeof( xAddress ) );
2158
2159 xAddress.sin_family = FREERTOS_AF_INET6;
2160 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2161
2162 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2163
2164 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
2165
2166 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2167
2168 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
2169
2170 xEventGroupWaitBits_ExpectAnyArgsAndReturn( pdPASS );
2171
2172 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), &xBoundTCPSocketsList );
2173
2174 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2175
2176 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2177
2178 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2179
2180 TEST_ASSERT_EQUAL( 0, xReturn );
2181 TEST_ASSERT_EQUAL( pdTRUE, xSocket.bits.bIsIPv6 );
2182 }
2183
2184 /**
2185 * @brief Connecting with an unbound socket. Sending to IP task fails.
2186 */
test_prvTCPConnectStart_SocketNotBound_Failure(void)2187 void test_prvTCPConnectStart_SocketNotBound_Failure( void )
2188 {
2189 BaseType_t xReturn;
2190 FreeRTOS_Socket_t xSocket;
2191 struct freertos_sockaddr xAddress;
2192
2193 memset( &xSocket, 0, sizeof( xSocket ) );
2194 memset( &xAddress, 0, sizeof( xAddress ) );
2195
2196 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2197
2198 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2199
2200 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
2201
2202 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2203
2204 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
2205
2206 xEventGroupWaitBits_ExpectAnyArgsAndReturn( pdPASS );
2207
2208 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), &xBoundTCPSocketsList );
2209
2210 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2211
2212 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdFAIL );
2213
2214 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2215
2216 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ECANCELED, xReturn );
2217 }
2218
2219 /**
2220 * @brief Connecting with an unbound socket. Connection is in progress.
2221 */
test_prvTCPConnectStart_SocketNotBound_Failure2(void)2222 void test_prvTCPConnectStart_SocketNotBound_Failure2( void )
2223 {
2224 BaseType_t xReturn;
2225 FreeRTOS_Socket_t xSocket;
2226 struct freertos_sockaddr xAddress;
2227
2228 memset( &xSocket, 0, sizeof( xSocket ) );
2229 memset( &xAddress, 0, sizeof( xAddress ) );
2230
2231 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2232 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
2233
2234 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2235
2236 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
2237
2238 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
2239
2240 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdPASS );
2241
2242 xEventGroupWaitBits_ExpectAnyArgsAndReturn( pdPASS );
2243
2244 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), &xBoundTCPSocketsList );
2245
2246 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2247
2248 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINPROGRESS, xReturn );
2249 }
2250
2251 /**
2252 * @brief Socket is already bound and is trying to connect.
2253 */
test_prvTCPConnectStart_SocketBound_Failure(void)2254 void test_prvTCPConnectStart_SocketBound_Failure( void )
2255 {
2256 BaseType_t xReturn;
2257 FreeRTOS_Socket_t xSocket;
2258 struct freertos_sockaddr xAddress;
2259
2260 memset( &xSocket, 0, sizeof( xSocket ) );
2261 memset( &xAddress, 0, sizeof( xAddress ) );
2262
2263 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2264 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
2265
2266 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), &xBoundTCPSocketsList );
2267
2268 xReturn = prvTCPConnectStart( &xSocket, &xAddress );
2269
2270 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINPROGRESS, xReturn );
2271 }
2272
2273 /**
2274 * @brief invalid values.
2275 */
test_prvTCPSendCheck_InvalidValues(void)2276 void test_prvTCPSendCheck_InvalidValues( void )
2277 {
2278 int32_t lReturn;
2279 FreeRTOS_Socket_t xSocket;
2280 size_t uxDataLength;
2281 uint8_t ucStream[ 1500 ];
2282 eIPTCPState_t array[] = { eCLOSED, eCLOSE_WAIT, eCLOSING };
2283 StreamBuffer_t xLocalStreamBuffer;
2284
2285 memset( &xSocket, 0, sizeof( xSocket ) );
2286
2287 /* Invalid protocol. */
2288 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2289 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2290 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, lReturn );
2291
2292 /* Unbound socket. */
2293 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
2294 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2295 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2296 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, lReturn );
2297
2298 /* No memory. */
2299 xSocket.u.xTCP.bits.bMallocError = pdTRUE;
2300 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2301 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2302 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2303 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOMEM, lReturn );
2304
2305 /* Invalid states. */
2306 xSocket.u.xTCP.bits.bMallocError = pdFALSE;
2307 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2308
2309 for( unsigned int i = 0; i < sizeof( array ) / sizeof( eIPTCPState_t ); i++ )
2310 {
2311 xSocket.u.xTCP.eTCPState = array[ i ];
2312 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2313 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2314 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, lReturn );
2315 }
2316
2317 /* Closing connection. */
2318 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2319 xSocket.u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;
2320 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2321 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2322 TEST_ASSERT_EQUAL( 0, lReturn );
2323
2324 /* 0 data length. */
2325 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2326 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
2327 uxDataLength = 0;
2328 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2329 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2330 TEST_ASSERT_EQUAL( 0, lReturn );
2331
2332 /* Could not allocate a stream. */
2333 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2334 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
2335 uxDataLength = 10;
2336 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2337 pvPortMalloc_ExpectAnyArgsAndReturn( NULL );
2338 vTCPStateChange_ExpectAnyArgs();
2339 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2340 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOMEM, lReturn );
2341
2342 /* Allocate a stream. */
2343 memset( &xSocket, 0, sizeof( xSocket ) );
2344 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2345 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2346 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
2347 uxDataLength = 10;
2348 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2349 size_t xSizeOfBufferRequested = ( ( sizeof( size_t ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xLocalStreamBuffer ) ) - sizeof( xLocalStreamBuffer.ucArray );
2350 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
2351 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2352 TEST_ASSERT_EQUAL( 1, lReturn );
2353 TEST_ASSERT_EQUAL( ( sizeof( size_t ) & ( ~( sizeof( size_t ) - 1U ) ) ), ( ( StreamBuffer_t * ) ucStream )->LENGTH );
2354 TEST_ASSERT_EQUAL( ucStream, xSocket.u.xTCP.txStream );
2355
2356 /* Already allocated a stream. */
2357 memset( &xSocket, 0, sizeof( xSocket ) );
2358 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2359 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2360 xSocket.u.xTCP.bits.bFinSent = pdFALSE_UNSIGNED;
2361 xSocket.u.xTCP.txStream = &xLocalStreamBuffer;
2362 uxDataLength = 10;
2363 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2364 lReturn = prvTCPSendCheck( &xSocket, uxDataLength );
2365 TEST_ASSERT_EQUAL( 1, lReturn );
2366 }
2367
2368 /**
2369 * @brief Bound TCP socket list is empty.
2370 */
test_xTCPTimerCheck_EmptyList(void)2371 void test_xTCPTimerCheck_EmptyList( void )
2372 {
2373 TickType_t xReturn;
2374 BaseType_t xWillSleep = pdFALSE;
2375
2376 xTaskGetTickCount_ExpectAndReturn( 0 );
2377
2378 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2379
2380 xReturn = xTCPTimerCheck( xWillSleep );
2381
2382 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 1000 ), xReturn );
2383 }
2384
2385 /**
2386 * @brief Socket checking results in an error.
2387 */
test_xTCPTimerCheck_NonEmptyList_SocketCheckError(void)2388 void test_xTCPTimerCheck_NonEmptyList_SocketCheckError( void )
2389 {
2390 TickType_t xReturn;
2391 BaseType_t xWillSleep = pdFALSE;
2392 ListItem_t xLocalListItem;
2393 FreeRTOS_Socket_t xSocket;
2394
2395 memset( &xSocket, 0, sizeof( xSocket ) );
2396 xSocket.u.xTCP.usTimeout = 10;
2397
2398 xTaskGetTickCount_ExpectAndReturn( 100 );
2399
2400 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2401
2402 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2403
2404 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2405
2406 xTCPSocketCheck_ExpectAndReturn( &xSocket, -1 );
2407
2408 xReturn = xTCPTimerCheck( xWillSleep );
2409
2410 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 1000 ), xReturn );
2411 }
2412
2413 /**
2414 * @brief Socket checking successful.
2415 */
test_xTCPTimerCheck_NonEmptyList_NoError(void)2416 void test_xTCPTimerCheck_NonEmptyList_NoError( void )
2417 {
2418 TickType_t xReturn;
2419 BaseType_t xWillSleep = pdFALSE;
2420 ListItem_t xLocalListItem;
2421 FreeRTOS_Socket_t xSocket;
2422
2423 memset( &xSocket, 0, sizeof( xSocket ) );
2424
2425 xSocket.u.xTCP.usTimeout = 10;
2426
2427 xTaskGetTickCount_ExpectAndReturn( 100 );
2428
2429 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2430
2431 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2432
2433 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2434
2435 xTCPSocketCheck_ExpectAndReturn( &xSocket, 0 );
2436
2437 xReturn = xTCPTimerCheck( xWillSleep );
2438
2439 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 1000 ), xReturn );
2440 }
2441
2442 /**
2443 * @brief Delta of times is less than the timeout value.
2444 */
test_xTCPTimerCheck_NonEmptyList_DeltaLessThanTimeout(void)2445 void test_xTCPTimerCheck_NonEmptyList_DeltaLessThanTimeout( void )
2446 {
2447 TickType_t xReturn;
2448 BaseType_t xWillSleep;
2449 ListItem_t xLocalListItem;
2450 FreeRTOS_Socket_t xSocket, xTimeOutZeroSocket;
2451
2452 memset( &xSocket, 0, sizeof( xSocket ) );
2453 memset( &xTimeOutZeroSocket, 0, sizeof( xTimeOutZeroSocket ) );
2454
2455 xSocket.u.xTCP.usTimeout = 10;
2456
2457 xTaskGetTickCount_ExpectAndReturn( 0 );
2458
2459 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2460
2461 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xTimeOutZeroSocket );
2462
2463 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2464
2465 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2466
2467 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2468
2469 xReturn = xTCPTimerCheck( xWillSleep );
2470
2471 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 9 ), xReturn );
2472 TEST_ASSERT_EQUAL( 9, xSocket.u.xTCP.usTimeout );
2473 }
2474
2475 /**
2476 * @brief Delta of times is less than the timeout value.
2477 */
test_xTCPTimerCheck_NonEmptyList_DeltaLessThanTimeout1(void)2478 void test_xTCPTimerCheck_NonEmptyList_DeltaLessThanTimeout1( void )
2479 {
2480 TickType_t xReturn;
2481 BaseType_t xWillSleep;
2482 ListItem_t xLocalListItem;
2483 FreeRTOS_Socket_t xSocket, xTimeOutZeroSocket;
2484
2485 memset( &xSocket, 0, sizeof( xSocket ) );
2486 memset( &xTimeOutZeroSocket, 0, sizeof( xTimeOutZeroSocket ) );
2487
2488 xSocket.u.xTCP.usTimeout = 1008;
2489
2490 xTaskGetTickCount_ExpectAndReturn( 0 );
2491
2492 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2493
2494 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xTimeOutZeroSocket );
2495
2496 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2497
2498 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2499
2500 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2501
2502 xReturn = xTCPTimerCheck( xWillSleep );
2503
2504 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 1000 ), xReturn );
2505 TEST_ASSERT_EQUAL( 1007, xSocket.u.xTCP.usTimeout );
2506 }
2507
2508 /**
2509 * @brief Event bits are non-zero and will sleep flag is reset.
2510 */
test_xTCPTimerCheck_EventBitsNonZeroWontSleep(void)2511 void test_xTCPTimerCheck_EventBitsNonZeroWontSleep( void )
2512 {
2513 TickType_t xReturn;
2514 BaseType_t xWillSleep = 0;
2515 ListItem_t xLocalListItem;
2516 FreeRTOS_Socket_t xSocket, xTimeOutZeroSocket;
2517
2518 memset( &xSocket, 0, sizeof( xSocket ) );
2519 memset( &xTimeOutZeroSocket, 0, sizeof( xTimeOutZeroSocket ) );
2520
2521 xSocket.u.xTCP.usTimeout = 1008;
2522 xSocket.xEventBits = 12;
2523
2524 xTaskGetTickCount_ExpectAndReturn( 0 );
2525
2526 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2527
2528 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xTimeOutZeroSocket );
2529
2530 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2531
2532 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2533
2534 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2535
2536 xReturn = xTCPTimerCheck( xWillSleep );
2537
2538 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 0 ), xReturn );
2539 TEST_ASSERT_EQUAL( 1007, xSocket.u.xTCP.usTimeout );
2540 }
2541
2542 /**
2543 * @brief Event bits are non-zero and will sleep flag is set.
2544 */
test_xTCPTimerCheck_EventBitsNonZeroWillSleep(void)2545 void test_xTCPTimerCheck_EventBitsNonZeroWillSleep( void )
2546 {
2547 TickType_t xReturn;
2548 BaseType_t xWillSleep = pdTRUE;
2549 ListItem_t xLocalListItem;
2550 FreeRTOS_Socket_t xSocket, xTimeOutZeroSocket;
2551
2552 memset( &xSocket, 0, sizeof( xSocket ) );
2553 memset( &xTimeOutZeroSocket, 0, sizeof( xTimeOutZeroSocket ) );
2554
2555 xSocket.u.xTCP.usTimeout = 1008;
2556 xSocket.xEventBits = 12;
2557
2558 xTaskGetTickCount_ExpectAndReturn( 0 );
2559
2560 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalListItem );
2561
2562 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xTimeOutZeroSocket );
2563
2564 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2565
2566 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2567
2568 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2569
2570 xReturn = xTCPTimerCheck( xWillSleep );
2571
2572 TEST_ASSERT_EQUAL( pdMS_TO_TICKS( ( TickType_t ) 1000 ), xReturn );
2573 TEST_ASSERT_EQUAL( 1007, xSocket.u.xTCP.usTimeout );
2574 }
2575
2576 /**
2577 * @brief Found a matching socket in lookup.
2578 */
test_pxTCPSocketLookup_FoundAMatch(void)2579 void test_pxTCPSocketLookup_FoundAMatch( void )
2580 {
2581 FreeRTOS_Socket_t * pxReturn, xSocket, xMatchingSocket;
2582 uint32_t ulLocalIP = 0xAABBCCDD;
2583 UBaseType_t uxLocalPort = 0x1234;
2584 IPv46_Address_t xRemoteIP;
2585
2586 xRemoteIP.xIs_IPv6 = pdFALSE;
2587 xRemoteIP.xIPAddress.ulIP_IPv4 = 0xBCBCDCDC;
2588 UBaseType_t uxRemotePort = 0x4567;
2589 ListItem_t xLocalListItem;
2590
2591 memset( &xSocket, 0, sizeof( xSocket ) );
2592 memset( &xMatchingSocket, 0, sizeof( xMatchingSocket ) );
2593
2594 xMatchingSocket.usLocalPort = uxLocalPort;
2595 xMatchingSocket.u.xTCP.usRemotePort = uxRemotePort;
2596 xMatchingSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = xRemoteIP.xIPAddress.ulIP_IPv4;
2597
2598 /* First iteration, no match. */
2599 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
2600 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2601
2602 /* Second iteration and we have a match. */
2603 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2604 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xMatchingSocket );
2605
2606 pxReturn = pxTCPSocketLookup( ulLocalIP, uxLocalPort, xRemoteIP, uxRemotePort );
2607
2608 TEST_ASSERT_EQUAL_PTR( &xMatchingSocket, pxReturn );
2609 }
2610
2611 /**
2612 * @brief No match found while looking up a socket. IP doesn't match.
2613 */
test_pxTCPSocketLookup_NoMatch(void)2614 void test_pxTCPSocketLookup_NoMatch( void )
2615 {
2616 FreeRTOS_Socket_t * pxReturn, xSocket, xMatchingSocket;
2617 uint32_t ulLocalIP = 0xAABBCCDD;
2618 UBaseType_t uxLocalPort = 0x1234;
2619 IPv46_Address_t xRemoteIP;
2620
2621 xRemoteIP.xIs_IPv6 = pdFALSE;
2622 xRemoteIP.xIPAddress.ulIP_IPv4 = 0xBCBCDCDC;
2623 UBaseType_t uxRemotePort = 0x4567;
2624 ListItem_t xLocalListItem;
2625
2626 memset( &xSocket, 0, sizeof( xSocket ) );
2627 memset( &xMatchingSocket, 0, sizeof( xMatchingSocket ) );
2628
2629 xMatchingSocket.usLocalPort = uxLocalPort;
2630 xMatchingSocket.u.xTCP.usRemotePort = uxRemotePort;
2631 xMatchingSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = xRemoteIP.xIPAddress.ulIP_IPv4 + 1;
2632
2633 /* First iteration, no match. */
2634 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
2635 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2636
2637 /* Second iteration and we have a match. */
2638 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2639 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xMatchingSocket );
2640
2641 /* Third iteration. */
2642 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2643
2644 pxReturn = pxTCPSocketLookup( ulLocalIP, uxLocalPort, xRemoteIP, uxRemotePort );
2645
2646 TEST_ASSERT_EQUAL_PTR( NULL, pxReturn );
2647 }
2648
2649 /**
2650 * @brief No match found while looking up a socket. IP and port number doesn't match.
2651 */
test_pxTCPSocketLookup_NoMatch2(void)2652 void test_pxTCPSocketLookup_NoMatch2( void )
2653 {
2654 FreeRTOS_Socket_t * pxReturn, xSocket, xMatchingSocket;
2655 uint32_t ulLocalIP = 0xAABBCCDD;
2656 UBaseType_t uxLocalPort = 0x1234;
2657 IPv46_Address_t xRemoteIP;
2658
2659 xRemoteIP.xIs_IPv6 = pdFALSE;
2660 xRemoteIP.xIPAddress.ulIP_IPv4 = 0xBCBCDCDC;
2661 UBaseType_t uxRemotePort = 0x4567;
2662 ListItem_t xLocalListItem;
2663
2664 memset( &xSocket, 0, sizeof( xSocket ) );
2665 memset( &xMatchingSocket, 0, sizeof( xMatchingSocket ) );
2666
2667 xMatchingSocket.usLocalPort = uxLocalPort;
2668 xMatchingSocket.u.xTCP.usRemotePort = uxRemotePort + 1;
2669 xMatchingSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = xRemoteIP.xIPAddress.ulIP_IPv4 + 1;
2670
2671 /* First iteration, no match. */
2672 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
2673 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2674
2675 /* Second iteration and we have a match. */
2676 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2677 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xMatchingSocket );
2678
2679 /* Third iteration. */
2680 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2681
2682 pxReturn = pxTCPSocketLookup( ulLocalIP, uxLocalPort, xRemoteIP, uxRemotePort );
2683
2684 TEST_ASSERT_EQUAL_PTR( NULL, pxReturn );
2685 }
2686
2687 /**
2688 * @brief Found a partial match based on IP.
2689 */
test_pxTCPSocketLookup_FoundAPartialMatch(void)2690 void test_pxTCPSocketLookup_FoundAPartialMatch( void )
2691 {
2692 FreeRTOS_Socket_t * pxReturn, xSocket, xMatchingSocket;
2693 uint32_t ulLocalIP = 0xAABBCCDD;
2694 UBaseType_t uxLocalPort = 0x1234;
2695 IPv46_Address_t xRemoteIP;
2696
2697 xRemoteIP.xIs_IPv6 = pdFALSE;
2698 xRemoteIP.xIPAddress.ulIP_IPv4 = 0xBCBCDCDC;
2699 UBaseType_t uxRemotePort = 0x4567;
2700 ListItem_t xLocalListItem;
2701
2702 memset( &xSocket, 0, sizeof( xSocket ) );
2703 memset( &xMatchingSocket, 0, sizeof( xMatchingSocket ) );
2704
2705 xMatchingSocket.usLocalPort = uxLocalPort;
2706 xMatchingSocket.u.xTCP.usRemotePort = uxRemotePort + 1;
2707 xMatchingSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = xRemoteIP.xIPAddress.ulIP_IPv4;
2708 xMatchingSocket.u.xTCP.eTCPState = eTCP_LISTEN;
2709
2710 /* First iteration, no match. */
2711 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
2712 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2713
2714 /* Second iteration and we have a partial match. */
2715 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2716 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xMatchingSocket );
2717
2718 /* Third iteration. */
2719 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
2720
2721 pxReturn = pxTCPSocketLookup( ulLocalIP, uxLocalPort, xRemoteIP, uxRemotePort );
2722
2723 TEST_ASSERT_EQUAL_PTR( &xMatchingSocket, pxReturn );
2724 }
2725
2726 /**
2727 * @brief Found a match socket based on IPv6.
2728 */
test_pxTCPSocketLookup_IPv6Match(void)2729 void test_pxTCPSocketLookup_IPv6Match( void )
2730 {
2731 FreeRTOS_Socket_t * pxReturn, xSocket, xMatchingSocket;
2732 uint32_t ulLocalIP = 0xAABBCCDD;
2733 UBaseType_t uxLocalPort = 0x1234;
2734 IPv46_Address_t xRemoteIP;
2735 UBaseType_t uxRemotePort = 0x4567;
2736 ListItem_t xLocalListItem;
2737
2738 memset( &xSocket, 0, sizeof( xSocket ) );
2739 memset( &xRemoteIP, 0, sizeof( xRemoteIP ) );
2740 memset( &xMatchingSocket, 0, sizeof( xMatchingSocket ) );
2741
2742 xRemoteIP.xIs_IPv6 = pdTRUE;
2743 memcpy( xRemoteIP.xIPAddress.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2744
2745 xMatchingSocket.usLocalPort = uxLocalPort;
2746 xMatchingSocket.u.xTCP.usRemotePort = uxRemotePort;
2747 memcpy( xMatchingSocket.u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2748
2749 /* First iteration, no match. */
2750 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
2751 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
2752
2753 /* Second iteration and we have a match. */
2754 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
2755 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xMatchingSocket );
2756 pxTCPSocketLookup_IPv6_ExpectAndReturn( &xMatchingSocket, NULL, &xMatchingSocket );
2757 pxTCPSocketLookup_IPv6_IgnoreArg_pxAddress();
2758
2759 pxReturn = pxTCPSocketLookup( ulLocalIP, uxLocalPort, xRemoteIP, uxRemotePort );
2760
2761 TEST_ASSERT_EQUAL_PTR( &xMatchingSocket, pxReturn );
2762 }
2763
2764 /**
2765 * @brief Low and high space fields zero.
2766 */
test_prvTCPCreateStream(void)2767 void test_prvTCPCreateStream( void )
2768 {
2769 StreamBuffer_t * pxReturn;
2770 FreeRTOS_Socket_t xSocket;
2771 BaseType_t xIsInputStream = pdTRUE;
2772 uint8_t ucStream[ ipconfigTCP_MSS ];
2773
2774 memset( &xSocket, 0, sizeof( xSocket ) );
2775
2776 xSocket.u.xTCP.uxRxStreamSize = 20;
2777 xSocket.u.xTCP.usMSS = 2;
2778 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( *pxReturn ) ) - sizeof( pxReturn->ucArray );
2779
2780 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ( StreamBuffer_t * ) ucStream );
2781
2782 pxReturn = prvTCPCreateStream( &xSocket, xIsInputStream );
2783
2784 TEST_ASSERT_EQUAL( 4, xSocket.u.xTCP.uxLittleSpace );
2785 TEST_ASSERT_EQUAL( 16, xSocket.u.xTCP.uxEnoughSpace );
2786 TEST_ASSERT_EQUAL( ucStream, xSocket.u.xTCP.rxStream );
2787 }
2788
2789 /**
2790 * @brief Low and high space fields zero.
2791 */
test_prvTCPCreateStream1(void)2792 void test_prvTCPCreateStream1( void )
2793 {
2794 StreamBuffer_t * pxReturn;
2795 FreeRTOS_Socket_t xSocket;
2796 BaseType_t xIsInputStream = pdTRUE;
2797 uint8_t ucStream[ ipconfigTCP_MSS ];
2798
2799 memset( &xSocket, 0, sizeof( xSocket ) );
2800
2801 xSocket.u.xTCP.uxRxStreamSize = 0;
2802 xSocket.u.xTCP.usMSS = 2;
2803 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( *pxReturn ) ) - sizeof( pxReturn->ucArray );
2804
2805 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ( StreamBuffer_t * ) ucStream );
2806
2807 pxReturn = prvTCPCreateStream( &xSocket, xIsInputStream );
2808
2809 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.uxLittleSpace );
2810 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.uxEnoughSpace );
2811 TEST_ASSERT_EQUAL( ucStream, xSocket.u.xTCP.rxStream );
2812 }
2813
2814 /**
2815 * @brief Low and high space fields non-zero.
2816 */
test_prvTCPCreateStream_LowAndHighFieldsDefined(void)2817 void test_prvTCPCreateStream_LowAndHighFieldsDefined( void )
2818 {
2819 StreamBuffer_t * pxReturn;
2820 FreeRTOS_Socket_t xSocket;
2821 BaseType_t xIsInputStream = pdTRUE;
2822 uint8_t ucStream[ ipconfigTCP_MSS ];
2823
2824 memset( &xSocket, 0, sizeof( xSocket ) );
2825
2826 xSocket.u.xTCP.uxRxStreamSize = 20;
2827 xSocket.u.xTCP.uxLittleSpace = 3;
2828 xSocket.u.xTCP.uxEnoughSpace = 17;
2829 xSocket.u.xTCP.usMSS = 10;
2830
2831 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( *pxReturn ) ) - sizeof( pxReturn->ucArray );
2832
2833 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ( StreamBuffer_t * ) ucStream );
2834
2835 pxReturn = prvTCPCreateStream( &xSocket, xIsInputStream );
2836
2837 TEST_ASSERT_EQUAL( 3, xSocket.u.xTCP.uxLittleSpace );
2838 TEST_ASSERT_EQUAL( 17, xSocket.u.xTCP.uxEnoughSpace );
2839 TEST_ASSERT_EQUAL( ucStream, xSocket.u.xTCP.rxStream );
2840 }
2841
2842 /**
2843 * @brief Failed to allocate the stream.
2844 */
test_lTCPAddRxdata_StreamCannotBeAllocated(void)2845 void test_lTCPAddRxdata_StreamCannotBeAllocated( void )
2846 {
2847 int32_t lReturn;
2848 FreeRTOS_Socket_t xSocket;
2849 size_t uxOffset;
2850 uint8_t pcData[ 20 ];
2851 uint32_t ulByteCount;
2852 StreamBuffer_t xStreamBuffer;
2853
2854 memset( &xSocket, 0, sizeof( xSocket ) );
2855
2856 xSocket.u.xTCP.uxRxStreamSize = 20;
2857 xSocket.u.xTCP.uxLittleSpace = 3;
2858 xSocket.u.xTCP.uxEnoughSpace = 17;
2859 xSocket.u.xTCP.usMSS = 10;
2860
2861 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
2862
2863 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, NULL );
2864
2865 vTCPStateChange_Expect( &xSocket, eCLOSE_WAIT );
2866
2867 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
2868
2869 TEST_ASSERT_EQUAL( -1, lReturn );
2870 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bMallocError );
2871 }
2872
2873 /**
2874 * @brief Successfully added all bytes in the stream.
2875 */
test_lTCPAddRxdata_SteamCreationSuccessful_AllBytesAdded(void)2876 void test_lTCPAddRxdata_SteamCreationSuccessful_AllBytesAdded( void )
2877 {
2878 int32_t lReturn;
2879 FreeRTOS_Socket_t xSocket;
2880 size_t uxOffset = 0;
2881 uint8_t pcData[ 20 ];
2882 uint32_t ulByteCount = 120;
2883 uint8_t ucStream[ ipconfigTCP_MSS ];
2884 StreamBuffer_t xStreamBuffer;
2885
2886 memset( &xSocket, 0, sizeof( xSocket ) );
2887
2888 xSocket.u.xTCP.uxRxStreamSize = 20;
2889 xSocket.u.xTCP.uxLittleSpace = 3;
2890 xSocket.u.xTCP.uxEnoughSpace = 17;
2891 xSocket.u.xTCP.usMSS = 10;
2892
2893 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
2894
2895 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ( StreamBuffer_t * ) ucStream );
2896
2897 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount );
2898
2899 uxStreamBufferFrontSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10 );
2900
2901 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
2902
2903 TEST_ASSERT_EQUAL( ulByteCount, lReturn );
2904 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
2905 TEST_ASSERT_EQUAL( eSOCKET_RECEIVE, xSocket.xEventBits );
2906 }
2907
2908 /**
2909 * @brief Only able to add few bytes.
2910 */
test_lTCPAddRxdata_SteamCreationSuccessful_AllBytesNotAdded(void)2911 void test_lTCPAddRxdata_SteamCreationSuccessful_AllBytesNotAdded( void )
2912 {
2913 int32_t lReturn;
2914 FreeRTOS_Socket_t xSocket;
2915 size_t uxOffset = 0;
2916 uint8_t pcData[ 20 ];
2917 uint32_t ulByteCount = 120;
2918 uint8_t ucStream[ ipconfigTCP_MSS ];
2919 StreamBuffer_t xStreamBuffer;
2920
2921 memset( &xSocket, 0, sizeof( xSocket ) );
2922
2923 xSocket.u.xTCP.uxRxStreamSize = 20;
2924 xSocket.u.xTCP.uxLittleSpace = 3;
2925 xSocket.u.xTCP.uxEnoughSpace = 17;
2926 xSocket.u.xTCP.usMSS = 10;
2927
2928 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
2929
2930 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
2931
2932 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount - 10 );
2933
2934 uxStreamBufferFrontSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10 );
2935
2936 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
2937
2938 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
2939 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
2940 TEST_ASSERT_EQUAL( eSOCKET_RECEIVE, xSocket.xEventBits );
2941 }
2942
2943 /**
2944 * @brief Space in the front of the stream buffer is less than the low space value.
2945 */
test_lTCPAddRxdata_FrontSpaceLessThanLowMark(void)2946 void test_lTCPAddRxdata_FrontSpaceLessThanLowMark( void )
2947 {
2948 int32_t lReturn;
2949 FreeRTOS_Socket_t xSocket;
2950 size_t uxOffset = 0;
2951 uint8_t pcData[ 20 ];
2952 uint32_t ulByteCount = 120;
2953 uint8_t ucStream[ ipconfigTCP_MSS ];
2954 StreamBuffer_t xStreamBuffer;
2955
2956 memset( &xSocket, 0, sizeof( xSocket ) );
2957
2958 xSocket.u.xTCP.uxRxStreamSize = 200;
2959 xSocket.u.xTCP.uxLittleSpace = 120;
2960 xSocket.u.xTCP.uxEnoughSpace = 200;
2961 xSocket.xSelectBits = eSELECT_READ;
2962 xSocket.u.xTCP.usMSS = 10;
2963
2964 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
2965
2966 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
2967
2968 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount - 10 );
2969
2970 uxStreamBufferFrontSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10 );
2971
2972 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2973
2974 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
2975
2976 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
2977 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
2978 TEST_ASSERT_EQUAL( eSOCKET_RECEIVE | ( eSELECT_READ << SOCKET_EVENT_BIT_COUNT ), xSocket.xEventBits );
2979 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bLowWater );
2980 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bWinChange );
2981 TEST_ASSERT_EQUAL( 1U, xSocket.u.xTCP.usTimeout );
2982 }
2983
2984 /**
2985 * @brief the low water bit is set.
2986 */
test_lTCPAddRxdata_LowWaterTrue(void)2987 void test_lTCPAddRxdata_LowWaterTrue( void )
2988 {
2989 int32_t lReturn;
2990 FreeRTOS_Socket_t xSocket;
2991 size_t uxOffset = 0;
2992 uint8_t pcData[ 20 ];
2993 uint32_t ulByteCount = 120;
2994 uint8_t ucStream[ ipconfigTCP_MSS ];
2995 StreamBuffer_t xStreamBuffer;
2996
2997 memset( &xSocket, 0, sizeof( xSocket ) );
2998
2999 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) ucStream;
3000 xSocket.u.xTCP.uxRxStreamSize = 200;
3001 xSocket.u.xTCP.uxLittleSpace = 120;
3002 xSocket.u.xTCP.uxEnoughSpace = 200;
3003 xSocket.xSelectBits = eSELECT_READ;
3004 xSocket.u.xTCP.bits.bLowWater = pdTRUE;
3005 xSocket.u.xTCP.usMSS = 10;
3006
3007 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount - 10 );
3008
3009 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
3010
3011 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
3012 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
3013 TEST_ASSERT_EQUAL( eSOCKET_RECEIVE | ( eSELECT_READ << SOCKET_EVENT_BIT_COUNT ), xSocket.xEventBits );
3014 }
3015
3016 /**
3017 * @brief Receive callback is added.
3018 */
test_lTCPAddRxdata_HasValidHandler(void)3019 void test_lTCPAddRxdata_HasValidHandler( void )
3020 {
3021 int32_t lReturn;
3022 FreeRTOS_Socket_t xSocket;
3023 size_t uxOffset = 0;
3024 uint8_t pcData[ 20 ];
3025 uint32_t ulByteCount = 120;
3026 uint8_t ucStream[ ipconfigTCP_MSS ];
3027 StreamBuffer_t xStreamBuffer;
3028
3029 xLocalReceiveCallback_Called = 0;
3030
3031 memset( &xSocket, 0, sizeof( xSocket ) );
3032
3033 xSocket.u.xTCP.uxRxStreamSize = 200;
3034 xSocket.u.xTCP.uxLittleSpace = 120;
3035 xSocket.u.xTCP.uxEnoughSpace = 200;
3036 xSocket.xSelectBits = eSELECT_READ;
3037 xSocket.u.xTCP.pxHandleReceive = xLocalReceiveCallback;
3038 xSocket.u.xTCP.usMSS = 10;
3039
3040 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
3041
3042 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
3043
3044 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0U );
3045
3046 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, NULL, ulByteCount, ulByteCount - 10 );
3047
3048 uxStreamBufferGet_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0U, NULL, ulByteCount, pdFALSE, pdTRUE );
3049
3050 uxStreamBufferGetPtr_ExpectAnyArgsAndReturn( 0U );
3051
3052 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
3053
3054 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
3055 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
3056 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
3057 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bLowWater );
3058 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bWinChange );
3059 TEST_ASSERT_EQUAL( 0U, xSocket.u.xTCP.usTimeout );
3060 TEST_ASSERT_EQUAL( 1U, xLocalReceiveCallback_Called );
3061 }
3062
3063 /**
3064 * @brief Call back added but the data to be added is NULL meaning peeking mode.
3065 */
test_lTCPAddRxdata_HasValidHandler_DataNULL(void)3066 void test_lTCPAddRxdata_HasValidHandler_DataNULL( void )
3067 {
3068 int32_t lReturn;
3069 FreeRTOS_Socket_t xSocket;
3070 size_t uxOffset = 0;
3071 uint32_t ulByteCount = 120;
3072 uint8_t ucStream[ ipconfigTCP_MSS ];
3073 StreamBuffer_t xStreamBuffer;
3074
3075 xLocalReceiveCallback_Called = 0;
3076
3077 memset( &xSocket, 0, sizeof( xSocket ) );
3078
3079 xSocket.u.xTCP.uxRxStreamSize = 200;
3080 xSocket.u.xTCP.uxLittleSpace = 120;
3081 xSocket.u.xTCP.uxEnoughSpace = 200;
3082 xSocket.xSelectBits = eSELECT_READ;
3083 xSocket.u.xTCP.pxHandleReceive = xLocalReceiveCallback;
3084 xSocket.u.xTCP.usMSS = 10;
3085
3086 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
3087
3088 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
3089
3090 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0U );
3091
3092 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, NULL, ulByteCount, ulByteCount - 10 );
3093
3094 uxStreamBufferGetPtr_ExpectAnyArgsAndReturn( 0U );
3095
3096 lReturn = lTCPAddRxdata( &xSocket, uxOffset, NULL, ulByteCount );
3097
3098 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
3099 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
3100 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
3101 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bLowWater );
3102 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bWinChange );
3103 TEST_ASSERT_EQUAL( 0U, xSocket.u.xTCP.usTimeout );
3104 TEST_ASSERT_EQUAL( 0U, xLocalReceiveCallback_Called );
3105 }
3106
3107 /**
3108 * @brief Has a callback and the offset is non-zero unlike previous cases.
3109 */
test_lTCPAddRxdata_HasValidHandler_NonZeroOffset(void)3110 void test_lTCPAddRxdata_HasValidHandler_NonZeroOffset( void )
3111 {
3112 int32_t lReturn;
3113 FreeRTOS_Socket_t xSocket;
3114 size_t uxOffset = 10;
3115 uint8_t pcData[ 20 ];
3116 uint32_t ulByteCount = 120;
3117 uint8_t ucStream[ ipconfigTCP_MSS ];
3118 StreamBuffer_t xStreamBuffer;
3119
3120 xLocalReceiveCallback_Called = 0;
3121
3122 memset( &xSocket, 0, sizeof( xSocket ) );
3123
3124 xSocket.u.xTCP.uxRxStreamSize = 200;
3125 xSocket.u.xTCP.uxLittleSpace = 120;
3126 xSocket.u.xTCP.uxEnoughSpace = 200;
3127 xSocket.xSelectBits = eSELECT_READ;
3128 xSocket.u.xTCP.pxHandleReceive = xLocalReceiveCallback;
3129 xSocket.u.xTCP.usMSS = 10;
3130
3131 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
3132
3133 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
3134
3135 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0U );
3136
3137 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount - 10 );
3138
3139 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
3140
3141 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
3142 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
3143 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
3144 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bLowWater );
3145 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bWinChange );
3146 TEST_ASSERT_EQUAL( 0U, xSocket.u.xTCP.usTimeout );
3147 TEST_ASSERT_EQUAL( 0U, xLocalReceiveCallback_Called );
3148 }
3149
3150 /**
3151 * @brief Buffer size is non-zero.
3152 */
test_lTCPAddRxdata_HasValidHandlerWithNonZeroSize(void)3153 void test_lTCPAddRxdata_HasValidHandlerWithNonZeroSize( void )
3154 {
3155 int32_t lReturn;
3156 FreeRTOS_Socket_t xSocket;
3157 size_t uxOffset = 0;
3158 uint8_t pcData[ 20 ];
3159 uint32_t ulByteCount = 120;
3160 uint8_t ucStream[ ipconfigTCP_MSS ];
3161 StreamBuffer_t xStreamBuffer;
3162
3163 xLocalReceiveCallback_Called = 0;
3164
3165 memset( &xSocket, 0, sizeof( xSocket ) );
3166
3167 xSocket.u.xTCP.uxRxStreamSize = 200;
3168 xSocket.u.xTCP.uxLittleSpace = 120;
3169 xSocket.u.xTCP.uxEnoughSpace = 200;
3170 xSocket.xSelectBits = eSELECT_READ;
3171 xSocket.u.xTCP.pxHandleReceive = xLocalReceiveCallback;
3172 xSocket.u.xTCP.usMSS = 10;
3173
3174 size_t xSizeOfBufferRequested = ( ( ( sizeof( size_t ) + xSocket.u.xTCP.uxRxStreamSize ) & ( ~( sizeof( size_t ) - 1U ) ) ) + sizeof( xStreamBuffer ) ) - sizeof( xStreamBuffer.ucArray );
3175
3176 pvPortMalloc_ExpectAndReturn( xSizeOfBufferRequested, ucStream );
3177
3178 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 10U );
3179
3180 uxStreamBufferAdd_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, uxOffset, pcData, ulByteCount, ulByteCount - 10 );
3181
3182 uxStreamBufferGetPtr_ExpectAnyArgsAndReturn( 0U );
3183
3184 lReturn = lTCPAddRxdata( &xSocket, uxOffset, pcData, ulByteCount );
3185
3186 TEST_ASSERT_EQUAL( ulByteCount - 10, lReturn );
3187 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bMallocError );
3188 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
3189 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bLowWater );
3190 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bWinChange );
3191 TEST_ASSERT_EQUAL( 0U, xSocket.u.xTCP.usTimeout );
3192 TEST_ASSERT_EQUAL( 0U, xLocalReceiveCallback_Called );
3193 }
3194
3195 /**
3196 * @brief All combination of inputs. See below comments.
3197 */
test_xSocketValid(void)3198 void test_xSocketValid( void )
3199 {
3200 BaseType_t xReturn;
3201 FreeRTOS_Socket_t xSocket;
3202
3203 /* NULL Socket. */
3204 xReturn = xSocketValid( NULL );
3205 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
3206
3207 /* Invalid Socket. */
3208 xReturn = xSocketValid( ( FreeRTOS_Socket_t * ) FREERTOS_INVALID_SOCKET );
3209 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
3210
3211 /* Valid Socket. */
3212 xReturn = xSocketValid( &xSocket );
3213 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
3214 }
3215
3216 /**
3217 * @brief This function just prints out some data. It is expected to make call to the
3218 * below function. Nothing more.
3219 */
test_FreeRTOS_netstat(void)3220 void test_FreeRTOS_netstat( void )
3221 {
3222 xSendEventStructToIPTask_ExpectAndReturn( NULL, pdMS_TO_TICKS( 1000U ), pdPASS );
3223 xSendEventStructToIPTask_IgnoreArg_pxEvent();
3224 FreeRTOS_netstat();
3225 }
3226
