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_IPv4_Sockets.h"
52 #include "mock_FreeRTOS_IPv6_Sockets.h"
53 #include "mock_FreeRTOS_Sockets.h"
54
55 #include "FreeRTOS_Sockets.h"
56
57 #include "FreeRTOS_Sockets_stubs.c"
58 #include "catch_assert.h"
59
60 #include "FreeRTOSIPConfig.h"
61
62 /* =========================== EXTERN VARIABLES =========================== */
63
64 extern List_t xBoundUDPSocketsList;
65 extern List_t xBoundTCPSocketsList;
66
67 /* 2001::1 */
68 static IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
69
70 /* ============================== Test Cases ============================== */
71
72 /**
73 * @brief Creation of socket when socket size determination fails as IP task is not ready.
74 */
test_FreeRTOS_socket_SockSizeFailure(void)75 void test_FreeRTOS_socket_SockSizeFailure( void )
76 {
77 Socket_t xSocket;
78 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
79 FreeRTOS_Socket_t const * pxSocket = NULL;
80
81 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
82
83 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
84
85 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, xSocket );
86 }
87
88 /**
89 * @brief Creation of socket when socket size determination fails as IP task is not ready.
90 */
test_FreeRTOS_socket_SockSizeFailure_SockDependent(void)91 void test_FreeRTOS_socket_SockSizeFailure_SockDependent( void )
92 {
93 Socket_t xSocket;
94 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM | FREERTOS_SOCK_DGRAM;
95 BaseType_t xProtocol = FREERTOS_SOCK_DEPENDENT_PROTO;
96 FreeRTOS_Socket_t const * pxSocket = NULL;
97
98 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
99
100 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
101
102 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, xSocket );
103 }
104
105 /**
106 * @brief Creation of socket when no memory could be allocated.
107 */
test_FreeRTOS_socket_NoMemory(void)108 void test_FreeRTOS_socket_NoMemory( void )
109 {
110 Socket_t xSocket;
111 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
112 FreeRTOS_Socket_t const * pxSocket = NULL;
113
114 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
115
116 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
117 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
118
119 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), NULL );
120
121 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
122
123 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, xSocket );
124 }
125
126 /**
127 * @brief Creation of socket when event group creation fails.
128 */
test_FreeRTOS_socket_EventGroupCreationFailed(void)129 void test_FreeRTOS_socket_EventGroupCreationFailed( void )
130 {
131 Socket_t xSocket;
132 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
133 FreeRTOS_Socket_t const * pxSocket = NULL;
134 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ) ];
135
136 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
137
138 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
139 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
140
141 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), ( void * ) ucSocket );
142
143 xEventGroupCreate_ExpectAndReturn( NULL );
144
145 vPortFree_Expect( ucSocket );
146
147 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
148
149 TEST_ASSERT_EQUAL( FREERTOS_INVALID_SOCKET, xSocket );
150 }
151
152 /**
153 * @brief Creation of socket when the protocol is TCP.
154 */
test_FreeRTOS_socket_TCPSocket_ProtocolDependent(void)155 void test_FreeRTOS_socket_TCPSocket_ProtocolDependent( void )
156 {
157 Socket_t xSocket;
158 FreeRTOS_Socket_t * pxSocket;
159 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_SOCK_DEPENDENT_PROTO;
160 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ) ];
161 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
162
163 pxSocket = ( FreeRTOS_Socket_t * ) ucSocket;
164
165 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
166
167 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
168 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
169
170 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), ( void * ) ucSocket );
171
172 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
173
174 FreeRTOS_round_up_ExpectAndReturn( ipconfigTCP_TX_BUFFER_LENGTH, ipconfigTCP_MSS, 0xAABB );
175 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( ipconfigTCP_RX_BUFFER_LENGTH / 2U ) / ipconfigTCP_MSS, 0x1234 );
176 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( 0xAABB / 2U ) / ipconfigTCP_MSS, 0x3456 );
177
178 vListInitialiseItem_Expect( &( pxSocket->xBoundSocketListItem ) );
179
180 listSET_LIST_ITEM_OWNER_Expect( &( pxSocket->xBoundSocketListItem ), pxSocket );
181
182
183 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
184
185 TEST_ASSERT_EQUAL( ucSocket, xSocket );
186 TEST_ASSERT_EQUAL( xSocket->xEventGroup, xEventGroup );
187 TEST_ASSERT_EQUAL( xSocket->xReceiveBlockTime, ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME );
188 TEST_ASSERT_EQUAL( xSocket->xSendBlockTime, ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME );
189 TEST_ASSERT_EQUAL( xSocket->ucSocketOptions, ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT );
190 TEST_ASSERT_EQUAL( xSocket->ucProtocol, ( uint8_t ) FREERTOS_IPPROTO_TCP );
191 TEST_ASSERT_EQUAL( xSocket->u.xTCP.usMSS, ( uint16_t ) ipconfigTCP_MSS );
192 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxRxStreamSize, ( size_t ) ipconfigTCP_RX_BUFFER_LENGTH );
193 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxTxStreamSize, 0xAABB );
194 TEST_ASSERT_EQUAL( 0x1234, pxSocket->u.xTCP.uxRxWinSize );
195 TEST_ASSERT_EQUAL( 0x3456, pxSocket->u.xTCP.uxTxWinSize );
196 }
197
198 /**
199 * @brief Creation of socket when the protocol is TCP.
200 */
test_FreeRTOS_socket_TCPSocket(void)201 void test_FreeRTOS_socket_TCPSocket( void )
202 {
203 Socket_t xSocket;
204 FreeRTOS_Socket_t * pxSocket;
205 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
206 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ) ];
207 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
208
209 pxSocket = ( FreeRTOS_Socket_t * ) ucSocket;
210
211 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
212
213 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
214 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
215
216 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), ( void * ) ucSocket );
217
218 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
219
220 FreeRTOS_round_up_ExpectAndReturn( ipconfigTCP_TX_BUFFER_LENGTH, ipconfigTCP_MSS, 0xAABB );
221 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( ipconfigTCP_RX_BUFFER_LENGTH / 2U ) / ipconfigTCP_MSS, 0x1234 );
222 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( 0xAABB / 2U ) / ipconfigTCP_MSS, 0x3456 );
223
224 vListInitialiseItem_Expect( &( pxSocket->xBoundSocketListItem ) );
225
226 listSET_LIST_ITEM_OWNER_Expect( &( pxSocket->xBoundSocketListItem ), pxSocket );
227
228 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
229
230 TEST_ASSERT_EQUAL( ucSocket, xSocket );
231 TEST_ASSERT_EQUAL( xSocket->xEventGroup, xEventGroup );
232 TEST_ASSERT_EQUAL( xSocket->xReceiveBlockTime, ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME );
233 TEST_ASSERT_EQUAL( xSocket->xSendBlockTime, ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME );
234 TEST_ASSERT_EQUAL( xSocket->ucSocketOptions, ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT );
235 TEST_ASSERT_EQUAL( xSocket->ucProtocol, ( uint8_t ) xProtocol );
236 TEST_ASSERT_EQUAL( xSocket->u.xTCP.usMSS, ( uint16_t ) ipconfigTCP_MSS );
237 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxRxStreamSize, ( size_t ) ipconfigTCP_RX_BUFFER_LENGTH );
238 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxTxStreamSize, 0xAABB );
239 TEST_ASSERT_EQUAL( 0x1234, pxSocket->u.xTCP.uxRxWinSize );
240 TEST_ASSERT_EQUAL( 0x3456, pxSocket->u.xTCP.uxTxWinSize );
241 }
242
243 /**
244 * @brief Creation of socket when the protocol is UDP.
245 */
test_FreeRTOS_socket_UDPSocket(void)246 void test_FreeRTOS_socket_UDPSocket( void )
247 {
248 Socket_t xSocket;
249 FreeRTOS_Socket_t * pxSocket;
250 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_IPPROTO_UDP;
251 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xUDP ) ];
252 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
253
254 pxSocket = ( FreeRTOS_Socket_t * ) ucSocket;
255
256 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
257
258 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
259 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
260
261 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xUDP ), ( void * ) ucSocket );
262
263 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
264
265 vListInitialise_Expect( &( pxSocket->u.xUDP.xWaitingPacketsList ) );
266
267 vListInitialiseItem_Expect( &( pxSocket->xBoundSocketListItem ) );
268
269 listSET_LIST_ITEM_OWNER_Expect( &( pxSocket->xBoundSocketListItem ), pxSocket );
270
271 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
272
273 TEST_ASSERT_EQUAL( ucSocket, xSocket );
274 TEST_ASSERT_EQUAL( xSocket->xEventGroup, xEventGroup );
275 TEST_ASSERT_EQUAL( xSocket->xReceiveBlockTime, ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME );
276 TEST_ASSERT_EQUAL( xSocket->xSendBlockTime, ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME );
277 TEST_ASSERT_EQUAL( xSocket->ucSocketOptions, ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT );
278 TEST_ASSERT_EQUAL( xSocket->ucProtocol, ( uint8_t ) xProtocol );
279 TEST_ASSERT_EQUAL( xSocket->u.xUDP.uxMaxPackets, ( UBaseType_t ) ipconfigUDP_MAX_RX_PACKETS );
280 }
281
282 /**
283 * @brief Creation of socket when the protocol is UDP.
284 */
test_FreeRTOS_socket_UDPSocket_ProtocolDependent(void)285 void test_FreeRTOS_socket_UDPSocket_ProtocolDependent( void )
286 {
287 Socket_t xSocket;
288 FreeRTOS_Socket_t * pxSocket;
289 BaseType_t xDomain = FREERTOS_AF_INET, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_SOCK_DEPENDENT_PROTO;
290 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xUDP ) ];
291 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
292
293 pxSocket = ( FreeRTOS_Socket_t * ) ucSocket;
294
295 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
296
297 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
298 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
299
300 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xUDP ), ( void * ) ucSocket );
301
302 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
303
304 vListInitialise_Expect( &( pxSocket->u.xUDP.xWaitingPacketsList ) );
305
306 vListInitialiseItem_Expect( &( pxSocket->xBoundSocketListItem ) );
307
308 listSET_LIST_ITEM_OWNER_Expect( &( pxSocket->xBoundSocketListItem ), pxSocket );
309
310 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
311
312 TEST_ASSERT_EQUAL( ucSocket, xSocket );
313 TEST_ASSERT_EQUAL( xSocket->xEventGroup, xEventGroup );
314 TEST_ASSERT_EQUAL( xSocket->xReceiveBlockTime, ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME );
315 TEST_ASSERT_EQUAL( xSocket->xSendBlockTime, ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME );
316 TEST_ASSERT_EQUAL( xSocket->ucSocketOptions, ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT );
317 TEST_ASSERT_EQUAL( xSocket->ucProtocol, ( uint8_t ) FREERTOS_IPPROTO_UDP );
318 TEST_ASSERT_EQUAL( xSocket->u.xUDP.uxMaxPackets, ( UBaseType_t ) ipconfigUDP_MAX_RX_PACKETS );
319 }
320
321 /**
322 * @brief Assertion when unknown domain comes.
323 */
test_FreeRTOS_socket_unknownDomain(void)324 void test_FreeRTOS_socket_unknownDomain( void )
325 {
326 BaseType_t xDomain = FREERTOS_AF_INET + 1, xType = FREERTOS_SOCK_DGRAM, xProtocol = FREERTOS_SOCK_DEPENDENT_PROTO;
327
328 catch_assert( FreeRTOS_socket( xDomain, xType, xProtocol ) );
329 }
330
331 /**
332 * @brief Creation of socket when the protocol is TCPv6.
333 */
test_FreeRTOS_socket_TCPv6Socket(void)334 void test_FreeRTOS_socket_TCPv6Socket( void )
335 {
336 Socket_t xSocket;
337 FreeRTOS_Socket_t * pxSocket;
338 BaseType_t xDomain = FREERTOS_AF_INET6, xType = FREERTOS_SOCK_STREAM, xProtocol = FREERTOS_IPPROTO_TCP;
339 uint8_t ucSocket[ ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ) ];
340 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
341
342 pxSocket = ( FreeRTOS_Socket_t * ) ucSocket;
343
344 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
345
346 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundUDPSocketsList, pdTRUE );
347 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
348
349 pvPortMalloc_ExpectAndReturn( ( sizeof( *pxSocket ) - sizeof( pxSocket->u ) ) + sizeof( pxSocket->u.xTCP ), ( void * ) ucSocket );
350
351 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
352
353 FreeRTOS_round_up_ExpectAndReturn( ipconfigTCP_TX_BUFFER_LENGTH, ipconfigTCP_MSS, 0xAABB );
354 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( ipconfigTCP_RX_BUFFER_LENGTH / 2U ) / ipconfigTCP_MSS, 0x1234 );
355 FreeRTOS_max_size_t_ExpectAndReturn( 1U, ( uint32_t ) ( 0xAABB / 2U ) / ipconfigTCP_MSS, 0x3456 );
356
357 vListInitialiseItem_Expect( &( pxSocket->xBoundSocketListItem ) );
358
359 listSET_LIST_ITEM_OWNER_Expect( &( pxSocket->xBoundSocketListItem ), pxSocket );
360
361 xSocket = FreeRTOS_socket( xDomain, xType, xProtocol );
362
363 TEST_ASSERT_EQUAL( ucSocket, xSocket );
364 TEST_ASSERT_EQUAL( xSocket->xEventGroup, xEventGroup );
365 TEST_ASSERT_EQUAL( xSocket->xReceiveBlockTime, ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME );
366 TEST_ASSERT_EQUAL( xSocket->xSendBlockTime, ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME );
367 TEST_ASSERT_EQUAL( xSocket->ucSocketOptions, ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT );
368 TEST_ASSERT_EQUAL( xSocket->ucProtocol, ( uint8_t ) xProtocol );
369 TEST_ASSERT_EQUAL( xSocket->u.xTCP.usMSS, ( uint16_t ) ipconfigTCP_MSS - ( ipSIZE_OF_IPv6_HEADER - ipSIZE_OF_IPv4_HEADER ) );
370 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxRxStreamSize, ( size_t ) ipconfigTCP_RX_BUFFER_LENGTH );
371 TEST_ASSERT_EQUAL( xSocket->u.xTCP.uxTxStreamSize, 0xAABB );
372 TEST_ASSERT_EQUAL( 0x1234, pxSocket->u.xTCP.uxRxWinSize );
373 TEST_ASSERT_EQUAL( 0x3456, pxSocket->u.xTCP.uxTxWinSize );
374 }
375
376 /**
377 * @brief Creation of socket-set when there is no memory.
378 */
test_FreeRTOS_CreateSocketSet_NoMemory(void)379 void test_FreeRTOS_CreateSocketSet_NoMemory( void )
380 {
381 SocketSelect_t * pxSocketSet;
382
383 pvPortMalloc_ExpectAndReturn( sizeof( *pxSocketSet ), NULL );
384
385 pxSocketSet = FreeRTOS_CreateSocketSet();
386
387 TEST_ASSERT_EQUAL( NULL, pxSocketSet );
388 }
389
390 /**
391 * @brief Creation of socket-set when event group creation fails.
392 */
test_FreeRTOS_CreateSocketSet_EventGroupCreationFails(void)393 void test_FreeRTOS_CreateSocketSet_EventGroupCreationFails( void )
394 {
395 SocketSelect_t * pxSocketSet;
396 uint8_t ucSocket[ sizeof( *pxSocketSet ) ];
397
398 pvPortMalloc_ExpectAndReturn( sizeof( *pxSocketSet ), ucSocket );
399
400 xEventGroupCreate_ExpectAndReturn( NULL );
401
402 vPortFree_Expect( ucSocket );
403
404 pxSocketSet = FreeRTOS_CreateSocketSet();
405
406 TEST_ASSERT_EQUAL( NULL, pxSocketSet );
407 }
408
409 /**
410 * @brief Creation of socket-set happy path.
411 */
test_FreeRTOS_CreateSocketSet_HappyPath(void)412 void test_FreeRTOS_CreateSocketSet_HappyPath( void )
413 {
414 SocketSelect_t * pxSocketSet;
415 uint8_t ucSocketSet[ sizeof( *pxSocketSet ) ];
416 uint8_t xEventGroup[ sizeof( uintptr_t ) ];
417
418 pvPortMalloc_ExpectAndReturn( sizeof( *pxSocketSet ), ucSocketSet );
419
420 xEventGroupCreate_ExpectAndReturn( ( EventGroupHandle_t ) xEventGroup );
421
422 pxSocketSet = FreeRTOS_CreateSocketSet();
423
424 TEST_ASSERT_EQUAL( ucSocketSet, pxSocketSet );
425 TEST_ASSERT_EQUAL( xEventGroup, pxSocketSet->xSelectGroup );
426 }
427
428 /**
429 * @brief Deletion of socket-set happy path.
430 */
test_FreeRTOS_DeleteSocketSet_happyPath(void)431 void test_FreeRTOS_DeleteSocketSet_happyPath( void )
432 {
433 SocketSet_t xSocketSet;
434
435 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
436 xSendEventStructToIPTask_IgnoreArg_pxEvent();
437
438 FreeRTOS_DeleteSocketSet( xSocketSet );
439 }
440
441 /**
442 * @brief Deletion of socket-set when sending of event to IP task fails.
443 */
test_FreeRTOS_DeleteSocketSet_SendingFailed(void)444 void test_FreeRTOS_DeleteSocketSet_SendingFailed( void )
445 {
446 SocketSet_t xSocketSet;
447
448 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdFAIL );
449 xSendEventStructToIPTask_IgnoreArg_pxEvent();
450
451 FreeRTOS_DeleteSocketSet( xSocketSet );
452 }
453
454 /**
455 * @brief Assertion when socket is NULL.
456 */
test_FreeRTOS_FD_SET_CatchAssert1(void)457 void test_FreeRTOS_FD_SET_CatchAssert1( void )
458 {
459 Socket_t xSocket = NULL;
460 SocketSet_t xSocketSet;
461 EventBits_t xBitsToSet;
462
463 catch_assert( FreeRTOS_FD_SET( xSocket, xSocketSet, xBitsToSet ) );
464 }
465
466 /**
467 * @brief Assertion when socket-set is NULL.
468 */
test_FreeRTOS_FD_SET_CatchAssert2(void)469 void test_FreeRTOS_FD_SET_CatchAssert2( void )
470 {
471 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
472 Socket_t xSocket = ( Socket_t ) ucSocket;
473 SocketSet_t xSocketSet = NULL;
474 EventBits_t xBitsToSet;
475
476 catch_assert( FreeRTOS_FD_SET( xSocket, xSocketSet, xBitsToSet ) );
477 }
478
479 /**
480 * @brief Test when no-bits are to be set.
481 */
test_FreeRTOS_FD_SET_NoBitsToSet(void)482 void test_FreeRTOS_FD_SET_NoBitsToSet( void )
483 {
484 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
485 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
486 Socket_t xSocket = ( Socket_t ) ucSocket;
487 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
488 EventBits_t xBitsToSet = 0;
489
490 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
491 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
492
493 FreeRTOS_FD_SET( xSocket, xSocketSet, xBitsToSet );
494
495 TEST_ASSERT_EQUAL( 0, xSocket->xSelectBits );
496 }
497
498 /**
499 * @brief Test for when all bits are to be set.
500 */
test_FreeRTOS_FD_SET_AllBitsToSet(void)501 void test_FreeRTOS_FD_SET_AllBitsToSet( void )
502 {
503 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
504 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
505 Socket_t xSocket = ( Socket_t ) ucSocket;
506 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
507 EventBits_t xBitsToSet = eSELECT_ALL;
508
509 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
510 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
511
512 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, 0 );
513 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
514
515 FreeRTOS_FD_SET( xSocket, xSocketSet, xBitsToSet );
516
517 TEST_ASSERT_EQUAL( eSELECT_ALL, xSocket->xSelectBits );
518 TEST_ASSERT_EQUAL( ucSocketSet, xSocket->pxSocketSet );
519 }
520
521 /**
522 * @brief Assertion when socket is NULL.
523 */
test_FreeRTOS_FD_CLR_CatchAssert1(void)524 void test_FreeRTOS_FD_CLR_CatchAssert1( void )
525 {
526 Socket_t xSocket = NULL;
527 SocketSet_t xSocketSet;
528 EventBits_t xBitsToClear;
529
530 catch_assert( FreeRTOS_FD_CLR( xSocket, xSocketSet, xBitsToClear ) );
531 }
532
533 /**
534 * @brief Assertion when socket-set is NULL.
535 */
test_FreeRTOS_FD_CLR_CatchAssert2(void)536 void test_FreeRTOS_FD_CLR_CatchAssert2( void )
537 {
538 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
539 Socket_t xSocket = ( Socket_t ) ucSocket;
540 SocketSet_t xSocketSet = NULL;
541 EventBits_t xBitsToClear;
542
543 catch_assert( FreeRTOS_FD_CLR( xSocket, xSocketSet, xBitsToClear ) );
544 }
545
546 /**
547 * @brief No bits to be cleared.
548 */
test_FreeRTOS_FD_CLR_NoBitsToClear(void)549 void test_FreeRTOS_FD_CLR_NoBitsToClear( void )
550 {
551 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
552 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
553 Socket_t xSocket = ( Socket_t ) ucSocket;
554 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
555 EventBits_t xBitsToClear = 0;
556
557 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
558 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
559
560 xSocket->xSelectBits = 0;
561
562 FreeRTOS_FD_CLR( xSocket, xSocketSet, xBitsToClear );
563
564 TEST_ASSERT_EQUAL( NULL, xSocket->pxSocketSet );
565 TEST_ASSERT_EQUAL( 0, xSocket->xSelectBits );
566 }
567
568 /**
569 * @brief All bits to be cleared.
570 */
test_FreeRTOS_FD_CLR_AllBitsToClear(void)571 void test_FreeRTOS_FD_CLR_AllBitsToClear( void )
572 {
573 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
574 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
575 Socket_t xSocket = ( Socket_t ) ucSocket;
576 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
577 EventBits_t xBitsToClear = 0;
578
579 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
580 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
581
582 xSocket->xSelectBits = eSELECT_ALL;
583
584 FreeRTOS_FD_CLR( xSocket, xSocketSet, xBitsToClear );
585
586 TEST_ASSERT_EQUAL( xSocketSet, xSocket->pxSocketSet );
587 TEST_ASSERT_EQUAL( eSELECT_ALL, xSocket->xSelectBits );
588 }
589
590 /**
591 * @brief Assertion when socket is NULL.
592 */
test_FreeRTOS_FD_ISSET_CatchAssert1(void)593 void test_FreeRTOS_FD_ISSET_CatchAssert1( void )
594 {
595 Socket_t xSocket = NULL;
596 SocketSet_t xSocketSet;
597
598 /* Assertion that the socket must be non-NULL. */
599 catch_assert( FreeRTOS_FD_ISSET( xSocket, xSocketSet ) );
600 }
601
602 /**
603 * @brief Assertion when socket-set is NULL.
604 */
test_FreeRTOS_FD_ISSET_CatchAssert2(void)605 void test_FreeRTOS_FD_ISSET_CatchAssert2( void )
606 {
607 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
608 Socket_t xSocket = ( Socket_t ) ucSocket;
609 SocketSet_t xSocketSet = NULL;
610
611 /* Assertion that the socket set must be non-NULL. */
612 catch_assert( FreeRTOS_FD_ISSET( xSocket, xSocketSet ) );
613 }
614
615 /**
616 * @brief Test for when the socket set is different.
617 */
test_FreeRTOS_FD_ISSET_SocketSetDifferent(void)618 void test_FreeRTOS_FD_ISSET_SocketSetDifferent( void )
619 {
620 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
621 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
622 Socket_t xSocket = ( Socket_t ) ucSocket;
623 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
624 EventBits_t xReturn;
625
626 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
627 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
628
629 xReturn = FreeRTOS_FD_ISSET( xSocket, xSocketSet );
630
631 TEST_ASSERT_EQUAL( 0, xReturn );
632 }
633
634 /**
635 * @brief Happy path.
636 */
test_FreeRTOS_FD_ISSET_SocketSetSame(void)637 void test_FreeRTOS_FD_ISSET_SocketSetSame( void )
638 {
639 uint8_t ucSocket[ sizeof( FreeRTOS_Socket_t ) ];
640 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
641 Socket_t xSocket = ( Socket_t ) ucSocket;
642 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
643 EventBits_t xReturn;
644
645 memset( ucSocket, 0, sizeof( FreeRTOS_Socket_t ) );
646 memset( ucSocketSet, 0, sizeof( SocketSelect_t ) );
647
648 xSocket->pxSocketSet = xSocketSet;
649
650 xSocket->xSocketBits = 0x12;
651
652 xReturn = FreeRTOS_FD_ISSET( xSocket, xSocketSet );
653
654 TEST_ASSERT_EQUAL( 0x12 & eSELECT_ALL, xReturn );
655 }
656
657 /**
658 * @brief Assertion when socket-set is NULL.
659 */
test_FreeRTOS_select_CatchAssert(void)660 void test_FreeRTOS_select_CatchAssert( void )
661 {
662 BaseType_t xReturn;
663 SocketSet_t xSocketSet = NULL;
664 TickType_t xBlockTimeTicks;
665
666 /* Assertion that the socket set must be non-NULL. */
667 catch_assert( FreeRTOS_select( xSocketSet, xBlockTimeTicks ) );
668 }
669
670 /**
671 * @brief Test case when bits matched.
672 */
test_FreeRTOS_select_BitsMatched(void)673 void test_FreeRTOS_select_BitsMatched( void )
674 {
675 BaseType_t xReturn;
676 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
677 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
678 TickType_t xBlockTimeTicks = 0xAB12;
679
680 vTaskSetTimeOutState_ExpectAnyArgs();
681
682 xEventGroupWaitBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( ( EventBits_t ) eSELECT_ALL ), pdFALSE, pdFALSE, xBlockTimeTicks, pdFALSE );
683
684 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdFALSE );
685
686 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
687
688 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, 0, 0x123 );
689
690 xReturn = FreeRTOS_select( xSocketSet, xBlockTimeTicks );
691
692 TEST_ASSERT_EQUAL( 0x123, xReturn );
693 }
694
695 /**
696 * @brief Call to select timed out.
697 */
test_FreeRTOS_select_Timeout(void)698 void test_FreeRTOS_select_Timeout( void )
699 {
700 BaseType_t xReturn;
701 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
702 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
703 TickType_t xBlockTimeTicks = 0xAB12;
704
705 vTaskSetTimeOutState_ExpectAnyArgs();
706
707 xEventGroupWaitBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( ( EventBits_t ) eSELECT_ALL ), pdFALSE, pdFALSE, xBlockTimeTicks, pdFALSE );
708
709 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdFALSE );
710
711 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
712
713 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, 0, 0 );
714
715 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
716
717 xReturn = FreeRTOS_select( xSocketSet, xBlockTimeTicks );
718
719 TEST_ASSERT_EQUAL( 0, xReturn );
720 }
721
722 /**
723 * @brief Call to select timed out second time.
724 */
test_FreeRTOS_select_TimeoutSecondTime(void)725 void test_FreeRTOS_select_TimeoutSecondTime( void )
726 {
727 BaseType_t xReturn;
728 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
729 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
730 TickType_t xBlockTimeTicks = 0xAB12;
731
732 vTaskSetTimeOutState_ExpectAnyArgs();
733
734 for( int i = 0; i < 2; i++ )
735 {
736 xEventGroupWaitBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( ( EventBits_t ) eSELECT_ALL ), pdFALSE, pdFALSE, xBlockTimeTicks, pdFALSE );
737
738 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdFALSE );
739
740 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
741
742 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, 0, 0 );
743
744 if( i == 0 )
745 {
746 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
747 }
748 else
749 {
750 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
751 }
752 }
753
754 xReturn = FreeRTOS_select( xSocketSet, xBlockTimeTicks );
755
756 TEST_ASSERT_EQUAL( 0, xReturn );
757 }
758
759 /**
760 * @brief Found the bits for which the select function was waiting.
761 */
test_FreeRTOS_select_FoundWaitBits(void)762 void test_FreeRTOS_select_FoundWaitBits( void )
763 {
764 BaseType_t xReturn;
765 uint8_t ucSocketSet[ sizeof( SocketSelect_t ) ];
766 SocketSet_t xSocketSet = ( SocketSet_t ) ucSocketSet;
767 TickType_t xBlockTimeTicks = 0xAB12;
768
769 vTaskSetTimeOutState_ExpectAnyArgs();
770
771 xEventGroupWaitBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( ( EventBits_t ) eSELECT_ALL ), pdFALSE, pdFALSE, xBlockTimeTicks, eSELECT_INTR );
772
773 xEventGroupClearBits_ExpectAndReturn( xSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_INTR, pdFALSE );
774
775 xReturn = FreeRTOS_select( xSocketSet, xBlockTimeTicks );
776
777 TEST_ASSERT_EQUAL( eSELECT_INTR, xReturn );
778 }
779
780 /**
781 * @brief Bind cannot be call from IP task.
782 */
test_FreeRTOS_bind_catchAssert(void)783 void test_FreeRTOS_bind_catchAssert( void )
784 {
785 BaseType_t xReturn;
786 Socket_t xSocket;
787 struct freertos_sockaddr xAddress;
788 socklen_t xAddressLength = 0;
789
790 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
791
792 catch_assert( FreeRTOS_bind( xSocket, &xAddress, xAddressLength ) );
793 }
794
795 /**
796 * @brief Binding a NULL socket.
797 */
test_FreeRTOS_bind_SocketIsNULL(void)798 void test_FreeRTOS_bind_SocketIsNULL( void )
799 {
800 BaseType_t xReturn;
801 Socket_t xSocket = NULL;
802 struct freertos_sockaddr xAddress;
803 socklen_t xAddressLength = 0;
804
805 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
806
807 xReturn = FreeRTOS_bind( xSocket, &xAddress, xAddressLength );
808
809 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
810 }
811
812 /**
813 * @brief Binding invalid socket.
814 */
test_FreeRTOS_bind_SocketIsInvalid(void)815 void test_FreeRTOS_bind_SocketIsInvalid( void )
816 {
817 BaseType_t xReturn;
818 Socket_t xSocket = FREERTOS_INVALID_SOCKET;
819 struct freertos_sockaddr xAddress;
820 socklen_t xAddressLength = 0;
821
822 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
823
824 xReturn = FreeRTOS_bind( xSocket, &xAddress, xAddressLength );
825
826 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
827 }
828
829 /**
830 * @brief Binding already bound socket.
831 */
test_FreeRTOS_bind_SocketIsAlreadyBound(void)832 void test_FreeRTOS_bind_SocketIsAlreadyBound( void )
833 {
834 BaseType_t xReturn;
835 FreeRTOS_Socket_t xSocket;
836 struct freertos_sockaddr xAddress;
837 socklen_t xAddressLength;
838
839 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
840
841 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), ( struct xLIST * ) ( uintptr_t ) 0x11223344 );
842
843 xReturn = FreeRTOS_bind( &xSocket, &xAddress, xAddressLength );
844
845 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
846 }
847
848 /**
849 * @brief Binding event to IP task cannot be sent.
850 */
test_FreeRTOS_bind_SendToIPTaskFailed(void)851 void test_FreeRTOS_bind_SendToIPTaskFailed( void )
852 {
853 BaseType_t xReturn;
854 FreeRTOS_Socket_t xSocket;
855 struct freertos_sockaddr xAddress;
856 socklen_t xAddressLength;
857
858 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
859
860 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
861
862 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdFAIL );
863 xSendEventStructToIPTask_IgnoreArg_pxEvent();
864
865 xReturn = FreeRTOS_bind( &xSocket, NULL, xAddressLength );
866
867 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ECANCELED, xReturn );
868 }
869
870 /**
871 * @brief IP task did not bind the socket.
872 */
test_FreeRTOS_bind_IPTaskDidNotBindTheSocket(void)873 void test_FreeRTOS_bind_IPTaskDidNotBindTheSocket( void )
874 {
875 BaseType_t xReturn;
876 FreeRTOS_Socket_t xSocket;
877 struct freertos_sockaddr xAddress;
878 socklen_t xAddressLength;
879
880 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
881
882 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
883
884 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
885 xSendEventStructToIPTask_IgnoreArg_pxEvent();
886
887 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, ( EventBits_t ) eSOCKET_BOUND, pdTRUE, pdFALSE, portMAX_DELAY, pdPASS );
888
889 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
890
891 xReturn = FreeRTOS_bind( &xSocket, NULL, xAddressLength );
892
893 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
894 }
895
896 /**
897 * @brief IP task bound to socket to a NULL address.
898 */
test_FreeRTOS_bind_NonNullAddress(void)899 void test_FreeRTOS_bind_NonNullAddress( void )
900 {
901 BaseType_t xReturn;
902 FreeRTOS_Socket_t xSocket;
903 struct freertos_sockaddr xAddress;
904 socklen_t xAddressLength;
905
906 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
907
908 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
909
910 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
911 xSendEventStructToIPTask_IgnoreArg_pxEvent();
912
913 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, ( EventBits_t ) eSOCKET_BOUND, pdTRUE, pdFALSE, portMAX_DELAY, pdPASS );
914
915 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
916
917 xReturn = FreeRTOS_bind( &xSocket, &xAddress, xAddressLength );
918
919 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
920 }
921
922 /**
923 * @brief IPv4 socket did not bind the socket.
924 */
test_FreeRTOS_bind_IPTaskDidNotBindTheSocketIPv4Address(void)925 void test_FreeRTOS_bind_IPTaskDidNotBindTheSocketIPv4Address( void )
926 {
927 BaseType_t xReturn;
928 FreeRTOS_Socket_t xSocket;
929 struct freertos_sockaddr xAddress;
930 socklen_t xAddressLength;
931 uint32_t ulExpectIPAddress = 0xC0A80101; /* 192.168.1.1 */
932 uint16_t usExpectPort = 0x1234;
933
934 xAddress.sin_family = FREERTOS_AF_INET4;
935 xAddress.sin_address.ulIP_IPv4 = FreeRTOS_htonl( ulExpectIPAddress );
936 xAddress.sin_port = FreeRTOS_htons( usExpectPort );
937
938 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
939
940 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
941
942 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
943 xSendEventStructToIPTask_IgnoreArg_pxEvent();
944
945 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, ( EventBits_t ) eSOCKET_BOUND, pdTRUE, pdFALSE, portMAX_DELAY, pdPASS );
946
947 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
948
949 xReturn = FreeRTOS_bind( &xSocket, &xAddress, xAddressLength );
950
951 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
952 TEST_ASSERT_EQUAL( pdFALSE, xSocket.bits.bIsIPv6 );
953 TEST_ASSERT_EQUAL( ulExpectIPAddress, xSocket.xLocalAddress.ulIP_IPv4 );
954 TEST_ASSERT_EQUAL( usExpectPort, xSocket.usLocalPort );
955 }
956
957 /**
958 * @brief IPv6 socket did not bind the socket.
959 */
test_FreeRTOS_bind_IPTaskDidNotBindTheSocketIPv6Address(void)960 void test_FreeRTOS_bind_IPTaskDidNotBindTheSocketIPv6Address( void )
961 {
962 BaseType_t xReturn;
963 FreeRTOS_Socket_t xSocket;
964 struct freertos_sockaddr xAddress;
965 socklen_t xAddressLength;
966 IPv6_Address_t xExpectIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } }; /* 2001::1 */
967 uint16_t usExpectPort = 0x1234;
968
969 xAddress.sin_family = FREERTOS_AF_INET6;
970 memcpy( xAddress.sin_address.xIP_IPv6.ucBytes, xExpectIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
971 xAddress.sin_port = FreeRTOS_htons( usExpectPort );
972
973 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
974
975 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
976
977 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
978 xSendEventStructToIPTask_IgnoreArg_pxEvent();
979
980 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, ( EventBits_t ) eSOCKET_BOUND, pdTRUE, pdFALSE, portMAX_DELAY, pdPASS );
981
982 listLIST_ITEM_CONTAINER_ExpectAndReturn( &( xSocket.xBoundSocketListItem ), NULL );
983
984 xReturn = FreeRTOS_bind( &xSocket, &xAddress, xAddressLength );
985
986 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
987 TEST_ASSERT_EQUAL( pdTRUE, xSocket.bits.bIsIPv6 );
988 TEST_ASSERT_EQUAL_MEMORY( xExpectIPv6Address.ucBytes, xSocket.xLocalAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
989 TEST_ASSERT_EQUAL( usExpectPort, xSocket.usLocalPort );
990 }
991
992 /**
993 * @brief Trying to close a NULL socket.
994 */
test_FreeRTOS_closesocket_NULLSocket(void)995 void test_FreeRTOS_closesocket_NULLSocket( void )
996 {
997 BaseType_t xReturn;
998 Socket_t xSocket = NULL;
999
1000 xReturn = FreeRTOS_closesocket( xSocket );
1001
1002 TEST_ASSERT_EQUAL( 0, xReturn );
1003 }
1004
1005 /**
1006 * @brief Trying to close an invalid socket.
1007 */
test_FreeRTOS_closesocket_InvalidSocket(void)1008 void test_FreeRTOS_closesocket_InvalidSocket( void )
1009 {
1010 BaseType_t xReturn;
1011 Socket_t xSocket = ( Socket_t ) ( uintptr_t ) FREERTOS_INVALID_SOCKET;
1012
1013 xReturn = FreeRTOS_closesocket( xSocket );
1014
1015 TEST_ASSERT_EQUAL( 0, xReturn );
1016 }
1017
1018 /**
1019 * @brief Sending event to IP task failed.
1020 */
test_FreeRTOS_closesocket_TCPSocketSendFail(void)1021 void test_FreeRTOS_closesocket_TCPSocketSendFail( void )
1022 {
1023 BaseType_t xReturn;
1024 FreeRTOS_Socket_t xSocket;
1025
1026 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1027
1028 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1029
1030 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdFAIL );
1031 xSendEventStructToIPTask_IgnoreArg_pxEvent();
1032
1033 xReturn = FreeRTOS_closesocket( &xSocket );
1034
1035 TEST_ASSERT_EQUAL( -1, xReturn );
1036 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleConnected );
1037 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleReceive );
1038 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleSent );
1039 }
1040
1041 /**
1042 * @brief Closing socket successful.
1043 */
test_FreeRTOS_closesocket_TCPSocketSendPass(void)1044 void test_FreeRTOS_closesocket_TCPSocketSendPass( void )
1045 {
1046 BaseType_t xReturn;
1047 FreeRTOS_Socket_t xSocket;
1048
1049 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1050
1051 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_TCP;
1052
1053 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
1054 xSendEventStructToIPTask_IgnoreArg_pxEvent();
1055
1056 xReturn = FreeRTOS_closesocket( &xSocket );
1057
1058 TEST_ASSERT_EQUAL( 1, xReturn );
1059 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleConnected );
1060 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleReceive );
1061 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxHandleSent );
1062 }
1063
1064 /**
1065 * @brief UDP socket closing failed as sending event to IP task failed.
1066 */
test_FreeRTOS_closesocket_UDPSocketSendFail(void)1067 void test_FreeRTOS_closesocket_UDPSocketSendFail( void )
1068 {
1069 BaseType_t xReturn;
1070 FreeRTOS_Socket_t xSocket;
1071
1072 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1073
1074 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
1075
1076 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdFAIL );
1077 xSendEventStructToIPTask_IgnoreArg_pxEvent();
1078
1079 xReturn = FreeRTOS_closesocket( &xSocket );
1080
1081 TEST_ASSERT_EQUAL( -1, xReturn );
1082 TEST_ASSERT_EQUAL( NULL, xSocket.u.xUDP.pxHandleReceive );
1083 TEST_ASSERT_EQUAL( NULL, xSocket.u.xUDP.pxHandleSent );
1084 }
1085
1086 /**
1087 * @brief Closing UDP socket successful.
1088 */
test_FreeRTOS_closesocket_UDPSocketSendPass(void)1089 void test_FreeRTOS_closesocket_UDPSocketSendPass( void )
1090 {
1091 BaseType_t xReturn;
1092 FreeRTOS_Socket_t xSocket;
1093
1094 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1095
1096 xSocket.ucProtocol = ( uint8_t ) FREERTOS_IPPROTO_UDP;
1097
1098 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
1099 xSendEventStructToIPTask_IgnoreArg_pxEvent();
1100
1101 xReturn = FreeRTOS_closesocket( &xSocket );
1102
1103 TEST_ASSERT_EQUAL( 1, xReturn );
1104 TEST_ASSERT_EQUAL( NULL, xSocket.u.xUDP.pxHandleReceive );
1105 TEST_ASSERT_EQUAL( NULL, xSocket.u.xUDP.pxHandleSent );
1106 }
1107
1108 /**
1109 * @brief Closing socket with unknown protocol.
1110 */
test_FreeRTOS_closesocket_UnknownProtocol(void)1111 void test_FreeRTOS_closesocket_UnknownProtocol( void )
1112 {
1113 BaseType_t xReturn;
1114 FreeRTOS_Socket_t xSocket;
1115
1116 memset( &xSocket, 0xAB, sizeof( xSocket ) );
1117
1118 xSendEventStructToIPTask_ExpectAndReturn( NULL, portMAX_DELAY, pdPASS );
1119 xSendEventStructToIPTask_IgnoreArg_pxEvent();
1120
1121 xReturn = FreeRTOS_closesocket( &xSocket );
1122
1123 TEST_ASSERT_EQUAL( 1, xReturn );
1124 }
1125
1126 /**
1127 * @brief Setting option of a NULL socket.
1128 */
test_FreeRTOS_setsockopt_NULLSocket(void)1129 void test_FreeRTOS_setsockopt_NULLSocket( void )
1130 {
1131 BaseType_t xReturn;
1132 FreeRTOS_Socket_t xSocket;
1133 int32_t lLevel;
1134 int32_t lOptionName;
1135 const void * pvOptionValue;
1136 size_t uxOptionLength;
1137
1138 xReturn = FreeRTOS_setsockopt( NULL, lLevel, lOptionName, pvOptionValue, uxOptionLength );
1139 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1140 }
1141
1142 /**
1143 * @brief Setting option of an invalid socket.
1144 */
test_FreeRTOS_setsockopt_InvalidSocket(void)1145 void test_FreeRTOS_setsockopt_InvalidSocket( void )
1146 {
1147 BaseType_t xReturn;
1148 FreeRTOS_Socket_t xSocket;
1149 int32_t lLevel;
1150 int32_t lOptionName;
1151 const void * pvOptionValue;
1152 size_t uxOptionLength;
1153
1154 xReturn = FreeRTOS_setsockopt( FREERTOS_INVALID_SOCKET, lLevel, lOptionName, pvOptionValue, uxOptionLength );
1155 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1156 }
1157
1158 /**
1159 * @brief
1160 */
test_FreeRTOS_setsockopt_RecvTimeOut(void)1161 void test_FreeRTOS_setsockopt_RecvTimeOut( void )
1162 {
1163 BaseType_t xReturn;
1164 FreeRTOS_Socket_t xSocket;
1165 int32_t lLevel;
1166 int32_t lOptionName = FREERTOS_SO_RCVTIMEO;
1167 TickType_t vOptionValue = 0x123;
1168 size_t uxOptionLength;
1169
1170 memset( &xSocket, 0, sizeof( xSocket ) );
1171
1172 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1173 TEST_ASSERT_EQUAL( 0, xReturn );
1174 TEST_ASSERT_EQUAL( vOptionValue, xSocket.xReceiveBlockTime );
1175 }
1176
1177 /**
1178 * @brief Setting timeout option.
1179 */
test_FreeRTOS_setsockopt_SendTimeOut(void)1180 void test_FreeRTOS_setsockopt_SendTimeOut( void )
1181 {
1182 BaseType_t xReturn;
1183 FreeRTOS_Socket_t xSocket;
1184 int32_t lLevel;
1185 int32_t lOptionName = FREERTOS_SO_SNDTIMEO;
1186 TickType_t vOptionValue = 0x123;
1187 size_t uxOptionLength;
1188
1189 memset( &xSocket, 0, sizeof( xSocket ) );
1190
1191 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1192
1193 TEST_ASSERT_EQUAL( 0, xReturn );
1194 TEST_ASSERT_EQUAL( vOptionValue, xSocket.xSendBlockTime );
1195 }
1196
1197 /**
1198 * @brief Setting send timeout option for UDP socket.
1199 */
test_FreeRTOS_setsockopt_SendTimeOutUDP(void)1200 void test_FreeRTOS_setsockopt_SendTimeOutUDP( void )
1201 {
1202 BaseType_t xReturn;
1203 FreeRTOS_Socket_t xSocket;
1204 int32_t lLevel;
1205 int32_t lOptionName = FREERTOS_SO_SNDTIMEO;
1206 TickType_t vOptionValue = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS;
1207 size_t uxOptionLength;
1208
1209 memset( &xSocket, 0, sizeof( xSocket ) );
1210
1211 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1212
1213 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1214
1215 TEST_ASSERT_EQUAL( 0, xReturn );
1216 TEST_ASSERT_EQUAL( vOptionValue, xSocket.xSendBlockTime );
1217 }
1218
1219 /**
1220 * @brief Setting send timeout option for UDP socket, timeout is more than maximum allowed value.
1221 */
test_FreeRTOS_setsockopt_SendTimeOutUDPMoreBockingTime(void)1222 void test_FreeRTOS_setsockopt_SendTimeOutUDPMoreBockingTime( void )
1223 {
1224 BaseType_t xReturn;
1225 FreeRTOS_Socket_t xSocket;
1226 int32_t lLevel;
1227 int32_t lOptionName = FREERTOS_SO_SNDTIMEO;
1228 TickType_t vOptionValue = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS + 100;
1229 size_t uxOptionLength;
1230
1231 memset( &xSocket, 0, sizeof( xSocket ) );
1232
1233 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1234
1235 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1236
1237 TEST_ASSERT_EQUAL( 0, xReturn );
1238 TEST_ASSERT_EQUAL( ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS, xSocket.xSendBlockTime );
1239 }
1240
1241 /**
1242 * @brief Setting maximum waiting packet limit in UDP socket.
1243 */
test_FreeRTOS_setsockopt_UDPMaxRxPackets(void)1244 void test_FreeRTOS_setsockopt_UDPMaxRxPackets( void )
1245 {
1246 BaseType_t xReturn;
1247 FreeRTOS_Socket_t xSocket;
1248 int32_t lLevel;
1249 int32_t lOptionName = FREERTOS_SO_UDP_MAX_RX_PACKETS;
1250 UBaseType_t vOptionValue = 100;
1251 size_t uxOptionLength;
1252
1253 memset( &xSocket, 0, sizeof( xSocket ) );
1254
1255 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1256
1257 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1258
1259 TEST_ASSERT_EQUAL( 0, xReturn );
1260 TEST_ASSERT_EQUAL( 100, xSocket.u.xUDP.uxMaxPackets );
1261 }
1262
1263 /**
1264 * @brief Setting maximum waiting packet limit in non-UDP socket.
1265 */
test_FreeRTOS_setsockopt_UDPMaxRxPacketsNonUDPSock(void)1266 void test_FreeRTOS_setsockopt_UDPMaxRxPacketsNonUDPSock( void )
1267 {
1268 BaseType_t xReturn;
1269 FreeRTOS_Socket_t xSocket;
1270 int32_t lLevel;
1271 int32_t lOptionName = FREERTOS_SO_UDP_MAX_RX_PACKETS;
1272 UBaseType_t vOptionValue = 100;
1273 size_t uxOptionLength;
1274
1275 memset( &xSocket, 0, sizeof( xSocket ) );
1276
1277 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1278
1279 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1280
1281 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1282 TEST_ASSERT_EQUAL( 0, xSocket.u.xUDP.uxMaxPackets );
1283 }
1284
1285 /**
1286 * @brief Set UDP checksum option with NULL value.
1287 */
test_FreeRTOS_setsockopt_UDPChkSumNULL(void)1288 void test_FreeRTOS_setsockopt_UDPChkSumNULL( void )
1289 {
1290 BaseType_t xReturn;
1291 FreeRTOS_Socket_t xSocket;
1292 int32_t lLevel;
1293 int32_t lOptionName = FREERTOS_SO_UDPCKSUM_OUT;
1294 UBaseType_t vOptionValue = 100;
1295 size_t uxOptionLength;
1296
1297 memset( &xSocket, 0, sizeof( xSocket ) );
1298
1299 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1300 xSocket.ucSocketOptions = ( uint8_t ) FREERTOS_SO_UDPCKSUM_OUT;
1301
1302 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, NULL, uxOptionLength );
1303
1304 TEST_ASSERT_EQUAL( 0, xReturn );
1305 TEST_ASSERT_EQUAL( 0, xSocket.ucSocketOptions );
1306 }
1307
1308 /**
1309 * @brief Set UDP checksum option.
1310 */
test_FreeRTOS_setsockopt_UDPChkSum(void)1311 void test_FreeRTOS_setsockopt_UDPChkSum( void )
1312 {
1313 BaseType_t xReturn;
1314 FreeRTOS_Socket_t xSocket;
1315 int32_t lLevel;
1316 int32_t lOptionName = FREERTOS_SO_UDPCKSUM_OUT;
1317 UBaseType_t vOptionValue = 100;
1318 size_t uxOptionLength;
1319
1320 memset( &xSocket, 0, sizeof( xSocket ) );
1321
1322 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1323
1324 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1325
1326 TEST_ASSERT_EQUAL( 0, xReturn );
1327 TEST_ASSERT_EQUAL( FREERTOS_SO_UDPCKSUM_OUT, xSocket.ucSocketOptions );
1328 }
1329
1330 /**
1331 * @brief Set TCP connection handler for UDP socket.
1332 */
test_FreeRTOS_setsockopt_TCPConnInvalidProtocol(void)1333 void test_FreeRTOS_setsockopt_TCPConnInvalidProtocol( void )
1334 {
1335 BaseType_t xReturn;
1336 FreeRTOS_Socket_t xSocket;
1337 int32_t lLevel;
1338 int32_t lOptionName = FREERTOS_SO_TCP_CONN_HANDLER;
1339 UBaseType_t vOptionValue = 100;
1340 size_t uxOptionLength;
1341
1342 memset( &xSocket, 0, sizeof( xSocket ) );
1343
1344 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1345
1346 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1347
1348 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1349 }
1350
1351 /**
1352 * @brief TCP connection handler success.
1353 */
test_FreeRTOS_setsockopt_TCPConnSuccess(void)1354 void test_FreeRTOS_setsockopt_TCPConnSuccess( void )
1355 {
1356 BaseType_t xReturn;
1357 FreeRTOS_Socket_t xSocket;
1358 int32_t lLevel;
1359 int32_t lOptionName = FREERTOS_SO_TCP_CONN_HANDLER;
1360 F_TCP_UDP_Handler_t vOptionValue;
1361 size_t uxOptionLength;
1362
1363 memset( &xSocket, 0, sizeof( xSocket ) );
1364
1365 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1366
1367 vOptionValue.pxOnTCPConnected = ( FOnConnected_t ) 0x123ABD;
1368
1369 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1370
1371 TEST_ASSERT_EQUAL( 0, xReturn );
1372 TEST_ASSERT_EQUAL( 0x123ABD, xSocket.u.xTCP.pxHandleConnected );
1373 }
1374
1375 /**
1376 * @brief
1377 */
test_FreeRTOS_setsockopt_TCPRecvInvalidProtocol(void)1378 void test_FreeRTOS_setsockopt_TCPRecvInvalidProtocol( void )
1379 {
1380 BaseType_t xReturn;
1381 FreeRTOS_Socket_t xSocket;
1382 int32_t lLevel;
1383 int32_t lOptionName = FREERTOS_SO_TCP_RECV_HANDLER;
1384 UBaseType_t vOptionValue = 100;
1385 size_t uxOptionLength;
1386
1387 memset( &xSocket, 0, sizeof( xSocket ) );
1388
1389 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1390
1391 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1392
1393 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1394 }
1395
1396 /**
1397 * @brief TCP receive handler success.
1398 */
test_FreeRTOS_setsockopt_TCPRecvSuccess(void)1399 void test_FreeRTOS_setsockopt_TCPRecvSuccess( void )
1400 {
1401 BaseType_t xReturn;
1402 FreeRTOS_Socket_t xSocket;
1403 int32_t lLevel;
1404 int32_t lOptionName = FREERTOS_SO_TCP_RECV_HANDLER;
1405 F_TCP_UDP_Handler_t vOptionValue;
1406 size_t uxOptionLength;
1407
1408 memset( &xSocket, 0, sizeof( xSocket ) );
1409
1410 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1411
1412 vOptionValue.pxOnTCPReceive = ( FOnTCPReceive_t ) 0x123ABD;
1413
1414 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1415
1416 TEST_ASSERT_EQUAL( 0, xReturn );
1417 TEST_ASSERT_EQUAL( 0x123ABD, xSocket.u.xTCP.pxHandleReceive );
1418 }
1419
1420 /**
1421 * @brief Setting TCP send handler for a UDP socket.
1422 */
test_FreeRTOS_setsockopt_TCPSendInvalidProtocol(void)1423 void test_FreeRTOS_setsockopt_TCPSendInvalidProtocol( void )
1424 {
1425 BaseType_t xReturn;
1426 FreeRTOS_Socket_t xSocket;
1427 int32_t lLevel;
1428 int32_t lOptionName = FREERTOS_SO_TCP_SENT_HANDLER;
1429 UBaseType_t vOptionValue = 100;
1430 size_t uxOptionLength;
1431
1432 memset( &xSocket, 0, sizeof( xSocket ) );
1433
1434 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1435
1436 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1437
1438 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1439 }
1440
1441 /**
1442 * @brief Set TCP sending handler.
1443 */
test_FreeRTOS_setsockopt_TCPSendSuccess(void)1444 void test_FreeRTOS_setsockopt_TCPSendSuccess( void )
1445 {
1446 BaseType_t xReturn;
1447 FreeRTOS_Socket_t xSocket;
1448 int32_t lLevel;
1449 int32_t lOptionName = FREERTOS_SO_TCP_SENT_HANDLER;
1450 F_TCP_UDP_Handler_t vOptionValue;
1451 size_t uxOptionLength;
1452
1453 memset( &xSocket, 0, sizeof( xSocket ) );
1454
1455 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1456
1457 vOptionValue.pxOnTCPSent = ( FOnTCPSent_t ) 0x123ABD;
1458
1459 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1460
1461 TEST_ASSERT_EQUAL( 0, xReturn );
1462 TEST_ASSERT_EQUAL( 0x123ABD, xSocket.u.xTCP.pxHandleSent );
1463 }
1464
1465 /**
1466 * @brief Set UDP receive handler for a TCP socket.
1467 */
test_FreeRTOS_setsockopt_UDPRecvInvalidProtocol(void)1468 void test_FreeRTOS_setsockopt_UDPRecvInvalidProtocol( void )
1469 {
1470 BaseType_t xReturn;
1471 FreeRTOS_Socket_t xSocket;
1472 int32_t lLevel;
1473 int32_t lOptionName = FREERTOS_SO_UDP_RECV_HANDLER;
1474 UBaseType_t vOptionValue = 100;
1475 size_t uxOptionLength;
1476
1477 memset( &xSocket, 0, sizeof( xSocket ) );
1478
1479 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1480
1481 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1482
1483 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1484 }
1485
1486 /**
1487 * @brief Set UDP receive handler.
1488 */
test_FreeRTOS_setsockopt_UDPRecvSuccess(void)1489 void test_FreeRTOS_setsockopt_UDPRecvSuccess( void )
1490 {
1491 BaseType_t xReturn;
1492 FreeRTOS_Socket_t xSocket;
1493 int32_t lLevel;
1494 int32_t lOptionName = FREERTOS_SO_UDP_RECV_HANDLER;
1495 F_TCP_UDP_Handler_t vOptionValue;
1496 size_t uxOptionLength;
1497
1498 memset( &xSocket, 0, sizeof( xSocket ) );
1499
1500 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1501
1502 vOptionValue.pxOnUDPReceive = ( FOnUDPReceive_t ) 0x123ABD;
1503
1504 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1505
1506 TEST_ASSERT_EQUAL( 0, xReturn );
1507 TEST_ASSERT_EQUAL( 0x123ABD, xSocket.u.xUDP.pxHandleReceive );
1508 }
1509
1510 /**
1511 * @brief UDP send handler for TCP socket.
1512 */
test_FreeRTOS_setsockopt_UDPSendInvalidProtocol(void)1513 void test_FreeRTOS_setsockopt_UDPSendInvalidProtocol( void )
1514 {
1515 BaseType_t xReturn;
1516 FreeRTOS_Socket_t xSocket;
1517 int32_t lLevel;
1518 int32_t lOptionName = FREERTOS_SO_UDP_SENT_HANDLER;
1519 UBaseType_t vOptionValue = 100;
1520 size_t uxOptionLength;
1521
1522 memset( &xSocket, 0, sizeof( xSocket ) );
1523
1524 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1525
1526 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1527
1528 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1529 }
1530
1531 /**
1532 * @brief Set UDP send handler.
1533 */
test_FreeRTOS_setsockopt_UDPSendSuccess(void)1534 void test_FreeRTOS_setsockopt_UDPSendSuccess( void )
1535 {
1536 BaseType_t xReturn;
1537 FreeRTOS_Socket_t xSocket;
1538 int32_t lLevel;
1539 int32_t lOptionName = FREERTOS_SO_UDP_SENT_HANDLER;
1540 F_TCP_UDP_Handler_t vOptionValue;
1541 size_t uxOptionLength;
1542
1543 memset( &xSocket, 0, sizeof( xSocket ) );
1544
1545 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1546
1547 vOptionValue.pxOnUDPSent = ( FOnUDPSent_t ) 0x123ABD;
1548
1549 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1550
1551 TEST_ASSERT_EQUAL( 0, xReturn );
1552 TEST_ASSERT_EQUAL( 0x123ABD, xSocket.u.xUDP.pxHandleSent );
1553 }
1554
1555 /**
1556 * @brief Set semaphore for a socket.
1557 */
test_FreeRTOS_setsockopt_SetSemaphore(void)1558 void test_FreeRTOS_setsockopt_SetSemaphore( void )
1559 {
1560 BaseType_t xReturn;
1561 FreeRTOS_Socket_t xSocket;
1562 int32_t lLevel;
1563 int32_t lOptionName = FREERTOS_SO_SET_SEMAPHORE;
1564 SemaphoreHandle_t vOptionValue;
1565 size_t uxOptionLength;
1566
1567 memset( &xSocket, 0, sizeof( xSocket ) );
1568
1569 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1570
1571 TEST_ASSERT_EQUAL( 0, xReturn );
1572 TEST_ASSERT_EQUAL( vOptionValue, xSocket.pxUserSemaphore );
1573 }
1574
1575 /**
1576 * @brief Set wakeup callback.
1577 */
test_FreeRTOS_setsockopt_WakeUpCallback(void)1578 void test_FreeRTOS_setsockopt_WakeUpCallback( void )
1579 {
1580 BaseType_t xReturn;
1581 FreeRTOS_Socket_t xSocket;
1582 int32_t lLevel;
1583 int32_t lOptionName = FREERTOS_SO_WAKEUP_CALLBACK;
1584 SemaphoreHandle_t vOptionValue;
1585 size_t uxOptionLength;
1586
1587 memset( &xSocket, 0, sizeof( xSocket ) );
1588
1589 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1590
1591 TEST_ASSERT_EQUAL( 0, xReturn );
1592 TEST_ASSERT_EQUAL( &vOptionValue, xSocket.pxUserWakeCallback );
1593 }
1594
1595 /**
1596 * @brief Set low high water mark of socket having invalid protocol.
1597 */
test_FreeRTOS_setsockopt_SetLowHighWaterInvalidProtocol(void)1598 void test_FreeRTOS_setsockopt_SetLowHighWaterInvalidProtocol( void )
1599 {
1600 BaseType_t xReturn;
1601 FreeRTOS_Socket_t xSocket;
1602 int32_t lLevel;
1603 int32_t lOptionName = FREERTOS_SO_SET_LOW_HIGH_WATER;
1604 SemaphoreHandle_t vOptionValue;
1605 size_t uxOptionLength;
1606
1607 memset( &xSocket, 0, sizeof( xSocket ) );
1608
1609 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1610
1611 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1612
1613 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1614 }
1615
1616 /**
1617 * @brief Set low high water mark of socket with invalid values.
1618 */
test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues1(void)1619 void test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues1( void )
1620 {
1621 BaseType_t xReturn;
1622 FreeRTOS_Socket_t xSocket;
1623 int32_t lLevel;
1624 int32_t lOptionName = FREERTOS_SO_SET_LOW_HIGH_WATER;
1625 LowHighWater_t vOptionValue;
1626 size_t uxOptionLength;
1627
1628 memset( &xSocket, 0, sizeof( xSocket ) );
1629
1630 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1631
1632 vOptionValue.uxLittleSpace = 0x123;
1633 vOptionValue.uxEnoughSpace = vOptionValue.uxLittleSpace;
1634
1635 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1636
1637 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1638 }
1639
1640 /**
1641 * @brief Set low high water mark of socket with invalid values.
1642 */
test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues2(void)1643 void test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues2( void )
1644 {
1645 BaseType_t xReturn;
1646 FreeRTOS_Socket_t xSocket;
1647 int32_t lLevel;
1648 int32_t lOptionName = FREERTOS_SO_SET_LOW_HIGH_WATER;
1649 LowHighWater_t vOptionValue;
1650 size_t uxOptionLength;
1651
1652 memset( &xSocket, 0, sizeof( xSocket ) );
1653
1654 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1655
1656 vOptionValue.uxLittleSpace = 0x123;
1657 vOptionValue.uxEnoughSpace = vOptionValue.uxLittleSpace - 0x12;
1658
1659 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1660
1661 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1662 }
1663
1664 /**
1665 * @brief Set low high water mark of socket with invalid values.
1666 */
test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues3(void)1667 void test_FreeRTOS_setsockopt_SetLowHighWaterInvalidValues3( void )
1668 {
1669 BaseType_t xReturn;
1670 FreeRTOS_Socket_t xSocket;
1671 int32_t lLevel;
1672 int32_t lOptionName = FREERTOS_SO_SET_LOW_HIGH_WATER;
1673 LowHighWater_t vOptionValue;
1674 size_t uxOptionLength;
1675
1676 memset( &xSocket, 0, sizeof( xSocket ) );
1677
1678 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1679
1680 vOptionValue.uxLittleSpace = 0x123;
1681 vOptionValue.uxEnoughSpace = vOptionValue.uxLittleSpace + 0x123;
1682 xSocket.u.xTCP.uxRxStreamSize = vOptionValue.uxEnoughSpace - 0x12;
1683
1684 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1685
1686 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1687 }
1688
1689 /**
1690 * @brief Set low high water mark of socket.
1691 */
test_FreeRTOS_setsockopt_SetLowHighWaterHappyPath(void)1692 void test_FreeRTOS_setsockopt_SetLowHighWaterHappyPath( void )
1693 {
1694 BaseType_t xReturn;
1695 FreeRTOS_Socket_t xSocket;
1696 int32_t lLevel;
1697 int32_t lOptionName = FREERTOS_SO_SET_LOW_HIGH_WATER;
1698 LowHighWater_t vOptionValue;
1699 size_t uxOptionLength;
1700
1701 memset( &xSocket, 0, sizeof( xSocket ) );
1702
1703 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1704
1705 vOptionValue.uxLittleSpace = 0x123;
1706 vOptionValue.uxEnoughSpace = vOptionValue.uxLittleSpace + 0x123;
1707 xSocket.u.xTCP.uxRxStreamSize = vOptionValue.uxEnoughSpace + 0x12;
1708
1709 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1710
1711 TEST_ASSERT_EQUAL( 0, xReturn );
1712 TEST_ASSERT_EQUAL( vOptionValue.uxLittleSpace, xSocket.u.xTCP.uxLittleSpace );
1713 TEST_ASSERT_EQUAL( vOptionValue.uxEnoughSpace, xSocket.u.xTCP.uxEnoughSpace );
1714 }
1715
1716 /**
1717 * @brief Send buffer set for TCP socket.
1718 */
test_FreeRTOS_setsockopt_SendBuff(void)1719 void test_FreeRTOS_setsockopt_SendBuff( void )
1720 {
1721 BaseType_t xReturn;
1722 FreeRTOS_Socket_t xSocket;
1723 int32_t lLevel;
1724 int32_t lOptionName = FREERTOS_SO_SNDBUF;
1725 uint32_t vOptionValue = 0xABCD1234;
1726 size_t uxOptionLength;
1727
1728 memset( &xSocket, 0, sizeof( xSocket ) );
1729
1730 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1731 xSocket.u.xTCP.txStream = NULL;
1732 xSocket.u.xTCP.usMSS = 0x12;
1733
1734 FreeRTOS_round_up_ExpectAndReturn( vOptionValue, xSocket.u.xTCP.usMSS, 0xAB );
1735
1736 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1737
1738 TEST_ASSERT_EQUAL( 0, xReturn );
1739 TEST_ASSERT_EQUAL( 0xAB, xSocket.u.xTCP.uxTxStreamSize );
1740 }
1741
1742 /**
1743 * @brief Receive buffer set for TCP socket.
1744 */
test_FreeRTOS_setsockopt_RecvBuff(void)1745 void test_FreeRTOS_setsockopt_RecvBuff( void )
1746 {
1747 BaseType_t xReturn;
1748 FreeRTOS_Socket_t xSocket;
1749 int32_t lLevel;
1750 int32_t lOptionName = FREERTOS_SO_RCVBUF;
1751 uint32_t vOptionValue = 0xABCD1234;
1752 size_t uxOptionLength;
1753
1754 memset( &xSocket, 0, sizeof( xSocket ) );
1755
1756 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1757 xSocket.u.xTCP.rxStream = NULL;
1758
1759 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1760
1761 TEST_ASSERT_EQUAL( 0, xReturn );
1762 TEST_ASSERT_EQUAL( vOptionValue, xSocket.u.xTCP.uxRxStreamSize );
1763 }
1764
1765 /**
1766 * @brief Set windows properties of a socket for a UDP socket.
1767 */
test_FreeRTOS_setsockopt_WinPropsInvalidProtocol(void)1768 void test_FreeRTOS_setsockopt_WinPropsInvalidProtocol( void )
1769 {
1770 BaseType_t xReturn;
1771 FreeRTOS_Socket_t xSocket;
1772 int32_t lLevel;
1773 int32_t lOptionName = FREERTOS_SO_WIN_PROPERTIES;
1774 uint32_t vOptionValue = 0xABCD1234;
1775 size_t uxOptionLength;
1776
1777 memset( &xSocket, 0, sizeof( xSocket ) );
1778
1779 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1780
1781 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1782
1783 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1784 }
1785
1786 /**
1787 * @brief Set windows properties of a socket which doesn't have a valid Tx stream.
1788 */
test_FreeRTOS_setsockopt_WinPropsInvalidTxStream(void)1789 void test_FreeRTOS_setsockopt_WinPropsInvalidTxStream( void )
1790 {
1791 BaseType_t xReturn;
1792 FreeRTOS_Socket_t xSocket;
1793 int32_t lLevel;
1794 int32_t lOptionName = FREERTOS_SO_WIN_PROPERTIES;
1795 uint32_t vOptionValue = 0xABCD1234;
1796 size_t uxOptionLength;
1797
1798 memset( &xSocket, 0, sizeof( xSocket ) );
1799
1800 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1801 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) 0x1234;
1802
1803 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1804
1805 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1806 }
1807
1808 /**
1809 * @brief Set windows properties of a socket which doesn't have a valid Rx stream.
1810 */
test_FreeRTOS_setsockopt_WinPropsInvalidRxStream(void)1811 void test_FreeRTOS_setsockopt_WinPropsInvalidRxStream( void )
1812 {
1813 BaseType_t xReturn;
1814 FreeRTOS_Socket_t xSocket;
1815 int32_t lLevel;
1816 int32_t lOptionName = FREERTOS_SO_WIN_PROPERTIES;
1817 WinProperties_t vOptionValue;
1818 size_t uxOptionLength;
1819
1820 memset( &xSocket, 0, sizeof( xSocket ) );
1821
1822 vOptionValue.lTxBufSize = 0xBB;
1823
1824 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1825 xSocket.u.xTCP.rxStream = ( StreamBuffer_t * ) 0x1234;
1826 xSocket.u.xTCP.usMSS = 0x12;
1827
1828 FreeRTOS_round_up_ExpectAndReturn( vOptionValue.lTxBufSize, xSocket.u.xTCP.usMSS, 0xAB );
1829
1830 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1831
1832 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1833 }
1834
1835 /**
1836 * @brief Set windows properties of a socket whose windowing has not been initialised.
1837 */
test_FreeRTOS_setsockopt_WinPropsTCPWinNotInit(void)1838 void test_FreeRTOS_setsockopt_WinPropsTCPWinNotInit( void )
1839 {
1840 BaseType_t xReturn;
1841 FreeRTOS_Socket_t xSocket;
1842 int32_t lLevel;
1843 int32_t lOptionName = FREERTOS_SO_WIN_PROPERTIES;
1844 WinProperties_t vOptionValue;
1845 size_t uxOptionLength;
1846
1847 memset( &xSocket, 0, sizeof( xSocket ) );
1848 memset( &vOptionValue, 0xCB, sizeof( vOptionValue ) );
1849
1850 vOptionValue.lTxBufSize = 0xBB;
1851
1852 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1853 xSocket.u.xTCP.usMSS = 0x12;
1854 xSocket.u.xTCP.xTCPWindow.u.bits.bHasInit = pdFALSE;
1855
1856 FreeRTOS_round_up_ExpectAndReturn( vOptionValue.lTxBufSize, xSocket.u.xTCP.usMSS, 0xAB );
1857
1858 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1859
1860 TEST_ASSERT_EQUAL( 0, xReturn );
1861 TEST_ASSERT_EQUAL( ( uint32_t ) vOptionValue.lTxWinSize, xSocket.u.xTCP.uxRxWinSize );
1862 TEST_ASSERT_EQUAL( ( uint32_t ) vOptionValue.lTxWinSize, xSocket.u.xTCP.uxTxWinSize );
1863 }
1864
1865 /**
1866 * @brief Set windows properties of a socket whose windowing has been initialised.
1867 */
test_FreeRTOS_setsockopt_WinPropsTCPWinInit(void)1868 void test_FreeRTOS_setsockopt_WinPropsTCPWinInit( void )
1869 {
1870 BaseType_t xReturn;
1871 FreeRTOS_Socket_t xSocket;
1872 int32_t lLevel;
1873 int32_t lOptionName = FREERTOS_SO_WIN_PROPERTIES;
1874 WinProperties_t vOptionValue;
1875 size_t uxOptionLength;
1876
1877 memset( &xSocket, 0, sizeof( xSocket ) );
1878 memset( &vOptionValue, 0xCB, sizeof( vOptionValue ) );
1879
1880 vOptionValue.lTxBufSize = 0xBB;
1881
1882 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1883 xSocket.u.xTCP.usMSS = 0x12;
1884 xSocket.u.xTCP.xTCPWindow.u.bits.bHasInit = pdTRUE;
1885
1886 FreeRTOS_round_up_ExpectAndReturn( vOptionValue.lTxBufSize, xSocket.u.xTCP.usMSS, 0xAB );
1887
1888 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1889
1890 TEST_ASSERT_EQUAL( 0, xReturn );
1891 TEST_ASSERT_EQUAL( ( uint32_t ) vOptionValue.lRxWinSize, xSocket.u.xTCP.uxRxWinSize );
1892 TEST_ASSERT_EQUAL( ( uint32_t ) vOptionValue.lTxWinSize, xSocket.u.xTCP.uxTxWinSize );
1893 TEST_ASSERT_EQUAL_UINT32( ( ( uint32_t ) vOptionValue.lRxWinSize * xSocket.u.xTCP.usMSS ), xSocket.u.xTCP.xTCPWindow.xSize.ulRxWindowLength );
1894 TEST_ASSERT_EQUAL_UINT32( ( ( uint32_t ) vOptionValue.lTxWinSize * xSocket.u.xTCP.usMSS ), xSocket.u.xTCP.xTCPWindow.xSize.ulTxWindowLength );
1895 }
1896
1897 /**
1898 * @brief Set option to reuse socket of a UDP socket.
1899 */
test_FreeRTOS_setsockopt_ReUseListenSock_InvalidProtocol(void)1900 void test_FreeRTOS_setsockopt_ReUseListenSock_InvalidProtocol( void )
1901 {
1902 BaseType_t xReturn;
1903 FreeRTOS_Socket_t xSocket;
1904 int32_t lLevel;
1905 int32_t lOptionName = FREERTOS_SO_REUSE_LISTEN_SOCKET;
1906 BaseType_t vOptionValue;
1907 size_t uxOptionLength;
1908
1909 memset( &xSocket, 0, sizeof( xSocket ) );
1910 memset( &vOptionValue, 0xCB, sizeof( vOptionValue ) );
1911
1912 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1913
1914 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1915
1916 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1917 }
1918
1919 /**
1920 * @brief Set reuse of a socket to true.
1921 */
test_FreeRTOS_setsockopt_ReUseListenSock_Set(void)1922 void test_FreeRTOS_setsockopt_ReUseListenSock_Set( void )
1923 {
1924 BaseType_t xReturn;
1925 FreeRTOS_Socket_t xSocket;
1926 int32_t lLevel;
1927 int32_t lOptionName = FREERTOS_SO_REUSE_LISTEN_SOCKET;
1928 BaseType_t vOptionValue = pdTRUE;
1929 size_t uxOptionLength;
1930
1931 memset( &xSocket, 0, sizeof( xSocket ) );
1932
1933 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1934
1935 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1936
1937 TEST_ASSERT_EQUAL( 0, xReturn );
1938 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bReuseSocket );
1939 }
1940
1941 /**
1942 * @brief Set reuse of a socket to false.
1943 */
test_FreeRTOS_setsockopt_ReUseListenSock_Reset(void)1944 void test_FreeRTOS_setsockopt_ReUseListenSock_Reset( void )
1945 {
1946 BaseType_t xReturn;
1947 FreeRTOS_Socket_t xSocket;
1948 int32_t lLevel;
1949 int32_t lOptionName = FREERTOS_SO_REUSE_LISTEN_SOCKET;
1950 BaseType_t vOptionValue = pdFALSE;
1951 size_t uxOptionLength;
1952
1953 memset( &xSocket, 0, sizeof( xSocket ) );
1954
1955 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
1956 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
1957
1958 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1959
1960 TEST_ASSERT_EQUAL( 0, xReturn );
1961 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bReuseSocket );
1962 }
1963
1964 /**
1965 * @brief Close after send of a UDP socket.
1966 */
test_FreeRTOS_setsockopt_SockClose_InvalidProtocol(void)1967 void test_FreeRTOS_setsockopt_SockClose_InvalidProtocol( void )
1968 {
1969 BaseType_t xReturn;
1970 FreeRTOS_Socket_t xSocket;
1971 int32_t lLevel;
1972 int32_t lOptionName = FREERTOS_SO_CLOSE_AFTER_SEND;
1973 BaseType_t vOptionValue;
1974 size_t uxOptionLength;
1975
1976 memset( &xSocket, 0, sizeof( xSocket ) );
1977
1978 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
1979
1980 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
1981
1982 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
1983 }
1984
1985 /**
1986 * @brief Close after send option set.
1987 */
test_FreeRTOS_setsockopt_SockClose_Set(void)1988 void test_FreeRTOS_setsockopt_SockClose_Set( void )
1989 {
1990 BaseType_t xReturn;
1991 FreeRTOS_Socket_t xSocket;
1992 int32_t lLevel;
1993 int32_t lOptionName = FREERTOS_SO_CLOSE_AFTER_SEND;
1994 BaseType_t vOptionValue = pdTRUE;
1995 size_t uxOptionLength;
1996
1997 memset( &xSocket, 0, sizeof( xSocket ) );
1998
1999 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2000
2001 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2002
2003 TEST_ASSERT_EQUAL( 0, xReturn );
2004 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bCloseAfterSend );
2005 }
2006
2007 /**
2008 * @brief Close after send option reset.
2009 */
test_FreeRTOS_setsockopt_SockClose_Reset(void)2010 void test_FreeRTOS_setsockopt_SockClose_Reset( void )
2011 {
2012 BaseType_t xReturn;
2013 FreeRTOS_Socket_t xSocket;
2014 int32_t lLevel;
2015 int32_t lOptionName = FREERTOS_SO_CLOSE_AFTER_SEND;
2016 BaseType_t vOptionValue = pdFALSE;
2017 size_t uxOptionLength;
2018
2019 memset( &xSocket, 0, sizeof( xSocket ) );
2020
2021 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2022 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
2023
2024 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2025
2026 TEST_ASSERT_EQUAL( 0, xReturn );
2027 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bCloseAfterSend );
2028 }
2029
2030 /**
2031 * @brief Set full size of UDP socket.
2032 */
test_FreeRTOS_setsockopt_SetFullSize_InvalidProtocol(void)2033 void test_FreeRTOS_setsockopt_SetFullSize_InvalidProtocol( void )
2034 {
2035 BaseType_t xReturn;
2036 FreeRTOS_Socket_t xSocket;
2037 int32_t lLevel;
2038 int32_t lOptionName = FREERTOS_SO_SET_FULL_SIZE;
2039 BaseType_t vOptionValue;
2040 size_t uxOptionLength;
2041
2042 memset( &xSocket, 0, sizeof( xSocket ) );
2043
2044 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
2045
2046 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2047
2048 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2049 }
2050
2051 /**
2052 * @brief Set full size option set.
2053 */
test_FreeRTOS_setsockopt_SetFullSize_Set(void)2054 void test_FreeRTOS_setsockopt_SetFullSize_Set( void )
2055 {
2056 BaseType_t xReturn;
2057 FreeRTOS_Socket_t xSocket;
2058 int32_t lLevel;
2059 int32_t lOptionName = FREERTOS_SO_SET_FULL_SIZE;
2060 BaseType_t vOptionValue = pdTRUE;
2061 size_t uxOptionLength;
2062
2063 memset( &xSocket, 0, sizeof( xSocket ) );
2064
2065 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2066
2067 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2068
2069 TEST_ASSERT_EQUAL( 0, xReturn );
2070 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.xTCPWindow.u.bits.bSendFullSize );
2071 }
2072
2073 /**
2074 * @brief Set full size option reset but the state is not correct.
2075 */
test_FreeRTOS_setsockopt_SetFullSize_Reset_StateIncorrect(void)2076 void test_FreeRTOS_setsockopt_SetFullSize_Reset_StateIncorrect( void )
2077 {
2078 BaseType_t xReturn;
2079 FreeRTOS_Socket_t xSocket;
2080 int32_t lLevel;
2081 int32_t lOptionName = FREERTOS_SO_SET_FULL_SIZE;
2082 BaseType_t vOptionValue = pdFALSE;
2083 size_t uxOptionLength;
2084
2085 memset( &xSocket, 0, sizeof( xSocket ) );
2086
2087 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2088 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
2089 xSocket.u.xTCP.eTCPState = eESTABLISHED - 1;
2090
2091 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2092
2093 TEST_ASSERT_EQUAL( 0, xReturn );
2094 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.xTCPWindow.u.bits.bSendFullSize );
2095 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.usTimeout );
2096 }
2097
2098 /**
2099 * @brief Set full size option reset.
2100 */
test_FreeRTOS_setsockopt_SetFullSize_Reset_StateCorrect(void)2101 void test_FreeRTOS_setsockopt_SetFullSize_Reset_StateCorrect( void )
2102 {
2103 BaseType_t xReturn;
2104 FreeRTOS_Socket_t xSocket;
2105 int32_t lLevel;
2106 int32_t lOptionName = FREERTOS_SO_SET_FULL_SIZE;
2107 BaseType_t vOptionValue = pdFALSE;
2108 size_t uxOptionLength;
2109
2110 memset( &xSocket, 0, sizeof( xSocket ) );
2111
2112 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2113 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
2114 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2115
2116 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2117
2118 TEST_ASSERT_EQUAL( 0, xReturn );
2119 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.xTCPWindow.u.bits.bSendFullSize );
2120 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.usTimeout );
2121 }
2122
2123 /**
2124 * @brief Set full size option reset.
2125 */
test_FreeRTOS_setsockopt_SetFullSize_Reset_HappyPath(void)2126 void test_FreeRTOS_setsockopt_SetFullSize_Reset_HappyPath( void )
2127 {
2128 BaseType_t xReturn;
2129 FreeRTOS_Socket_t xSocket;
2130 int32_t lLevel;
2131 int32_t lOptionName = FREERTOS_SO_SET_FULL_SIZE;
2132 BaseType_t vOptionValue = pdFALSE;
2133 size_t uxOptionLength;
2134
2135 memset( &xSocket, 0, sizeof( xSocket ) );
2136
2137 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2138 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
2139 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2140 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) 0xABCD;
2141
2142 uxStreamBufferGetSize_ExpectAndReturn( xSocket.u.xTCP.txStream, 0x123 );
2143 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdTRUE );
2144
2145 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2146
2147 TEST_ASSERT_EQUAL( 0, xReturn );
2148 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.xTCPWindow.u.bits.bSendFullSize );
2149 TEST_ASSERT_EQUAL( 1, xSocket.u.xTCP.usTimeout );
2150 }
2151
2152 /**
2153 * @brief Stop receive with a UDP socket.
2154 */
test_FreeRTOS_setsockopt_StopRx_InvalidProtocol(void)2155 void test_FreeRTOS_setsockopt_StopRx_InvalidProtocol( void )
2156 {
2157 BaseType_t xReturn;
2158 FreeRTOS_Socket_t xSocket;
2159 int32_t lLevel;
2160 int32_t lOptionName = FREERTOS_SO_STOP_RX;
2161 BaseType_t vOptionValue;
2162 size_t uxOptionLength;
2163
2164 memset( &xSocket, 0, sizeof( xSocket ) );
2165
2166 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
2167
2168 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2169
2170 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2171 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bWinChange );
2172 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.usTimeout );
2173 }
2174
2175 /**
2176 * @brief Stop receive set.
2177 */
test_FreeRTOS_setsockopt_StopRx_Set(void)2178 void test_FreeRTOS_setsockopt_StopRx_Set( void )
2179 {
2180 BaseType_t xReturn;
2181 FreeRTOS_Socket_t xSocket;
2182 int32_t lLevel;
2183 int32_t lOptionName = FREERTOS_SO_STOP_RX;
2184 BaseType_t vOptionValue = pdTRUE;
2185 size_t uxOptionLength;
2186
2187 memset( &xSocket, 0, sizeof( xSocket ) );
2188
2189 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2190
2191 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2192
2193 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2194
2195 TEST_ASSERT_EQUAL( 0, xReturn );
2196 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bRxStopped );
2197 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bWinChange );
2198 TEST_ASSERT_EQUAL( 1, xSocket.u.xTCP.usTimeout );
2199 }
2200
2201 /**
2202 * @brief Stop receive reset.
2203 */
test_FreeRTOS_setsockopt_StopRx_Reset(void)2204 void test_FreeRTOS_setsockopt_StopRx_Reset( void )
2205 {
2206 BaseType_t xReturn;
2207 FreeRTOS_Socket_t xSocket;
2208 int32_t lLevel;
2209 int32_t lOptionName = FREERTOS_SO_STOP_RX;
2210 BaseType_t vOptionValue = pdFALSE;
2211 size_t uxOptionLength;
2212
2213 memset( &xSocket, 0, sizeof( xSocket ) );
2214
2215 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2216 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE;
2217
2218 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2219
2220 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2221
2222 TEST_ASSERT_EQUAL( 0, xReturn );
2223 TEST_ASSERT_EQUAL( pdFALSE, xSocket.u.xTCP.bits.bRxStopped );
2224 TEST_ASSERT_EQUAL( pdTRUE, xSocket.u.xTCP.bits.bWinChange );
2225 TEST_ASSERT_EQUAL( 1, xSocket.u.xTCP.usTimeout );
2226 }
2227
2228 /**
2229 * @brief Setting an invalid option.
2230 */
test_FreeRTOS_setsockopt_InvalidOption(void)2231 void test_FreeRTOS_setsockopt_InvalidOption( void )
2232 {
2233 BaseType_t xReturn;
2234 FreeRTOS_Socket_t xSocket;
2235 int32_t lLevel;
2236 int32_t lOptionName = 100;
2237 BaseType_t vOptionValue = pdFALSE;
2238 size_t uxOptionLength;
2239
2240 memset( &xSocket, 0, sizeof( xSocket ) );
2241
2242 xReturn = FreeRTOS_setsockopt( &xSocket, lLevel, lOptionName, &vOptionValue, uxOptionLength );
2243
2244 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOPROTOOPT, xReturn );
2245 }
2246
2247 /**
2248 * @brief Translate 32-bit IP to string.
2249 */
test_FreeRTOS_inet_ntoa_1(void)2250 void test_FreeRTOS_inet_ntoa_1( void )
2251 {
2252 const char * pucReturn;
2253 uint32_t ulIPAddress = 0;
2254 char pcBuffer[ 255 ];
2255 char * pucIdealReturn = "0.0.0.0";
2256
2257 pucReturn = FreeRTOS_inet_ntoa( ulIPAddress, pcBuffer );
2258
2259 TEST_ASSERT_EQUAL( pucReturn, pcBuffer );
2260 TEST_ASSERT_EQUAL_STRING( pucIdealReturn, pucReturn );
2261 }
2262
2263 /**
2264 * @brief Translate 32-bit IP to string.
2265 */
test_FreeRTOS_inet_ntoa_2(void)2266 void test_FreeRTOS_inet_ntoa_2( void )
2267 {
2268 const char * pucReturn;
2269 uint32_t ulIPAddress = 0xAAAAAAAA;
2270 char pcBuffer[ 255 ];
2271 char * pucIdealReturn = "170.170.170.170";
2272
2273 pucReturn = FreeRTOS_inet_ntoa( ulIPAddress, pcBuffer );
2274
2275 TEST_ASSERT_EQUAL( pucReturn, pcBuffer );
2276 TEST_ASSERT_EQUAL_STRING( pucIdealReturn, pucReturn );
2277 }
2278
2279 /**
2280 * @brief Translate 32-bit IP to string.
2281 */
test_FreeRTOS_inet_ntoa_3(void)2282 void test_FreeRTOS_inet_ntoa_3( void )
2283 {
2284 const char * pucReturn;
2285 uint32_t ulIPAddress = 0xFFFFFFFF;
2286 char pcBuffer[ 255 ];
2287 char * pucIdealReturn = "255.255.255.255";
2288
2289 pucReturn = FreeRTOS_inet_ntoa( ulIPAddress, pcBuffer );
2290
2291 TEST_ASSERT_EQUAL( pucReturn, pcBuffer );
2292 TEST_ASSERT_EQUAL_STRING( pucIdealReturn, pucReturn );
2293 }
2294
2295 /**
2296 * @brief Incorrect address family.
2297 */
test_FreeRTOS_inet_pton_IncorrectAddressFamily(void)2298 void test_FreeRTOS_inet_pton_IncorrectAddressFamily( void )
2299 {
2300 BaseType_t xReturn;
2301 BaseType_t xAddressFamily = FREERTOS_AF_INET + 1;
2302 const char * pcSource;
2303 void * pvDestination;
2304
2305 xReturn = FreeRTOS_inet_pton( xAddressFamily, pcSource, pvDestination );
2306
2307 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EAFNOSUPPORT, xReturn );
2308 }
2309
2310 /**
2311 * @brief Octal notation being converted.
2312 */
test_FreeRTOS_inet_pton_Octal(void)2313 void test_FreeRTOS_inet_pton_Octal( void )
2314 {
2315 BaseType_t xReturn;
2316 BaseType_t xAddressFamily = FREERTOS_AF_INET;
2317 const char * pcSource = "00.01.2.3";
2318 uint32_t ulDestination = 0;
2319
2320 FreeRTOS_inet_pton4_ExpectAndReturn( pcSource, &ulDestination, pdFAIL );
2321 xReturn = FreeRTOS_inet_pton( xAddressFamily, pcSource, &ulDestination );
2322
2323 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
2324 TEST_ASSERT_EQUAL( 0, ulDestination );
2325 }
2326
2327 /**
2328 * @brief Happy path of this function.
2329 */
test_FreeRTOS_inet_pton_HappyPath(void)2330 void test_FreeRTOS_inet_pton_HappyPath( void )
2331 {
2332 BaseType_t xReturn;
2333 BaseType_t xAddressFamily = FREERTOS_AF_INET;
2334 const char * pcSource = "255.255.255.255";
2335 uint32_t ulDestination;
2336 uint32_t ulExpectDestination = 0xFFFFFFFF;
2337
2338 FreeRTOS_inet_pton4_ExpectAndReturn( pcSource, &ulDestination, pdPASS );
2339 FreeRTOS_inet_pton4_ReturnMemThruPtr_pvDestination( &ulExpectDestination, sizeof( ulExpectDestination ) );
2340 xReturn = FreeRTOS_inet_pton( xAddressFamily, pcSource, &ulDestination );
2341
2342 TEST_ASSERT_EQUAL( pdPASS, xReturn );
2343 TEST_ASSERT_EQUAL_UINT32( ulExpectDestination, ulDestination );
2344 }
2345
2346 /**
2347 * @brief Happy path of this function for IPv6.
2348 */
test_FreeRTOS_inet_pton_IPv6HappyPath(void)2349 void test_FreeRTOS_inet_pton_IPv6HappyPath( void )
2350 {
2351 BaseType_t xReturn;
2352 BaseType_t xAddressFamily = FREERTOS_AF_INET6;
2353 const char * pcSource = "2001::1";
2354 IPv6_Address_t xDestination;
2355 IPv6_Address_t * pxExpectDestination = &xIPv6Address;
2356
2357 FreeRTOS_inet_pton6_ExpectAndReturn( pcSource, &xDestination, pdPASS );
2358 FreeRTOS_inet_pton6_ReturnMemThruPtr_pvDestination( pxExpectDestination->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2359 xReturn = FreeRTOS_inet_pton( xAddressFamily, pcSource, &xDestination );
2360
2361 TEST_ASSERT_EQUAL( pdPASS, xReturn );
2362 TEST_ASSERT_EQUAL_MEMORY( pxExpectDestination->ucBytes, xDestination.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2363 }
2364
2365 /**
2366 * @brief Translate array to string for MAC address.
2367 */
test_FreeRTOS_EUI48_ntop1(void)2368 void test_FreeRTOS_EUI48_ntop1( void )
2369 {
2370 uint8_t pucSource[ 6 ] = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
2371 char pcTarget[ 18 ];
2372 char cTen = 'A';
2373 char cSeparator = ':';
2374
2375 memset( pcTarget, 0, sizeof( pcTarget ) );
2376
2377 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2378 TEST_ASSERT_EQUAL_STRING( "AA:AA:AA:AA:AA:AA", pcTarget );
2379
2380 cTen = 'a';
2381 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2382 TEST_ASSERT_EQUAL_STRING( "aa:aa:aa:aa:aa:aa", pcTarget );
2383
2384 cTen = 'a';
2385 cSeparator = '-';
2386 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2387 TEST_ASSERT_EQUAL_STRING( "aa-aa-aa-aa-aa-aa", pcTarget );
2388 }
2389
2390 /**
2391 * @brief Translate array to string for MAC address.
2392 */
test_FreeRTOS_EUI48_ntop2(void)2393 void test_FreeRTOS_EUI48_ntop2( void )
2394 {
2395 uint8_t pucSource[ 6 ] = { 0x12, 0x34, 0x56, 0x78, 0xef, 0xdc };
2396 char pcTarget[ 18 ];
2397 char cTen = 'A';
2398 char cSeparator = ':';
2399
2400 memset( pcTarget, 0, sizeof( pcTarget ) );
2401
2402 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2403 TEST_ASSERT_EQUAL_STRING( "12:34:56:78:EF:DC", pcTarget );
2404
2405 cSeparator = '-';
2406 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2407 TEST_ASSERT_EQUAL_STRING( "12-34-56-78-EF-DC", pcTarget );
2408
2409 cTen = 'a';
2410 cSeparator = ':';
2411 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2412 TEST_ASSERT_EQUAL_STRING( "12:34:56:78:ef:dc", pcTarget );
2413
2414 cTen = 'a';
2415 cSeparator = '-';
2416 FreeRTOS_EUI48_ntop( pucSource, pcTarget, cTen, cSeparator );
2417 TEST_ASSERT_EQUAL_STRING( "12-34-56-78-ef-dc", pcTarget );
2418 }
2419
2420 /**
2421 * @brief Translate array to string for MAC address. Invalid values.
2422 */
test_FreeRTOS_EUI48_pton_InvalidInput(void)2423 void test_FreeRTOS_EUI48_pton_InvalidInput( void )
2424 {
2425 BaseType_t xReturn;
2426 const char * pcSource = "12345678::::";
2427 uint8_t pucTarget[ 6 ];
2428
2429 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2430 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
2431 }
2432
2433 /**
2434 * @brief Translate array to string for MAC address. Invalid values.
2435 */
test_FreeRTOS_EUI48_pton_InvalidInput2(void)2436 void test_FreeRTOS_EUI48_pton_InvalidInput2( void )
2437 {
2438 BaseType_t xReturn;
2439 const char * pcSource = "12:34:56:78:ab:ty";
2440 uint8_t pucTarget[ 6 ];
2441
2442 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2443 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
2444 }
2445
2446 /**
2447 * @brief Translate array to string for MAC address. Invalid values.
2448 */
test_FreeRTOS_EUI48_pton_InvalidInput3(void)2449 void test_FreeRTOS_EUI48_pton_InvalidInput3( void )
2450 {
2451 BaseType_t xReturn;
2452 const char * pcSource = "12:34#56:78:ab:cd";
2453 uint8_t pucTarget[ 6 ];
2454
2455 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2456 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
2457 }
2458
2459 /**
2460 * @brief Translate array to string for MAC address. Invalid values.
2461 */
test_FreeRTOS_EUI48_pton_InvalidInput4(void)2462 void test_FreeRTOS_EUI48_pton_InvalidInput4( void )
2463 {
2464 BaseType_t xReturn;
2465 const char * pcSource = "";
2466 uint8_t pucTarget[ 6 ];
2467
2468 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2469 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
2470 }
2471
2472 /**
2473 * @brief Translate string to array for MAC address.
2474 */
test_FreeRTOS_EUI48_pton_HappyPath(void)2475 void test_FreeRTOS_EUI48_pton_HappyPath( void )
2476 {
2477 BaseType_t xReturn;
2478 const char * pcSource = "12:34:56:78:ab:cd";
2479 uint8_t pucTarget[ 6 ];
2480 uint8_t pucIdeal[] = { 0x12, 0x34, 0x56, 0x78, 0xab, 0xcd };
2481
2482 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2483 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
2484 TEST_ASSERT_EQUAL_UINT8_ARRAY( pucIdeal, pucTarget, 6 );
2485 }
2486
2487 /**
2488 * @brief Translate string to array for MAC address.
2489 */
test_FreeRTOS_EUI48_pton_HappyPath1(void)2490 void test_FreeRTOS_EUI48_pton_HappyPath1( void )
2491 {
2492 BaseType_t xReturn;
2493 const char * pcSource = "12-34-56-78-ab-cd";
2494 uint8_t pucTarget[ 6 ];
2495 uint8_t pucIdeal[] = { 0x12, 0x34, 0x56, 0x78, 0xab, 0xcd };
2496
2497 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2498 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
2499 TEST_ASSERT_EQUAL_UINT8_ARRAY( pucIdeal, pucTarget, 6 );
2500 }
2501
2502 /**
2503 * @brief Translate string to array for MAC address.
2504 */
test_FreeRTOS_EUI48_pton_HappyPath2(void)2505 void test_FreeRTOS_EUI48_pton_HappyPath2( void )
2506 {
2507 BaseType_t xReturn;
2508 const char * pcSource = "FF-34-56-78-ab-cd";
2509 uint8_t pucTarget[ 6 ];
2510 uint8_t pucIdeal[] = { 0xff, 0x34, 0x56, 0x78, 0xab, 0xcd };
2511
2512 xReturn = FreeRTOS_EUI48_pton( pcSource, pucTarget );
2513 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
2514 TEST_ASSERT_EQUAL_UINT8_ARRAY( pucIdeal, pucTarget, 6 );
2515 }
2516
2517 /**
2518 * @brief Invalid input to convert to IP address.
2519 */
test_FreeRTOS_inet_addr_InvalidString(void)2520 void test_FreeRTOS_inet_addr_InvalidString( void )
2521 {
2522 uint32_t ulReturn;
2523 char * pcIPAddress = "0..12.34.4";
2524
2525 FreeRTOS_inet_pton4_ExpectAndReturn( pcIPAddress, NULL, pdFAIL );
2526 FreeRTOS_inet_pton4_IgnoreArg_pvDestination();
2527 ulReturn = FreeRTOS_inet_addr( pcIPAddress );
2528 TEST_ASSERT_EQUAL( 0, ulReturn );
2529 }
2530
2531 /**
2532 * @brief Valid input to convert to IP address.
2533 */
test_FreeRTOS_inet_addr_ValidString(void)2534 void test_FreeRTOS_inet_addr_ValidString( void )
2535 {
2536 uint32_t ulExpectAnswer = 0x04030201;
2537 uint32_t ulReturn;
2538 char * pcIPAddress = "1.2.3.4";
2539
2540 FreeRTOS_inet_pton4_ExpectAndReturn( pcIPAddress, NULL, pdPASS );
2541 FreeRTOS_inet_pton4_IgnoreArg_pvDestination();
2542 FreeRTOS_inet_pton4_ReturnMemThruPtr_pvDestination( &ulExpectAnswer, sizeof( ulExpectAnswer ) );
2543 ulReturn = FreeRTOS_inet_addr( pcIPAddress );
2544 TEST_ASSERT_EQUAL( ulExpectAnswer, ulReturn );
2545 }
2546
2547 /**
2548 * @brief Get local address from a socket.
2549 */
test_FreeRTOS_GetLocalAddress(void)2550 void test_FreeRTOS_GetLocalAddress( void )
2551 {
2552 size_t uxReturn;
2553 FreeRTOS_Socket_t xSocket;
2554 struct freertos_sockaddr xAddress;
2555
2556 memset( &xSocket, 0, sizeof( xSocket ) );
2557 memset( &xAddress, 0, sizeof( xAddress ) );
2558
2559 xSocket.usLocalPort = 0xAB12;
2560 xSocket.xLocalAddress.ulIP_IPv4 = 0xABFC8769;
2561
2562 uxReturn = FreeRTOS_GetLocalAddress( &xSocket, &xAddress );
2563
2564 TEST_ASSERT_EQUAL( sizeof( xAddress ), uxReturn );
2565 TEST_ASSERT_EQUAL( FreeRTOS_htonl( 0xABFC8769 ), xAddress.sin_address.ulIP_IPv4 );
2566 TEST_ASSERT_EQUAL( FreeRTOS_htons( 0xAB12 ), xAddress.sin_port );
2567 }
2568
2569 /**
2570 * @brief Get local address from an IPv6 socket.
2571 */
test_FreeRTOS_GetLocalAddress_IPv6(void)2572 void test_FreeRTOS_GetLocalAddress_IPv6( void )
2573 {
2574 size_t uxReturn;
2575 FreeRTOS_Socket_t xSocket;
2576 struct freertos_sockaddr xAddress;
2577 IPv6_Address_t xIPAddress = { { 0x20 } };
2578
2579 memset( &xSocket, 0, sizeof( xSocket ) );
2580 memset( &xAddress, 0, sizeof( xAddress ) );
2581
2582 xSocket.bits.bIsIPv6 = pdTRUE;
2583 xSocket.usLocalPort = 0xAB12;
2584 memcpy( xSocket.xLocalAddress.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2585
2586 uxReturn = FreeRTOS_GetLocalAddress( &xSocket, &xAddress );
2587
2588 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, xAddress.sin_family );
2589 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, xAddress.sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2590 TEST_ASSERT_EQUAL( FreeRTOS_htons( 0xAB12 ), xAddress.sin_port );
2591 }
2592
2593 /**
2594 * @brief All fields are NULL in the socket.
2595 */
test_FreeRTOS_connect_SocketValuesNULL(void)2596 void test_FreeRTOS_connect_SocketValuesNULL( void )
2597 {
2598 BaseType_t xResult;
2599 FreeRTOS_Socket_t xSocket;
2600 struct freertos_sockaddr xAddress;
2601 socklen_t xAddressLength;
2602
2603 memset( &xSocket, 0, sizeof( xSocket ) );
2604
2605 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2606
2607 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EBADF, xResult );
2608 }
2609
2610 /**
2611 * @brief Test for invalid values.
2612 */
test_FreeRTOS_connect_InvalidValues(void)2613 void test_FreeRTOS_connect_InvalidValues( void )
2614 {
2615 BaseType_t xResult;
2616 FreeRTOS_Socket_t xSocket;
2617 struct freertos_sockaddr xAddress;
2618 socklen_t xAddressLength;
2619
2620 memset( &xSocket, 0, sizeof( xSocket ) );
2621
2622 /* Invalid protocol. */
2623 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
2624 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2625 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EBADF, xResult );
2626
2627 /* Socket not bound. Binding failed. */
2628 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2629 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
2630 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
2631 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( NULL );
2632 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( pdFAIL );
2633 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2634 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ECANCELED, xResult );
2635
2636 /* Socket NULL. */
2637 xResult = FreeRTOS_connect( NULL, &xAddress, xAddressLength );
2638 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EBADF, xResult );
2639
2640 /* Address NULL. */
2641 xResult = FreeRTOS_connect( &xSocket, NULL, xAddressLength );
2642 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xResult );
2643 }
2644
2645 /**
2646 * @brief Non blocking connect.
2647 */
test_FreeRTOS_connect_NonBlocking(void)2648 void test_FreeRTOS_connect_NonBlocking( void )
2649 {
2650 BaseType_t xResult;
2651 FreeRTOS_Socket_t xSocket;
2652 struct freertos_sockaddr xAddress;
2653 socklen_t xAddressLength;
2654
2655 memset( &xSocket, 0, sizeof( xSocket ) );
2656
2657 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2658 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2659
2660 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2661 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2662
2663 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2664
2665 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EWOULDBLOCK, xResult );
2666 }
2667
2668 /**
2669 * @brief Timeout in connection.
2670 */
test_FreeRTOS_connect_Timeout(void)2671 void test_FreeRTOS_connect_Timeout( void )
2672 {
2673 BaseType_t xResult;
2674 FreeRTOS_Socket_t xSocket;
2675 struct freertos_sockaddr xAddress;
2676 socklen_t xAddressLength;
2677
2678 memset( &xSocket, 0, sizeof( xSocket ) );
2679
2680 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2681 /* Non 0 value to show blocking. */
2682 xSocket.xReceiveBlockTime = 0x123;
2683 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2684
2685 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2686 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2687
2688 /* Using a local variable. */
2689 vTaskSetTimeOutState_ExpectAnyArgs();
2690
2691 /* No timeout the first time. */
2692 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
2693
2694 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_CONNECT | eSOCKET_CLOSED, pdTRUE, pdFALSE, xSocket.xReceiveBlockTime, pdTRUE );
2695
2696 /* Timed out! */
2697 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdTRUE );
2698
2699 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2700
2701 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ETIMEDOUT, xResult );
2702 }
2703
2704 /**
2705 * @brief Timeout in connection.
2706 */
test_FreeRTOS_connect_SocketClosed(void)2707 void test_FreeRTOS_connect_SocketClosed( void )
2708 {
2709 BaseType_t xResult;
2710 FreeRTOS_Socket_t xSocket;
2711 struct freertos_sockaddr xAddress;
2712 socklen_t xAddressLength;
2713
2714 memset( &xSocket, 0, sizeof( xSocket ) );
2715
2716 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2717 /* Non 0 value to show blocking. */
2718 xSocket.xReceiveBlockTime = 0x123;
2719 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2720
2721 vTCPStateChange_Expect( &xSocket, eCONNECT_SYN );
2722 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2723
2724 /* Using a local variable. */
2725 vTaskSetTimeOutState_ExpectAnyArgs();
2726
2727 /* No timeout the first time. */
2728 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
2729
2730 xEventGroupWaitBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_CONNECT | eSOCKET_CLOSED, pdTRUE, pdFALSE, xSocket.xReceiveBlockTime, eSOCKET_CLOSED );
2731
2732 xResult = FreeRTOS_connect( &xSocket, &xAddress, xAddressLength );
2733
2734 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOTCONN, xResult );
2735 }
2736
2737 /**
2738 * @brief Connection successful.
2739 */
test_FreeRTOS_connect_Connected(void)2740 void test_FreeRTOS_connect_Connected( void )
2741 {
2742 BaseType_t xResult;
2743 struct freertos_sockaddr xAddress;
2744 socklen_t xAddressLength;
2745
2746 memset( &xGlobalSocket, 0, sizeof( xGlobalSocket ) );
2747 memset( &xAddress, 0, sizeof( xAddress ) );
2748
2749 xAddress.sin_family = FREERTOS_AF_INET4;
2750
2751 xGlobalSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2752 /* Non 0 value to show blocking. */
2753 xGlobalSocket.xReceiveBlockTime = 0x123;
2754 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2755
2756 vTCPStateChange_Expect( &xGlobalSocket, eCONNECT_SYN );
2757 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2758
2759 /* Using a local variable. */
2760 vTaskSetTimeOutState_ExpectAnyArgs();
2761
2762 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFALSE );
2763
2764 xEventGroupWaitBits_Stub( xStubForEventGroupWaitBits );
2765
2766 xResult = FreeRTOS_connect( &xGlobalSocket, &xAddress, xAddressLength );
2767
2768 TEST_ASSERT_EQUAL( 0, xResult );
2769 }
2770
2771 /**
2772 * @brief Connection failed due to error happening during sleep.
2773 */
test_FreeRTOS_connect_SocketErrorDuringSleep(void)2774 void test_FreeRTOS_connect_SocketErrorDuringSleep( void )
2775 {
2776 BaseType_t xResult;
2777 struct freertos_sockaddr xAddress;
2778 socklen_t xAddressLength;
2779
2780 memset( &xGlobalSocket, 0, sizeof( xGlobalSocket ) );
2781
2782 xGlobalSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2783 /* Non 0 value to show blocking. */
2784 xGlobalSocket.xReceiveBlockTime = 0x123;
2785 listLIST_ITEM_CONTAINER_ExpectAnyArgsAndReturn( &xBoundTCPSocketsList );
2786
2787 vTCPStateChange_Expect( &xGlobalSocket, eCONNECT_SYN );
2788 xSendEventToIPTask_ExpectAndReturn( eTCPTimerEvent, pdPASS );
2789
2790 /* Set the global socket handler to error during sleep. */
2791 vTaskSetTimeOutState_Stub( vStub_vTaskSetTimeOutState_socketError );
2792
2793 xResult = FreeRTOS_connect( &xGlobalSocket, &xAddress, xAddressLength );
2794
2795 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xResult );
2796 }
2797
2798 /**
2799 * @brief Invalid protocol.
2800 */
test_FreeRTOS_GetRemoteAddress_InvalidProtocol(void)2801 void test_FreeRTOS_GetRemoteAddress_InvalidProtocol( void )
2802 {
2803 BaseType_t xReturn;
2804 FreeRTOS_Socket_t xSocket;
2805 struct freertos_sockaddr xAddress;
2806
2807 memset( &xSocket, 0, sizeof( xSocket ) );
2808 memset( &xAddress, 0, sizeof( xAddress ) );
2809
2810 xReturn = FreeRTOS_GetRemoteAddress( &xSocket, &xAddress );
2811
2812 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2813 }
2814
2815 /**
2816 * @brief happy path.
2817 */
test_FreeRTOS_GetRemoteAddress_HappyPath(void)2818 void test_FreeRTOS_GetRemoteAddress_HappyPath( void )
2819 {
2820 BaseType_t xReturn;
2821 FreeRTOS_Socket_t xSocket;
2822 struct freertos_sockaddr xAddress;
2823
2824 memset( &xSocket, 0, sizeof( xSocket ) );
2825 memset( &xAddress, 0, sizeof( xAddress ) );
2826
2827 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2828 xSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = 0xABCDEF12;
2829 xSocket.u.xTCP.usRemotePort = 0x1234;
2830
2831 xReturn = FreeRTOS_GetRemoteAddress( &xSocket, &xAddress );
2832
2833 TEST_ASSERT_EQUAL( sizeof( xAddress ), xReturn );
2834 TEST_ASSERT_EQUAL( FreeRTOS_htonl( 0xABCDEF12 ), xAddress.sin_address.ulIP_IPv4 );
2835 TEST_ASSERT_EQUAL( FreeRTOS_htons( 0x1234 ), xAddress.sin_port );
2836 }
2837
2838 /**
2839 * @brief IPv6 happy path.
2840 */
test_FreeRTOS_GetRemoteAddress_IPv6HappyPath(void)2841 void test_FreeRTOS_GetRemoteAddress_IPv6HappyPath( void )
2842 {
2843 BaseType_t xReturn;
2844 FreeRTOS_Socket_t xSocket;
2845 struct freertos_sockaddr xAddress;
2846
2847 memset( &xSocket, 0, sizeof( xSocket ) );
2848 memset( &xAddress, 0, sizeof( xAddress ) );
2849
2850 xSocket.bits.bIsIPv6 = pdTRUE_UNSIGNED;
2851 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2852 memcpy( xSocket.u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2853 xSocket.u.xTCP.usRemotePort = 0x1234;
2854
2855 xReturn = FreeRTOS_GetRemoteAddress( &xSocket, &xAddress );
2856
2857 TEST_ASSERT_EQUAL( sizeof( xAddress ), xReturn );
2858 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, xAddress.sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2859 TEST_ASSERT_EQUAL( FreeRTOS_htons( 0x1234 ), xAddress.sin_port );
2860 }
2861
2862 /**
2863 * @brief Invalid values.
2864 */
test_FreeRTOS_maywrite_InvalidValues(void)2865 void test_FreeRTOS_maywrite_InvalidValues( void )
2866 {
2867 BaseType_t xReturn;
2868 FreeRTOS_Socket_t xSocket;
2869
2870 memset( &xSocket, 0, sizeof( xSocket ) );
2871
2872 /* Invalid Protocol. */
2873 xReturn = FreeRTOS_maywrite( &xSocket );
2874 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2875
2876 /* Invalid States. */
2877 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2878 xSocket.u.xTCP.eTCPState = eTCP_LISTEN; /* eCONNECT_SYN - 1 */
2879 xReturn = FreeRTOS_maywrite( &xSocket );
2880 TEST_ASSERT_EQUAL( -1, xReturn );
2881
2882 xSocket.u.xTCP.eTCPState = eFIN_WAIT_1; /* eESTABLISHED + 1 */
2883 xReturn = FreeRTOS_maywrite( &xSocket );
2884 TEST_ASSERT_EQUAL( -1, xReturn );
2885
2886 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
2887 xReturn = FreeRTOS_maywrite( &xSocket );
2888 TEST_ASSERT_EQUAL( 0, xReturn );
2889
2890 xSocket.u.xTCP.eTCPState = eSYN_FIRST; /* eCONNECT_SYN + 1 */
2891 xReturn = FreeRTOS_maywrite( &xSocket );
2892 TEST_ASSERT_EQUAL( 0, xReturn );
2893
2894 /* Transmission NULL. */
2895 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2896 xSocket.u.xTCP.uxTxStreamSize = 0x123;
2897 xReturn = FreeRTOS_maywrite( &xSocket );
2898 TEST_ASSERT_EQUAL( 0x123, xReturn );
2899 }
2900
2901 /**
2902 * @brief Happy path.
2903 */
test_FreeRTOS_maywrite_HappyPath(void)2904 void test_FreeRTOS_maywrite_HappyPath( void )
2905 {
2906 BaseType_t xReturn;
2907 FreeRTOS_Socket_t xSocket;
2908 uint8_t ucStream[ 20 ];
2909
2910 memset( &xSocket, 0, sizeof( xSocket ) );
2911
2912 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
2913 xSocket.u.xTCP.eTCPState = eESTABLISHED;
2914 xSocket.u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
2915
2916 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0x3344 );
2917
2918 xReturn = FreeRTOS_maywrite( &xSocket );
2919 TEST_ASSERT_EQUAL( 0x3344, xReturn );
2920 }
2921
2922 /**
2923 * @brief Test setting socket ID when the socket is NULL.
2924 */
test_xSocketSetSocketID_NULLSocket(void)2925 void test_xSocketSetSocketID_NULLSocket( void )
2926 {
2927 BaseType_t xReturn;
2928
2929 xReturn = xSocketSetSocketID( NULL, NULL );
2930
2931 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2932 }
2933
2934 /**
2935 * @brief Test setting socket ID when the socket is invalid.
2936 */
test_xSocketSetSocketID_InvalidSocket(void)2937 void test_xSocketSetSocketID_InvalidSocket( void )
2938 {
2939 BaseType_t xReturn;
2940
2941 xReturn = xSocketSetSocketID( FREERTOS_INVALID_SOCKET, NULL );
2942
2943 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
2944 }
2945
2946 /**
2947 * @brief Test setting socket ID when the socket is Valid.
2948 */
test_xSocketSetSocketID_ValidSocket(void)2949 void test_xSocketSetSocketID_ValidSocket( void )
2950 {
2951 BaseType_t xReturn;
2952 FreeRTOS_Socket_t xSocket;
2953 BaseType_t AnchorVariable;
2954
2955 memset( &xSocket, 0, sizeof( xSocket ) );
2956
2957 xReturn = xSocketSetSocketID( &xSocket, &AnchorVariable );
2958
2959 TEST_ASSERT_EQUAL( 0, xReturn );
2960 TEST_ASSERT_EQUAL( &AnchorVariable, xSocket.pvSocketID );
2961 }
2962
2963 /**
2964 * @brief Test setting socket ID when the socket is NULL.
2965 */
test_pvSocketGetSocketID_NULLSocket(void)2966 void test_pvSocketGetSocketID_NULLSocket( void )
2967 {
2968 void * pvReturn;
2969
2970 pvReturn = pvSocketGetSocketID( NULL );
2971
2972 TEST_ASSERT_EQUAL( NULL, pvReturn );
2973 }
2974
2975 /**
2976 * @brief Test setting socket ID when the socket is invalid.
2977 */
test_pvSocketGetSocketID_InvalidSocket(void)2978 void test_pvSocketGetSocketID_InvalidSocket( void )
2979 {
2980 void * pvReturn;
2981
2982 pvReturn = pvSocketGetSocketID( FREERTOS_INVALID_SOCKET );
2983
2984 TEST_ASSERT_EQUAL( NULL, pvReturn );
2985 }
2986
2987 /**
2988 * @brief Test setting socket ID when the socket is Valid.
2989 */
test_pvSocketGetSocketID_ValidSocket(void)2990 void test_pvSocketGetSocketID_ValidSocket( void )
2991 {
2992 BaseType_t pvReturn;
2993 FreeRTOS_Socket_t xSocket;
2994 BaseType_t AnchorVariable;
2995
2996 memset( &xSocket, 0, sizeof( xSocket ) );
2997
2998 xSocket.pvSocketID = &AnchorVariable;
2999
3000 pvReturn = ( BaseType_t ) pvSocketGetSocketID( &xSocket );
3001
3002 TEST_ASSERT_EQUAL( &AnchorVariable, pvReturn );
3003 }
3004
3005 /**
3006 * @brief This function just prints out some data. It is expected to make calls to the
3007 * below functions when IP stack is not initialised.
3008 */
test_vTCPNetStat_IPStackNotInit(void)3009 void test_vTCPNetStat_IPStackNotInit( void )
3010 {
3011 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( 0 );
3012 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 0 );
3013
3014 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdFALSE );
3015
3016 vTCPNetStat();
3017 }
3018
3019 /**
3020 * @brief This function just prints out some data. It is expected to make calls to the
3021 * below functions when IP stack is initialised. It is expected to go through the
3022 * list of TCP and UDP sockets which are bound and print them out.
3023 */
test_vTCPNetStat_IPStackInit(void)3024 void test_vTCPNetStat_IPStackInit( void )
3025 {
3026 ListItem_t xLocalTCPItem, xLocalUDPItem, xIterator;
3027 FreeRTOS_Socket_t xSocket, xSocket2;
3028
3029 memset( &xSocket, 0, sizeof( xSocket ) );
3030 memset( &xSocket2, 0, sizeof( xSocket2 ) );
3031
3032 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( 0 );
3033 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 0 );
3034
3035 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
3036
3037 listGET_END_MARKER_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalTCPItem );
3038 listGET_END_MARKER_ExpectAndReturn( &xBoundUDPSocketsList, &xLocalUDPItem );
3039
3040 /* First Iteration. */
3041 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xIterator );
3042
3043 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xSocket );
3044
3045 xTaskGetTickCount_ExpectAndReturn( 0x10 );
3046
3047 uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
3048
3049 /* Second Iteration. */
3050 xSocket2.u.xTCP.eTCPState = eTCP_LISTEN;
3051 listGET_NEXT_ExpectAndReturn( &xIterator, &xIterator );
3052 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xSocket2 );
3053
3054 xTaskGetTickCount_ExpectAndReturn( 0x20 );
3055
3056 /* TCP last iteration. */
3057 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalTCPItem );
3058
3059
3060 /* UDP */
3061 /* First Iteration. */
3062 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundUDPSocketsList, &xIterator );
3063
3064 /* Second Iteration. */
3065 listGET_NEXT_ExpectAndReturn( &xIterator, &xIterator );
3066
3067 /* TCP last iteration. */
3068 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalUDPItem );
3069
3070 vTCPNetStat();
3071 }
3072
3073 /**
3074 * @brief This function just prints out some data. It is expected to change the age ( current tick - last alive )
3075 * if it's greater than 999999.
3076 */
test_vTCPNetStat_LongTimeSinceLastAlive(void)3077 void test_vTCPNetStat_LongTimeSinceLastAlive( void )
3078 {
3079 ListItem_t xLocalTCPItem, xLocalUDPItem, xIterator;
3080 FreeRTOS_Socket_t xSocket, xSocket2;
3081
3082 memset( &xSocket, 0, sizeof( xSocket ) );
3083 memset( &xSocket2, 0, sizeof( xSocket2 ) );
3084
3085 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( 0 );
3086 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 0 );
3087
3088 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
3089
3090 listGET_END_MARKER_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalTCPItem );
3091 listGET_END_MARKER_ExpectAndReturn( &xBoundUDPSocketsList, &xLocalUDPItem );
3092
3093 /* First Iteration. */
3094 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xIterator );
3095
3096 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xSocket );
3097
3098 xTaskGetTickCount_ExpectAndReturn( 1000000U );
3099
3100 /* Second Iteration. */
3101 xSocket2.u.xTCP.eTCPState = eTCP_LISTEN;
3102 listGET_NEXT_ExpectAndReturn( &xIterator, &xIterator );
3103 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xSocket2 );
3104
3105 xTaskGetTickCount_ExpectAndReturn( 0x20 );
3106
3107 /* TCP last iteration. */
3108 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalTCPItem );
3109
3110
3111 /* UDP */
3112 /* First Iteration. */
3113 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundUDPSocketsList, &xIterator );
3114
3115 /* Second Iteration. */
3116 listGET_NEXT_ExpectAndReturn( &xIterator, &xIterator );
3117
3118 /* TCP last iteration. */
3119 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalUDPItem );
3120
3121 vTCPNetStat();
3122 }
3123
3124 /**
3125 * @brief This function just prints out some data. It is able to print IPv6
3126 * socket as well.
3127 */
test_vTCPNetStat_IPv6Socket(void)3128 void test_vTCPNetStat_IPv6Socket( void )
3129 {
3130 ListItem_t xLocalTCPItem, xLocalUDPItem, xIterator;
3131 FreeRTOS_Socket_t xSocket;
3132
3133 memset( &xSocket, 0, sizeof( xSocket ) );
3134
3135 xSocket.bits.bIsIPv6 = pdTRUE_UNSIGNED;
3136
3137 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( 0 );
3138 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 0 );
3139
3140 listLIST_IS_INITIALISED_ExpectAndReturn( &xBoundTCPSocketsList, pdTRUE );
3141
3142 listGET_END_MARKER_ExpectAndReturn( &xBoundTCPSocketsList, &xLocalTCPItem );
3143 listGET_END_MARKER_ExpectAndReturn( &xBoundUDPSocketsList, &xLocalUDPItem );
3144
3145 /* First Iteration. */
3146 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundTCPSocketsList, &xIterator );
3147
3148 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xIterator, &xSocket );
3149
3150 xTaskGetTickCount_ExpectAndReturn( 0x10 );
3151
3152 /* TCP last iteration. */
3153 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalTCPItem );
3154
3155 /* UDP */
3156 /* First Iteration. */
3157 listGET_HEAD_ENTRY_ExpectAndReturn( &xBoundUDPSocketsList, &xIterator );
3158
3159 /* Second Iteration. */
3160 listGET_NEXT_ExpectAndReturn( &xIterator, &xIterator );
3161
3162 /* TCP last iteration. */
3163 listGET_NEXT_ExpectAndReturn( &xIterator, &xLocalUDPItem );
3164
3165 vTCPNetStat();
3166 }
3167
3168 /**
3169 * @brief Socket select function when only UDP sockets are bound.
3170 */
test_vSocketSelect_UDPSocketsOnly(void)3171 void test_vSocketSelect_UDPSocketsOnly( void )
3172 {
3173 SocketSelect_t xSocketSet;
3174 ListItem_t xLocalListItem;
3175 FreeRTOS_Socket_t xSocket, xSocket2, xSocket3, xSocket4;
3176
3177 memset( &xSocket, 0, sizeof( xSocket ) );
3178 memset( &xSocket2, 0, sizeof( xSocket2 ) );
3179 memset( &xSocket3, 0, sizeof( xSocket3 ) );
3180 memset( &xSocket4, 0, sizeof( xSocket4 ) );
3181
3182 xSocket2.pxSocketSet = &xSocketSet;
3183 xSocket3.pxSocketSet = &xSocketSet;
3184 xSocket4.pxSocketSet = &xSocketSet;
3185
3186 /* Round 0. Not same socket set. */
3187 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ), &xLocalListItem );
3188 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket );
3189
3190 /* Round 1. Same socket set. No select bits. */
3191 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3192 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket2 );
3193
3194 /* Round 2. Same socket set. elect bits. */
3195 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3196 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket3 );
3197
3198 xSocket3.xSelectBits = eSELECT_READ;
3199 listCURRENT_LIST_LENGTH_ExpectAndReturn( &( xSocket3.u.xUDP.xWaitingPacketsList ), 0 );
3200
3201 /* Round 3. Same socket set. elect bits. */
3202 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3203 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket4 );
3204
3205 xSocket4.xSelectBits = eSELECT_READ;
3206 listCURRENT_LIST_LENGTH_ExpectAndReturn( &( xSocket4.u.xUDP.xWaitingPacketsList ), 3 );
3207
3208 /* Last item. */
3209 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ) );
3210
3211 /* Last item. Nothing in TCP. */
3212 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
3213
3214 xEventGroupClearBits_ExpectAndReturn( xSocketSet.xSelectGroup, 0, 0 );
3215
3216 xEventGroupSetBits_ExpectAndReturn( xSocketSet.xSelectGroup, eSELECT_READ | eSELECT_CALL_IP, pdPASS );
3217
3218 vSocketSelect( &xSocketSet );
3219
3220 TEST_ASSERT_EQUAL( 0, xSocket.xSocketBits );
3221 TEST_ASSERT_EQUAL( 0, xSocket2.xSocketBits );
3222 TEST_ASSERT_EQUAL( 0, xSocket3.xSocketBits );
3223 TEST_ASSERT_EQUAL( eSELECT_READ, xSocket4.xSocketBits );
3224 }
3225
3226 /**
3227 * @brief Socket select function when only TCP sockets are bound.
3228 */
test_vSocketSelect_TCPSocketsOnly(void)3229 void test_vSocketSelect_TCPSocketsOnly( void )
3230 {
3231 SocketSelect_t xSocketSet;
3232 ListItem_t xLocalListItem;
3233 uint8_t ucStream[ 20 ];
3234 FreeRTOS_Socket_t xSocket[ 9 ], xPeerSocket, xPeerSocket1;
3235
3236 for( int i = 1; i < 9; i++ )
3237 {
3238 memset( &xSocket[ i ], 0, sizeof( xSocket[ i ] ) );
3239 xSocket[ i ].pxSocketSet = &xSocketSet;
3240 xSocket[ i ].ucProtocol = FREERTOS_IPPROTO_TCP;
3241 }
3242
3243 memset( &xPeerSocket, 0, sizeof( xPeerSocket ) );
3244 memset( &xPeerSocket1, 0, sizeof( xPeerSocket1 ) );
3245 memset( &xSocket[ 0 ], 0, sizeof( xSocket[ 0 ] ) );
3246
3247 xSocket[ 0 ].ucProtocol = FREERTOS_IPPROTO_TCP;
3248
3249 /* Last item. Nothing in UDP. */
3250 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ) );
3251
3252 /* Round 0. Not same socket set. */
3253 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), &xLocalListItem );
3254 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 0 ] );
3255
3256 /* Round 1. Same socket set. No bits Set. */
3257 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3258 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 1 ] );
3259
3260 /* Round 2. Same socket set. All bits Set. */
3261 xSocket[ 2 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3262 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3263 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 2 ] );
3264
3265 /* Round 3. */
3266 xSocket[ 3 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3267 xSocket[ 3 ].u.xTCP.bits.bPassAccept = pdTRUE;
3268 xSocket[ 3 ].u.xTCP.eTCPState = eTCP_LISTEN;
3269 xSocket[ 3 ].u.xTCP.pxPeerSocket = &xPeerSocket;
3270 xSocket[ 3 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3271 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3272 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 3 ] );
3273
3274 /* Round 4. */
3275 xSocket[ 4 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3276 xSocket[ 4 ].u.xTCP.bits.bPassAccept = pdTRUE;
3277 xSocket[ 4 ].u.xTCP.eTCPState = eTCP_LISTEN;
3278 xSocket[ 4 ].u.xTCP.pxPeerSocket = &xPeerSocket1;
3279 xSocket[ 4 ].u.xTCP.pxPeerSocket->u.xTCP.bits.bPassAccept = pdTRUE;
3280 xSocket[ 4 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3281 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3282 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 4 ] );
3283
3284 /* Round 5. */
3285 xSocket[ 5 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3286 xSocket[ 5 ].u.xTCP.eTCPState = eTCP_LISTEN;
3287 xSocket[ 5 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3288 xSocket[ 5 ].u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
3289 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3290 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 5 ] );
3291 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0xABCD );
3292
3293 /* Round 5. */
3294 xSocket[ 6 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3295 xSocket[ 6 ].u.xTCP.eTCPState = eCLOSE_WAIT;
3296 xSocket[ 6 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3297 xSocket[ 6 ].u.xTCP.txStream = ( StreamBuffer_t * ) ucStream;
3298 xSocket[ 6 ].u.xTCP.rxStream = ( StreamBuffer_t * ) ucStream;
3299 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3300 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 6 ] );
3301 uxStreamBufferGetSize_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0xAB );
3302 uxStreamBufferGetSpace_ExpectAndReturn( ( StreamBuffer_t * ) ucStream, 0xABCD );
3303
3304 /* Round 6. */
3305 xSocket[ 7 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3306 xSocket[ 7 ].u.xTCP.eTCPState = eESTABLISHED;
3307 xSocket[ 7 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3308 xSocket[ 7 ].u.xTCP.bits.bPassQueued = pdTRUE;
3309 xSocket[ 7 ].u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
3310 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3311 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 7 ] );
3312
3313 /* Round 7. */
3314 xSocket[ 8 ].xSelectBits = eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE;
3315 xSocket[ 8 ].u.xTCP.eTCPState = eESTABLISHED;
3316 xSocket[ 8 ].u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
3317 xSocket[ 8 ].u.xTCP.bits.bPassQueued = pdTRUE;
3318 xSocket[ 8 ].u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
3319 xSocket[ 8 ].u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
3320 xSocket[ 8 ].u.xTCP.bits.bConnPassed = pdTRUE_UNSIGNED;
3321 listGET_NEXT_ExpectAndReturn( &xLocalListItem, &xLocalListItem );
3322 listGET_LIST_ITEM_OWNER_ExpectAndReturn( &xLocalListItem, &xSocket[ 8 ] );
3323
3324 /* Last item. */
3325 listGET_NEXT_ExpectAndReturn( &xLocalListItem, ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
3326
3327 xEventGroupClearBits_ExpectAndReturn( xSocketSet.xSelectGroup, 0, eSELECT_READ );
3328
3329 xEventGroupSetBits_ExpectAnyArgsAndReturn( pdPASS );
3330
3331 vSocketSelect( &xSocketSet );
3332
3333 TEST_ASSERT_EQUAL( 0, xSocket[ 0 ].xSocketBits );
3334 TEST_ASSERT_EQUAL( 0, xSocket[ 1 ].xSocketBits );
3335 TEST_ASSERT_EQUAL( eSELECT_EXCEPT, xSocket[ 2 ].xSocketBits );
3336 TEST_ASSERT_EQUAL( pdFALSE, xSocket[ 2 ].u.xTCP.bits.bConnPassed );
3337 TEST_ASSERT_EQUAL( 0, xSocket[ 3 ].xSocketBits );
3338 TEST_ASSERT_EQUAL( eSELECT_READ, xSocket[ 4 ].xSocketBits );
3339 TEST_ASSERT_EQUAL( eSELECT_WRITE, xSocket[ 5 ].xSocketBits );
3340 TEST_ASSERT_EQUAL( eSELECT_WRITE | eSELECT_READ | eSELECT_EXCEPT, xSocket[ 6 ].xSocketBits );
3341 TEST_ASSERT_EQUAL( eSELECT_WRITE, xSocket[ 7 ].xSocketBits );
3342 TEST_ASSERT_EQUAL( eSELECT_READ, xSocket[ 8 ].xSocketBits );
3343 }
3344
3345 /**
3346 * @brief Socket select function when no sockets are bound.
3347 */
test_vSocketSelect_NoSocketsAtAll(void)3348 void test_vSocketSelect_NoSocketsAtAll( void )
3349 {
3350 SocketSelect_t xSocketSet;
3351 ListItem_t xLocalListItem;
3352 uint8_t ucStream[ 20 ];
3353
3354 /* Last item. Nothing in UDP. */
3355 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundUDPSocketsList.xListEnd ) );
3356
3357 /* Last item. Nothing in TCP. */
3358 listGET_NEXT_ExpectAndReturn( ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ), ( ListItem_t * ) &( xBoundTCPSocketsList.xListEnd ) );
3359
3360 xEventGroupClearBits_ExpectAndReturn( xSocketSet.xSelectGroup, 0, eSELECT_READ );
3361 xEventGroupClearBits_ExpectAnyArgsAndReturn( pdPASS );
3362 xEventGroupSetBits_ExpectAndReturn( xSocketSet.xSelectGroup, eSELECT_CALL_IP, pdPASS );
3363
3364 vSocketSelect( &xSocketSet );
3365 }
3366
3367 /**
3368 * @brief Signalling socket with invalid values given for socket.
3369 */
test_FreeRTOS_SignalSocket_InvalidSocket(void)3370 void test_FreeRTOS_SignalSocket_InvalidSocket( void )
3371 {
3372 BaseType_t xReturn;
3373 FreeRTOS_Socket_t xSocket;
3374
3375 memset( &xSocket, 0, sizeof( xSocket ) );
3376
3377 xReturn = FreeRTOS_SignalSocket( NULL );
3378 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
3379
3380 xReturn = FreeRTOS_SignalSocket( &xSocket );
3381 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
3382 }
3383
3384 /**
3385 * @brief Event group is present for the socket being signalled.
3386 */
test_FreeRTOS_SignalSocket_NonNULLEventGroup(void)3387 void test_FreeRTOS_SignalSocket_NonNULLEventGroup( void )
3388 {
3389 BaseType_t xReturn;
3390 FreeRTOS_Socket_t xSocket;
3391 SocketSelect_t xSocketSet;
3392 uint8_t xEventGroup[ sizeof( size_t ) ];
3393
3394 memset( &xSocket, 0, sizeof( xSocket ) );
3395 memset( &xSocketSet, 0, sizeof( xSocketSet ) );
3396
3397 xSocket.pxSocketSet = &xSocketSet;
3398 xSocket.xEventGroup = ( EventGroupHandle_t ) xEventGroup;
3399
3400 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_INTR, pdFALSE );
3401
3402 xReturn = FreeRTOS_SignalSocket( &xSocket );
3403 TEST_ASSERT_EQUAL( 0, xReturn );
3404 }
3405
3406 /**
3407 * @brief Select group is present for the socket being called.
3408 */
test_FreeRTOS_SignalSocket_NonNULLSelectGroup(void)3409 void test_FreeRTOS_SignalSocket_NonNULLSelectGroup( void )
3410 {
3411 BaseType_t xReturn;
3412 FreeRTOS_Socket_t xSocket;
3413 SocketSelect_t xSocketSet;
3414 uint8_t xSelectGroup[ sizeof( size_t ) ];
3415
3416 memset( &xSocket, 0, sizeof( xSocket ) );
3417 memset( &xSocketSet, 0, sizeof( xSocketSet ) );
3418
3419 xSocket.pxSocketSet = &xSocketSet;
3420 xSocket.pxSocketSet->xSelectGroup = ( EventGroupHandle_t ) xSelectGroup;
3421
3422 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSELECT_INTR, pdFALSE );
3423
3424 xReturn = FreeRTOS_SignalSocket( &xSocket );
3425 TEST_ASSERT_EQUAL( 0, xReturn );
3426 }
3427
3428 /**
3429 * @brief Catch various asserts.
3430 */
test_FreeRTOS_SignalSocketFromISR_catchAsserts(void)3431 void test_FreeRTOS_SignalSocketFromISR_catchAsserts( void )
3432 {
3433 FreeRTOS_Socket_t xSocket;
3434 BaseType_t xHigherPriorityTaskWoken;
3435
3436 /* Socket cannot be NULL. */
3437 catch_assert( FreeRTOS_SignalSocketFromISR( NULL, &xHigherPriorityTaskWoken ) );
3438
3439 memset( &xSocket, 0, sizeof( xSocket ) );
3440 /* Socket must have TCP protocol. */
3441 catch_assert( FreeRTOS_SignalSocketFromISR( &xSocket, &xHigherPriorityTaskWoken ) );
3442
3443 memset( &xSocket, 0, sizeof( xSocket ) );
3444 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
3445 /* Event group must be non-NULL. */
3446 catch_assert( FreeRTOS_SignalSocketFromISR( &xSocket, &xHigherPriorityTaskWoken ) );
3447 }
3448
3449 /**
3450 * @brief happy path of the function.
3451 */
test_FreeRTOS_SignalSocketFromISR_HappyPath(void)3452 void test_FreeRTOS_SignalSocketFromISR_HappyPath( void )
3453 {
3454 BaseType_t xReturn;
3455 FreeRTOS_Socket_t xSocket;
3456 BaseType_t xHigherPriorityTaskWoken;
3457 uint8_t xEventGroup[ sizeof( size_t ) ];
3458
3459 memset( &xSocket, 0, sizeof( xSocket ) );
3460 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
3461 xSocket.xEventGroup = ( EventGroupHandle_t ) xEventGroup;
3462
3463 xQueueGenericSendFromISR_ExpectAnyArgsAndReturn( 0xABC );
3464
3465 xReturn = FreeRTOS_SignalSocketFromISR( &xSocket, &xHigherPriorityTaskWoken );
3466 TEST_ASSERT_EQUAL( 0xABC, xReturn );
3467 }
3468
3469 /**
3470 * @brief Get TCPv4 packets property string.
3471 */
test_prvSocketProps_TCPv4()3472 void test_prvSocketProps_TCPv4()
3473 {
3474 FreeRTOS_Socket_t xSocket;
3475 uint32_t ulExpectSrcIP = 0xC0A80101;
3476 uint32_t ulExpectRemoteIP = 0xC0A80102;
3477 uint16_t usSrcPort = 1024U;
3478 uint16_t usRemotePort = 2048U;
3479 const char * pcReturn;
3480
3481 memset( &xSocket, 0, sizeof( xSocket ) );
3482 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
3483 xSocket.bits.bIsIPv6 = pdFALSE;
3484 xSocket.xLocalAddress.ulIP_IPv4 = ulExpectSrcIP;
3485 xSocket.usLocalPort = usSrcPort;
3486 xSocket.u.xTCP.xRemoteIP.ulIP_IPv4 = ulExpectRemoteIP;
3487 xSocket.u.xTCP.usRemotePort = usRemotePort;
3488
3489 pcReturn = prvSocketProps( &xSocket );
3490 TEST_ASSERT_EQUAL_STRING( "c0a80101ip port 1024 to c0a80102ip port 2048", pcReturn );
3491 }
3492
3493 /**
3494 * @brief Get UDPv4 packets property string.
3495 */
test_prvSocketProps_UDPv4()3496 void test_prvSocketProps_UDPv4()
3497 {
3498 FreeRTOS_Socket_t xSocket;
3499 uint32_t ulExpectSrcIP = 0xC0A80101;
3500 const char * pcReturn;
3501
3502 memset( &xSocket, 0, sizeof( xSocket ) );
3503 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
3504 xSocket.bits.bIsIPv6 = pdFALSE;
3505 xSocket.xLocalAddress.ulIP_IPv4 = ulExpectSrcIP;
3506 xSocket.usLocalPort = 1024U;
3507
3508 pcReturn = prvSocketProps( &xSocket );
3509 TEST_ASSERT_EQUAL_STRING( "c0a80101ip port 1024", pcReturn );
3510 }
3511
3512 /**
3513 * @brief Get TCPv6 packets property string.
3514 */
test_prvSocketProps_TCPv6()3515 void test_prvSocketProps_TCPv6()
3516 {
3517 FreeRTOS_Socket_t xSocket;
3518 IPv6_Address_t * pxIPv6SrcAddress = &xIPv6Address; /* 2001::1 */
3519 IPv6_Address_t xIPv6RemoteAddress = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 } }; /* 2001::2 */
3520 uint16_t usSrcPort = 1024U;
3521 uint16_t usRemotePort = 2048U;
3522 const char * pcReturn;
3523
3524 memset( &xSocket, 0, sizeof( xSocket ) );
3525 xSocket.ucProtocol = FREERTOS_IPPROTO_TCP;
3526 xSocket.bits.bIsIPv6 = pdTRUE;
3527 memcpy( xSocket.xLocalAddress.xIP_IPv6.ucBytes, pxIPv6SrcAddress->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3528 xSocket.usLocalPort = usSrcPort;
3529 memcpy( xSocket.u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, xIPv6RemoteAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3530 xSocket.u.xTCP.usRemotePort = usRemotePort;
3531
3532 pcReturn = prvSocketProps( &xSocket );
3533 }
3534
3535 /**
3536 * @brief Get UDPv6 packets property string.
3537 */
test_prvSocketProps_UDPv6()3538 void test_prvSocketProps_UDPv6()
3539 {
3540 FreeRTOS_Socket_t xSocket;
3541 IPv6_Address_t * pxIPv6SrcAddress = &xIPv6Address; /* 2001::1 */
3542 uint16_t usSrcPort = 1024U;
3543 const char * pcReturn;
3544
3545 memset( &xSocket, 0, sizeof( xSocket ) );
3546 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP;
3547 xSocket.bits.bIsIPv6 = pdTRUE;
3548 memcpy( xSocket.xLocalAddress.xIP_IPv6.ucBytes, pxIPv6SrcAddress->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3549 xSocket.usLocalPort = usSrcPort;
3550
3551 pcReturn = prvSocketProps( &xSocket );
3552 }
3553
3554 /**
3555 * @brief Get packets property string with unknown protocol.
3556 */
test_prvSocketProps_UnknownProtocol()3557 void test_prvSocketProps_UnknownProtocol()
3558 {
3559 FreeRTOS_Socket_t xSocket;
3560 IPv6_Address_t * pxIPv6SrcAddress = &xIPv6Address; /* 2001::1 */
3561 uint16_t usSrcPort = 1024U;
3562 const char * pcReturn;
3563
3564 memset( &xSocket, 0, sizeof( xSocket ) );
3565 xSocket.ucProtocol = FREERTOS_IPPROTO_UDP + 1;
3566 xSocket.bits.bIsIPv6 = pdTRUE;
3567 memcpy( xSocket.xLocalAddress.xIP_IPv6.ucBytes, pxIPv6SrcAddress->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3568 xSocket.usLocalPort = usSrcPort;
3569
3570 pcReturn = prvSocketProps( &xSocket );
3571 }
3572
3573 /**
3574 * @brief Happy path of this function for IPv4.
3575 */
test_FreeRTOS_inet_ntop_IPv4(void)3576 void test_FreeRTOS_inet_ntop_IPv4( void )
3577 {
3578 const char * pcReturn;
3579 uint32_t ulIPAddress = 0x10101010; /* 16.16.16.16 */
3580 char * pcExpectResult = "16.16.16.16";
3581 const size_t xSize = 16;
3582 char cDestination[ xSize ];
3583 BaseType_t xAddressFamily = FREERTOS_AF_INET4;
3584
3585 memset( cDestination, 0, sizeof( cDestination ) );
3586
3587 FreeRTOS_inet_ntop4_ExpectAndReturn( &ulIPAddress, cDestination, xSize, cDestination );
3588 FreeRTOS_inet_ntop4_ReturnMemThruPtr_pcDestination( pcExpectResult, strlen( pcExpectResult ) );
3589 pcReturn = FreeRTOS_inet_ntop( xAddressFamily, &ulIPAddress, cDestination, xSize );
3590
3591 TEST_ASSERT_EQUAL_STRING( pcExpectResult, pcReturn );
3592 }
3593
3594 /**
3595 * @brief Happy path of this function for IPv4.
3596 */
test_FreeRTOS_inet_ntop_IPv6(void)3597 void test_FreeRTOS_inet_ntop_IPv6( void )
3598 {
3599 const char * pcReturn;
3600 IPv6_Address_t * pxIPAddress = &xIPv6Address;
3601 char * pcExpectResult = "2001::1";
3602 const size_t xSize = 16;
3603 char cDestination[ xSize ];
3604 BaseType_t xAddressFamily = FREERTOS_AF_INET6;
3605
3606 memset( cDestination, 0, sizeof( cDestination ) );
3607
3608 FreeRTOS_inet_ntop6_ExpectAndReturn( pxIPAddress, cDestination, xSize, cDestination );
3609 FreeRTOS_inet_ntop6_ReturnMemThruPtr_pcDestination( pcExpectResult, strlen( pcExpectResult ) );
3610 pcReturn = FreeRTOS_inet_ntop( xAddressFamily, pxIPAddress, cDestination, xSize );
3611
3612 TEST_ASSERT_EQUAL_STRING( pcExpectResult, pcReturn );
3613 }
3614
3615 /**
3616 * @brief Happy path of this function for unknown family.
3617 */
test_FreeRTOS_inet_ntop_Unknown(void)3618 void test_FreeRTOS_inet_ntop_Unknown( void )
3619 {
3620 const char * pcReturn;
3621 uint32_t ulIPAddress = 0x10101010; /* 16.16.16.16 */
3622 char * pcExpectResult = "16.16.16.16";
3623 const size_t xSize = 16;
3624 char cDestination[ xSize ];
3625 BaseType_t xAddressFamily = FREERTOS_AF_INET6 + 1;
3626
3627 memset( cDestination, 0, sizeof( cDestination ) );
3628
3629 pcReturn = FreeRTOS_inet_ntop( xAddressFamily, &ulIPAddress, cDestination, xSize );
3630
3631 TEST_ASSERT_EQUAL( NULL, pcReturn );
3632 }
3633
3634 /**
3635 * @brief Query socket type of IPv4 socket.
3636 */
test_FreeRTOS_GetIPType_IPv4HappyPath(void)3637 void test_FreeRTOS_GetIPType_IPv4HappyPath( void )
3638 {
3639 BaseType_t xReturn;
3640 FreeRTOS_Socket_t xSocket;
3641
3642 memset( &xSocket, 0, sizeof( xSocket ) );
3643
3644 xSocket.bits.bIsIPv6 = pdFALSE_UNSIGNED;
3645
3646 xReturn = FreeRTOS_GetIPType( &xSocket );
3647
3648 TEST_ASSERT_EQUAL( ipTYPE_IPv4, xReturn );
3649 }
3650
3651 /**
3652 * @brief Query socket type of IPv6 socket.
3653 */
test_FreeRTOS_GetIPType_IPv6HappyPath(void)3654 void test_FreeRTOS_GetIPType_IPv6HappyPath( void )
3655 {
3656 BaseType_t xReturn;
3657 FreeRTOS_Socket_t xSocket;
3658
3659 memset( &xSocket, 0, sizeof( xSocket ) );
3660
3661 xSocket.bits.bIsIPv6 = pdTRUE_UNSIGNED;
3662
3663 xReturn = FreeRTOS_GetIPType( &xSocket );
3664
3665 TEST_ASSERT_EQUAL( ipTYPE_IPv6, xReturn );
3666 }
3667
