1 /*
2 * FreeRTOS+TCP V3.1.0
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_TCP_IP_list_macros.h"
39
40 /* This must come after list.h is included (in this case, indirectly
41 * by mock_list.h). */
42 #include "mock_queue.h"
43 #include "mock_task.h"
44 #include "mock_event_groups.h"
45 #include "mock_list.h"
46
47 #include "mock_FreeRTOS_IP.h"
48 #include "mock_FreeRTOS_IP_Utils.h"
49 #include "mock_NetworkBufferManagement.h"
50 #include "mock_NetworkInterface.h"
51 #include "mock_FreeRTOS_Sockets.h"
52 #include "mock_FreeRTOS_Stream_Buffer.h"
53 #include "mock_FreeRTOS_TCP_WIN.h"
54 #include "mock_FreeRTOS_TCP_State_Handling.h"
55 #include "mock_FreeRTOS_UDP_IP.h"
56 #include "mock_FreeRTOS_TCP_Transmission.h"
57 #include "mock_FreeRTOS_TCP_Reception.h"
58
59 #include "catch_assert.h"
60
61 #include "FreeRTOSIPConfig.h"
62
63 #include "FreeRTOS_TCP_IP_stubs.c"
64 #include "FreeRTOS_TCP_IP.h"
65
66 FreeRTOS_Socket_t xSocket, * pxSocket;
67 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
68
69 extern BaseType_t xTCPWindowLoggingLevel;
70 extern FreeRTOS_Socket_t * xSocketToClose;
71 extern FreeRTOS_Socket_t * xSocketToListen;
72
73 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ] =
74 {
75 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x00, 0x45, 0x00,
76 0x00, 0x34, 0x15, 0xc2, 0x40, 0x00, 0x40, 0x06, 0xa8, 0x8e, 0xc0, 0xa8, 0x00, 0x08, 0xac, 0xd9,
77 0x0e, 0xea, 0xea, 0xfe, 0x01, 0xbb, 0x8b, 0xaf, 0x8a, 0x24, 0xdc, 0x96, 0x95, 0x7a, 0x80, 0x10,
78 0x01, 0xf5, 0x7c, 0x9a, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0xb8, 0x53, 0x57, 0x27, 0xb2, 0xce,
79 0xc3, 0x17
80 };
81
82 static Socket_t xHandleConnectedSocket;
83 static size_t xHandleConnectedLength;
HandleConnected(Socket_t xSocket,size_t xLength)84 static void HandleConnected( Socket_t xSocket,
85 size_t xLength )
86 {
87 TEST_ASSERT_EQUAL( xHandleConnectedSocket, xSocket );
88 TEST_ASSERT_EQUAL( xHandleConnectedLength, xLength );
89 }
90
91 /* Set the ACK message to NULL. */
prvTCPReturnPacket_StubReturnNULL(FreeRTOS_Socket_t * pxSocket,NetworkBufferDescriptor_t * pxDescriptor,uint32_t ulLen,BaseType_t xReleaseAfterSend,int timesCalled)92 static void prvTCPReturnPacket_StubReturnNULL( FreeRTOS_Socket_t * pxSocket,
93 NetworkBufferDescriptor_t * pxDescriptor,
94 uint32_t ulLen,
95 BaseType_t xReleaseAfterSend,
96 int timesCalled )
97 {
98 ( void ) pxDescriptor;
99 ( void ) ulLen;
100 ( void ) xReleaseAfterSend;
101 ( void ) timesCalled;
102 pxSocket->u.xTCP.pxAckMessage = NULL;
103 }
104
105 /* test vSocketCloseNextTime function */
test_vSocketCloseNextTime_Null_Socket(void)106 void test_vSocketCloseNextTime_Null_Socket( void )
107 {
108 vSocketCloseNextTime( NULL );
109 }
110
111 /* test vSocketCloseNextTime function */
test_vSocketCloseNextTime_Not_Close_Socket(void)112 void test_vSocketCloseNextTime_Not_Close_Socket( void )
113 {
114 memset( &xSocket, 0, sizeof( xSocket ) );
115
116 vSocketCloseNextTime( &xSocket );
117 }
118
119 /* test vSocketCloseNextTime function */
test_vSocketCloseNextTime_Not_Close_Same_Socket(void)120 void test_vSocketCloseNextTime_Not_Close_Same_Socket( void )
121 {
122 memset( &xSocket, 0, sizeof( xSocket ) );
123
124 vSocketCloseNextTime( &xSocket );
125 }
126
127
128 /* test vSocketCloseNextTime function */
test_vSocketCloseNextTime_Close_Previous_Socket(void)129 void test_vSocketCloseNextTime_Close_Previous_Socket( void )
130 {
131 FreeRTOS_Socket_t NewSocket;
132
133 vSocketClose_ExpectAnyArgsAndReturn( NULL );
134 vSocketCloseNextTime( &NewSocket );
135 }
136
test_vSocketListenNextTime(void)137 void test_vSocketListenNextTime( void )
138 {
139 FreeRTOS_Socket_t xSocket;
140
141 xSocketToListen = NULL;
142
143 vSocketListenNextTime( &xSocket );
144
145 TEST_ASSERT_EQUAL( &xSocket, xSocketToListen );
146 }
147
test_vSocketListenNextTime1(void)148 void test_vSocketListenNextTime1( void )
149 {
150 FreeRTOS_Socket_t xSocket;
151
152 xSocketToListen = &xSocket;
153
154 FreeRTOS_listen_ExpectAndReturn( ( Socket_t ) xSocketToListen, xSocketToListen->u.xTCP.usBacklog, 0 );
155 vSocketListenNextTime( NULL );
156
157 TEST_ASSERT_EQUAL( NULL, xSocketToListen );
158 }
159
test_vSocketListenNextTime2(void)160 void test_vSocketListenNextTime2( void )
161 {
162 FreeRTOS_Socket_t xSocket;
163
164 xSocketToListen = &xSocket;
165
166 vSocketListenNextTime( xSocketToListen );
167
168 TEST_ASSERT_EQUAL( &xSocket, xSocketToListen );
169 }
170
171 /* test xTCPSocketCheck function */
test_xTCPSocketCheck_AllInputsZero1(void)172 void test_xTCPSocketCheck_AllInputsZero1( void )
173 {
174 BaseType_t xReturn, xToReturn = 0xAABBCCDD;
175 TickType_t xDelayReturn = 0;
176
177 memset( &xSocket, 0, sizeof( xSocket ) );
178
179 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
180 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &xDelayReturn );
181
182 prvTCPStatusAgeCheck_ExpectAnyArgsAndReturn( xToReturn );
183
184 xReturn = xTCPSocketCheck( &xSocket );
185
186 TEST_ASSERT_EQUAL( xToReturn, xReturn );
187 }
188
189 /* test xTCPSocketCheck function */
test_xTCPSocketCheck_StateEstablished(void)190 void test_xTCPSocketCheck_StateEstablished( void )
191 {
192 BaseType_t xReturn, xToReturn = 0xAABBCCDD;
193 FreeRTOS_Socket_t xSocket;
194 TickType_t xDelayReturn = 0;
195
196 memset( &xSocket, 0, sizeof( xSocket ) );
197
198 xSocket.u.xTCP.eTCPState = eESTABLISHED;
199
200 prvTCPSendPacket_ExpectAndReturn( &xSocket, 0 );
201
202 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
203 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &xDelayReturn );
204
205 prvTCPStatusAgeCheck_ExpectAnyArgsAndReturn( xToReturn );
206
207 xReturn = xTCPSocketCheck( &xSocket );
208
209 TEST_ASSERT_EQUAL( xToReturn, xReturn );
210 }
211
212 /* test xTCPSocketCheck function */
test_xTCPSocketCheck_StateEstablished_TxStreamNonNull(void)213 void test_xTCPSocketCheck_StateEstablished_TxStreamNonNull( void )
214 {
215 BaseType_t xReturn, xToReturn = 0xAABBCCDD;
216 FreeRTOS_Socket_t xSocket;
217 TickType_t xDelayReturn = 0;
218
219 memset( &xSocket, 0, sizeof( xSocket ) );
220
221 xSocket.u.xTCP.eTCPState = eESTABLISHED;
222 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
223
224 prvTCPAddTxData_Expect( &xSocket );
225
226 prvTCPSendPacket_ExpectAndReturn( &xSocket, 0 );
227
228 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
229 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &xDelayReturn );
230
231 prvTCPStatusAgeCheck_ExpectAnyArgsAndReturn( xToReturn );
232
233 xReturn = xTCPSocketCheck( &xSocket );
234
235 TEST_ASSERT_EQUAL( xToReturn, xReturn );
236 }
237
238 /* test xTCPSocketCheck function */
test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1(void)239 void test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1( void )
240 {
241 BaseType_t xReturn, xToReturn = 0xAABBCCDD;
242 FreeRTOS_Socket_t xSocket;
243 TickType_t xDelayReturn = 0;
244
245 memset( &xSocket, 0, sizeof( xSocket ) );
246
247 xSocket.u.xTCP.eTCPState = eESTABLISHED;
248 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
249 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
250
251 prvTCPAddTxData_Expect( &xSocket );
252
253 prvTCPReturnPacket_Expect( &xSocket, xSocket.u.xTCP.pxAckMessage, ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER, ipconfigZERO_COPY_TX_DRIVER );
254
255 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
256 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &xDelayReturn );
257
258 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
259
260 prvTCPSendPacket_ExpectAndReturn( &xSocket, 0 );
261
262 prvTCPStatusAgeCheck_ExpectAndReturn( &xSocket, xToReturn );
263
264 xReturn = xTCPSocketCheck( &xSocket );
265
266 TEST_ASSERT_EQUAL( xToReturn, xReturn );
267 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
268 TEST_ASSERT_EQUAL( 1U, xSocket.u.xTCP.usTimeout );
269 }
270
271 /* test xTCPSocketCheck function */
test_xTCPSocketCheck_StateEstablished_TxStreamNonNull_BufferFreed(void)272 void test_xTCPSocketCheck_StateEstablished_TxStreamNonNull_BufferFreed( void )
273 {
274 BaseType_t xReturn, xToReturn = 0xAABBCCDD;
275 FreeRTOS_Socket_t xSocket;
276 TickType_t xDelayReturn = 0;
277
278 memset( &xSocket, 0, sizeof( xSocket ) );
279
280 xSocket.u.xTCP.eTCPState = eESTABLISHED;
281 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
282 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
283
284 prvTCPAddTxData_Expect( &xSocket );
285
286 prvTCPReturnPacket_Stub( prvTCPReturnPacket_StubReturnNULL );
287
288 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
289 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &xDelayReturn );
290
291 prvTCPSendPacket_ExpectAndReturn( &xSocket, 0 );
292
293 prvTCPStatusAgeCheck_ExpectAndReturn( &xSocket, xToReturn );
294
295 xReturn = xTCPSocketCheck( &xSocket );
296
297 TEST_ASSERT_EQUAL( xToReturn, xReturn );
298 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
299 TEST_ASSERT_EQUAL( 1U, xSocket.u.xTCP.usTimeout );
300 }
301
302 /* @brief Test xTCPSocketCheck function when the stream is non-NULL and the
303 * time out is non-zero. */
test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1_NonZeroTimeout(void)304 void test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1_NonZeroTimeout( void )
305 {
306 BaseType_t xReturn, xToReturn = 0;
307 FreeRTOS_Socket_t xSocket;
308 TickType_t xDelayReturn = 0;
309
310 memset( &xSocket, 0, sizeof( xSocket ) );
311
312 xSocket.u.xTCP.eTCPState = eESTABLISHED;
313 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
314 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
315 xSocket.u.xTCP.usTimeout = 100;
316
317 prvTCPAddTxData_Expect( &xSocket );
318
319 prvTCPReturnPacket_Expect( &xSocket, xSocket.u.xTCP.pxAckMessage, ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER, ipconfigZERO_COPY_TX_DRIVER );
320
321 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
322
323 xReturn = xTCPSocketCheck( &xSocket );
324
325 TEST_ASSERT_EQUAL( xToReturn, xReturn );
326 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
327 TEST_ASSERT_EQUAL( 100U, xSocket.u.xTCP.usTimeout );
328 }
329
330 /* @brief Test xTCPSocketCheck function when the stream is non-NULL and the
331 * time out is non-zero. The port number cannot be allowed to issue log
332 * messages. */
test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1_NonZeroTimeout_NoLogPort(void)333 void test_xTCPSocketCheck_StateEstablished_TxStreamNonNull1_NonZeroTimeout_NoLogPort( void )
334 {
335 BaseType_t xReturn, xToReturn = 0, xBackup;
336 FreeRTOS_Socket_t xSocket;
337 TickType_t xDelayReturn = 0;
338
339 memset( &xSocket, 0, sizeof( xSocket ) );
340
341 xSocket.u.xTCP.eTCPState = eESTABLISHED;
342 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
343 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
344 xSocket.u.xTCP.usTimeout = 100;
345 xSocket.usLocalPort = 23U;
346
347 xBackup = xTCPWindowLoggingLevel;
348 xTCPWindowLoggingLevel = 2;
349
350 prvTCPAddTxData_Expect( &xSocket );
351
352 prvTCPReturnPacket_Expect( &xSocket, xSocket.u.xTCP.pxAckMessage, ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER, ipconfigZERO_COPY_TX_DRIVER );
353
354 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
355
356 xReturn = xTCPSocketCheck( &xSocket );
357
358 TEST_ASSERT_EQUAL( xToReturn, xReturn );
359 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
360 TEST_ASSERT_EQUAL( 100U, xSocket.u.xTCP.usTimeout );
361
362 xTCPWindowLoggingLevel = xBackup;
363 }
364
365 /* @brief Test xTCPSocketCheck function when the stream is non-NULL and the
366 * time out is non-zero. The port number cannot be allowed to issue log
367 * messages. */
test_xTCPSocketCheck_StateCLOSED_TxStreamNonNull1_NonZeroTimeout(void)368 void test_xTCPSocketCheck_StateCLOSED_TxStreamNonNull1_NonZeroTimeout( void )
369 {
370 BaseType_t xReturn, xToReturn = 0;
371 FreeRTOS_Socket_t xSocket;
372 TickType_t xDelayReturn = 0;
373
374 memset( &xSocket, 0, sizeof( xSocket ) );
375
376 xSocket.u.xTCP.eTCPState = eCLOSED;
377 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
378 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
379 xSocket.u.xTCP.usTimeout = 100;
380 xSocket.usLocalPort = 23U;
381
382 xTCPWindowLoggingLevel = 2;
383
384 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
385
386 xReturn = xTCPSocketCheck( &xSocket );
387
388 TEST_ASSERT_EQUAL( xToReturn, xReturn );
389 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
390 TEST_ASSERT_EQUAL( 100U, xSocket.u.xTCP.usTimeout );
391
392 xTCPWindowLoggingLevel = 1;
393 }
394
395 /* @brief Test xTCPSocketCheck function when the stream is non-NULL and the
396 * time out is non-zero. Additionally, the user has requested to shutdown
397 * the socket. */
test_xTCPSocketCheck_StateeCONNECT_SYN_TxStreamNonNull_UserShutdown(void)398 void test_xTCPSocketCheck_StateeCONNECT_SYN_TxStreamNonNull_UserShutdown( void )
399 {
400 BaseType_t xReturn, xToReturn = 0;
401 FreeRTOS_Socket_t xSocket;
402
403 memset( &xSocket, 0, sizeof( xSocket ) );
404
405 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
406 xSocket.u.xTCP.txStream = ( void * ) &xSocket;
407 xSocket.u.xTCP.pxAckMessage = ( void * ) &xSocket;
408 xSocket.u.xTCP.usTimeout = 100;
409 xSocket.u.xTCP.bits.bUserShutdown = pdTRUE_UNSIGNED;
410
411 vReleaseNetworkBufferAndDescriptor_Expect( xSocket.u.xTCP.pxAckMessage );
412
413 prvTCPSendPacket_ExpectAndReturn( &xSocket, 0 );
414
415 prvTCPStatusAgeCheck_ExpectAndReturn( &xSocket, xToReturn );
416
417 xReturn = xTCPSocketCheck( &xSocket );
418
419 TEST_ASSERT_EQUAL( xToReturn, xReturn );
420 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxAckMessage );
421 /* ARP phase. Check every half second. */
422 TEST_ASSERT_EQUAL( 500U, xSocket.u.xTCP.usTimeout );
423 }
424
425 /* @brief Test prvTCPTouchSocket function. */
test_prvTCPTouchSocket(void)426 void test_prvTCPTouchSocket( void )
427 {
428 FreeRTOS_Socket_t xSocket;
429 BaseType_t xTickCountAck = 0xAABBEEDD;
430 BaseType_t xTickCountAlive = 0xAABBEFDD;
431
432 memset( &xSocket, 0xAA, sizeof( xSocket ) );
433
434 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
435 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
436
437 prvTCPTouchSocket( &xSocket );
438
439 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
440 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
441 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
442 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
443 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
444 }
445
446 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_ConnSyn_State_Not_Active(void)447 void test_prvTCPNextTimeout_ConnSyn_State_Not_Active( void )
448 {
449 TickType_t Return = 0;
450
451 pxSocket = &xSocket;
452
453 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
454 pxSocket->u.xTCP.bits.bConnPrepared = pdFALSE;
455 pxSocket->u.xTCP.ucRepCount = 0;
456
457 Return = prvTCPNextTimeout( pxSocket );
458 TEST_ASSERT_EQUAL( 500, Return );
459 }
460
461 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_ConnSyn_State_Active_Rep0(void)462 void test_prvTCPNextTimeout_ConnSyn_State_Active_Rep0( void )
463 {
464 TickType_t Return = 0;
465
466 pxSocket = &xSocket;
467
468 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
469 pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE;
470 pxSocket->u.xTCP.ucRepCount = 0;
471
472 Return = prvTCPNextTimeout( pxSocket );
473 TEST_ASSERT_EQUAL( 1, Return );
474 }
475
476 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_ConnSyn_State_Active_Rep1(void)477 void test_prvTCPNextTimeout_ConnSyn_State_Active_Rep1( void )
478 {
479 TickType_t Return = 0;
480
481 pxSocket = &xSocket;
482
483 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
484 pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE;
485 pxSocket->u.xTCP.ucRepCount = 1;
486
487 Return = prvTCPNextTimeout( pxSocket );
488 TEST_ASSERT_EQUAL( 3000, Return );
489 }
490
491 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_ConnSyn_State_Active_Rep3(void)492 void test_prvTCPNextTimeout_ConnSyn_State_Active_Rep3( void )
493 {
494 TickType_t Return = 0;
495
496 pxSocket = &xSocket;
497
498 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
499 pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE;
500 pxSocket->u.xTCP.ucRepCount = 3;
501
502 Return = prvTCPNextTimeout( pxSocket );
503 TEST_ASSERT_EQUAL( 11000, Return );
504 }
505
506 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_Established_State_Active_Timeout_Set(void)507 void test_prvTCPNextTimeout_Established_State_Active_Timeout_Set( void )
508 {
509 TickType_t Return = 0;
510
511 pxSocket = &xSocket;
512
513 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
514 pxSocket->u.xTCP.usTimeout = 5000;
515 pxSocket->u.xTCP.ucRepCount = 3;
516
517 Return = prvTCPNextTimeout( pxSocket );
518 TEST_ASSERT_EQUAL( 5000, Return );
519 }
520
521 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_Has_Data_With_Delay(void)522 void test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_Has_Data_With_Delay( void )
523 {
524 TickType_t Return = 0;
525
526 pxSocket = &xSocket;
527 TickType_t TxWinReturn = 1000;
528
529 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
530 pxSocket->u.xTCP.usTimeout = 0;
531 pxSocket->u.xTCP.ucRepCount = 3;
532
533 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
534 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &TxWinReturn );
535
536 Return = prvTCPNextTimeout( pxSocket );
537 TEST_ASSERT_EQUAL( 1000, Return );
538 }
539
540 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_Has_Data_Without_Delay(void)541 void test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_Has_Data_Without_Delay( void )
542 {
543 TickType_t Return = 0;
544
545 pxSocket = &xSocket;
546 TickType_t TxWinReturn = 0;
547
548 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
549 pxSocket->u.xTCP.usTimeout = 0;
550 pxSocket->u.xTCP.ucRepCount = 3;
551
552 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdTRUE );
553 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &TxWinReturn );
554
555 Return = prvTCPNextTimeout( pxSocket );
556 TEST_ASSERT_EQUAL( 1, Return );
557 }
558
559 /* test prvTCPNextTimeout function */
test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_No_Data_Without_Delay(void)560 void test_prvTCPNextTimeout_Established_State_Active_Timeout_Not_Set_No_Data_Without_Delay( void )
561 {
562 TickType_t Return = 0;
563
564 pxSocket = &xSocket;
565 TickType_t TxWinReturn = 0;
566
567 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
568 pxSocket->u.xTCP.usTimeout = 0;
569 pxSocket->u.xTCP.ucRepCount = 3;
570
571 xTCPWindowTxHasData_ExpectAnyArgsAndReturn( pdFALSE );
572 xTCPWindowTxHasData_ReturnThruPtr_pulDelay( &TxWinReturn );
573
574 Return = prvTCPNextTimeout( pxSocket );
575 TEST_ASSERT_EQUAL( tcpMAXIMUM_TCP_WAKEUP_TIME_MS, Return );
576 }
577
578 /* @brief Test vTCPStateChange function when the state to be reached and the
579 * current state equal to closed state. */
test_vTCPStateChange_ClosedState(void)580 void test_vTCPStateChange_ClosedState( void )
581 {
582 FreeRTOS_Socket_t xSocket;
583 enum eTCP_STATE eTCPState;
584 BaseType_t xTickCountAck = 0xAABBEEDD;
585 BaseType_t xTickCountAlive = 0xAABBEFDD;
586
587 memset( &xSocket, 0, sizeof( xSocket ) );
588 eTCPState = eCLOSED;
589
590 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
591 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
592
593 vSocketWakeUpUser_Expect( &xSocket );
594
595 vTCPStateChange( &xSocket, eTCPState );
596
597 TEST_ASSERT_EQUAL( eCLOSED, xSocket.u.xTCP.eTCPState );
598 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
599 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
600 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
601 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
602 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
603 }
604
605 /* @brief Test vTCPStateChange function when the state to be reached is closed wait
606 * and current state is equal to connect syn. */
test_vTCPStateChange_ClosedWaitState_PrvStateSyn(void)607 void test_vTCPStateChange_ClosedWaitState_PrvStateSyn( void )
608 {
609 FreeRTOS_Socket_t xSocket;
610 enum eTCP_STATE eTCPState;
611 BaseType_t xTickCountAck = 0xAABBEEDD;
612 BaseType_t xTickCountAlive = 0xAABBEFDD;
613
614 memset( &xSocket, 0, sizeof( xSocket ) );
615 eTCPState = eCLOSE_WAIT;
616
617 xSocket.u.xTCP.eTCPState = eCONNECT_SYN;
618
619 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
620 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
621 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
622
623 vSocketWakeUpUser_Expect( &xSocket );
624
625 vTCPStateChange( &xSocket, eTCPState );
626
627 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
628 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
629 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
630 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
631 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
632 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
633 }
634
635 /* @brief Test vTCPStateChange function when the state to be reached is closed wait
636 * and current state is equal to syn first. */
test_vTCPStateChange_ClosedWaitState_PrvStateSynFirst(void)637 void test_vTCPStateChange_ClosedWaitState_PrvStateSynFirst( void )
638 {
639 FreeRTOS_Socket_t xSocket;
640 enum eTCP_STATE eTCPState;
641 BaseType_t xTickCountAck = 0xAABBEEDD;
642 BaseType_t xTickCountAlive = 0xAABBEFDD;
643
644 memset( &xSocket, 0, sizeof( xSocket ) );
645 eTCPState = eCLOSE_WAIT;
646
647 xSocket.u.xTCP.eTCPState = eSYN_FIRST;
648
649 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
650 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
651 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
652
653 vSocketWakeUpUser_Expect( &xSocket );
654
655 vTCPStateChange( &xSocket, eTCPState );
656
657 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
658 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
659 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
660 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
661 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
662 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
663 }
664
665 /* @brief Test vTCPStateChange function when the state to be reached is closed wait
666 * and current state is equal to syn first. */
test_vTCPStateChange_ClosedWaitState_CurrentStateSynFirstNextStateCloseWait(void)667 void test_vTCPStateChange_ClosedWaitState_CurrentStateSynFirstNextStateCloseWait( void )
668 {
669 FreeRTOS_Socket_t xSocket;
670 enum eTCP_STATE eTCPState;
671 BaseType_t xTickCountAck = 0xAABBEEDD;
672 BaseType_t xTickCountAlive = 0xAABBEFDD;
673
674 memset( &xSocket, 0, sizeof( xSocket ) );
675 eTCPState = eCLOSE_WAIT;
676
677 xSocketToListen = NULL;
678
679 xSocket.u.xTCP.eTCPState = eSYN_FIRST;
680 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
681
682 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
683 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
684 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
685
686 vSocketWakeUpUser_Expect( &xSocket );
687
688 vTCPStateChange( &xSocket, eTCPState );
689
690 TEST_ASSERT_EQUAL( eCLOSED, xSocket.u.xTCP.eTCPState );
691 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
692 TEST_ASSERT_EQUAL( &xSocket, xSocketToListen );
693 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
694 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
695 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
696 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
697 }
698
699 /* @brief Test vTCPStateChange function when the state to be reached is closed wait
700 * and current state is equal to syn received. */
test_vTCPStateChange_ClosedWaitState_PrvStateSynRecvd(void)701 void test_vTCPStateChange_ClosedWaitState_PrvStateSynRecvd( void )
702 {
703 FreeRTOS_Socket_t xSocket;
704 enum eTCP_STATE eTCPState;
705 BaseType_t xTickCountAck = 0xAABBEEDD;
706 BaseType_t xTickCountAlive = 0xAABBEFDD;
707
708 memset( &xSocket, 0, sizeof( xSocket ) );
709 eTCPState = eCLOSE_WAIT;
710
711 xSocket.u.xTCP.eTCPState = eSYN_RECEIVED;
712
713 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
714 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
715 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
716
717 vSocketWakeUpUser_Expect( &xSocket );
718
719 vTCPStateChange( &xSocket, eTCPState );
720
721 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
722 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
723 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
724 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
725 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
726 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
727 }
728
729 /* @brief Test vTCPStateChange function when the state to be reached and the
730 * current state equal to close wait state. */
test_vTCPStateChange_ClosedWaitState(void)731 void test_vTCPStateChange_ClosedWaitState( void )
732 {
733 FreeRTOS_Socket_t xSocket;
734 enum eTCP_STATE eTCPState;
735 BaseType_t xTickCountAck = 0xAABBEEDD;
736 BaseType_t xTickCountAlive = 0xAABBEFDD;
737
738 memset( &xSocket, 0, sizeof( xSocket ) );
739 eTCPState = eCLOSE_WAIT;
740
741 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
742 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
743
744 vSocketWakeUpUser_Expect( &xSocket );
745
746 vTCPStateChange( &xSocket, eTCPState );
747
748 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
749 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
750 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
751 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
752 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
753 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
754 }
755
756 /* @brief Test vTCPStateChange function when the state to be reached and the
757 * current state equal to close wait state. Additionally, the pass queued
758 * bit is set and the function is being called from IP task. */
test_vTCPStateChange_ClosedWaitState_CallingFromIPTask(void)759 void test_vTCPStateChange_ClosedWaitState_CallingFromIPTask( void )
760 {
761 FreeRTOS_Socket_t xSocket;
762 enum eTCP_STATE eTCPState;
763 BaseType_t xTickCountAck = 0xAABBEEDD;
764 BaseType_t xTickCountAlive = 0xAABBEFDD;
765
766 memset( &xSocket, 0, sizeof( xSocket ) );
767 xSocket.u.xTCP.eTCPState = eCLOSE_WAIT;
768 eTCPState = eCLOSE_WAIT;
769
770 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
771
772 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
773
774 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
775 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
776
777 vSocketWakeUpUser_Expect( &xSocket );
778
779 vTCPStateChange( &xSocket, eTCPState );
780
781 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
782 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
783 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
784 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
785 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
786 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
787 }
788
789 /* @brief Test vTCPStateChange function when the state to be reached and the
790 * current state equal to close wait state. Additionally, the pass queued
791 * bit is set and the function is not being called from IP task. */
test_vTCPStateChange_ClosedWaitState_NotCallingFromIPTask(void)792 void test_vTCPStateChange_ClosedWaitState_NotCallingFromIPTask( void )
793 {
794 FreeRTOS_Socket_t xSocket;
795 enum eTCP_STATE eTCPState;
796 BaseType_t xTickCountAck = 0xAABBEEDD;
797 BaseType_t xTickCountAlive = 0xAABBEFDD;
798
799 memset( &xSocket, 0, sizeof( xSocket ) );
800 eTCPState = eCLOSE_WAIT;
801
802 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
803
804 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
805
806 catch_assert( vTCPStateChange( &xSocket, eTCPState ) );
807 }
808
809 /* @brief Test vTCPStateChange function when the state to be reached and the
810 * current state equal to close wait state. Additionally, the pass accept
811 * bit is set and the function is being called from IP task. */
test_vTCPStateChange_ClosedWaitState_CallingFromIPTask1(void)812 void test_vTCPStateChange_ClosedWaitState_CallingFromIPTask1( void )
813 {
814 FreeRTOS_Socket_t xSocket;
815 enum eTCP_STATE eTCPState;
816 BaseType_t xTickCountAck = 0xAABBEEDD;
817 BaseType_t xTickCountAlive = 0xAABBEFDD;
818
819 memset( &xSocket, 0, sizeof( xSocket ) );
820 eTCPState = eCLOSE_WAIT;
821
822 xSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
823
824 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
825
826 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
827 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
828
829 vSocketWakeUpUser_Expect( &xSocket );
830
831 vTCPStateChange( &xSocket, eTCPState );
832
833 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
834 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
835 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
836 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
837 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
838 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
839 }
840
841 /* @brief Test vTCPStateChange function when the state to be reached and the
842 * current state equal to close wait state. Additionally, the pass accept
843 * bit is set and the function is not being called from IP task. */
test_vTCPStateChange_ClosedWaitState_NotCallingFromIPTask1(void)844 void test_vTCPStateChange_ClosedWaitState_NotCallingFromIPTask1( void )
845 {
846 FreeRTOS_Socket_t xSocket;
847 enum eTCP_STATE eTCPState;
848
849 memset( &xSocket, 0, sizeof( xSocket ) );
850 eTCPState = eCLOSE_WAIT;
851
852 xSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
853
854 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
855
856 catch_assert( vTCPStateChange( &xSocket, eTCPState ) );
857 }
858
859 /* @brief Test vTCPStateChange function when the state to be reached and the
860 * current state equal to close wait state. Additionally, the pass accept
861 * and reuse socket bits are set. */
test_vTCPStateChange_ClosedWaitState_ReuseSocket(void)862 void test_vTCPStateChange_ClosedWaitState_ReuseSocket( void )
863 {
864 FreeRTOS_Socket_t xSocket;
865 enum eTCP_STATE eTCPState;
866 BaseType_t xTickCountAck = 0xAABBEEDD;
867 BaseType_t xTickCountAlive = 0xAABBEFDD;
868
869 memset( &xSocket, 0, sizeof( xSocket ) );
870 eTCPState = eCLOSE_WAIT;
871
872 xSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
873 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
874
875 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
876 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
877
878 vSocketWakeUpUser_Expect( &xSocket );
879
880 vTCPStateChange( &xSocket, eTCPState );
881
882 TEST_ASSERT_EQUAL( eCLOSE_WAIT, xSocket.u.xTCP.eTCPState );
883 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
884 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
885 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
886 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
887 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
888 }
889
890 /* @brief Test vTCPStateChange function when the state to be reached and the
891 * current state equal to established state. Additionally, the pass accept
892 * and reuse socket bits are set. */
test_vTCPStateChange_EstablishedState_ReuseSocket(void)893 void test_vTCPStateChange_EstablishedState_ReuseSocket( void )
894 {
895 FreeRTOS_Socket_t xSocket;
896 enum eTCP_STATE eTCPState;
897 BaseType_t xTickCountAck = 0xAABBEEDD;
898 BaseType_t xTickCountAlive = 0xAABBEFDD;
899 BaseType_t xBackup;
900
901 memset( &xSocket, 0, sizeof( xSocket ) );
902 eTCPState = eESTABLISHED;
903 xSocket.u.xTCP.eTCPState = eESTABLISHED;
904
905 xSocket.u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
906 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
907
908 xBackup = xTCPWindowLoggingLevel;
909 xTCPWindowLoggingLevel = -1;
910
911 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
912 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
913
914 vSocketWakeUpUser_Expect( &xSocket );
915
916 vTCPStateChange( &xSocket, eTCPState );
917
918 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
919 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
920 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
921 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
922 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
923 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
924
925 xTCPWindowLoggingLevel = xBackup;
926 }
927
928 /* @brief Test vTCPStateChange function when the state to be reached is closed and the
929 * current state is established state. Additionally, the pass accept
930 * and reuse socket bits are set. */
test_vTCPStateChange_EstablishedToClosedState_SocketInactive(void)931 void test_vTCPStateChange_EstablishedToClosedState_SocketInactive( void )
932 {
933 FreeRTOS_Socket_t xSocket;
934 enum eTCP_STATE eTCPState;
935 BaseType_t xTickCountAck = 0xAABBEEDD;
936 BaseType_t xTickCountAlive = 0xAABBEFDD;
937 BaseType_t xBackup;
938
939 memset( &xSocket, 0, sizeof( xSocket ) );
940 eTCPState = eCLOSED;
941 xSocket.u.xTCP.eTCPState = eESTABLISHED;
942
943 xSocket.u.xTCP.usTimeout = 100;
944
945 xBackup = xTCPWindowLoggingLevel;
946 xTCPWindowLoggingLevel = 2;
947
948 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, 0 );
949
950 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
951 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
952
953 vSocketWakeUpUser_Expect( &xSocket );
954
955 vTCPStateChange( &xSocket, eTCPState );
956
957 TEST_ASSERT_EQUAL( eCLOSED, xSocket.u.xTCP.eTCPState );
958 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
959 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
960 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
961 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
962 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
963 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.usTimeout );
964 TEST_ASSERT_EQUAL( eSOCKET_CLOSED, xSocket.xEventBits );
965
966 xTCPWindowLoggingLevel = xBackup;
967 }
968
969 /* @brief Test vTCPStateChange function when the state to be reached is closed and the
970 * current state is established state.
971 */
test_vTCPStateChange_EstablishedToClosedState_SocketActive(void)972 void test_vTCPStateChange_EstablishedToClosedState_SocketActive( void )
973 {
974 FreeRTOS_Socket_t xSocket;
975 enum eTCP_STATE eTCPState;
976 BaseType_t xTickCountAck = 0xAABBEEDD;
977 BaseType_t xTickCountAlive = 0xAABBEFDD;
978 BaseType_t xBackup;
979
980 memset( &xSocket, 0, sizeof( xSocket ) );
981 eTCPState = eCLOSED;
982 xSocket.u.xTCP.eTCPState = eESTABLISHED;
983
984 xSocket.u.xTCP.usTimeout = 100;
985 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
986
987 xBackup = xTCPWindowLoggingLevel;
988 xTCPWindowLoggingLevel = 2;
989
990 xHandleConnectedSocket = &xSocket;
991 xHandleConnectedLength = 0;
992
993 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
994
995 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
996 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
997
998 vSocketWakeUpUser_Expect( &xSocket );
999
1000 vTCPStateChange( &xSocket, eTCPState );
1001
1002 TEST_ASSERT_EQUAL( eCLOSED, xSocket.u.xTCP.eTCPState );
1003 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1004 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1005 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1006 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1007 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1008 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1009 TEST_ASSERT_EQUAL( eSOCKET_CLOSED, xSocket.xEventBits );
1010
1011 xTCPWindowLoggingLevel = xBackup;
1012 }
1013
1014 /* @brief Test vTCPStateChange function when the state to be reached is closed and the
1015 * current state is established state. Socket select bit is set to select except. */
test_vTCPStateChange_EstablishedToClosedState_SocketActive_SelectExcept(void)1016 void test_vTCPStateChange_EstablishedToClosedState_SocketActive_SelectExcept( void )
1017 {
1018 FreeRTOS_Socket_t xSocket;
1019 enum eTCP_STATE eTCPState;
1020 BaseType_t xTickCountAck = 0xAABBEEDD;
1021 BaseType_t xTickCountAlive = 0xAABBEFDD;
1022 BaseType_t xBackup;
1023
1024 memset( &xSocket, 0, sizeof( xSocket ) );
1025 eTCPState = eCLOSED;
1026 xSocket.u.xTCP.eTCPState = eESTABLISHED;
1027
1028 xSocket.u.xTCP.usTimeout = 100;
1029 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1030 xSocket.xSelectBits = eSELECT_EXCEPT;
1031
1032 xBackup = xTCPWindowLoggingLevel;
1033 xTCPWindowLoggingLevel = 2;
1034
1035 xHandleConnectedSocket = &xSocket;
1036 xHandleConnectedLength = 0;
1037
1038 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1039
1040 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1041 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1042
1043 vSocketWakeUpUser_Expect( &xSocket );
1044
1045 vTCPStateChange( &xSocket, eTCPState );
1046
1047 TEST_ASSERT_EQUAL( eCLOSED, xSocket.u.xTCP.eTCPState );
1048 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1049 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1050 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1051 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1052 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1053 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1054 TEST_ASSERT_EQUAL( eSOCKET_CLOSED | ( eSELECT_EXCEPT << SOCKET_EVENT_BIT_COUNT ), xSocket.xEventBits );
1055
1056 xTCPWindowLoggingLevel = xBackup;
1057 }
1058
1059 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1060 * current state is closed. Socket select bit is set to select except. */
test_vTCPStateChange_ClosedToEstablishedState_SocketActive_SelectExcept(void)1061 void test_vTCPStateChange_ClosedToEstablishedState_SocketActive_SelectExcept( void )
1062 {
1063 FreeRTOS_Socket_t xSocket;
1064 enum eTCP_STATE eTCPState;
1065 BaseType_t xTickCountAck = 0xAABBEEDD;
1066 BaseType_t xTickCountAlive = 0xAABBEFDD;
1067 BaseType_t xBackup;
1068
1069 memset( &xSocket, 0, sizeof( xSocket ) );
1070 eTCPState = eESTABLISHED;
1071 xSocket.u.xTCP.eTCPState = eCLOSED;
1072
1073 xSocket.u.xTCP.usTimeout = 100;
1074 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1075 xSocket.xSelectBits = eSELECT_EXCEPT;
1076
1077 xHandleConnectedSocket = &xSocket;
1078 /* Expect the connected field to be set. */
1079 xHandleConnectedLength = 1;
1080
1081 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1082
1083 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1084 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1085
1086 vSocketWakeUpUser_Expect( &xSocket );
1087
1088 vTCPStateChange( &xSocket, eTCPState );
1089
1090 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1091 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1092 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1093 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1094 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1095 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1096 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1097 TEST_ASSERT_EQUAL( eSOCKET_CONNECT, xSocket.xEventBits );
1098 }
1099
1100 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1101 * current state is closed. Socket select bit is set to select write. */
test_vTCPStateChange_ClosedToEstablishedState_SocketActive_SelectWrite(void)1102 void test_vTCPStateChange_ClosedToEstablishedState_SocketActive_SelectWrite( void )
1103 {
1104 FreeRTOS_Socket_t xSocket;
1105 enum eTCP_STATE eTCPState;
1106 BaseType_t xTickCountAck = 0xAABBEEDD;
1107 BaseType_t xTickCountAlive = 0xAABBEFDD;
1108 BaseType_t xBackup;
1109
1110 memset( &xSocket, 0, sizeof( xSocket ) );
1111 eTCPState = eESTABLISHED;
1112 xSocket.u.xTCP.eTCPState = eCLOSED;
1113
1114 xSocket.u.xTCP.usTimeout = 100;
1115 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1116 xSocket.xSelectBits = eSELECT_WRITE;
1117
1118 xHandleConnectedSocket = &xSocket;
1119 /* Expect the connected field to be set. */
1120 xHandleConnectedLength = 1;
1121
1122 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1123
1124 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1125 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1126
1127 vSocketWakeUpUser_Expect( &xSocket );
1128
1129 vTCPStateChange( &xSocket, eTCPState );
1130
1131 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1132 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1133 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1134 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1135 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1136 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1137 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1138 TEST_ASSERT_EQUAL( eSOCKET_CONNECT | ( eSELECT_WRITE << SOCKET_EVENT_BIT_COUNT ), xSocket.xEventBits );
1139 }
1140
1141 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1142 * current state is closed. Socket select bit is set to select write. Also, this socket
1143 * is an orphan. Since parent socket is NULL and reuse bit is not set, it will hit an
1144 * assertion.*/
test_vTCPStateChange_ClosedToEstablishedState_SelectWrite_QueuedBitSet(void)1145 void test_vTCPStateChange_ClosedToEstablishedState_SelectWrite_QueuedBitSet( void )
1146 {
1147 FreeRTOS_Socket_t xSocket;
1148 enum eTCP_STATE eTCPState;
1149 BaseType_t xTickCountAck = 0xAABBEEDD;
1150 BaseType_t xTickCountAlive = 0xAABBEFDD;
1151 BaseType_t xBackup;
1152
1153 memset( &xSocket, 0, sizeof( xSocket ) );
1154 eTCPState = eESTABLISHED;
1155 xSocket.u.xTCP.eTCPState = eCLOSED;
1156
1157 xSocket.u.xTCP.usTimeout = 100;
1158 xSocket.xSelectBits = eSELECT_WRITE;
1159 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
1160 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1161
1162 catch_assert( vTCPStateChange( &xSocket, eTCPState ) );
1163 }
1164
1165 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1166 * current state is closed. Socket select bit is set to select write. Also, this socket
1167 * is an orphan. Parent socket is non-NULL and reuse bit is not set. */
test_vTCPStateChange_ClosedToEstablishedState_SelectWrite_QueuedBitSet_ParentNonNULL(void)1168 void test_vTCPStateChange_ClosedToEstablishedState_SelectWrite_QueuedBitSet_ParentNonNULL( void )
1169 {
1170 FreeRTOS_Socket_t xSocket, xParentSock;
1171 enum eTCP_STATE eTCPState;
1172 BaseType_t xTickCountAck = 0xAABBEEDD;
1173 BaseType_t xTickCountAlive = 0xAABBEFDD;
1174 BaseType_t xBackup;
1175
1176 memset( &xSocket, 0, sizeof( xSocket ) );
1177 memset( &xParentSock, 0, sizeof( xParentSock ) );
1178 eTCPState = eESTABLISHED;
1179 xSocket.u.xTCP.eTCPState = eCLOSED;
1180
1181 xSocket.u.xTCP.usTimeout = 100;
1182 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1183 xSocket.xSelectBits = eSELECT_WRITE;
1184 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
1185 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1186 xSocket.u.xTCP.pxPeerSocket = &xParentSock;
1187
1188 xHandleConnectedSocket = &xSocket;
1189 /* Expect the connected field to be set. */
1190 xHandleConnectedLength = 1;
1191
1192 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1193
1194 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1195 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1196
1197 vSocketWakeUpUser_Expect( &xParentSock );
1198
1199 vTCPStateChange( &xSocket, eTCPState );
1200
1201 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1202 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1203 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1204 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1205 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1206 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1207 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1208 TEST_ASSERT_EQUAL( eSOCKET_ACCEPT, xParentSock.xEventBits );
1209 TEST_ASSERT_EQUAL( &xSocket, xParentSock.u.xTCP.pxPeerSocket );
1210 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxPeerSocket );
1211 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bPassQueued );
1212 TEST_ASSERT_EQUAL( pdTRUE_UNSIGNED, xSocket.u.xTCP.bits.bPassAccept );
1213 }
1214
1215 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1216 * current state is closed. Socket select bit is set to select write. Also, this socket
1217 * is an orphan. Parent socket is non-NULL and reuse bit is not set. Additionally, the
1218 * parent socket has a connected handler. */
test_vTCPStateChange_ClosedToEstablishedState_QueuedBitSet_ParentNonNULL_HasHandler(void)1219 void test_vTCPStateChange_ClosedToEstablishedState_QueuedBitSet_ParentNonNULL_HasHandler( void )
1220 {
1221 FreeRTOS_Socket_t xSocket, xParentSock;
1222 enum eTCP_STATE eTCPState;
1223 BaseType_t xTickCountAck = 0xAABBEEDD;
1224 BaseType_t xTickCountAlive = 0xAABBEFDD;
1225 BaseType_t xBackup;
1226
1227 memset( &xSocket, 0, sizeof( xSocket ) );
1228 memset( &xParentSock, 0, sizeof( xParentSock ) );
1229 eTCPState = eESTABLISHED;
1230 xSocket.u.xTCP.eTCPState = eCLOSED;
1231
1232 xSocket.u.xTCP.usTimeout = 100;
1233 xParentSock.u.xTCP.pxHandleConnected = HandleConnected;
1234 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
1235 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1236 xSocket.u.xTCP.pxPeerSocket = &xParentSock;
1237
1238 xHandleConnectedSocket = &xParentSock;
1239 /* Expect the connected field to be set. */
1240 xHandleConnectedLength = 1;
1241
1242 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1243
1244 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1245 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1246
1247 vSocketWakeUpUser_Expect( &xParentSock );
1248
1249 vTCPStateChange( &xSocket, eTCPState );
1250
1251 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1252 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1253 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1254 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1255 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1256 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1257 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1258 TEST_ASSERT_EQUAL( eSOCKET_ACCEPT, xParentSock.xEventBits );
1259 TEST_ASSERT_EQUAL( &xSocket, xParentSock.u.xTCP.pxPeerSocket );
1260 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxPeerSocket );
1261 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bPassQueued );
1262 TEST_ASSERT_EQUAL( pdTRUE_UNSIGNED, xSocket.u.xTCP.bits.bPassAccept );
1263 }
1264
1265 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1266 * current state is closed. Socket select bit is set to select write. Also, this socket
1267 * is an orphan. Parent socket is non-NULL and reuse bit is not set. Additionally, the
1268 * parent socket has a connected handler. */
test_vTCPStateChange_ClosedToEstablishedState_QueuedBitSet_ParentNonNULL_HasHandler1(void)1269 void test_vTCPStateChange_ClosedToEstablishedState_QueuedBitSet_ParentNonNULL_HasHandler1( void )
1270 {
1271 FreeRTOS_Socket_t xSocket, xParentSock;
1272 enum eTCP_STATE eTCPState;
1273 BaseType_t xTickCountAck = 0xAABBEEDD;
1274 BaseType_t xTickCountAlive = 0xAABBEFDD;
1275 BaseType_t xBackup;
1276
1277 memset( &xSocket, 0, sizeof( xSocket ) );
1278 memset( &xParentSock, 0, sizeof( xParentSock ) );
1279 eTCPState = eESTABLISHED;
1280 xSocket.u.xTCP.eTCPState = eCLOSED;
1281
1282 xSocket.u.xTCP.usTimeout = 100;
1283 xParentSock.u.xTCP.pxHandleConnected = HandleConnected;
1284 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1285 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
1286 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1287 xSocket.u.xTCP.pxPeerSocket = &xParentSock;
1288 xParentSock.u.xTCP.pxPeerSocket = &xSocket;
1289
1290 xHandleConnectedSocket = &xParentSock;
1291 /* Expect the connected field to be set. */
1292 xHandleConnectedLength = 1;
1293
1294 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1295
1296 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1297 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1298
1299 vSocketWakeUpUser_Expect( &xParentSock );
1300
1301 vTCPStateChange( &xSocket, eTCPState );
1302
1303 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1304 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1305 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1306 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1307 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1308 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1309 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1310 TEST_ASSERT_EQUAL( eSOCKET_ACCEPT, xParentSock.xEventBits );
1311 TEST_ASSERT_EQUAL( &xSocket, xParentSock.u.xTCP.pxPeerSocket );
1312 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxPeerSocket );
1313 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bPassQueued );
1314 TEST_ASSERT_EQUAL( pdTRUE_UNSIGNED, xSocket.u.xTCP.bits.bPassAccept );
1315 }
1316
1317 /* @brief Test vTCPStateChange function when the state to be reached is established and the
1318 * current state is closed. Socket select bit is set to select read. Also, this socket
1319 * is an orphan. Parent socket is NULL and reuse bit is set. */
test_vTCPStateChange_ClosedToEstablishedState_SelectRead_QueuedBitSet_ParentNULLReuse(void)1320 void test_vTCPStateChange_ClosedToEstablishedState_SelectRead_QueuedBitSet_ParentNULLReuse( void )
1321 {
1322 FreeRTOS_Socket_t xSocket;
1323 enum eTCP_STATE eTCPState;
1324 BaseType_t xTickCountAck = 0xAABBEEDD;
1325 BaseType_t xTickCountAlive = 0xAABBEFDD;
1326 BaseType_t xBackup;
1327
1328 memset( &xSocket, 0, sizeof( xSocket ) );
1329
1330 eTCPState = eESTABLISHED;
1331 xSocket.u.xTCP.eTCPState = eCLOSED;
1332
1333 xSocket.u.xTCP.usTimeout = 100;
1334 xSocket.u.xTCP.pxHandleConnected = HandleConnected;
1335 xSocket.xSelectBits = eSELECT_READ;
1336 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
1337 xSocket.u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
1338 xSocket.u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
1339
1340 xHandleConnectedSocket = &xSocket;
1341 /* Expect the connected field to be set. */
1342 xHandleConnectedLength = 1;
1343
1344 prvTCPSocketIsActive_ExpectAndReturn( xSocket.u.xTCP.eTCPState, pdTRUE );
1345
1346 xTaskGetTickCount_ExpectAndReturn( xTickCountAck );
1347 xTaskGetTickCount_ExpectAndReturn( xTickCountAlive );
1348
1349 vSocketWakeUpUser_Expect( &xSocket );
1350
1351 vTCPStateChange( &xSocket, eTCPState );
1352
1353 TEST_ASSERT_EQUAL( eESTABLISHED, xSocket.u.xTCP.eTCPState );
1354 TEST_ASSERT_EQUAL( xTickCountAck, xSocket.u.xTCP.xLastActTime );
1355 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bWaitKeepAlive );
1356 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bSendKeepAlive );
1357 TEST_ASSERT_EQUAL( 0, xSocket.u.xTCP.ucKeepRepCount );
1358 TEST_ASSERT_EQUAL( xTickCountAlive, xSocket.u.xTCP.xLastAliveTime );
1359 TEST_ASSERT_EQUAL( 100, xSocket.u.xTCP.usTimeout );
1360 TEST_ASSERT_EQUAL( NULL, xSocket.u.xTCP.pxPeerSocket );
1361 TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, xSocket.u.xTCP.bits.bPassQueued );
1362 TEST_ASSERT_EQUAL( pdTRUE_UNSIGNED, xSocket.u.xTCP.bits.bPassAccept );
1363 TEST_ASSERT_EQUAL( eSOCKET_ACCEPT | ( eSELECT_READ << SOCKET_EVENT_BIT_COUNT ), xSocket.xEventBits );
1364 }
1365
1366 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Null_Descriptor(void)1367 void test_xProcessReceivedTCPPacket_Null_Descriptor( void )
1368 {
1369 BaseType_t Return = pdFALSE;
1370
1371 pxNetworkBuffer = &xNetworkBuffer;
1372 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1373
1374 pxNetworkBuffer->xDataLength = 40;
1375
1376 catch_assert( xProcessReceivedTCPPacket( NULL ) );
1377 }
1378
1379 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Null_Buffer(void)1380 void test_xProcessReceivedTCPPacket_Null_Buffer( void )
1381 {
1382 BaseType_t Return = pdFALSE;
1383
1384 pxNetworkBuffer = &xNetworkBuffer;
1385 pxNetworkBuffer->pucEthernetBuffer = NULL;
1386
1387 pxNetworkBuffer->xDataLength = 40;
1388
1389 catch_assert( xProcessReceivedTCPPacket( pxNetworkBuffer ) );
1390 }
1391
1392 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Minimal_Data_Length(void)1393 void test_xProcessReceivedTCPPacket_Minimal_Data_Length( void )
1394 {
1395 BaseType_t Return = pdFALSE;
1396
1397 pxNetworkBuffer = &xNetworkBuffer;
1398 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1399
1400 pxNetworkBuffer->xDataLength = 40;
1401
1402 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1403 TEST_ASSERT_EQUAL( pdFALSE, Return );
1404 }
1405
1406 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_No_Socket(void)1407 void test_xProcessReceivedTCPPacket_No_Socket( void )
1408 {
1409 BaseType_t Return = pdFALSE;
1410
1411 pxNetworkBuffer = &xNetworkBuffer;
1412 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1413 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1414
1415 pxNetworkBuffer->xDataLength = 100;
1416 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_ACK;
1417
1418 pxTCPSocketLookup_ExpectAnyArgsAndReturn( NULL );
1419
1420 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1421 TEST_ASSERT_EQUAL( pdFALSE, Return );
1422 }
1423
1424 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_No_Active_Socket(void)1425 void test_xProcessReceivedTCPPacket_No_Active_Socket( void )
1426 {
1427 BaseType_t Return = pdFALSE;
1428
1429 pxNetworkBuffer = &xNetworkBuffer;
1430 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1431 pxSocket = &xSocket;
1432 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1433
1434 pxNetworkBuffer->xDataLength = 100;
1435 pxSocket->u.xTCP.eTCPState = eCLOSE_WAIT;
1436 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1437
1438 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1439 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdFALSE );
1440
1441 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1442 TEST_ASSERT_EQUAL( pdFALSE, Return );
1443 }
1444
1445 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_No_Active_Socket_Send_Reset(void)1446 void test_xProcessReceivedTCPPacket_No_Active_Socket_Send_Reset( void )
1447 {
1448 BaseType_t Return = pdFALSE;
1449
1450 pxNetworkBuffer = &xNetworkBuffer;
1451 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1452 pxSocket = &xSocket;
1453 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1454
1455 pxNetworkBuffer->xDataLength = 100;
1456 pxSocket->u.xTCP.eTCPState = eCLOSE_WAIT;
1457 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1458
1459 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1460 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdFALSE );
1461 prvTCPSendReset_ExpectAnyArgsAndReturn( pdTRUE );
1462
1463 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1464 TEST_ASSERT_EQUAL( pdFALSE, Return );
1465 }
1466
1467 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Not_Syn_No_Rst(void)1468 void test_xProcessReceivedTCPPacket_Listen_State_Not_Syn_No_Rst( void )
1469 {
1470 BaseType_t Return = pdFALSE;
1471
1472 pxNetworkBuffer = &xNetworkBuffer;
1473 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1474 pxSocket = &xSocket;
1475 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1476
1477 pxNetworkBuffer->xDataLength = 100;
1478 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1479 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1480
1481 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1482 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1483
1484 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1485 TEST_ASSERT_EQUAL( pdFALSE, Return );
1486 }
1487
1488 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Not_Syn_Rst(void)1489 void test_xProcessReceivedTCPPacket_Listen_State_Not_Syn_Rst( void )
1490 {
1491 BaseType_t Return = pdFALSE;
1492
1493 pxNetworkBuffer = &xNetworkBuffer;
1494 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1495 pxSocket = &xSocket;
1496 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1497
1498 pxNetworkBuffer->xDataLength = 100;
1499 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1500 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_ACK;
1501
1502 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1503 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1504 prvTCPSendReset_ExpectAnyArgsAndReturn( pdTRUE );
1505
1506 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1507 TEST_ASSERT_EQUAL( pdFALSE, Return );
1508 }
1509
1510 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Syn_Null_Socket(void)1511 void test_xProcessReceivedTCPPacket_Listen_State_Syn_Null_Socket( void )
1512 {
1513 BaseType_t Return = pdFALSE;
1514
1515 pxNetworkBuffer = &xNetworkBuffer;
1516 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1517 pxSocket = &xSocket;
1518 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1519
1520 pxNetworkBuffer->xDataLength = 100;
1521 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1522 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1523
1524 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1525 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1526 prvHandleListen_ExpectAnyArgsAndReturn( NULL );
1527
1528 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1529 TEST_ASSERT_EQUAL( pdFALSE, Return );
1530 }
1531
1532 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Syn_NoOp_Sent_Something(void)1533 void test_xProcessReceivedTCPPacket_Listen_State_Syn_NoOp_Sent_Something( void )
1534 {
1535 BaseType_t Return = pdFALSE;
1536
1537 pxNetworkBuffer = &xNetworkBuffer;
1538 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1539 pxSocket = &xSocket;
1540 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1541
1542 pxNetworkBuffer->xDataLength = 100;
1543 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1544 pxSocket->u.xTCP.usTimeout = 1000;
1545 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1546 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x50;
1547
1548 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1549 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1550 prvHandleListen_ExpectAnyArgsAndReturn( pxSocket );
1551 xTaskGetTickCount_ExpectAndReturn( 1000 );
1552 xTaskGetTickCount_ExpectAndReturn( 1500 );
1553 prvTCPHandleState_ExpectAnyArgsAndReturn( 70 );
1554 prvTCPSendRepeated_ExpectAnyArgsAndReturn( 70 );
1555 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
1556
1557 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1558 TEST_ASSERT_EQUAL( pdTRUE, Return );
1559 }
1560
1561 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Syn_NoOp_Sent_None(void)1562 void test_xProcessReceivedTCPPacket_Listen_State_Syn_NoOp_Sent_None( void )
1563 {
1564 BaseType_t Return = pdFALSE;
1565
1566 pxNetworkBuffer = &xNetworkBuffer;
1567 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1568 pxSocket = &xSocket;
1569 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1570
1571 pxNetworkBuffer->xDataLength = 100;
1572 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1573 pxSocket->u.xTCP.usTimeout = 1000;
1574 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1575 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x50;
1576
1577 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1578 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1579 prvHandleListen_ExpectAnyArgsAndReturn( pxSocket );
1580 xTaskGetTickCount_ExpectAndReturn( 1000 );
1581 xTaskGetTickCount_ExpectAndReturn( 1500 );
1582 prvTCPHandleState_ExpectAnyArgsAndReturn( 0 );
1583 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
1584
1585 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1586 TEST_ASSERT_EQUAL( pdTRUE, Return );
1587 }
1588
1589 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Syn_With_Op_Check_Failed(void)1590 void test_xProcessReceivedTCPPacket_Listen_State_Syn_With_Op_Check_Failed( void )
1591 {
1592 BaseType_t Return = pdFALSE;
1593 NetworkBufferDescriptor_t * pNullBuffer = NULL;
1594
1595 pxNetworkBuffer = &xNetworkBuffer;
1596 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1597 pxSocket = &xSocket;
1598 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1599
1600 pxNetworkBuffer->xDataLength = 100;
1601 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1602 pxSocket->u.xTCP.usTimeout = 1000;
1603 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1604 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x80;
1605
1606 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1607 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1608 prvHandleListen_ExpectAnyArgsAndReturn( pxSocket );
1609 xTaskGetTickCount_ExpectAndReturn( 1000 );
1610 xTaskGetTickCount_ExpectAndReturn( 1500 );
1611 prvCheckOptions_ExpectAnyArgsAndReturn( pdFALSE );
1612
1613 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1614 TEST_ASSERT_EQUAL( pdFALSE, Return );
1615 }
1616
1617
1618 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Listen_State_Syn_With_Op_Sent_Something_Buffer_Gone(void)1619 void test_xProcessReceivedTCPPacket_Listen_State_Syn_With_Op_Sent_Something_Buffer_Gone( void )
1620 {
1621 BaseType_t Return = pdFALSE;
1622 NetworkBufferDescriptor_t * pNullBuffer = NULL;
1623
1624 pxNetworkBuffer = &xNetworkBuffer;
1625 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1626 pxSocket = &xSocket;
1627 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1628
1629 pxNetworkBuffer->xDataLength = 100;
1630 pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1631 pxSocket->u.xTCP.usTimeout = 1000;
1632 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1633 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x80;
1634
1635 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1636 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1637 prvHandleListen_ExpectAnyArgsAndReturn( pxSocket );
1638 xTaskGetTickCount_ExpectAndReturn( 1000 );
1639 xTaskGetTickCount_ExpectAndReturn( 1500 );
1640 prvCheckOptions_ExpectAnyArgsAndReturn( pdTRUE );
1641 prvTCPHandleState_ExpectAnyArgsAndReturn( 70 );
1642 prvTCPSendRepeated_ExpectAnyArgsAndReturn( 70 );
1643 prvTCPSendRepeated_ReturnThruPtr_ppxNetworkBuffer( &pNullBuffer );
1644
1645 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1646 TEST_ASSERT_EQUAL( pdTRUE, Return );
1647 }
1648
1649 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Syn(void)1650 void test_xProcessReceivedTCPPacket_Establish_State_Syn( void )
1651 {
1652 BaseType_t Return = pdFALSE;
1653
1654 pxNetworkBuffer = &xNetworkBuffer;
1655 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1656 pxSocket = &xSocket;
1657 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1658
1659 pxNetworkBuffer->xDataLength = 100;
1660 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1661 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1662
1663 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1664 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1665
1666 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1667 TEST_ASSERT_EQUAL( pdFALSE, Return );
1668 }
1669
1670 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_ConnectSyn_State_Rst_Change_State(void)1671 void test_xProcessReceivedTCPPacket_ConnectSyn_State_Rst_Change_State( void )
1672 {
1673 BaseType_t Return = pdFALSE;
1674
1675 pxNetworkBuffer = &xNetworkBuffer;
1676 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1677 pxSocket = &xSocket;
1678 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1679
1680 pxNetworkBuffer->xDataLength = 100;
1681 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
1682 pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber = 0;
1683 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 1 );
1684 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1685
1686 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1687 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1688 xTaskGetTickCount_ExpectAndReturn( 1000 );
1689 xTaskGetTickCount_ExpectAndReturn( 1500 );
1690
1691 vSocketWakeUpUser_Expect( pxSocket );
1692
1693 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1694 TEST_ASSERT_EQUAL( pdFALSE, Return );
1695 TEST_ASSERT_EQUAL( eCLOSED, pxSocket->u.xTCP.eTCPState );
1696 }
1697
1698 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_ConnectSyn_State_Rst_SeqNo_Wrong(void)1699 void test_xProcessReceivedTCPPacket_ConnectSyn_State_Rst_SeqNo_Wrong( void )
1700 {
1701 BaseType_t Return = pdFALSE;
1702
1703 pxNetworkBuffer = &xNetworkBuffer;
1704 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1705 pxSocket = &xSocket;
1706 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1707
1708 pxNetworkBuffer->xDataLength = 100;
1709 pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
1710 pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber = 0;
1711 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1712 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1713
1714 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1715 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1716
1717 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1718 TEST_ASSERT_EQUAL( pdFALSE, Return );
1719 }
1720
1721 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_SynReceived_State_Rst(void)1722 void test_xProcessReceivedTCPPacket_SynReceived_State_Rst( void )
1723 {
1724 BaseType_t Return = pdFALSE;
1725
1726 pxNetworkBuffer = &xNetworkBuffer;
1727 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1728 pxSocket = &xSocket;
1729 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1730
1731 pxNetworkBuffer->xDataLength = 100;
1732 pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
1733 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1734 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x50;
1735 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1001 );
1736 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1737 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
1738
1739 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1740 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1741 xTaskGetTickCount_ExpectAndReturn( 1000 );
1742 xTaskGetTickCount_ExpectAndReturn( 1500 );
1743 prvTCPHandleState_ExpectAnyArgsAndReturn( 0 );
1744 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
1745
1746 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1747 TEST_ASSERT_EQUAL( pdTRUE, Return );
1748 }
1749
1750
1751 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Rst_Change_State(void)1752 void test_xProcessReceivedTCPPacket_Establish_State_Rst_Change_State( void )
1753 {
1754 BaseType_t Return = pdFALSE;
1755
1756 pxNetworkBuffer = &xNetworkBuffer;
1757 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1758 pxSocket = &xSocket;
1759 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1760
1761 pxNetworkBuffer->xDataLength = 100;
1762 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1763 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1764 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1000 );
1765 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1766 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1767
1768 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1769 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1770 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1771 xTaskGetTickCount_ExpectAndReturn( 1000 );
1772 xTaskGetTickCount_ExpectAndReturn( 1500 );
1773
1774 vSocketWakeUpUser_Expect( pxSocket );
1775
1776 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1777 TEST_ASSERT_EQUAL( pdFALSE, Return );
1778 TEST_ASSERT_EQUAL( eCLOSED, pxSocket->u.xTCP.eTCPState );
1779 }
1780
1781 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_InRange(void)1782 void test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_InRange( void )
1783 {
1784 BaseType_t Return = pdFALSE;
1785
1786 pxNetworkBuffer = &xNetworkBuffer;
1787 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1788 pxSocket = &xSocket;
1789 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1790
1791 pxNetworkBuffer->xDataLength = 100;
1792 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1793 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1794 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1001 );
1795 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1796 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1797
1798 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1799 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1800 xSequenceGreaterThan_ExpectAnyArgsAndReturn( pdTRUE );
1801 xSequenceLessThan_ExpectAnyArgsAndReturn( pdTRUE );
1802 prvTCPSendChallengeAck_ExpectAnyArgsAndReturn( pdTRUE );
1803
1804 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1805 TEST_ASSERT_EQUAL( pdFALSE, Return );
1806 }
1807
1808 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_OutRange1(void)1809 void test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_OutRange1( void )
1810 {
1811 BaseType_t Return = pdFALSE;
1812
1813 pxNetworkBuffer = &xNetworkBuffer;
1814 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1815 pxSocket = &xSocket;
1816 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1817
1818 pxNetworkBuffer->xDataLength = 100;
1819 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1820 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1821 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1001 );
1822 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1823 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1824
1825 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1826 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1827 xSequenceGreaterThan_ExpectAnyArgsAndReturn( pdTRUE );
1828 xSequenceLessThan_ExpectAnyArgsAndReturn( pdFALSE );
1829
1830 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1831 TEST_ASSERT_EQUAL( pdFALSE, Return );
1832 }
1833
1834 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_OutRange2(void)1835 void test_xProcessReceivedTCPPacket_Establish_State_Rst_Seq_OutRange2( void )
1836 {
1837 BaseType_t Return = pdFALSE;
1838
1839 pxNetworkBuffer = &xNetworkBuffer;
1840 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1841 pxSocket = &xSocket;
1842 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1843
1844 pxNetworkBuffer->xDataLength = 100;
1845 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1846 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1847 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1001 );
1848 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1849 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_RST;
1850
1851 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1852 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1853 xSequenceGreaterThan_ExpectAnyArgsAndReturn( pdFALSE );
1854
1855 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1856 TEST_ASSERT_EQUAL( pdFALSE, Return );
1857 }
1858
1859
1860 /* test xProcessReceivedTCPPacket function */
test_xProcessReceivedTCPPacket_Establish_State_Ack(void)1861 void test_xProcessReceivedTCPPacket_Establish_State_Ack( void )
1862 {
1863 BaseType_t Return = pdFALSE;
1864
1865 pxNetworkBuffer = &xNetworkBuffer;
1866 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1867 pxSocket = &xSocket;
1868 ProtocolHeaders_t * pxProtocolHeaders = ( ( const ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
1869
1870 pxNetworkBuffer->xDataLength = 100;
1871 pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1872 pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 1000;
1873 pxProtocolHeaders->xTCPHeader.ucTCPOffset = 0x50;
1874 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( 1001 );
1875 pxProtocolHeaders->xTCPHeader.ulAckNr = FreeRTOS_htonl( 100 );
1876 pxProtocolHeaders->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_ACK;
1877
1878 pxTCPSocketLookup_ExpectAnyArgsAndReturn( pxSocket );
1879 prvTCPSocketIsActive_ExpectAnyArgsAndReturn( pdTRUE );
1880 xTaskGetTickCount_ExpectAndReturn( 1000 );
1881 xTaskGetTickCount_ExpectAndReturn( 1500 );
1882 prvTCPHandleState_ExpectAnyArgsAndReturn( 0 );
1883 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
1884
1885 Return = xProcessReceivedTCPPacket( pxNetworkBuffer );
1886 TEST_ASSERT_EQUAL( pdTRUE, Return );
1887 }
1888
test_Helper_ListInitialise(List_t * const pxList)1889 static void test_Helper_ListInitialise( List_t * const pxList )
1890 {
1891 /* The list structure contains a list item which is used to mark the
1892 * end of the list. To initialise the list the list end is inserted
1893 * as the only list entry. */
1894 pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM. This is checked and valid. */
1895
1896 /* The list end value is the highest possible value in the list to
1897 * ensure it remains at the end of the list. */
1898 pxList->xListEnd.xItemValue = portMAX_DELAY;
1899
1900 /* The list end next and previous pointers point to itself so we know
1901 * when the list is empty. */
1902 pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM. This is checked and valid. */
1903 pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM. This is checked and valid. */
1904
1905 pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
1906
1907 /* Write known values into the list if
1908 * configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
1909 listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
1910 listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
1911 }
1912
test_Helper_ListInsertEnd(List_t * const pxList,ListItem_t * const pxNewListItem)1913 static void test_Helper_ListInsertEnd( List_t * const pxList,
1914 ListItem_t * const pxNewListItem )
1915 {
1916 ListItem_t * const pxIndex = pxList->pxIndex;
1917
1918 /* Only effective when configASSERT() is also defined, these tests may catch
1919 * the list data structures being overwritten in memory. They will not catch
1920 * data errors caused by incorrect configuration or use of FreeRTOS. */
1921 listTEST_LIST_INTEGRITY( pxList );
1922 listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
1923
1924 /* Insert a new list item into pxList, but rather than sort the list,
1925 * makes the new list item the last item to be removed by a call to
1926 * listGET_OWNER_OF_NEXT_ENTRY(). */
1927 pxNewListItem->pxNext = pxIndex;
1928 pxNewListItem->pxPrevious = pxIndex->pxPrevious;
1929
1930 /* Only used during decision coverage testing. */
1931 mtCOVERAGE_TEST_DELAY();
1932
1933 pxIndex->pxPrevious->pxNext = pxNewListItem;
1934 pxIndex->pxPrevious = pxNewListItem;
1935
1936 /* Remember which list the item is in. */
1937 pxNewListItem->pxContainer = pxList;
1938
1939 ( pxList->uxNumberOfItems )++;
1940 }
1941
1942 /* test xTCPCheckNewClient function */
test_xTCPCheckNewClient_Empty_List(void)1943 void test_xTCPCheckNewClient_Empty_List( void )
1944 {
1945 BaseType_t Return = pdFALSE;
1946
1947 pxSocket = &xSocket;
1948 List_t * pSocketList = &xBoundTCPSocketsList;
1949 MiniListItem_t EndItem;
1950
1951 test_Helper_ListInitialise( pSocketList );
1952
1953 pxSocket->usLocalPort = 40000;
1954 Return = xTCPCheckNewClient( pxSocket );
1955 TEST_ASSERT_EQUAL( pdFALSE, Return );
1956 TEST_ASSERT_EQUAL( NULL, pxSocket->u.xTCP.pxPeerSocket );
1957 }
1958
1959 /* test xTCPCheckNewClient function */
test_xTCPCheckNewClient_Not_Found_No_Port(void)1960 void test_xTCPCheckNewClient_Not_Found_No_Port( void )
1961 {
1962 BaseType_t Return = pdFALSE;
1963
1964 pxSocket = &xSocket;
1965 List_t * pSocketList = &xBoundTCPSocketsList;
1966 ListItem_t NewEntry;
1967
1968 pxSocket->xBoundSocketListItem.xItemValue = 443;
1969
1970 test_Helper_ListInitialise( pSocketList );
1971 test_Helper_ListInsertEnd( &xBoundTCPSocketsList, &( pxSocket->xBoundSocketListItem ) );
1972
1973 pxSocket->usLocalPort = FreeRTOS_ntohs( 40000 );
1974 Return = xTCPCheckNewClient( pxSocket );
1975 TEST_ASSERT_EQUAL( pdFALSE, Return );
1976 TEST_ASSERT_EQUAL( NULL, pxSocket->u.xTCP.pxPeerSocket );
1977 }
1978
1979 /* test xTCPCheckNewClient function */
test_xTCPCheckNewClient_Not_Found_Not_TCP(void)1980 void test_xTCPCheckNewClient_Not_Found_Not_TCP( void )
1981 {
1982 BaseType_t Return = pdFALSE;
1983
1984 pxSocket = &xSocket;
1985 List_t * pSocketList = &xBoundTCPSocketsList;
1986 ListItem_t NewEntry;
1987
1988 pxSocket->xBoundSocketListItem.xItemValue = 40000;
1989 pxSocket->xBoundSocketListItem.pvOwner = pxSocket;
1990 pxSocket->ucProtocol = FREERTOS_IPPROTO_UDP;
1991 pxSocket->u.xTCP.bits.bPassAccept = pdTRUE;
1992
1993
1994 test_Helper_ListInitialise( pSocketList );
1995 test_Helper_ListInsertEnd( &xBoundTCPSocketsList, &( pxSocket->xBoundSocketListItem ) );
1996
1997 pxSocket->usLocalPort = FreeRTOS_ntohs( 40000 );
1998 Return = xTCPCheckNewClient( pxSocket );
1999 TEST_ASSERT_EQUAL( pdFALSE, Return );
2000 TEST_ASSERT_EQUAL( NULL, pxSocket->u.xTCP.pxPeerSocket );
2001 }
2002
2003 /* test xTCPCheckNewClient function */
test_xTCPCheckNewClient_Not_Found_Not_Aceept(void)2004 void test_xTCPCheckNewClient_Not_Found_Not_Aceept( void )
2005 {
2006 BaseType_t Return = pdFALSE;
2007
2008 pxSocket = &xSocket;
2009 List_t * pSocketList = &xBoundTCPSocketsList;
2010 ListItem_t NewEntry;
2011
2012 pxSocket->xBoundSocketListItem.xItemValue = 40000;
2013 pxSocket->xBoundSocketListItem.pvOwner = pxSocket;
2014 pxSocket->ucProtocol = FREERTOS_IPPROTO_TCP;
2015 pxSocket->u.xTCP.bits.bPassAccept = pdFALSE;
2016
2017
2018 test_Helper_ListInitialise( pSocketList );
2019 test_Helper_ListInsertEnd( &xBoundTCPSocketsList, &( pxSocket->xBoundSocketListItem ) );
2020
2021 pxSocket->usLocalPort = FreeRTOS_ntohs( 40000 );
2022 Return = xTCPCheckNewClient( pxSocket );
2023 TEST_ASSERT_EQUAL( pdFALSE, Return );
2024 TEST_ASSERT_EQUAL( NULL, pxSocket->u.xTCP.pxPeerSocket );
2025 }
2026
2027 /* test xTCPCheckNewClient function */
test_xTCPCheckNewClient_Found(void)2028 void test_xTCPCheckNewClient_Found( void )
2029 {
2030 BaseType_t Return = pdFALSE;
2031
2032 pxSocket = &xSocket;
2033 List_t * pSocketList = &xBoundTCPSocketsList;
2034 ListItem_t NewEntry;
2035
2036 pxSocket->xBoundSocketListItem.xItemValue = 40000;
2037 pxSocket->xBoundSocketListItem.pvOwner = pxSocket;
2038 pxSocket->ucProtocol = FREERTOS_IPPROTO_TCP;
2039 pxSocket->u.xTCP.bits.bPassAccept = pdTRUE;
2040
2041 test_Helper_ListInitialise( pSocketList );
2042 test_Helper_ListInsertEnd( &xBoundTCPSocketsList, &( pxSocket->xBoundSocketListItem ) );
2043
2044 pxSocket->usLocalPort = FreeRTOS_ntohs( 40000 );
2045 Return = xTCPCheckNewClient( pxSocket );
2046 TEST_ASSERT_EQUAL( pdTRUE, Return );
2047 TEST_ASSERT_EQUAL_PTR( pxSocket, pxSocket->u.xTCP.pxPeerSocket );
2048 }
2049
