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 "FreeRTOSIPConfig.h"
38
39 #include "mock_task.h"
40 #include "mock_list.h"
41
42 #include "mock_FreeRTOS_IP.h"
43 #include "mock_FreeRTOS_IP_Private.h"
44 #include "mock_NetworkBufferManagement.h"
45 #include "mock_FreeRTOS_DHCP.h"
46 #include "mock_FreeRTOS_TCP_Utils.h"
47 #include "mock_FreeRTOS_ND.h"
48
49 #include "FreeRTOS_TCP_Transmission.h"
50 #include "FreeRTOS_TCP_Transmission_IPv6_stubs.c"
51
52 #include "catch_assert.h"
53
54 /* =========================== EXTERN VARIABLES =========================== */
55
56 #define PACKET_LENGTH 50
57
58 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
59
60 /* =============================== Test Cases =============================== */
61
62 /**
63 * @brief This function verify handling when both
64 * 'pxNetworkBuffer' or 'pxSocket' is not defined.
65 * while returning a packet.
66 */
test_prvTCPReturnPacket_IPV6_BufferSocketNULL(void)67 void test_prvTCPReturnPacket_IPV6_BufferSocketNULL( void )
68 {
69 FreeRTOS_Socket_t * pxSocket = NULL;
70 NetworkBufferDescriptor_t * pxDescriptor = NULL;
71 uint32_t ulLen = PACKET_LENGTH;
72 BaseType_t xReleaseAfterSend = pdFALSE;
73
74 prvTCPReturnPacket_IPV6( pxSocket, pxDescriptor, ulLen, xReleaseAfterSend );
75 }
76
77 /**
78 * @brief This function verify handling case when
79 * only pxNetworkBuffer is NULL while
80 * returning a packet.
81 */
test_prvTCPReturnPacket_IPV6_BufferNULL(void)82 void test_prvTCPReturnPacket_IPV6_BufferNULL( void )
83 {
84 FreeRTOS_Socket_t xSocket;
85 NetworkBufferDescriptor_t * pxDescriptor = NULL;
86 uint32_t ulLen = PACKET_LENGTH;
87 BaseType_t xReleaseAfterSend = pdFALSE;
88
89 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
90
91 prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend );
92 }
93
94 /**
95 * @brief This function verify asserting when
96 * ethernet buffer is not initialized.
97 */
test_prvTCPReturnPacket_IPV6_pucEthernetBuffer_Assert(void)98 void test_prvTCPReturnPacket_IPV6_pucEthernetBuffer_Assert( void )
99 {
100 FreeRTOS_Socket_t * pxSocket = NULL;
101 NetworkBufferDescriptor_t xDescriptor;
102 uint32_t ulLen = PACKET_LENGTH;
103 BaseType_t xReleaseAfterSend = pdFALSE;
104 NetworkEndPoint_t xEndPoint;
105
106 memset( &xDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
107 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
108 xDescriptor.pxEndPoint = &xEndPoint;
109 xDescriptor.pucEthernetBuffer = NULL;
110
111 catch_assert( prvTCPReturnPacket_IPV6( pxSocket, &xDescriptor, ulLen, xReleaseAfterSend ) );
112 }
113
114 /**
115 * @brief This function verify handling case when
116 * only xSocket is NULL while
117 * returning a packet.
118 */
test_prvTCPReturnPacket_IPV6_SocketNULL(void)119 void test_prvTCPReturnPacket_IPV6_SocketNULL( void )
120 {
121 FreeRTOS_Socket_t * pxSocket = NULL;
122 NetworkBufferDescriptor_t xDescriptor;
123 uint32_t ulLen = PACKET_LENGTH;
124 BaseType_t xReleaseAfterSend = pdFALSE;
125 NetworkEndPoint_t xEndPoint;
126 NetworkInterface_t xNetworkInterfaces;
127
128 memset( &xDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
129 xDescriptor.pxEndPoint = &xEndPoint;
130 xDescriptor.pucEthernetBuffer = ucEthernetBuffer;
131 xDescriptor.pxEndPoint->pxNetworkInterface = &xNetworkInterfaces;
132 xDescriptor.pxEndPoint->pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
133
134 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
135 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
136
137 prvTCPReturnPacket_IPV6( pxSocket, &xDescriptor, ulLen, xReleaseAfterSend );
138 }
139
140 /**
141 * @brief This function verify handling case with valid
142 * pxNetworkBuffer and pxSocket where as network end
143 * point is NULL while returning a packet.
144 */
test_prvTCPReturnPacket_IPV6_NoEP_Found(void)145 void test_prvTCPReturnPacket_IPV6_NoEP_Found( void )
146 {
147 FreeRTOS_Socket_t xSocket;
148 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
149 uint32_t ulLen = PACKET_LENGTH;
150 BaseType_t xReleaseAfterSend = pdFALSE;
151 TCPPacket_IPv6_t * pxTCPPacket;
152
153 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
154 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
155
156 xDescriptor.pucEthernetBuffer = ucEthernetBuffer;
157 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) xDescriptor.pucEthernetBuffer );
158 xDescriptor.pxEndPoint = NULL;
159 xSocket.pxEndPoint = NULL;
160
161 prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend );
162 }
163
164 /**
165 * @brief This function verify handling case with valid
166 * pxNetworkBuffer and pxSocket & set EndPoint is
167 * not able to find an Endpoint .
168 */
test_prvTCPReturnPacket_IPV6_NoEP_ReleaseAfterSend(void)169 void test_prvTCPReturnPacket_IPV6_NoEP_ReleaseAfterSend( void )
170 {
171 FreeRTOS_Socket_t xSocket;
172 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
173 uint32_t ulLen = PACKET_LENGTH;
174 BaseType_t xReleaseAfterSend = pdTRUE;
175 TCPPacket_IPv6_t * pxTCPPacket;
176
177 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
178 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
179
180 xDescriptor.pucEthernetBuffer = ucEthernetBuffer;
181 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) xDescriptor.pucEthernetBuffer );
182 xDescriptor.pxEndPoint = NULL;
183
184 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
185
186 prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend );
187 }
188
189 /**
190 * @brief This function verify handling case with valid
191 * pxNetworkBuffer and pxSocket where as network end
192 * point does not have a valid NetworkInterface
193 * while returning a packet.
194 */
test_prvTCPReturnPacket_IPV6_Assert1(void)195 void test_prvTCPReturnPacket_IPV6_Assert1( void )
196 {
197 FreeRTOS_Socket_t xSocket;
198 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
199 uint32_t ulLen = PACKET_LENGTH;
200 BaseType_t xReleaseAfterSend = pdTRUE;
201 NetworkEndPoint_t xEndPoint;
202 TCPPacket_IPv6_t * pxTCPPacket;
203
204
205 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
206 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
207 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
208
209 xDescriptor.pucEthernetBuffer = ucEthernetBuffer;
210 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) xDescriptor.pucEthernetBuffer );
211 pxDescriptor->pxEndPoint = NULL;
212 pxDescriptor->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
213 xSocket.pxEndPoint = &xEndPoint;
214 xSocket.pxEndPoint->pxNetworkInterface = NULL;
215
216 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
217 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
218
219 catch_assert( prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend ) );
220 }
221
222
223 /**
224 * @brief This function verify handling case with valid
225 * pxNetworkBuffer and pxSocket where as network end
226 * point does not have a valid NetworkInterface
227 * while returning a packet.
228 */
test_prvTCPReturnPacket_IPV6_Assert2(void)229 void test_prvTCPReturnPacket_IPV6_Assert2( void )
230 {
231 FreeRTOS_Socket_t xSocket;
232 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
233 uint32_t ulLen = PACKET_LENGTH;
234 BaseType_t xReleaseAfterSend = pdTRUE;
235 NetworkEndPoint_t xEndPoint;
236 TCPPacket_IPv6_t * pxTCPPacket;
237 IPHeader_IPv6_t * pxIPHeader;
238 TCPWindow_t * pxTCPWindow = &( xSocket.u.xTCP.xTCPWindow );
239
240
241 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
242 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
243 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
244
245 pxDescriptor->pucEthernetBuffer = ucEthernetBuffer;
246 pxDescriptor->pxEndPoint = &xEndPoint;
247 pxDescriptor->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
248 pxDescriptor->pxEndPoint->pxNetworkInterface = NULL;
249 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) pxDescriptor->pucEthernetBuffer );
250 pxIPHeader = &pxTCPPacket->xIPHeader;
251
252 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
253 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
254
255 catch_assert( prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend ) );
256 }
257
258 /**
259 * @brief This function verify handling case with valid
260 * pxNetworkBuffer and pxSocket where as network end
261 * point does not have a valid NetworkInterface output
262 * function, while returning a packet.
263 */
test_prvTCPReturnPacket_IPV6_Assert3(void)264 void test_prvTCPReturnPacket_IPV6_Assert3( void )
265 {
266 FreeRTOS_Socket_t xSocket;
267 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
268 uint32_t ulLen = PACKET_LENGTH;
269 BaseType_t xReleaseAfterSend = pdTRUE;
270 NetworkEndPoint_t xEndPoint;
271 TCPPacket_IPv6_t * pxTCPPacket;
272 IPHeader_IPv6_t * pxIPHeader;
273 TCPWindow_t * pxTCPWindow = &( xSocket.u.xTCP.xTCPWindow );
274 NetworkInterface_t xNetworkInterfaces;
275
276
277 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
278 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
279 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
280
281 pxDescriptor->pucEthernetBuffer = ucEthernetBuffer;
282 pxDescriptor->pxEndPoint = &xEndPoint;
283 pxDescriptor->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
284 pxDescriptor->pxEndPoint->pxNetworkInterface = &xNetworkInterfaces;
285 pxDescriptor->pxEndPoint->pxNetworkInterface->pfOutput = NULL;
286 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) pxDescriptor->pucEthernetBuffer );
287 pxIPHeader = &pxTCPPacket->xIPHeader;
288
289 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
290 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
291
292 catch_assert( prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend ) );
293 }
294
295 /**
296 * @brief This function verify handling case with valid
297 * pxNetworkBuffer and pxSocket where as network end
298 * point does not have a valid NetworkInterface,
299 * while returning a packet.
300 */
test_prvTCPReturnPacket_IPV6_HappyPath_ReleaseAfterSend(void)301 void test_prvTCPReturnPacket_IPV6_HappyPath_ReleaseAfterSend( void )
302 {
303 FreeRTOS_Socket_t xSocket;
304 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
305 uint32_t ulLen = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
306 BaseType_t xReleaseAfterSend = pdTRUE;
307 NetworkEndPoint_t xEndPoint;
308 TCPPacket_IPv6_t * pxTCPPacket;
309 NetworkInterface_t xNetworkInterfaces;
310
311
312 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
313 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
314 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
315 memset( &xNetworkInterfaces, 0, sizeof( NetworkInterface_t ) );
316
317 xDescriptor.pucEthernetBuffer = ucEthernetBuffer;
318 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) xDescriptor.pucEthernetBuffer );
319 pxDescriptor->pxEndPoint = &xEndPoint;
320 pxDescriptor->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
321 pxDescriptor->pxEndPoint->pxNetworkInterface = &xNetworkInterfaces;
322 pxDescriptor->pxEndPoint->pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
323
324 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
325 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
326
327 prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend );
328 }
329
330 /**
331 * @brief This function verify handling case with valid
332 * pxNetworkBuffer and pxSocket where as network end
333 * point does not have a valid NetworkInterface,
334 * while returning a packet.
335 */
test_prvTCPReturnPacket_IPV6_HappyPath_NoReleaseAfterSend(void)336 void test_prvTCPReturnPacket_IPV6_HappyPath_NoReleaseAfterSend( void )
337 {
338 FreeRTOS_Socket_t xSocket;
339 NetworkBufferDescriptor_t xDescriptor, * pxDescriptor = &xDescriptor;
340 uint32_t ulLen = PACKET_LENGTH;
341 BaseType_t xReleaseAfterSend = pdFALSE;
342 NetworkEndPoint_t xEndPoint;
343 NetworkInterface_t xNetworkInterfaces;
344 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
345
346
347
348 memset( &xSocket, 0, sizeof( FreeRTOS_Socket_t ) );
349 memset( pxDescriptor, 0, sizeof( NetworkBufferDescriptor_t ) );
350 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
351 memset( &xNetworkInterfaces, 0, sizeof( NetworkInterface_t ) );
352
353 pxDescriptor->pucEthernetBuffer = ucEthernetBuffer;
354 pxDescriptor->pxEndPoint = &xEndPoint;
355 pxDescriptor->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
356 pxDescriptor->pxEndPoint->pxNetworkInterface = &xNetworkInterfaces;
357 pxDescriptor->pxEndPoint->pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
358
359 usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
360 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
361
362 prvTCPReturnPacket_IPV6( &xSocket, pxDescriptor, ulLen, xReleaseAfterSend );
363 }
364
365 /**
366 * @brief This function validates failure in creating a packet
367 * as failed to get ND Cache Entry and the End point
368 * was found to be NULL.
369 *
370 */
test_prvTCPPrepareConnect_IPV6_CacheMiss_NULLEP(void)371 void test_prvTCPPrepareConnect_IPV6_CacheMiss_NULLEP( void )
372 {
373 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
374 BaseType_t xReturn = pdFALSE;
375
376 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
377
378 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
379
380 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
381
382 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
383 }
384
385 /**
386 * @brief This function validates failure in creating a packet
387 * as after getting the ND Cache Entry, the
388 * End point was found to be NULL.
389 *
390 */
test_prvTCPPrepareConnect_IPV6_CacheHit_NULLEP(void)391 void test_prvTCPPrepareConnect_IPV6_CacheHit_NULLEP( void )
392 {
393 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
394 BaseType_t xReturn = pdFALSE;
395
396 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
397
398 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
399 ulApplicationGetNextSequenceNumber_ExpectAnyArgsAndReturn( 0 );
400
401 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
402
403 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
404 }
405
406 /**
407 * @brief This function validates failure in creating a packet
408 * as after getting the ND Cache Entry, but there
409 * was random number generation error.
410 *
411 */
test_prvTCPPrepareConnect_IPV6_CacheHit_RandNumFail(void)412 void test_prvTCPPrepareConnect_IPV6_CacheHit_RandNumFail( void )
413 {
414 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
415 BaseType_t xReturn = pdFALSE;
416
417 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
418
419 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
420 ulApplicationGetNextSequenceNumber_ExpectAnyArgsAndReturn( 10 );
421
422 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
423
424 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
425 }
426
427
428 /**
429 * @brief This function validates failure in creating a packet
430 * as there is no IP address, or an ARP is still in progress.
431 */
test_prvTCPPrepareConnect_IPV6_CantSendPacket_NULLEP(void)432 void test_prvTCPPrepareConnect_IPV6_CantSendPacket_NULLEP( void )
433 {
434 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
435 BaseType_t xReturn = pdFALSE;
436
437 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eCantSendPacket );
438
439 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
440
441 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
442
443 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
444 }
445
446 /**
447 * @brief This function validates failure in creating a packet
448 * as there is a cache miss but a valid Endpoint is found.
449 */
test_prvTCPPrepareConnect_IPV6_CacheMiss_ValidEP(void)450 void test_prvTCPPrepareConnect_IPV6_CacheMiss_ValidEP( void )
451 {
452 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
453 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
454 BaseType_t xReturn = pdFALSE;
455
456 memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
457 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
458 eNDGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
459
460 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
461 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
462
463 prvSocketSetMSS_ExpectAnyArgs();
464
465 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
466
467 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
468 TEST_ASSERT_EQUAL_MEMORY( pxSocket->pxEndPoint, pxEndPoint, sizeof( NetworkEndPoint_t ) );
469 }
470
471 /**
472 * @brief This function validates failure in creating a packet
473 * as cache get entry returns an unknown return value.
474 */
test_prvTCPPrepareConnect_IPV6_DefaultCase_ValidEP(void)475 void test_prvTCPPrepareConnect_IPV6_DefaultCase_ValidEP( void )
476 {
477 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
478 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
479 NetworkBufferDescriptor_t xNetworkBuffer;
480 BaseType_t xReturn = pdFALSE;
481
482 memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
483 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
484 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eCantSendPacket + 1 ); /* Default case */
485 eNDGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
486
487 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
488 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
489 vNDSendNeighbourSolicitation_ExpectAnyArgs();
490
491 prvSocketSetMSS_ExpectAnyArgs();
492
493 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
494
495 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
496 TEST_ASSERT_EQUAL_MEMORY( pxSocket->pxEndPoint, pxEndPoint, sizeof( NetworkEndPoint_t ) );
497 }
498
499 /**
500 * @brief This function validates successfully created a
501 * packet and sending the first SYN with IPv4 frame type.
502 */
test_prvTCPPrepareConnect_IPV6_HappyPath_IPv4(void)503 void test_prvTCPPrepareConnect_IPV6_HappyPath_IPv4( void )
504 {
505 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
506 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
507 NetworkBufferDescriptor_t xNetworkBuffer;
508 BaseType_t xReturn = pdFALSE;
509
510 memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
511 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
512 pxSocket->bits.bIsIPv6 = 0;
513
514 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
515 eNDGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
516
517 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
518 ulApplicationGetNextSequenceNumber_ExpectAnyArgsAndReturn( 10 );
519
520 prvSocketSetMSS_ExpectAnyArgs();
521
522 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
523
524 TEST_ASSERT_EQUAL( pdPASS, xReturn );
525 TEST_ASSERT_EQUAL_MEMORY( pxSocket->pxEndPoint, pxEndPoint, sizeof( NetworkEndPoint_t ) );
526 }
527
528 /**
529 * @brief This function validates successfully created a
530 * packet and sending the first SYN with IPv6 frame type.
531 */
test_prvTCPPrepareConnect_IPV6_HappyPath_IPv6(void)532 void test_prvTCPPrepareConnect_IPV6_HappyPath_IPv6( void )
533 {
534 FreeRTOS_Socket_t xSocket, * pxSocket = &xSocket;
535 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
536 NetworkBufferDescriptor_t xNetworkBuffer;
537 BaseType_t xReturn = pdFALSE;
538
539 memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
540 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
541 pxSocket->bits.bIsIPv6 = 1;
542 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
543 eNDGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
544
545 uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv6_HEADER );
546 ulApplicationGetNextSequenceNumber_ExpectAnyArgsAndReturn( 10 );
547
548 prvSocketSetMSS_ExpectAnyArgs();
549
550 xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
551
552 TEST_ASSERT_EQUAL( pdPASS, xReturn );
553 TEST_ASSERT_EQUAL_MEMORY( pxSocket->pxEndPoint, pxEndPoint, sizeof( NetworkEndPoint_t ) );
554 }
555
556 /**
557 * @brief This function validates sending a TCP protocol control packet,
558 * when an un synchronised packet is received.
559 */
test_prvTCPSendSpecialPktHelper_IPV6(void)560 void test_prvTCPSendSpecialPktHelper_IPV6( void )
561 {
562 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
563 TCPPacket_IPv6_t * pxTCPPacket;
564 uint8_t ucTCPFlags = tcpTCP_FLAG_RST;
565 BaseType_t xReturn;
566
567 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
568 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
569 pxTCPPacket->xTCPHeader.ucTCPFlags = 0;
570
571 xReturn = prvTCPSendSpecialPktHelper_IPV6( pxNetworkBuffer, ucTCPFlags );
572
573 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
574 TEST_ASSERT_EQUAL( ucTCPFlags, pxTCPPacket->xTCPHeader.ucTCPFlags );
575 TEST_ASSERT_EQUAL( ( ipSIZE_OF_TCP_HEADER ) << 2, pxTCPPacket->xTCPHeader.ucTCPOffset );
576 }
577
578 /**
579 * @brief This function validates sending a TCP protocol control packet,
580 * when an synchronize packet is received.
581 */
test_prvTCPSendSpecialPktHelper_IPV6_Syn(void)582 void test_prvTCPSendSpecialPktHelper_IPV6_Syn( void )
583 {
584 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
585 TCPPacket_IPv6_t * pxTCPPacket;
586 uint8_t ucTCPFlags = tcpTCP_FLAG_RST;
587 BaseType_t xReturn;
588
589 xNetworkBuffer.pucEthernetBuffer = ucEthernetBuffer;
590 pxTCPPacket = ( ( TCPPacket_IPv6_t * ) xNetworkBuffer.pucEthernetBuffer );
591 pxTCPPacket->xTCPHeader.ucTCPFlags = tcpTCP_FLAG_SYN;
592
593 xReturn = prvTCPSendSpecialPktHelper_IPV6( pxNetworkBuffer, ucTCPFlags );
594
595 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
596 TEST_ASSERT_EQUAL( ucTCPFlags, pxTCPPacket->xTCPHeader.ucTCPFlags );
597 TEST_ASSERT_EQUAL( ( ipSIZE_OF_TCP_HEADER ) << 2, pxTCPPacket->xTCPHeader.ucTCPOffset );
598 }
599
