1 /*
2 * FreeRTOS+TCP <DEVELOPMENT BRANCH>
3 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * http://aws.amazon.com/freertos
25 * http://www.FreeRTOS.org
26 */
27
28
29 /* Include Unity header */
30 #include "unity.h"
31
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36
37 #include "mock_task.h"
38 #include "mock_list.h"
39
40 /* This must come after list.h is included (in this case, indirectly
41 * by mock_list.h). */
42 #include "mock_IP_list_macros.h"
43 #include "mock_queue.h"
44 #include "mock_event_groups.h"
45 #include "mock_FreeRTOS_Stream_Buffer.h"
46
47 #include "mock_FreeRTOS_IP.h"
48 #include "mock_FreeRTOS_IP_Private.h"
49 #include "mock_FreeRTOS_IP_Utils.h"
50 #include "mock_FreeRTOS_IP_Timers.h"
51 #include "mock_FreeRTOS_TCP_IP.h"
52 #include "mock_FreeRTOS_ICMP.h"
53 #include "mock_FreeRTOS_ARP.h"
54 #include "mock_NetworkBufferManagement.h"
55 #include "mock_FreeRTOS_DHCP.h"
56 #include "mock_FreeRTOS_Sockets.h"
57 #include "mock_FreeRTOS_Routing.h"
58 #include "mock_FreeRTOS_DNS.h"
59 #include "mock_FreeRTOS_DNS_Cache.h"
60 #include "mock_FreeRTOS_UDP_IP.h"
61 #include "mock_FreeRTOS_ND.h"
62 #include "mock_FreeRTOS_IPv6.h"
63 #include "mock_FreeRTOS_IPv4.h"
64
65 #include "FreeRTOS_IP.h"
66
67 #include "FreeRTOS_IP_stubs.c"
68 #include "catch_assert.h"
69
70 #include "FreeRTOSIPConfig.h"
71
72 /* =========================== EXTERN VARIABLES =========================== */
73
74 extern NetworkInterface_t xInterfaces[ 1 ];
75 extern BaseType_t xIPTaskInitialised;
76 extern BaseType_t xNetworkDownEventPending;
77
78 void prvIPTask( void * pvParameters );
79 void prvProcessIPEventsAndTimers( void );
80 eFrameProcessingResult_t prvProcessIPPacket( IPPacket_t * pxIPPacket,
81 NetworkBufferDescriptor_t * const pxNetworkBuffer );
82 void prvProcessEthernetPacket( NetworkBufferDescriptor_t * const pxNetworkBuffer );
83
84 static BaseType_t NetworkInterfaceOutputFunction_Stub_Called = 0;
85
86 /* First IPv6 address is 2001:1234:5678::5 */
87 const IPv6_Address_t xIPAddressFive = { 0x20, 0x01, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05 };
88
89 /* Second IPv6 address is 2001:1234:5678::10 */
90 const IPv6_Address_t xIPAddressTen = { 0x20, 0x01, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 };
91
92 /* MAC Address for endpoint. */
93 const uint8_t ucMACAddress[ ipMAC_ADDRESS_LENGTH_BYTES ] = { 0xab, 0xcd, 0xef, 0x11, 0x22, 0x33 };
94
95 /* ============================ Unity Fixtures ============================ */
96
97 /*! called before each test case */
setUp(void)98 void setUp( void )
99 {
100 pxNetworkEndPoints = NULL;
101 pxNetworkInterfaces = NULL;
102 xNetworkDownEventPending = pdFALSE;
103 }
104
105 /*! called after each test case */
tearDown(void)106 void tearDown( void )
107 {
108 }
109
110 /* ======================== Stub Callback Functions ========================= */
111
NetworkInterfaceOutputFunction_Stub(struct xNetworkInterface * pxDescriptor,NetworkBufferDescriptor_t * const pxNetworkBuffer,BaseType_t xReleaseAfterSend)112 static BaseType_t NetworkInterfaceOutputFunction_Stub( struct xNetworkInterface * pxDescriptor,
113 NetworkBufferDescriptor_t * const pxNetworkBuffer,
114 BaseType_t xReleaseAfterSend )
115 {
116 NetworkInterfaceOutputFunction_Stub_Called++;
117 return 0;
118 }
119
120 static uint8_t ReleaseTCPPayloadBuffer[ 1500 ];
121 static BaseType_t ReleaseTCPPayloadBufferxByteCount = 100;
StubuxStreamBufferGetPtr_ReturnBadAddress(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)122 static size_t StubuxStreamBufferGetPtr_ReturnBadAddress( StreamBuffer_t * pxBuffer,
123 uint8_t ** ppucData,
124 int lCounter )
125 {
126 *ppucData = &ReleaseTCPPayloadBuffer[ 150 ];
127
128 return 0xFFFFFF;
129 }
130
StubuxStreamBufferGetPtr_ReturnIncorrectSize(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)131 static size_t StubuxStreamBufferGetPtr_ReturnIncorrectSize( StreamBuffer_t * pxBuffer,
132 uint8_t ** ppucData,
133 int lCounter )
134 {
135 *ppucData = &ReleaseTCPPayloadBuffer[ 0 ];
136
137 return( ReleaseTCPPayloadBufferxByteCount >> 1 );
138 }
139
StubuxStreamBufferGetPtr_ReturnCorrectVals(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)140 static size_t StubuxStreamBufferGetPtr_ReturnCorrectVals( StreamBuffer_t * pxBuffer,
141 uint8_t ** ppucData,
142 int lCounter )
143 {
144 *ppucData = &ReleaseTCPPayloadBuffer[ 0 ];
145
146 return ReleaseTCPPayloadBufferxByteCount;
147 }
148
149 /* ============================== Test Cases ============================== */
150
151 /**
152 * @brief test_vIPNetworkUpCalls
153 * To validate if vIPNetworkUpCalls calls corresponding APIs.
154 */
test_vIPNetworkUpCalls(void)155 void test_vIPNetworkUpCalls( void )
156 {
157 NetworkEndPoint_t xEndPoint = { 0 };
158
159 xEndPoint.bits.bEndPointUp = pdFALSE;
160
161 vApplicationIPNetworkEventHook_Multi_Expect( eNetworkUp, &xEndPoint );
162 vDNSInitialise_Expect();
163 vARPTimerReload_Expect( pdMS_TO_TICKS( 10000 ) );
164
165 vIPNetworkUpCalls( &xEndPoint );
166
167 TEST_ASSERT_EQUAL( pdTRUE, xEndPoint.bits.bEndPointUp );
168 }
169
170 /**
171 * @brief test_FreeRTOS_NetworkDown_SendToIPTaskSuccessful
172 * To validate if FreeRTOS_NetworkDown calls queue send when it's called from IP task.
173 */
test_FreeRTOS_NetworkDown_SendToIPTaskSuccessful(void)174 void test_FreeRTOS_NetworkDown_SendToIPTaskSuccessful( void )
175 {
176 struct xNetworkInterface xNetworkInterface;
177
178 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
179
180 xQueueGenericSend_ExpectAnyArgsAndReturn( pdPASS );
181
182 FreeRTOS_NetworkDown( &xNetworkInterface );
183
184 TEST_ASSERT_EQUAL( pdFALSE, xIsNetworkDownEventPending() );
185 }
186
187 /**
188 * @brief test_FreeRTOS_NetworkDown_SendToIPTaskNotSuccessful
189 * To validate if FreeRTOS_NetworkDown set network down event correctly when queue send failed.
190 */
test_FreeRTOS_NetworkDown_SendToIPTaskNotSuccessful(void)191 void test_FreeRTOS_NetworkDown_SendToIPTaskNotSuccessful( void )
192 {
193 struct xNetworkInterface xNetworkInterface;
194
195 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
196
197 xQueueGenericSend_ExpectAnyArgsAndReturn( pdFAIL );
198
199 FreeRTOS_NetworkDown( &xNetworkInterface );
200
201 TEST_ASSERT_EQUAL( pdTRUE, xIsNetworkDownEventPending() );
202 }
203
204 /**
205 * @brief test_FreeRTOS_NetworkDownFromISR_SendToIPTaskSuccessful
206 * FreeRTOS_NetworkDownFromISR sends by xQueueGenericSendFromISR and return value is true.
207 */
test_FreeRTOS_NetworkDownFromISR_SendToIPTaskSuccessful(void)208 void test_FreeRTOS_NetworkDownFromISR_SendToIPTaskSuccessful( void )
209 {
210 BaseType_t xHasPriorityTaskAwoken = pdTRUE;
211 BaseType_t xReturn;
212 struct xNetworkInterface xNetworkInterface;
213
214 xQueueGenericSendFromISR_ExpectAnyArgsAndReturn( pdPASS );
215 xQueueGenericSendFromISR_ReturnThruPtr_pxHigherPriorityTaskWoken( &xHasPriorityTaskAwoken );
216
217 xReturn = FreeRTOS_NetworkDownFromISR( &xNetworkInterface );
218
219 TEST_ASSERT_EQUAL( pdFALSE, xIsNetworkDownEventPending() );
220 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
221 }
222
223 /**
224 * @brief test_FreeRTOS_NetworkDownFromISR_SendToIPTaskUnsuccessful
225 * To validate if FreeRTOS_NetworkDownFromISR set network down event correct when send queue failed.
226 */
test_FreeRTOS_NetworkDownFromISR_SendToIPTaskUnsuccessful(void)227 void test_FreeRTOS_NetworkDownFromISR_SendToIPTaskUnsuccessful( void )
228 {
229 BaseType_t xHasPriorityTaskAwoken = pdFALSE;
230 BaseType_t xReturn;
231 struct xNetworkInterface xNetworkInterface;
232
233 xQueueGenericSendFromISR_ExpectAnyArgsAndReturn( pdFAIL );
234 xQueueGenericSendFromISR_ReturnThruPtr_pxHigherPriorityTaskWoken( &xHasPriorityTaskAwoken );
235
236 xReturn = FreeRTOS_NetworkDownFromISR( &xNetworkInterface );
237
238 TEST_ASSERT_EQUAL( pdTRUE, xIsNetworkDownEventPending() );
239 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
240 }
241
242 /**
243 * @brief test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig
244 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can return correct network buffer with maximum block time.
245 */
test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig(void)246 void test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig( void )
247 {
248 size_t uxRequestedSizeBytes = 300;
249 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS;
250 void * pvReturn;
251 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
252 uint8_t pucEthernetBuffer[ 1500 ];
253
254 /* Put the ethernet buffer in place. */
255 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
256 pxNetworkBuffer->xDataLength = 0;
257
258 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, uxBlockTimeTicks, pxNetworkBuffer );
259
260 pvReturn = FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, ipTYPE_IPv4 );
261
262 TEST_ASSERT_EQUAL( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, pxNetworkBuffer->xDataLength );
263 TEST_ASSERT_EQUAL_PTR( &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( UDPPacket_t ) ] ), pvReturn );
264 }
265
266 /**
267 * @brief test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeLessThanConfig
268 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can return correct network buffer with maximum block time - 1.
269 */
test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeLessThanConfig(void)270 void test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeLessThanConfig( void )
271 {
272 size_t uxRequestedSizeBytes = 300;
273 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS - 1;
274 void * pvReturn;
275 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
276 uint8_t pucEthernetBuffer[ 1500 ];
277
278 /* Put the ethernet buffer in place. */
279 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
280 pxNetworkBuffer->xDataLength = 0;
281
282 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, uxBlockTimeTicks, pxNetworkBuffer );
283
284 pvReturn = FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, ipTYPE_IPv4 );
285
286 TEST_ASSERT_EQUAL( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, pxNetworkBuffer->xDataLength );
287 TEST_ASSERT_EQUAL_PTR( &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( UDPPacket_t ) ] ), pvReturn );
288 }
289
290 /**
291 * @brief test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig
292 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can return correct network buffer with maximum block time + 1.
293 * And the block time is reduced to maximum block time.
294 */
test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig(void)295 void test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig( void )
296 {
297 size_t uxRequestedSizeBytes = 300;
298 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS + 1;
299 void * pvReturn;
300 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
301 uint8_t pucEthernetBuffer[ 1500 ];
302
303 /* Put the ethernet buffer in place. */
304 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
305 pxNetworkBuffer->xDataLength = 0;
306
307 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS, pxNetworkBuffer );
308
309 pvReturn = FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, ipTYPE_IPv4 );
310
311 TEST_ASSERT_EQUAL( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, pxNetworkBuffer->xDataLength );
312 TEST_ASSERT_EQUAL_PTR( &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( UDPPacket_t ) ] ), pvReturn );
313 }
314
315 /**
316 * @brief test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig_NULLBufferReturned
317 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can return NULL when pxGetNetworkBufferWithDescriptor returns NULL.
318 */
test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig_NULLBufferReturned(void)319 void test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeMoreThanConfig_NULLBufferReturned( void )
320 {
321 size_t uxRequestedSizeBytes = 300;
322 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS + 1;
323 void * pvReturn;
324
325 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( UDPPacket_t ) + uxRequestedSizeBytes, ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS, NULL );
326
327 pvReturn = FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, ipTYPE_IPv4 );
328
329 TEST_ASSERT_NULL( pvReturn );
330 }
331
332 /**
333 * @brief test_FreeRTOS_GetUDPPayloadBuffer_UnknownType
334 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can trigger assertion when the input type is neither IPv4 nor IPv6.
335 */
test_FreeRTOS_GetUDPPayloadBuffer_UnknownType(void)336 void test_FreeRTOS_GetUDPPayloadBuffer_UnknownType( void )
337 {
338 size_t uxRequestedSizeBytes = 300;
339 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS;
340
341 catch_assert( FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, 0xFF ) );
342 }
343
344 /**
345 * @brief test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig_IPv6
346 * To validate if FreeRTOS_GetUDPPayloadBuffer_Multi can return correct network buffer for IPv6.
347 */
test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig_IPv6(void)348 void test_FreeRTOS_GetUDPPayloadBuffer_BlockTimeEqualToConfig_IPv6( void )
349 {
350 size_t uxRequestedSizeBytes = 300;
351 TickType_t uxBlockTimeTicks = ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS;
352 void * pvReturn;
353 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer = &xNetworkBuffer;
354 uint8_t pucEthernetBuffer[ 1500 ];
355
356 /* Put the ethernet buffer in place. */
357 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
358 pxNetworkBuffer->xDataLength = 0;
359
360 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( UDPPacket_IPv6_t ) + uxRequestedSizeBytes, uxBlockTimeTicks, pxNetworkBuffer );
361
362 pvReturn = FreeRTOS_GetUDPPayloadBuffer_Multi( uxRequestedSizeBytes, uxBlockTimeTicks, ipTYPE_IPv6 );
363
364 TEST_ASSERT_EQUAL( sizeof( UDPPacket_IPv6_t ) + uxRequestedSizeBytes, pxNetworkBuffer->xDataLength );
365 TEST_ASSERT_EQUAL_PTR( &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( UDPPacket_IPv6_t ) ] ), pvReturn );
366 }
367
368 /**
369 * @brief test_FreeRTOS_ReleaseUDPPayloadBuffer
370 * To validate if FreeRTOS_ReleaseUDPPayloadBuffer release the correct pointer of buffer.
371 */
test_FreeRTOS_ReleaseUDPPayloadBuffer(void)372 void test_FreeRTOS_ReleaseUDPPayloadBuffer( void )
373 {
374 void * pvBuffer = ( void * ) 0xFFCDEA;
375
376 pxUDPPayloadBuffer_to_NetworkBuffer_ExpectAndReturn( pvBuffer, ( NetworkBufferDescriptor_t * ) 0x12123434 );
377 vReleaseNetworkBufferAndDescriptor_Expect( ( NetworkBufferDescriptor_t * ) 0x12123434 );
378
379 FreeRTOS_ReleaseUDPPayloadBuffer( pvBuffer );
380 }
381
382 /**
383 * @brief test_FreeRTOS_ReleaseUDPPayloadBuffer_NullNetworkDescriptor
384 * To validate if FreeRTOS_ReleaseUDPPayloadBuffer triggers assertion when network descriptor is NULL.
385 */
test_FreeRTOS_ReleaseUDPPayloadBuffer_NullNetworkDescriptor(void)386 void test_FreeRTOS_ReleaseUDPPayloadBuffer_NullNetworkDescriptor( void )
387 {
388 pxUDPPayloadBuffer_to_NetworkBuffer_ExpectAndReturn( NULL, ( NetworkBufferDescriptor_t * ) NULL );
389
390 catch_assert( FreeRTOS_ReleaseUDPPayloadBuffer( NULL ) );
391 }
392
393 /**
394 * @brief test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBufferAssert
395 * The input buffer pointer must be obtained by calling FreeRTOS_recv() with the FREERTOS_ZERO_COPY flag.
396 * Trigger assertion if the input buffer pointer is different from pointer returned from stream buffer API.
397 */
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBufferAssert(void)398 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBufferAssert( void )
399 {
400 FreeRTOS_Socket_t xSocket;
401 BaseType_t xByteCount = 100;
402
403 memset( &xSocket, 0, sizeof( xSocket ) );
404
405 uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnBadAddress );
406
407 catch_assert( FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, xByteCount ) );
408 }
409
410 /**
411 * @brief test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectSizeAssert
412 * To validate if FreeRTOS_ReleaseTCPPayloadBuffer triggers assertion when available buffer size
413 * is less than input length.
414 */
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectSizeAssert(void)415 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectSizeAssert( void )
416 {
417 FreeRTOS_Socket_t xSocket;
418
419 memset( &xSocket, 0, sizeof( xSocket ) );
420
421 uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnIncorrectSize );
422
423 catch_assert( FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount ) );
424 }
425
426 /**
427 * @brief test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBytesReleasedAssert
428 * To validate if FreeRTOS_ReleaseTCPPayloadBuffer triggers assertion when bytes
429 * released from FreeRTOS_recv() is different from request.
430 */
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBytesReleasedAssert(void)431 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBytesReleasedAssert( void )
432 {
433 FreeRTOS_Socket_t xSocket;
434
435 memset( &xSocket, 0, sizeof( xSocket ) );
436
437 uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnCorrectVals );
438
439 FreeRTOS_recv_ExpectAndReturn( &xSocket, NULL, ReleaseTCPPayloadBufferxByteCount, FREERTOS_MSG_DONTWAIT, ( ReleaseTCPPayloadBufferxByteCount >> 1 ) );
440
441 catch_assert( FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount ) );
442 }
443
444 /**
445 * @brief test_FreeRTOS_ReleaseTCPPayloadBuffer_HappyPath
446 * To validate happy path for FreeRTOS_ReleaseTCPPayloadBuffer.
447 */
test_FreeRTOS_ReleaseTCPPayloadBuffer_HappyPath(void)448 void test_FreeRTOS_ReleaseTCPPayloadBuffer_HappyPath( void )
449 {
450 FreeRTOS_Socket_t xSocket;
451 BaseType_t xReturn;
452
453 memset( &xSocket, 0, sizeof( xSocket ) );
454
455 uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnCorrectVals );
456
457 FreeRTOS_recv_ExpectAndReturn( &xSocket, NULL, ReleaseTCPPayloadBufferxByteCount, FREERTOS_MSG_DONTWAIT, ReleaseTCPPayloadBufferxByteCount );
458
459 xReturn = FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount );
460
461 TEST_ASSERT_EQUAL( pdPASS, xReturn );
462 }
463
464 /**
465 * @brief test_prvIPTask
466 * Check if prvIPTask() initialize functionalities and state variables as expected.
467 */
test_prvIPTask(void)468 void test_prvIPTask( void )
469 {
470 /* Reset the static variable. */
471 xIPTaskInitialised = pdFALSE;
472
473 /* In prvIPTask_Initialise. */
474 vNetworkTimerReload_Ignore();
475
476 /* In prvIPTask_Initialise. */
477 vTCPTimerReload_ExpectAnyArgs();
478 vIPSetARPResolutionTimerEnableState_Expect( pdFALSE );
479 vDNSInitialise_Ignore();
480 FreeRTOS_dnsclear_Ignore();
481
482 /* In prvIPTask. */
483 ipFOREVER_ExpectAndReturn( 0 );
484
485 /* Parameters do not matter here. */
486 prvIPTask( NULL );
487
488 TEST_ASSERT_EQUAL( pdTRUE, xIPTaskInitialised );
489 TEST_ASSERT_EQUAL( pdFALSE, xNetworkDownEventPending );
490 }
491
492 /**
493 * @brief test_prvIPTask_NetworkDown
494 * Check if prvIPTask() handles the network down event normally.
495 */
test_prvIPTask_NetworkDown(void)496 void test_prvIPTask_NetworkDown( void )
497 {
498 NetworkInterface_t xNetworkInterface;
499 IPStackEvent_t xDownEvent;
500
501 memset( &xNetworkInterface, 0, sizeof( xNetworkInterface ) );
502 pxNetworkInterfaces = &xNetworkInterface;
503
504 xDownEvent.eEventType = eNetworkDownEvent;
505 xDownEvent.pvData = &xNetworkInterface;
506
507 /* Reset the static variable. */
508 xIPTaskInitialised = pdFALSE;
509
510 /* In prvIPTask_Initialise. */
511 vNetworkTimerReload_Ignore();
512
513 /* In FreeRTOS_NetworkDown. */
514 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
515 xQueueGenericSend_ExpectAnyArgsAndReturn( pdPASS );
516
517 /* In prvIPTask_Initialise. */
518 vTCPTimerReload_ExpectAnyArgs();
519 vIPSetARPResolutionTimerEnableState_Expect( pdFALSE );
520 vDNSInitialise_Ignore();
521 FreeRTOS_dnsclear_Ignore();
522
523 /* In prvIPTask. */
524 ipFOREVER_ExpectAndReturn( pdTRUE );
525
526 /* In prvProcessIPEventsAndTimers. */
527 vCheckNetworkTimers_Ignore();
528 xCalculateSleepTime_ExpectAndReturn( 0 );
529 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
530 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xDownEvent, sizeof( xDownEvent ) );
531 prvProcessNetworkDownEvent_Expect( &xNetworkInterface );
532
533 /* In prvIPTask. */
534 ipFOREVER_ExpectAndReturn( pdFALSE );
535
536 /* Parameters do not matter here. */
537 prvIPTask( NULL );
538
539 TEST_ASSERT_EQUAL( pdTRUE, xIPTaskInitialised );
540 }
541
542 /**
543 * @brief test_prvProcessIPEventsAndTimers_NoEventReceived
544 * Check if prvProcessIPEventsAndTimers() runs normally without events.
545 */
test_prvProcessIPEventsAndTimers_NoEventReceived(void)546 void test_prvProcessIPEventsAndTimers_NoEventReceived( void )
547 {
548 vCheckNetworkTimers_Expect();
549
550 xCalculateSleepTime_ExpectAndReturn( 0 );
551
552 /* No event received. */
553 xQueueReceive_ExpectAnyArgsAndReturn( pdFALSE );
554
555 prvProcessIPEventsAndTimers();
556 }
557
558 /**
559 * @brief test_prvProcessIPEventsAndTimers_eNetworkRxEventNULL
560 * Check if prvProcessIPEventsAndTimers() triggers assertion when data pointer is NULL in eNetworkRxEvent.
561 */
test_prvProcessIPEventsAndTimers_eNetworkRxEventNULL(void)562 void test_prvProcessIPEventsAndTimers_eNetworkRxEventNULL( void )
563 {
564 IPStackEvent_t xReceivedEvent;
565
566 xReceivedEvent.eEventType = eNetworkRxEvent;
567 xReceivedEvent.pvData = NULL;
568
569 /* prvProcessIPEventsAndTimers */
570 vCheckNetworkTimers_Expect();
571 xCalculateSleepTime_ExpectAndReturn( 0 );
572 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
573 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
574
575 catch_assert( prvProcessIPEventsAndTimers() );
576 }
577
578 /**
579 * @brief test_prvProcessIPEventsAndTimers_eNetworkRxEvent
580 * Check if prvProcessIPEventsAndTimers() triggers assertion when data pointer is NULL in eNetworkRxEvent.
581 */
test_prvProcessIPEventsAndTimers_eNetworkRxEvent(void)582 void test_prvProcessIPEventsAndTimers_eNetworkRxEvent( void )
583 {
584 IPStackEvent_t xReceivedEvent;
585 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
586 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
587 EthernetHeader_t * pxEthernetHeader;
588
589 pxNetworkBuffer = &xNetworkBuffer;
590 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
591 pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t ) - 1;
592 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
593
594 xReceivedEvent.eEventType = eNetworkRxEvent;
595 xReceivedEvent.pvData = pxNetworkBuffer;
596
597 /* Put an unknown frame type for prvProcessEthernetPacket to release buffer directly. */
598 pxEthernetHeader->usFrameType = 0xFF;
599
600 /* prvProcessIPEventsAndTimers */
601 vCheckNetworkTimers_Expect();
602 xCalculateSleepTime_ExpectAndReturn( 0 );
603 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
604 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
605
606 /* prvProcessEthernetPacket */
607 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
608
609 prvProcessIPEventsAndTimers();
610 }
611
612 /**
613 * @brief test_prvProcessIPEventsAndTimers_eNetworkTxEvent
614 * Check if prvProcessIPEventsAndTimers() transmits data through network interface with eNetworkTxEvent.
615 */
test_prvProcessIPEventsAndTimers_eNetworkTxEvent(void)616 void test_prvProcessIPEventsAndTimers_eNetworkTxEvent( void )
617 {
618 struct xNetworkInterface xInterface;
619 IPStackEvent_t xReceivedEvent;
620 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
621 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
622
623 pxNetworkBuffer = &xNetworkBuffer;
624 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
625 pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t ) - 1;
626 pxNetworkBuffer->pxInterface = &xInterface;
627
628 NetworkInterfaceOutputFunction_Stub_Called = 0;
629 pxNetworkBuffer->pxInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
630
631 xReceivedEvent.eEventType = eNetworkTxEvent;
632 xReceivedEvent.pvData = pxNetworkBuffer;
633 xNetworkDownEventPending = pdFALSE;
634
635 /* prvProcessIPEventsAndTimers */
636 vCheckNetworkTimers_Expect();
637 xCalculateSleepTime_ExpectAndReturn( 0 );
638 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
639 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
640
641 NetworkInterfaceOutputFunction_Stub_Called = 0;
642
643 prvProcessIPEventsAndTimers();
644
645 TEST_ASSERT_EQUAL( 1, NetworkInterfaceOutputFunction_Stub_Called );
646 }
647
648 /**
649 * @brief test_prvProcessIPEventsAndTimers_eNetworkTxEvent_NullInterface
650 * Check if prvProcessIPEventsAndTimers() skip transmitting data through network interface
651 * when network interface pointer is NULL.
652 */
test_prvProcessIPEventsAndTimers_eNetworkTxEvent_NullInterface(void)653 void test_prvProcessIPEventsAndTimers_eNetworkTxEvent_NullInterface( void )
654 {
655 IPStackEvent_t xReceivedEvent;
656 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
657 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
658
659 pxNetworkBuffer = &xNetworkBuffer;
660 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
661 pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t ) - 1;
662 pxNetworkBuffer->pxInterface = NULL;
663
664 NetworkInterfaceOutputFunction_Stub_Called = 0;
665
666 xReceivedEvent.eEventType = eNetworkTxEvent;
667 xReceivedEvent.pvData = pxNetworkBuffer;
668 xNetworkDownEventPending = pdFALSE;
669
670 /* prvProcessIPEventsAndTimers */
671 vCheckNetworkTimers_Expect();
672 xCalculateSleepTime_ExpectAndReturn( 0 );
673 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
674 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
675
676 prvProcessIPEventsAndTimers();
677 }
678
679 /**
680 * @brief test_prvProcessIPEventsAndTimers_eARPTimerEvent
681 * Check if prvProcessIPEventsAndTimers() updates the cache for ARP/ND when timeout event triggered.
682 */
test_prvProcessIPEventsAndTimers_eARPTimerEvent(void)683 void test_prvProcessIPEventsAndTimers_eARPTimerEvent( void )
684 {
685 IPStackEvent_t xReceivedEvent;
686
687 xReceivedEvent.eEventType = eARPTimerEvent;
688 xReceivedEvent.pvData = NULL;
689
690 /* prvProcessIPEventsAndTimers */
691 vCheckNetworkTimers_Expect();
692 xCalculateSleepTime_ExpectAndReturn( 0 );
693 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
694 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
695 vARPAgeCache_Expect();
696 vNDAgeCache_Expect();
697
698 prvProcessIPEventsAndTimers();
699 }
700
701 /**
702 * @brief test_prvProcessIPEventsAndTimers_eSocketBindEvent
703 * To validate if prvProcessIPEventsAndTimers() binds IPv4 socket with its address/port successfully
704 * with eSocketBindEvent.
705 */
test_prvProcessIPEventsAndTimers_eSocketBindEvent(void)706 void test_prvProcessIPEventsAndTimers_eSocketBindEvent( void )
707 {
708 IPStackEvent_t xReceivedEvent;
709 FreeRTOS_Socket_t xSocket;
710
711 xReceivedEvent.eEventType = eSocketBindEvent;
712 xReceivedEvent.pvData = &xSocket;
713
714 xSocket.usLocalPort = ( uint16_t ) ~0U;
715 xSocket.xEventBits = 0;
716 xSocket.bits.bIsIPv6 = pdFALSE_UNSIGNED;
717
718 /* prvProcessIPEventsAndTimers */
719 vCheckNetworkTimers_Expect();
720 xCalculateSleepTime_ExpectAndReturn( 0 );
721 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
722 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
723 vSocketBind_ExpectAndReturn( &xSocket, NULL, sizeof( struct freertos_sockaddr ), pdFALSE, 0 );
724 vSocketBind_IgnoreArg_pxBindAddress();
725 vSocketWakeUpUser_Expect( &xSocket );
726
727 prvProcessIPEventsAndTimers();
728
729 TEST_ASSERT_EQUAL( 0, xSocket.usLocalPort );
730 TEST_ASSERT_EQUAL( eSOCKET_BOUND, xSocket.xEventBits | eSOCKET_BOUND );
731 }
732
733 /**
734 * @brief test_prvProcessIPEventsAndTimers_eSocketBindEvent_IPv6
735 * To validate if prvProcessIPEventsAndTimers() binds IPv6 socket with its address/port successfully
736 * with eSocketBindEvent.
737 */
test_prvProcessIPEventsAndTimers_eSocketBindEvent_IPv6(void)738 void test_prvProcessIPEventsAndTimers_eSocketBindEvent_IPv6( void )
739 {
740 IPStackEvent_t xReceivedEvent;
741 FreeRTOS_Socket_t xSocket;
742
743 xReceivedEvent.eEventType = eSocketBindEvent;
744 xReceivedEvent.pvData = &xSocket;
745
746 xSocket.usLocalPort = ( uint16_t ) ~0U;
747 xSocket.xEventBits = 0;
748 xSocket.bits.bIsIPv6 = pdTRUE_UNSIGNED;
749
750 /* prvProcessIPEventsAndTimers */
751 vCheckNetworkTimers_Expect();
752 xCalculateSleepTime_ExpectAndReturn( 0 );
753 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
754 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
755 vSocketBind_ExpectAndReturn( &xSocket, NULL, sizeof( struct freertos_sockaddr ), pdFALSE, 0 );
756 vSocketBind_IgnoreArg_pxBindAddress();
757 vSocketWakeUpUser_Expect( &xSocket );
758
759 prvProcessIPEventsAndTimers();
760
761 TEST_ASSERT_EQUAL( 0, xSocket.usLocalPort );
762 TEST_ASSERT_EQUAL( eSOCKET_BOUND, xSocket.xEventBits | eSOCKET_BOUND );
763 }
764
765 /**
766 * @brief test_prvProcessIPEventsAndTimers_eSocketCloseEvent
767 * To validate if prvProcessIPEventsAndTimers() close socket successfully with eSocketCloseEvent.
768 */
test_prvProcessIPEventsAndTimers_eSocketCloseEvent(void)769 void test_prvProcessIPEventsAndTimers_eSocketCloseEvent( void )
770 {
771 IPStackEvent_t xReceivedEvent;
772 FreeRTOS_Socket_t xSocket;
773
774 xReceivedEvent.eEventType = eSocketCloseEvent;
775 xReceivedEvent.pvData = &xSocket;
776
777 xSocket.usLocalPort = ( uint16_t ) ~0U;
778 xSocket.xEventBits = 0;
779
780 /* prvProcessIPEventsAndTimers */
781 vCheckNetworkTimers_Expect();
782 xCalculateSleepTime_ExpectAndReturn( 0 );
783 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
784 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
785 vSocketClose_ExpectAndReturn( &xSocket, 0 );
786
787 prvProcessIPEventsAndTimers();
788 }
789
790 /**
791 * @brief test_prvProcessIPEventsAndTimers_eStackTxEvent
792 * To validate if prvProcessIPEventsAndTimers() calls vProcessGeneratedUDPPacket() to handle
793 * eStackTxEvent for sending UDP/ping.
794 */
test_prvProcessIPEventsAndTimers_eStackTxEvent(void)795 void test_prvProcessIPEventsAndTimers_eStackTxEvent( void )
796 {
797 IPStackEvent_t xReceivedEvent;
798 NetworkBufferDescriptor_t xNetworkBuffer;
799
800 xReceivedEvent.eEventType = eStackTxEvent;
801 xReceivedEvent.pvData = &xNetworkBuffer;
802
803 /* prvProcessIPEventsAndTimers */
804 vCheckNetworkTimers_Expect();
805 xCalculateSleepTime_ExpectAndReturn( 0 );
806 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
807 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
808 vProcessGeneratedUDPPacket_Expect( &xNetworkBuffer );
809
810 prvProcessIPEventsAndTimers();
811 }
812
813 /**
814 * @brief test_prvProcessIPEventsAndTimers_eDHCPEvent
815 * To validate if prvProcessIPEventsAndTimers() calls vDHCPProcess() to handle eDHCPEvent.
816 */
test_prvProcessIPEventsAndTimers_eDHCPEvent(void)817 void test_prvProcessIPEventsAndTimers_eDHCPEvent( void )
818 {
819 IPStackEvent_t xReceivedEvent;
820 uint32_t ulDHCPEvent = 0x1234;
821 NetworkEndPoint_t xEndPoints, * pxEndPoints = &xEndPoints;
822
823 memset( pxEndPoints, 0, sizeof( NetworkEndPoint_t ) );
824 pxEndPoints->bits.bWantDHCP = pdTRUE_UNSIGNED;
825 pxEndPoints->bits.bIPv6 = pdFALSE_UNSIGNED;
826
827 xReceivedEvent.eEventType = eDHCPEvent;
828 xReceivedEvent.pvData = pxEndPoints;
829
830 /* prvProcessIPEventsAndTimers */
831 vCheckNetworkTimers_Expect();
832 xCalculateSleepTime_ExpectAndReturn( 0 );
833 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
834 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
835 vDHCPProcess_Expect( pdFALSE, pxEndPoints );
836
837 prvProcessIPEventsAndTimers();
838 }
839
840 /**
841 * @brief test_prvProcessIPEventsAndTimers_eSocketSelectEvent
842 * To validate if prvProcessIPEventsAndTimers() calls vSocketSelect() to handle eSocketSelectEvent.
843 */
test_prvProcessIPEventsAndTimers_eSocketSelectEvent(void)844 void test_prvProcessIPEventsAndTimers_eSocketSelectEvent( void )
845 {
846 IPStackEvent_t xReceivedEvent;
847 uint32_t ulData = 0x1234;
848
849 xReceivedEvent.eEventType = eSocketSelectEvent;
850 xReceivedEvent.pvData = ( void * ) ulData;
851
852 /* prvProcessIPEventsAndTimers */
853 vCheckNetworkTimers_Expect();
854 xCalculateSleepTime_ExpectAndReturn( 0 );
855 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
856 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
857 vSocketSelect_Expect( ( SocketSelect_t * ) ulData );
858
859 prvProcessIPEventsAndTimers();
860 }
861
862 /**
863 * @brief test_prvProcessIPEventsAndTimers_eSocketSelectEvent
864 * To validate if prvProcessIPEventsAndTimers() calls FreeRTOS_SignalSocket() to handle eSocketSignalEvent.
865 */
test_prvProcessIPEventsAndTimers_eSocketSignalEvent(void)866 void test_prvProcessIPEventsAndTimers_eSocketSignalEvent( void )
867 {
868 IPStackEvent_t xReceivedEvent;
869 uint32_t ulData = 0x1234;
870
871 xReceivedEvent.eEventType = eSocketSignalEvent;
872 xReceivedEvent.pvData = ( void * ) ulData;
873
874 /* prvProcessIPEventsAndTimers */
875 vCheckNetworkTimers_Expect();
876 xCalculateSleepTime_ExpectAndReturn( 0 );
877 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
878 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
879 FreeRTOS_SignalSocket_ExpectAndReturn( ( Socket_t ) ulData, 0 );
880
881 prvProcessIPEventsAndTimers();
882 }
883
884 /**
885 * @brief test_prvProcessIPEventsAndTimers_eTCPTimerEvent
886 * To validate if prvProcessIPEventsAndTimers() calls vIPSetTCPTimerExpiredState() to handle eTCPTimerEvent.
887 */
test_prvProcessIPEventsAndTimers_eTCPTimerEvent(void)888 void test_prvProcessIPEventsAndTimers_eTCPTimerEvent( void )
889 {
890 IPStackEvent_t xReceivedEvent;
891
892 xReceivedEvent.eEventType = eTCPTimerEvent;
893
894 /* prvProcessIPEventsAndTimers */
895 vCheckNetworkTimers_Expect();
896 xCalculateSleepTime_ExpectAndReturn( 0 );
897 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
898 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
899 vIPSetTCPTimerExpiredState_Expect( pdTRUE );
900
901 prvProcessIPEventsAndTimers();
902 }
903
904 /**
905 * @brief test_prvProcessIPEventsAndTimers_eTCPTimerEvent
906 * To validate if prvProcessIPEventsAndTimers() calls xTCPCheckNewClient() to handle eTCPAcceptEvent
907 * without new client comes.
908 */
test_prvProcessIPEventsAndTimers_eTCPAcceptEvent_NoNewClient(void)909 void test_prvProcessIPEventsAndTimers_eTCPAcceptEvent_NoNewClient( void )
910 {
911 IPStackEvent_t xReceivedEvent;
912 FreeRTOS_Socket_t xSocket;
913
914 xReceivedEvent.eEventType = eTCPAcceptEvent;
915 xReceivedEvent.pvData = &xSocket;
916
917 xSocket.xEventBits = 0;
918
919 /* prvProcessIPEventsAndTimers */
920 vCheckNetworkTimers_Expect();
921 xCalculateSleepTime_ExpectAndReturn( 0 );
922 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
923 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
924 xTCPCheckNewClient_ExpectAndReturn( &xSocket, pdFALSE );
925
926 prvProcessIPEventsAndTimers();
927
928 TEST_ASSERT_EQUAL( 0, xSocket.xEventBits );
929 }
930
931 /**
932 * @brief test_prvProcessIPEventsAndTimers_eTCPTimerEvent
933 * To validate if prvProcessIPEventsAndTimers() calls xTCPCheckNewClient() to handle eTCPAcceptEvent
934 * with new client comes.
935 */
test_prvProcessIPEventsAndTimers_eTCPAcceptEvent_NewClient(void)936 void test_prvProcessIPEventsAndTimers_eTCPAcceptEvent_NewClient( void )
937 {
938 IPStackEvent_t xReceivedEvent;
939 FreeRTOS_Socket_t xSocket;
940
941 xReceivedEvent.eEventType = eTCPAcceptEvent;
942 xReceivedEvent.pvData = &xSocket;
943
944 xSocket.xEventBits = 0;
945
946 /* prvProcessIPEventsAndTimers */
947 vCheckNetworkTimers_Expect();
948 xCalculateSleepTime_ExpectAndReturn( 0 );
949 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
950 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
951 xTCPCheckNewClient_ExpectAndReturn( &xSocket, pdTRUE );
952 vSocketWakeUpUser_Expect( &xSocket );
953
954 prvProcessIPEventsAndTimers();
955
956 TEST_ASSERT_EQUAL( eSOCKET_ACCEPT, xSocket.xEventBits | eSOCKET_ACCEPT );
957 }
958
959 /**
960 * @brief test_prvProcessIPEventsAndTimers_eTCPNetStat
961 * To validate if prvProcessIPEventsAndTimers() calls vTCPNetStat() to handle eTCPNetStat.
962 */
test_prvProcessIPEventsAndTimers_eTCPNetStat(void)963 void test_prvProcessIPEventsAndTimers_eTCPNetStat( void )
964 {
965 IPStackEvent_t xReceivedEvent;
966
967 xReceivedEvent.eEventType = eTCPNetStat;
968
969 /* prvProcessIPEventsAndTimers */
970 vCheckNetworkTimers_Expect();
971 xCalculateSleepTime_ExpectAndReturn( 0 );
972 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
973 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
974 vTCPNetStat_Expect();
975
976 prvProcessIPEventsAndTimers();
977 }
978
979 /**
980 * @brief test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent
981 * To validate if prvProcessIPEventsAndTimers() calls vEventGroupDelete() to handle eSocketSetDeleteEvent.
982 */
test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent(void)983 void test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent( void )
984 {
985 IPStackEvent_t xReceivedEvent;
986 SocketSelect_t * pxSocketSet = malloc( sizeof( SocketSelect_t ) );
987
988 xReceivedEvent.eEventType = eSocketSetDeleteEvent;
989 xReceivedEvent.pvData = pxSocketSet;
990
991 /* prvProcessIPEventsAndTimers */
992 vCheckNetworkTimers_Expect();
993 xCalculateSleepTime_ExpectAndReturn( 0 );
994 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
995 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
996 vEventGroupDelete_Expect( pxSocketSet->xSelectGroup );
997
998 prvProcessIPEventsAndTimers();
999 }
1000
1001 /**
1002 * @brief test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent_NetDownPending
1003 * To validate if prvProcessIPEventsAndTimers() handles pending network down events at the end function.
1004 */
test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent_NetDownPending(void)1005 void test_prvProcessIPEventsAndTimers_eSocketSetDeleteEvent_NetDownPending( void )
1006 {
1007 IPStackEvent_t xReceivedEvent;
1008 NetworkInterface_t xNetworkInterface[ 2 ], * pxInterface = &xNetworkInterface[ 1 ];
1009 SocketSelect_t * pxSocketSet = malloc( sizeof( SocketSelect_t ) );
1010
1011 xNetworkDownEventPending = pdTRUE;
1012 xNetworkInterface[ 0 ].bits.bCallDownEvent = pdFALSE_UNSIGNED;
1013 xNetworkInterface[ 1 ].bits.bCallDownEvent = pdTRUE_UNSIGNED;
1014
1015 xReceivedEvent.eEventType = eSocketSetDeleteEvent;
1016 xReceivedEvent.pvData = pxSocketSet;
1017
1018 /* prvProcessIPEventsAndTimers */
1019 vCheckNetworkTimers_Expect();
1020 xCalculateSleepTime_ExpectAndReturn( 0 );
1021 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
1022 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
1023 vEventGroupDelete_Expect( pxSocketSet->xSelectGroup );
1024
1025 /* prvIPTask_CheckPendingEvents */
1026 FreeRTOS_FirstNetworkInterface_ExpectAndReturn( &xNetworkInterface[ 0 ] );
1027 FreeRTOS_NextNetworkInterface_ExpectAndReturn( &xNetworkInterface[ 0 ], pxInterface );
1028 /* Since network down event is pending, a call to this function should be expected. */
1029 prvProcessNetworkDownEvent_Expect( pxInterface );
1030 FreeRTOS_NextNetworkInterface_ExpectAndReturn( pxInterface, NULL );
1031
1032 prvProcessIPEventsAndTimers();
1033
1034 TEST_ASSERT_EQUAL( pxInterface->bits.bCallDownEvent, pdFALSE_UNSIGNED );
1035 }
1036
1037 /**
1038 * @brief test_prvProcessIPEventsAndTimers_Error
1039 * To validate if prvProcessIPEventsAndTimers() ignores unknown event.
1040 */
test_prvProcessIPEventsAndTimers_Error(void)1041 void test_prvProcessIPEventsAndTimers_Error( void )
1042 {
1043 IPStackEvent_t xReceivedEvent;
1044
1045 xNetworkDownEventPending = pdFALSE;
1046
1047 xReceivedEvent.eEventType = eSocketSetDeleteEvent + 1;
1048
1049 /* prvProcessIPEventsAndTimers */
1050 vCheckNetworkTimers_Expect();
1051 xCalculateSleepTime_ExpectAndReturn( 0 );
1052 xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
1053 xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
1054
1055 prvProcessIPEventsAndTimers();
1056 }
1057
1058 /**
1059 * @brief test_FreeRTOS_SendPingRequest_HappyPath
1060 * To validate if FreeRTOS_SendPingRequest() prepares ping request and send an event to IP task.
1061 */
test_FreeRTOS_SendPingRequest_HappyPath(void)1062 void test_FreeRTOS_SendPingRequest_HappyPath( void )
1063 {
1064 BaseType_t xReturn;
1065 uint32_t ulIPAddress = 0xC0AB0101;
1066 /* 32 byte ping to send. */
1067 size_t uxNumberOfBytesToSend = 32;
1068 ICMPHeader_t * pxICMPHeader;
1069 EthernetHeader_t * pxEthernetHeader;
1070
1071 /* The value of blocking time doesn't matter since the test doesn't
1072 * actually block. */
1073 TickType_t uxBlockTimeTicks = 100;
1074
1075 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1076 uint8_t pucEthernetBuffer[ ipconfigNETWORK_MTU - ( sizeof( IPHeader_t ) + sizeof( ICMPHeader_t ) ) ];
1077
1078 pxNetworkBuffer = &xNetworkBuffer;
1079 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
1080
1081 pxICMPHeader = ( ICMPHeader_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipIP_PAYLOAD_OFFSET ] );
1082 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1083
1084 xIPTaskInitialised = pdTRUE;
1085
1086 /* FreeRTOS_SendPingRequest */
1087 /* At least 4 free network buffers must be there to send a ping. */
1088 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 4U );
1089 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNumberOfBytesToSend + sizeof( ICMPPacket_t ), uxBlockTimeTicks, pxNetworkBuffer );
1090
1091 /* xSendEventStructToIPTask */
1092 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1093 xQueueGenericSend_ExpectAnyArgsAndReturn( pdPASS );
1094
1095 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1096
1097 TEST_ASSERT_EQUAL( 1, xReturn );
1098 TEST_ASSERT_EQUAL( 8 /* ipICMP_ECHO_REQUEST */, pxICMPHeader->ucTypeOfMessage );
1099 TEST_ASSERT_EQUAL( 0, pxICMPHeader->ucTypeOfService );
1100 TEST_ASSERT_EQUAL( 1, pxICMPHeader->usIdentifier );
1101 TEST_ASSERT_EQUAL( 1, pxICMPHeader->usSequenceNumber );
1102 TEST_ASSERT_EQUAL( ipIPv4_FRAME_TYPE, pxEthernetHeader->usFrameType );
1103 TEST_ASSERT_EQUAL( FREERTOS_SO_UDPCKSUM_OUT, pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] );
1104 TEST_ASSERT_EQUAL( ulIPAddress, pxNetworkBuffer->xIPAddress.ulIP_IPv4 );
1105 TEST_ASSERT_EQUAL( ipPACKET_CONTAINS_ICMP_DATA, pxNetworkBuffer->usPort );
1106 }
1107
1108 /**
1109 * @brief test_FreeRTOS_SendPingRequest_SendingToIPTaskFails
1110 * To validate if FreeRTOS_SendPingRequest() release the ping request packet when fail to send event.
1111 */
test_FreeRTOS_SendPingRequest_SendingToIPTaskFails(void)1112 void test_FreeRTOS_SendPingRequest_SendingToIPTaskFails( void )
1113 {
1114 BaseType_t xReturn;
1115 uint32_t ulIPAddress = 0xC0AB0101;
1116 /* 32 byte ping to send. */
1117 size_t uxNumberOfBytesToSend = 32;
1118 ICMPHeader_t * pxICMPHeader;
1119 EthernetHeader_t * pxEthernetHeader;
1120
1121 /* The value of blocking time doesn't matter since the test doesn't
1122 * actually block. */
1123 TickType_t uxBlockTimeTicks = 100;
1124
1125 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1126 uint8_t pucEthernetBuffer[ ipconfigNETWORK_MTU - ( sizeof( IPHeader_t ) + sizeof( ICMPHeader_t ) ) ];
1127
1128 pxNetworkBuffer = &xNetworkBuffer;
1129 pxNetworkBuffer->pucEthernetBuffer = pucEthernetBuffer;
1130
1131 pxICMPHeader = ( ICMPHeader_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipIP_PAYLOAD_OFFSET ] );
1132 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1133
1134 /* FreeRTOS_SendPingRequest */
1135 /* At least 4 free network buffers must be there to send a ping. */
1136 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 4U );
1137 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNumberOfBytesToSend + sizeof( ICMPPacket_t ), uxBlockTimeTicks, pxNetworkBuffer );
1138
1139 /* xSendEventStructToIPTask */
1140 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1141 xQueueGenericSend_ExpectAnyArgsAndReturn( pdFAIL );
1142
1143 /* FreeRTOS_SendPingRequest */
1144 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1145
1146 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1147
1148 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1149 TEST_ASSERT_EQUAL( 8 /* ipICMP_ECHO_REQUEST */, pxICMPHeader->ucTypeOfMessage );
1150 TEST_ASSERT_EQUAL( 0, pxICMPHeader->ucTypeOfService );
1151 TEST_ASSERT_EQUAL( 1, pxICMPHeader->usIdentifier );
1152 TEST_ASSERT_EQUAL( 1, pxICMPHeader->usSequenceNumber );
1153 TEST_ASSERT_EQUAL( ipIPv4_FRAME_TYPE, pxEthernetHeader->usFrameType );
1154 TEST_ASSERT_EQUAL( FREERTOS_SO_UDPCKSUM_OUT, pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] );
1155 TEST_ASSERT_EQUAL( ulIPAddress, pxNetworkBuffer->xIPAddress.ulIP_IPv4 );
1156 TEST_ASSERT_EQUAL( ipPACKET_CONTAINS_ICMP_DATA, pxNetworkBuffer->usPort );
1157 }
1158
1159 /**
1160 * @brief test_FreeRTOS_SendPingRequest_TooManyBytes
1161 * To validate if FreeRTOS_SendPingRequest() returns fail when input bytes is too large.
1162 */
test_FreeRTOS_SendPingRequest_TooManyBytes(void)1163 void test_FreeRTOS_SendPingRequest_TooManyBytes( void )
1164 {
1165 BaseType_t xReturn;
1166 uint32_t ulIPAddress = 0xC0AB0101;
1167 size_t uxNumberOfBytesToSend = ipconfigNETWORK_MTU - ( sizeof( IPHeader_t ) + sizeof( ICMPHeader_t ) );
1168
1169 /* The value of blocking time doesn't matter since the test doesn't
1170 * actually block. */
1171 TickType_t uxBlockTimeTicks = 100;
1172
1173 /* FreeRTOS_SendPingRequest */
1174 /* At least 4 free network buffers must be there to send a ping. */
1175 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 4U );
1176
1177 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1178
1179 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1180 }
1181
1182 /**
1183 * @brief test_FreeRTOS_SendPingRequest_TooManyBytes
1184 * To validate if FreeRTOS_SendPingRequest() returns fail when input bytes is 0.
1185 */
test_FreeRTOS_SendPingRequest_TooLessBytes(void)1186 void test_FreeRTOS_SendPingRequest_TooLessBytes( void )
1187 {
1188 BaseType_t xReturn;
1189 uint32_t ulIPAddress = 0xC0AB0101;
1190 size_t uxNumberOfBytesToSend = 0;
1191
1192 /* The value of blocking time doesn't matter since the test doesn't
1193 * actually block. */
1194 TickType_t uxBlockTimeTicks = 100;
1195
1196 /* FreeRTOS_SendPingRequest */
1197 /* At least 4 free network buffers must be there to send a ping. */
1198 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 4U );
1199
1200 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1201
1202 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1203 }
1204
1205 /**
1206 * @brief test_FreeRTOS_SendPingRequest_NotEnoughFreeBuffers
1207 * To validate if FreeRTOS_SendPingRequest() returns fail when buffer size is not enough for input bytes.
1208 */
test_FreeRTOS_SendPingRequest_NotEnoughFreeBuffers(void)1209 void test_FreeRTOS_SendPingRequest_NotEnoughFreeBuffers( void )
1210 {
1211 BaseType_t xReturn;
1212 uint32_t ulIPAddress = 0xC0AB0101;
1213 /* 32 byte ping to send. */
1214 size_t uxNumberOfBytesToSend = 32;
1215
1216 /* The value of blocking time doesn't matter since the test doesn't
1217 * actually block. */
1218 TickType_t uxBlockTimeTicks = 100;
1219
1220 /* FreeRTOS_SendPingRequest */
1221 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 3U );
1222
1223 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1224
1225 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1226 }
1227
1228 /**
1229 * @brief test_FreeRTOS_SendPingRequest_NetworkBufferFailure
1230 * To validate if FreeRTOS_SendPingRequest() returns fail to get network buffer descriptor.
1231 */
test_FreeRTOS_SendPingRequest_NetworkBufferFailure(void)1232 void test_FreeRTOS_SendPingRequest_NetworkBufferFailure( void )
1233 {
1234 BaseType_t xReturn;
1235 uint32_t ulIPAddress = 0xC0AB0101;
1236 /* 32 byte ping to send. */
1237 size_t uxNumberOfBytesToSend = 32;
1238
1239 /* The value of blocking time doesn't matter since the test doesn't
1240 * actually block. */
1241 TickType_t uxBlockTimeTicks = 100;
1242
1243 /* FreeRTOS_SendPingRequest */
1244 uxGetNumberOfFreeNetworkBuffers_ExpectAndReturn( 4U );
1245 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNumberOfBytesToSend + sizeof( ICMPPacket_t ), uxBlockTimeTicks, NULL );
1246
1247 xReturn = FreeRTOS_SendPingRequest( ulIPAddress, uxNumberOfBytesToSend, uxBlockTimeTicks );
1248
1249 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1250 }
1251
1252 /**
1253 * @brief test_xSendEventToIPTask
1254 * To validate if xSendEventToIPTask() returns fail when IP task was not initialized.
1255 */
test_xSendEventToIPTask(void)1256 void test_xSendEventToIPTask( void )
1257 {
1258 BaseType_t xReturn;
1259 eIPEvent_t eEvent = eNetworkRxEvent;
1260
1261 xIPTaskInitialised = pdFALSE;
1262
1263 xReturn = xSendEventToIPTask( eEvent );
1264
1265 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1266 }
1267
1268 /**
1269 * @brief test_xSendEventStructToIPTask_IPTaskNotInit_NoNetworkDownEvent
1270 * To validate if xSendEventToIPTask() returns fail when IP task was not initialized
1271 * and the event is not eNetworkDownEvent.
1272 */
test_xSendEventStructToIPTask_IPTaskNotInit_NoNetworkDownEvent(void)1273 void test_xSendEventStructToIPTask_IPTaskNotInit_NoNetworkDownEvent( void )
1274 {
1275 BaseType_t xReturn;
1276 IPStackEvent_t xEvent;
1277 TickType_t uxTimeout;
1278
1279 xIPTaskInitialised = pdFALSE;
1280
1281 xEvent.eEventType = eNetworkDownEvent + 1;
1282
1283 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1284
1285 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1286 }
1287
1288 /**
1289 * @brief test_xSendEventStructToIPTask_IPTaskNotInit_NoNetworkDownEvent
1290 * To validate if xSendEventToIPTask() returns pass when the event is eNetworkDownEvent
1291 * even though IP task was not initialized.
1292 */
test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEvent(void)1293 void test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEvent( void )
1294 {
1295 BaseType_t xReturn;
1296 IPStackEvent_t xEvent;
1297 TickType_t uxTimeout = 0;
1298
1299 xIPTaskInitialised = pdFALSE;
1300 xEvent.eEventType = eNetworkDownEvent;
1301
1302 /* xSendEventStructToIPTask */
1303 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1304 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 0, 0, pdPASS );
1305
1306 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1307
1308 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1309 }
1310
1311 /**
1312 * @brief test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventInIPTask
1313 * To validate if xSendEventToIPTask() changes the timeout value to 0 when it's happening
1314 * in IP task.
1315 */
test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventInIPTask(void)1316 void test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventInIPTask( void )
1317 {
1318 BaseType_t xReturn;
1319 IPStackEvent_t xEvent;
1320 TickType_t uxTimeout = 1;
1321
1322 xIPTaskInitialised = pdFALSE;
1323 xEvent.eEventType = eNetworkDownEvent;
1324
1325 /* xSendEventStructToIPTask */
1326 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1327 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 0, 0, pdPASS );
1328
1329 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1330
1331 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1332 }
1333
1334 /**
1335 * @brief test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTask
1336 * To validate if xSendEventToIPTask() returns pass when the event is eNetworkDownEvent
1337 * and it's not happening in IP task.
1338 */
test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTask(void)1339 void test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTask( void )
1340 {
1341 BaseType_t xReturn;
1342 IPStackEvent_t xEvent;
1343 TickType_t uxTimeout = 0;
1344
1345 xIPTaskInitialised = pdFALSE;
1346 xEvent.eEventType = eNetworkDownEvent;
1347
1348 /* xSendEventStructToIPTask */
1349 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1350 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 0, 0, pdPASS );
1351
1352 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1353
1354 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1355 }
1356
1357 /**
1358 * @brief test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTaskTimeout
1359 * To validate if xSendEventToIPTask() keeps input timeout value to send event when it's
1360 * not happening in IP task.
1361 */
test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTaskTimeout(void)1362 void test_xSendEventStructToIPTask_IPTaskNotInit_NetworkDownEventNotIPTaskTimeout( void )
1363 {
1364 BaseType_t xReturn;
1365 IPStackEvent_t xEvent;
1366 TickType_t uxTimeout = 10;
1367
1368 xIPTaskInitialised = pdFALSE;
1369 xEvent.eEventType = eNetworkDownEvent;
1370
1371 /* xSendEventStructToIPTask */
1372 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1373 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 10, 0, pdPASS );
1374
1375 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1376
1377 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1378 }
1379
1380 /**
1381 * @brief test_xSendEventStructToIPTask_IPTaskInit_NetworkDownEvent
1382 * To validate if xSendEventToIPTask() sends eNetworkDownEvent to IP task successfully from other tasks.
1383 */
test_xSendEventStructToIPTask_IPTaskInit_NetworkDownEvent(void)1384 void test_xSendEventStructToIPTask_IPTaskInit_NetworkDownEvent( void )
1385 {
1386 BaseType_t xReturn;
1387 IPStackEvent_t xEvent;
1388 TickType_t uxTimeout = 10;
1389
1390 xIPTaskInitialised = pdTRUE;
1391 xEvent.eEventType = eNetworkDownEvent;
1392
1393 /* xSendEventStructToIPTask */
1394 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1395 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 10, 0, pdPASS );
1396
1397 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1398
1399 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1400 }
1401
1402 /**
1403 * @brief test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEvent
1404 * To validate if xSendEventToIPTask() sends eTCPTimerEvent to IP task successfully from other tasks
1405 * when no pending events in queue.
1406 */
test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEvent(void)1407 void test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEvent( void )
1408 {
1409 BaseType_t xReturn;
1410 IPStackEvent_t xEvent;
1411 TickType_t uxTimeout = 10;
1412
1413 xIPTaskInitialised = pdTRUE;
1414 xEvent.eEventType = eTCPTimerEvent;
1415
1416 /* xSendEventStructToIPTask */
1417 vIPSetTCPTimerExpiredState_Expect( pdTRUE );
1418 uxQueueMessagesWaiting_ExpectAndReturn( xNetworkEventQueue, 0 );
1419 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1420 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 10, 0, pdPASS );
1421
1422 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1423
1424 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1425 }
1426
1427 /**
1428 * @brief test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventFail
1429 * To validate if xSendEventToIPTask() fails to send eTCPTimerEvent to IP task from other tasks.
1430 */
test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventFail(void)1431 void test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventFail( void )
1432 {
1433 BaseType_t xReturn;
1434 IPStackEvent_t xEvent;
1435 TickType_t uxTimeout = 10;
1436
1437 xIPTaskInitialised = pdTRUE;
1438 xEvent.eEventType = eTCPTimerEvent;
1439
1440 /* xSendEventStructToIPTask */
1441 vIPSetTCPTimerExpiredState_Expect( pdTRUE );
1442 uxQueueMessagesWaiting_ExpectAndReturn( xNetworkEventQueue, 0 );
1443 xIsCallingFromIPTask_ExpectAndReturn( pdFALSE );
1444 xQueueGenericSend_ExpectAndReturn( xNetworkEventQueue, &xEvent, 10, 0, pdFAIL );
1445
1446 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1447
1448 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1449 }
1450
1451 /**
1452 * @brief test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventWithEventInQueue
1453 * To validate if xSendEventToIPTask() skip to send eTCPTimerEvent because there are
1454 * other pending events in queue.
1455 */
test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventWithEventInQueue(void)1456 void test_xSendEventStructToIPTask_IPTaskInit_eTCPTimerEventWithEventInQueue( void )
1457 {
1458 BaseType_t xReturn;
1459 IPStackEvent_t xEvent;
1460 TickType_t uxTimeout = 10;
1461
1462 xIPTaskInitialised = pdTRUE;
1463 xEvent.eEventType = eTCPTimerEvent;
1464
1465 /* xSendEventStructToIPTask */
1466 vIPSetTCPTimerExpiredState_Expect( pdTRUE );
1467 uxQueueMessagesWaiting_ExpectAndReturn( xNetworkEventQueue, 1 );
1468
1469 xReturn = xSendEventStructToIPTask( &xEvent, uxTimeout );
1470
1471 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1472 }
1473
1474 /**
1475 * @brief test_eConsiderFrameForProcessing_NullBufferDescriptor
1476 * eConsiderFrameForProcessing must return eReleaseBuffer with NULL input.
1477 */
test_eConsiderFrameForProcessing_NullBufferDescriptor(void)1478 void test_eConsiderFrameForProcessing_NullBufferDescriptor( void )
1479 {
1480 eFrameProcessingResult_t eResult;
1481
1482 eResult = eConsiderFrameForProcessing( NULL );
1483
1484 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1485 }
1486
1487 /**
1488 * @brief test_eConsiderFrameForProcessing_LocalMACMatch
1489 * eConsiderFrameForProcessing must return eProcessBuffer when the MAC address in packet
1490 * matches endpoint's MAC address and the frame type is valid.
1491 */
test_eConsiderFrameForProcessing_LocalMACMatch(void)1492 void test_eConsiderFrameForProcessing_LocalMACMatch( void )
1493 {
1494 eFrameProcessingResult_t eResult;
1495 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
1496 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1497 EthernetHeader_t * pxEthernetHeader;
1498
1499 /* eConsiderFrameForProcessing */
1500 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( pxEndPoint );
1501
1502 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1503 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1504
1505 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1506
1507 /* Align endpoint's & packet's MAC address. */
1508 memset( pxEndPoint->xMACAddress.ucBytes, 0xAA, sizeof( MACAddress_t ) );
1509 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, pxEndPoint->xMACAddress.ucBytes, sizeof( MACAddress_t ) );
1510 pxEthernetHeader->usFrameType = FreeRTOS_htons( 0x0800 );
1511
1512 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1513
1514 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
1515 }
1516
1517 /**
1518 * @brief test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType
1519 * eConsiderFrameForProcessing must return eReleaseBuffer when the frame type is unknown
1520 * even though the MAC address in packet matches endpoint's MAC address.
1521 */
test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType(void)1522 void test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType( void )
1523 {
1524 eFrameProcessingResult_t eResult;
1525 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
1526 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1527 EthernetHeader_t * pxEthernetHeader;
1528
1529 /* eConsiderFrameForProcessing */
1530 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( pxEndPoint );
1531
1532 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1533 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1534
1535 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1536
1537 /* Align endpoint's & packet's MAC address. */
1538 memset( pxEndPoint->xMACAddress.ucBytes, 0xAA, sizeof( MACAddress_t ) );
1539 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, pxEndPoint->xMACAddress.ucBytes, sizeof( MACAddress_t ) );
1540 pxEthernetHeader->usFrameType = FreeRTOS_htons( 0 );
1541
1542 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1543
1544 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1545 }
1546
1547 /**
1548 * @brief test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType1
1549 * eConsiderFrameForProcessing must return eReleaseBuffer when the frame type is unknown
1550 * even though the MAC address in packet matches endpoint's MAC address.
1551 */
test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType1(void)1552 void test_eConsiderFrameForProcessing_LocalMACMatchInvalidFrameType1( void )
1553 {
1554 eFrameProcessingResult_t eResult;
1555 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
1556 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1557 EthernetHeader_t * pxEthernetHeader;
1558
1559 /* eConsiderFrameForProcessing */
1560 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( pxEndPoint );
1561
1562 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1563 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1564
1565 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1566
1567 /* Align endpoint's & packet's MAC address. */
1568 memset( pxEndPoint->xMACAddress.ucBytes, 0xAA, sizeof( MACAddress_t ) );
1569 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, pxEndPoint->xMACAddress.ucBytes, sizeof( MACAddress_t ) );
1570 pxEthernetHeader->usFrameType = 0x0600;
1571
1572 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1573
1574 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1575 }
1576
1577 /**
1578 * @brief test_eConsiderFrameForProcessing_BroadCastMACMatch
1579 * eConsiderFrameForProcessing must return eProcessBuffer when the MAC address in packet
1580 * matches broadcast MAC address and the frame type is valid.
1581 */
test_eConsiderFrameForProcessing_BroadCastMACMatch(void)1582 void test_eConsiderFrameForProcessing_BroadCastMACMatch( void )
1583 {
1584 eFrameProcessingResult_t eResult;
1585 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1586 EthernetHeader_t * pxEthernetHeader;
1587
1588 /* eConsiderFrameForProcessing */
1589 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
1590
1591 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1592 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1593
1594 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1595
1596 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
1597 pxEthernetHeader->usFrameType = 0xFFFF;
1598
1599 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1600
1601 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
1602 }
1603
1604 /**
1605 * @brief test_eConsiderFrameForProcessing_BroadCastMACMatch
1606 * eConsiderFrameForProcessing must return eProcessBuffer when the MAC address in packet
1607 * matches LLMNR MAC address and the frame type is valid.
1608 */
test_eConsiderFrameForProcessing_LLMNR_MACMatch(void)1609 void test_eConsiderFrameForProcessing_LLMNR_MACMatch( void )
1610 {
1611 eFrameProcessingResult_t eResult;
1612 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1613 EthernetHeader_t * pxEthernetHeader;
1614
1615 /* eConsiderFrameForProcessing */
1616 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
1617
1618 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1619 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1620
1621 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1622
1623 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, xLLMNR_MacAdress.ucBytes, sizeof( MACAddress_t ) );
1624 pxEthernetHeader->usFrameType = 0xFFFF;
1625
1626 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1627
1628 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
1629 }
1630
1631 /**
1632 * @brief test_eConsiderFrameForProcessing_NotMatch
1633 * eConsiderFrameForProcessing must return eReleaseBuffer when the MAC address
1634 * in packet doesn't match any endpoint.
1635 */
test_eConsiderFrameForProcessing_NotMatch(void)1636 void test_eConsiderFrameForProcessing_NotMatch( void )
1637 {
1638 eFrameProcessingResult_t eResult;
1639 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1640 EthernetHeader_t * pxEthernetHeader;
1641 MACAddress_t xMACAddress = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
1642
1643 /* eConsiderFrameForProcessing */
1644 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
1645
1646 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1647 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1648
1649 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1650
1651 memcpy( pxEthernetHeader->xDestinationAddress.ucBytes, &xMACAddress, sizeof( MACAddress_t ) );
1652 pxEthernetHeader->usFrameType = 0xFFFF;
1653
1654 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1655
1656 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1657 }
1658
1659 /**
1660 * @brief test_eConsiderFrameForProcessing_IPv6BroadCastMACMatch
1661 * eConsiderFrameForProcessing must return eProcessBuffer when the MAC address in packet
1662 * matches IPv6 broadcast MAC address and the frame type is valid.
1663 */
test_eConsiderFrameForProcessing_IPv6BroadCastMACMatch(void)1664 void test_eConsiderFrameForProcessing_IPv6BroadCastMACMatch( void )
1665 {
1666 eFrameProcessingResult_t eResult;
1667 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1668 EthernetHeader_t * pxEthernetHeader;
1669
1670 /* eConsiderFrameForProcessing */
1671 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
1672
1673 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1674 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1675
1676 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1677
1678 pxEthernetHeader->xDestinationAddress.ucBytes[ 0 ] = ipMULTICAST_MAC_ADDRESS_IPv6_0;
1679 pxEthernetHeader->xDestinationAddress.ucBytes[ 1 ] = ipMULTICAST_MAC_ADDRESS_IPv6_1;
1680 pxEthernetHeader->usFrameType = 0xFFFF;
1681
1682 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1683
1684 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
1685 }
1686
1687 /**
1688 * @brief test_eConsiderFrameForProcessing_IPv6BroadCastMACPartialMatch
1689 * eConsiderFrameForProcessing must return eReleaseBuffer when the MAC address in packet
1690 * doesn't matches IPv6 broadcast MAC address.
1691 */
test_eConsiderFrameForProcessing_IPv6BroadCastMACPartialMatch(void)1692 void test_eConsiderFrameForProcessing_IPv6BroadCastMACPartialMatch( void )
1693 {
1694 eFrameProcessingResult_t eResult;
1695 uint8_t ucEthernetBuffer[ ipconfigTCP_MSS ];
1696 EthernetHeader_t * pxEthernetHeader;
1697
1698 /* eConsiderFrameForProcessing */
1699 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
1700
1701 /* Map the buffer onto Ethernet Header struct for easy access to fields. */
1702 pxEthernetHeader = ( EthernetHeader_t * ) ucEthernetBuffer;
1703
1704 memset( ucEthernetBuffer, 0x00, ipconfigTCP_MSS );
1705
1706 pxEthernetHeader->xDestinationAddress.ucBytes[ 0 ] = ipMULTICAST_MAC_ADDRESS_IPv6_0;
1707 pxEthernetHeader->xDestinationAddress.ucBytes[ 1 ] = 0x00;
1708 pxEthernetHeader->usFrameType = 0xFFFF;
1709
1710 eResult = eConsiderFrameForProcessing( ucEthernetBuffer );
1711
1712 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1713 }
1714
1715 /**
1716 * @brief test_prvProcessEthernetPacket_NoData
1717 * To validate if prvProcessEthernetPacket calls vReleaseNetworkBufferAndDescriptor
1718 * to release the network buffer descriptor.
1719 */
test_prvProcessEthernetPacket_NoData(void)1720 void test_prvProcessEthernetPacket_NoData( void )
1721 {
1722 NetworkBufferDescriptor_t xNetworkBuffer;
1723 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1724
1725 pxNetworkBuffer->xDataLength = 0;
1726 pxNetworkBuffer->pucEthernetBuffer = NULL;
1727
1728 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1729
1730 prvProcessEthernetPacket( pxNetworkBuffer );
1731 }
1732
1733 /**
1734 * @brief test_prvProcessEthernetPacket_NullNetworkBufferDescriptor
1735 * To validate if prvProcessEthernetPacket triggers assertion when input is NULL.
1736 */
test_prvProcessEthernetPacket_NullNetworkBufferDescriptor(void)1737 void test_prvProcessEthernetPacket_NullNetworkBufferDescriptor( void )
1738 {
1739 catch_assert( prvProcessEthernetPacket( NULL ) );
1740 }
1741
1742 /**
1743 * @brief test_prvProcessEthernetPacket_UnknownFrameType
1744 * To validate if prvProcessEthernetPacket calls vReleaseNetworkBufferAndDescriptor
1745 * to release the network buffer descriptor when the ethernet frame type is unknown.
1746 */
test_prvProcessEthernetPacket_UnknownFrameType(void)1747 void test_prvProcessEthernetPacket_UnknownFrameType( void )
1748 {
1749 NetworkBufferDescriptor_t xNetworkBuffer;
1750 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1751 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1752 EthernetHeader_t * pxEthernetHeader;
1753
1754 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1755 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1756 pxEthernetHeader = ( EthernetHeader_t * ) ucEtherBuffer;
1757 pxEthernetHeader->usFrameType = 0xFFFF;
1758
1759 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1760
1761 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1762
1763 prvProcessEthernetPacket( pxNetworkBuffer );
1764 }
1765
1766 /**
1767 * @brief test_prvProcessEthernetPacket_ARPFrameType1
1768 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eReleaseBuffer.
1769 */
test_prvProcessEthernetPacket_ARPFrameType1(void)1770 void test_prvProcessEthernetPacket_ARPFrameType1( void )
1771 {
1772 NetworkBufferDescriptor_t xNetworkBuffer;
1773 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1774 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1775 EthernetHeader_t * pxEthernetHeader;
1776
1777 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1778 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1779
1780 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1781
1782 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1783
1784 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1785
1786 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eReleaseBuffer );
1787
1788 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1789
1790 prvProcessEthernetPacket( pxNetworkBuffer );
1791 }
1792
1793 /**
1794 * @brief test_prvProcessEthernetPacket_ARPFrameType2
1795 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eProcessBuffer.
1796 */
test_prvProcessEthernetPacket_ARPFrameType2(void)1797 void test_prvProcessEthernetPacket_ARPFrameType2( void )
1798 {
1799 NetworkBufferDescriptor_t xNetworkBuffer;
1800 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1801 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1802 EthernetHeader_t * pxEthernetHeader;
1803
1804 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1805 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1806
1807 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1808
1809 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1810
1811 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1812
1813 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
1814
1815 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1816
1817 prvProcessEthernetPacket( pxNetworkBuffer );
1818 }
1819
1820 /**
1821 * @brief test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution
1822 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eWaitingARPResolution
1823 * without pxARPWaitingNetworkBuffer.
1824 */
test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution(void)1825 void test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution( void )
1826 {
1827 NetworkBufferDescriptor_t xNetworkBuffer;
1828 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1829 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1830 EthernetHeader_t * pxEthernetHeader;
1831
1832 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1833 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1834
1835 pxARPWaitingNetworkBuffer = NULL;
1836
1837 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1838
1839 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1840
1841 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1842
1843 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eWaitingARPResolution );
1844
1845 vIPTimerStartARPResolution_ExpectAnyArgs();
1846
1847 prvProcessEthernetPacket( pxNetworkBuffer );
1848 }
1849
1850 /**
1851 * @brief test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution2
1852 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eWaitingARPResolution
1853 * with pxARPWaitingNetworkBuffer.
1854 */
test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution2(void)1855 void test_prvProcessEthernetPacket_ARPFrameType_WaitingARPResolution2( void )
1856 {
1857 NetworkBufferDescriptor_t xNetworkBuffer;
1858 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1859 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1860 EthernetHeader_t * pxEthernetHeader;
1861
1862 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1863 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1864
1865 pxARPWaitingNetworkBuffer = ( NetworkBufferDescriptor_t * ) 0x1234ABCD;
1866
1867 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1868
1869 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1870
1871 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1872
1873 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eWaitingARPResolution );
1874
1875 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1876
1877 prvProcessEthernetPacket( pxNetworkBuffer );
1878 }
1879
1880 /**
1881 * @brief test_prvProcessEthernetPacket_ARPFrameType_eReturnEthernetFrame
1882 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eReturnEthernetFrame.
1883 */
test_prvProcessEthernetPacket_ARPFrameType_eReturnEthernetFrame(void)1884 void test_prvProcessEthernetPacket_ARPFrameType_eReturnEthernetFrame( void )
1885 {
1886 struct xNetworkInterface xInterface, * pxInterface = &xInterface;
1887 NetworkBufferDescriptor_t xNetworkBuffer, xARPWaitingBuffer;
1888 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1889 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1890 EthernetHeader_t * pxEthernetHeader;
1891 struct xNetworkEndPoint xEndPoint = { 0 };
1892
1893 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1894 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1895 pxNetworkBuffer->pxEndPoint = &xEndPoint;
1896 xEndPoint.pxNetworkInterface = &xInterfaces;
1897 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
1898 NetworkInterfaceOutputFunction_Stub_Called = 0;
1899
1900 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1901
1902 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1903
1904 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1905
1906 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eReturnEthernetFrame );
1907
1908 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
1909
1910 prvProcessEthernetPacket( pxNetworkBuffer );
1911
1912 TEST_ASSERT_EQUAL( 1, NetworkInterfaceOutputFunction_Stub_Called );
1913 }
1914
1915 /**
1916 * @brief test_prvProcessEthernetPacket_ARPFrameType_eReturnEthernetFrame
1917 * To validate the flow to handle ARP packets but eARPProcessPacket() returns eFrameConsumed.
1918 */
test_prvProcessEthernetPacket_ARPFrameType_eFrameConsumed(void)1919 void test_prvProcessEthernetPacket_ARPFrameType_eFrameConsumed( void )
1920 {
1921 NetworkBufferDescriptor_t xNetworkBuffer, xARPWaitingBuffer;
1922 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1923 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1924 EthernetHeader_t * pxEthernetHeader;
1925
1926 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
1927 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1928
1929 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1930
1931 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1932
1933 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1934
1935 eARPProcessPacket_ExpectAndReturn( pxNetworkBuffer, eFrameConsumed );
1936
1937 prvProcessEthernetPacket( pxNetworkBuffer );
1938 }
1939
1940 /**
1941 * @brief test_prvProcessEthernetPacket_ARPFrameType_SmallerDataLength
1942 * To validate the flow to handle ARP packets but the data length is smaller than
1943 * minimum size of ARP packet.
1944 */
test_prvProcessEthernetPacket_ARPFrameType_SmallerDataLength(void)1945 void test_prvProcessEthernetPacket_ARPFrameType_SmallerDataLength( void )
1946 {
1947 NetworkBufferDescriptor_t xNetworkBuffer;
1948 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1949 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1950 EthernetHeader_t * pxEthernetHeader;
1951
1952 pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t );
1953 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1954
1955 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1956
1957 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1958
1959 pxEthernetHeader->usFrameType = ipARP_FRAME_TYPE;
1960
1961 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1962
1963 prvProcessEthernetPacket( pxNetworkBuffer );
1964 }
1965
1966 /**
1967 * @brief test_prvProcessEthernetPacket_IPv4FrameType_LessData
1968 * To validate the flow to handle IPv4 packets but the data length is smaller than
1969 * minimum size of IPv4 packet.
1970 */
test_prvProcessEthernetPacket_IPv4FrameType_LessData(void)1971 void test_prvProcessEthernetPacket_IPv4FrameType_LessData( void )
1972 {
1973 NetworkBufferDescriptor_t xNetworkBuffer;
1974 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
1975 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
1976 EthernetHeader_t * pxEthernetHeader;
1977
1978 pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t );
1979 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
1980
1981 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1982
1983 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
1984
1985 pxEthernetHeader->usFrameType = ipIPv4_FRAME_TYPE;
1986
1987 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1988
1989 prvProcessEthernetPacket( pxNetworkBuffer );
1990 }
1991
1992 /**
1993 * @brief test_prvProcessEthernetPacket_IPv4FrameType_AptData
1994 * To validate the flow to handle IPv4 packets but the length in IP header is smaller than
1995 * minimum requirement.
1996 */
test_prvProcessEthernetPacket_IPv4FrameType_AptData(void)1997 void test_prvProcessEthernetPacket_IPv4FrameType_AptData( void )
1998 {
1999 NetworkBufferDescriptor_t xNetworkBuffer;
2000 NetworkBufferDescriptor_t * pxNetworkBuffer = &xNetworkBuffer;
2001 uint8_t ucEtherBuffer[ ipconfigTCP_MSS ];
2002 EthernetHeader_t * pxEthernetHeader;
2003 IPPacket_t * pxIPPacket;
2004 IPHeader_t * pxIPHeader;
2005
2006 memset( pxNetworkBuffer->pucEthernetBuffer, 0, ipconfigTCP_MSS );
2007
2008 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2009 pxNetworkBuffer->pucEthernetBuffer = ucEtherBuffer;
2010
2011 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
2012 pxEthernetHeader->usFrameType = ipIPv4_FRAME_TYPE;
2013
2014 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2015 pxIPHeader = &( pxIPPacket->xIPHeader );
2016 pxIPHeader->ucVersionHeaderLength = 0xF0;
2017
2018 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
2019
2020 prvProcessEthernetPacket( pxNetworkBuffer );
2021 }
2022
2023 /**
2024 * @brief test_prvProcessIPPacket_HeaderLengthSmaller
2025 * To validate the flow to handle IPv4 packets but the length in IP header is smaller than
2026 * minimum requirement.
2027 */
test_prvProcessIPPacket_HeaderLengthSmaller(void)2028 void test_prvProcessIPPacket_HeaderLengthSmaller( void )
2029 {
2030 eFrameProcessingResult_t eResult;
2031 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2032 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2033 IPPacket_t * pxIPPacket;
2034 IPHeader_t * pxIPHeader;
2035
2036 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2037
2038 pxNetworkBuffer = &xNetworkBuffer;
2039 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2040 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2041 pxIPHeader = &( pxIPPacket->xIPHeader );
2042 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2043
2044 pxIPHeader->ucVersionHeaderLength = 0xF0;
2045
2046 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2047
2048 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2049 }
2050
2051 /**
2052 * @brief test_prvProcessIPPacket_HeaderLengthGreater
2053 * To validate the flow to handle IPv4 packets but the length in IP header is greater than
2054 * network buffer size.
2055 */
test_prvProcessIPPacket_HeaderLengthGreater(void)2056 void test_prvProcessIPPacket_HeaderLengthGreater( void )
2057 {
2058 eFrameProcessingResult_t eResult;
2059 IPPacket_t * pxIPPacket;
2060 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2061 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2062 IPHeader_t * pxIPHeader;
2063
2064 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2065
2066 pxNetworkBuffer = &xNetworkBuffer;
2067 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2068 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2069 pxIPHeader = &( pxIPPacket->xIPHeader );
2070 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2071
2072 pxIPHeader->ucVersionHeaderLength = 0xFF;
2073
2074 /* Let the data length be greater than the ethernet header but small
2075 * enough to make the IP header bigger than the total length. */
2076 pxNetworkBuffer->xDataLength = 30;
2077
2078 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2079
2080 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2081 }
2082
2083 /**
2084 * @brief test_prvProcessIPPacket_UnknownFrameType
2085 * To validate the flow to handle unknown ethernet frame type.
2086 */
test_prvProcessIPPacket_UnknownFrameType(void)2087 void test_prvProcessIPPacket_UnknownFrameType( void )
2088 {
2089 eFrameProcessingResult_t eResult;
2090 IPPacket_t * pxIPPacket;
2091 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2092 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2093 IPHeader_t * pxIPHeader;
2094
2095 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2096
2097 pxNetworkBuffer = &xNetworkBuffer;
2098 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2099 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2100 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2101 pxIPPacket->xEthernetHeader.usFrameType = 0xFF;
2102
2103 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2104
2105 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2106 }
2107
2108 /**
2109 * @brief test_prvProcessIPPacket_ValidHeader_ARPResolutionReqd
2110 * To validate the flow to handle a valid IPv4 packet but need ARP resolution.
2111 */
test_prvProcessIPPacket_ValidHeader_ARPResolutionReqd(void)2112 void test_prvProcessIPPacket_ValidHeader_ARPResolutionReqd( void )
2113 {
2114 eFrameProcessingResult_t eResult;
2115 IPPacket_t * pxIPPacket;
2116 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2117 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2118 IPHeader_t * pxIPHeader;
2119
2120 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2121
2122 /* Initialize network buffer descriptor. */
2123 pxNetworkBuffer = &xNetworkBuffer;
2124 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2125
2126 /* Initialize ethernet layer. */
2127 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2128 pxIPHeader = &( pxIPPacket->xIPHeader );
2129 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2130 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2131
2132 /* Initialize IP layer. */
2133 pxIPHeader->ucVersionHeaderLength = 0x45;
2134
2135 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2136 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdTRUE );
2137
2138 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2139
2140 TEST_ASSERT_EQUAL( eWaitingARPResolution, eResult );
2141 }
2142
2143 /**
2144 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_InvalidProt
2145 * To validate the flow to handle a valid IPv4 packet but invalid protocol.
2146 */
test_prvProcessIPPacket_ARPResolutionNotReqd_InvalidProt(void)2147 void test_prvProcessIPPacket_ARPResolutionNotReqd_InvalidProt( void )
2148 {
2149 eFrameProcessingResult_t eResult;
2150 IPPacket_t * pxIPPacket;
2151 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2152 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2153 IPHeader_t * pxIPHeader;
2154
2155 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2156
2157 /* Initialize network buffer descriptor. */
2158 pxNetworkBuffer = &xNetworkBuffer;
2159 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2160 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2161
2162 /* Initialize ethernet layer. */
2163 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2164 pxIPHeader = &( pxIPPacket->xIPHeader );
2165 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2166 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2167
2168 /* Initialize IP layer. */
2169 pxIPHeader->ucVersionHeaderLength = 0x46;
2170 pxIPHeader->ucProtocol = 0xFF;
2171
2172 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2173 prvCheckIP4HeaderOptions_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
2174 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2175 vARPRefreshCacheEntryAge_ExpectAnyArgs();
2176
2177 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2178
2179 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2180 }
2181
2182 /**
2183 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPRelease
2184 * To validate the flow to handle a valid ICMPv4 packet. Then ProcessICMPPacket() returns eReleaseBuffer.
2185 */
test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPRelease(void)2186 void test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPRelease( void )
2187 {
2188 eFrameProcessingResult_t eResult;
2189 IPPacket_t * pxIPPacket;
2190 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2191 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2192 IPHeader_t * pxIPHeader;
2193
2194 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2195
2196 /* Initialize network buffer descriptor. */
2197 pxNetworkBuffer = &xNetworkBuffer;
2198 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2199 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2200
2201 /* Initialize ethernet layer. */
2202 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2203 pxIPHeader = &( pxIPPacket->xIPHeader );
2204 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2205 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2206
2207 /* Initialize IP layer. */
2208 pxIPHeader->ucVersionHeaderLength = 0x46;
2209 pxIPHeader->ucProtocol = ipPROTOCOL_ICMP;
2210
2211 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2212 prvCheckIP4HeaderOptions_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
2213 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2214 vARPRefreshCacheEntryAge_ExpectAnyArgs();
2215 ProcessICMPPacket_ExpectAndReturn( pxNetworkBuffer, eReleaseBuffer );
2216
2217 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2218
2219 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2220 }
2221
2222 /**
2223 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPProcess
2224 * To validate the flow to handle a valid ICMPv4 packet. Then ProcessICMPPacket() returns eProcessBuffer.
2225 */
test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPProcess(void)2226 void test_prvProcessIPPacket_ARPResolutionNotReqd_ICMPProcess( void )
2227 {
2228 eFrameProcessingResult_t eResult;
2229 IPPacket_t * pxIPPacket;
2230 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2231 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2232 IPHeader_t * pxIPHeader;
2233
2234 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2235
2236 /* Initialize network buffer descriptor. */
2237 pxNetworkBuffer = &xNetworkBuffer;
2238 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2239 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2240
2241 /* Initialize ethernet layer. */
2242 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2243 pxIPHeader = &( pxIPPacket->xIPHeader );
2244 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2245 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2246
2247 /* Initialize IP layer. */
2248 pxIPHeader->ucVersionHeaderLength = 0x46;
2249 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
2250
2251 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2252 prvCheckIP4HeaderOptions_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
2253 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2254 vARPRefreshCacheEntryAge_ExpectAnyArgs();
2255 ProcessICMPPacket_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
2256
2257 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2258
2259 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
2260 }
2261
2262 /**
2263 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPZeroLength
2264 * To validate the flow to handle a UDPv4 packet with 0 length in UDP header.
2265 */
test_prvProcessIPPacket_ARPResolutionNotReqd_UDPZeroLength(void)2266 void test_prvProcessIPPacket_ARPResolutionNotReqd_UDPZeroLength( void )
2267 {
2268 eFrameProcessingResult_t eResult;
2269 IPPacket_t * pxIPPacket;
2270 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2271 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2272 IPHeader_t * pxIPHeader;
2273 UDPPacket_t * pxUDPPacket;
2274
2275 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2276
2277 /* Initialize network buffer descriptor. */
2278 pxNetworkBuffer = &xNetworkBuffer;
2279 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2280 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2281
2282 /* Initialize ethernet layer. */
2283 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2284 pxIPHeader = &( pxIPPacket->xIPHeader );
2285 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2286 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2287
2288 /* Initialize IP layer. */
2289 pxIPHeader->ucVersionHeaderLength = 0x46;
2290 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2291
2292 /* Initialize UDP layer. */
2293 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2294 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_htons( 0 );
2295
2296 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2297 prvCheckIP4HeaderOptions_ExpectAndReturn( pxNetworkBuffer, eProcessBuffer );
2298
2299 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2300
2301 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2302 }
2303
2304 /**
2305 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPLengthGreaterThanIPHeader
2306 * To validate the flow to handle a UDPv4 packet when length of UDP header is greater
2307 * than the length in IP header.
2308 */
test_prvProcessIPPacket_ARPResolutionNotReqd_UDPLengthGreaterThanIPHeader(void)2309 void test_prvProcessIPPacket_ARPResolutionNotReqd_UDPLengthGreaterThanIPHeader( void )
2310 {
2311 eFrameProcessingResult_t eResult;
2312 IPPacket_t * pxIPPacket;
2313 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2314 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2315 IPHeader_t * pxIPHeader;
2316 UDPPacket_t * pxUDPPacket;
2317
2318 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2319
2320 /* Initialize network buffer descriptor. */
2321 pxNetworkBuffer = &xNetworkBuffer;
2322 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2323 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2324
2325 /* Initialize ethernet layer. */
2326 pxUDPPacket = ( ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
2327 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2328 pxIPHeader = &( pxIPPacket->xIPHeader );
2329 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2330 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2331
2332 /* Initialize IP layer. */
2333 pxIPHeader->ucVersionHeaderLength = 0x45;
2334 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2335 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2336
2337 /* Initialize UDP layer. */
2338 /* The length in IP header contains IP header + UDP. So UDP length shouldn't be same as length in IP header. */
2339 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2340
2341 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2342
2343 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2344
2345 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2346 }
2347
2348 /**
2349 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPHappyPath
2350 * To validate the flow to handle a valid UDPv4 packet.
2351 */
test_prvProcessIPPacket_ARPResolutionNotReqd_UDPHappyPath(void)2352 void test_prvProcessIPPacket_ARPResolutionNotReqd_UDPHappyPath( void )
2353 {
2354 eFrameProcessingResult_t eResult;
2355 IPPacket_t * pxIPPacket;
2356 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2357 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2358 IPHeader_t * pxIPHeader;
2359 UDPPacket_t * pxUDPPacket;
2360
2361 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2362
2363 /* Initialize network buffer descriptor. */
2364 pxNetworkBuffer = &xNetworkBuffer;
2365 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2366 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2367
2368 /* Initialize ethernet layer. */
2369 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2370 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2371 pxIPHeader = &( pxIPPacket->xIPHeader );
2372 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2373 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2374
2375 /* Initialize IP layer. */
2376 pxIPHeader->ucVersionHeaderLength = 0x45;
2377 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2378 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2379
2380 /* Initialize UDP layer. */
2381 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( sizeof( UDPPacket_t ) );
2382
2383 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2384 xProcessReceivedUDPPacket_ExpectAnyArgsAndReturn( pdPASS );
2385
2386 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2387
2388 TEST_ASSERT_EQUAL( eFrameConsumed, eResult );
2389 }
2390
2391 /**
2392 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPProcessFail
2393 * To validate the flow to handle a valid UDPv4 packet but got failure while calling xProcessReceivedUDPPacket().
2394 */
test_prvProcessIPPacket_ARPResolutionNotReqd_UDPProcessFail(void)2395 void test_prvProcessIPPacket_ARPResolutionNotReqd_UDPProcessFail( void )
2396 {
2397 eFrameProcessingResult_t eResult;
2398 IPPacket_t * pxIPPacket;
2399 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2400 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2401 IPHeader_t * pxIPHeader;
2402 UDPPacket_t * pxUDPPacket;
2403
2404 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2405
2406 /* Initialize network buffer descriptor. */
2407 pxNetworkBuffer = &xNetworkBuffer;
2408 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2409 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2410
2411 /* Initialize ethernet layer. */
2412 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2413 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2414 pxIPHeader = &( pxIPPacket->xIPHeader );
2415 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2416 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2417
2418 /* Initialize IP layer. */
2419 pxIPHeader->ucVersionHeaderLength = 0x45;
2420 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2421 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2422
2423 /* Initialize UDP layer. */
2424 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( sizeof( UDPPacket_t ) );
2425
2426 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2427 xProcessReceivedUDPPacket_ExpectAnyArgsAndReturn( pdFAIL );
2428
2429 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2430
2431 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2432 }
2433
2434 /**
2435 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPProcessFail
2436 * To validate the flow to handle a valid UDPv4 packet but got failure while calling xProcessReceivedUDPPacket()
2437 * because of waiting ARP resolution.
2438 */
test_prvProcessIPPacket_ARPResolutionReqd_UDP(void)2439 void test_prvProcessIPPacket_ARPResolutionReqd_UDP( void )
2440 {
2441 eFrameProcessingResult_t eResult;
2442 IPPacket_t * pxIPPacket;
2443 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2444 UBaseType_t uxHeaderLength = 0;
2445 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2446 IPHeader_t * pxIPHeader;
2447 UDPPacket_t * pxUDPPacket;
2448 BaseType_t xReturnValue = pdTRUE;
2449
2450 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2451
2452 /* Initialize network buffer descriptor. */
2453 pxNetworkBuffer = &xNetworkBuffer;
2454 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2455 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2456
2457 /* Initialize ethernet layer. */
2458 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2459 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2460 pxIPHeader = &( pxIPPacket->xIPHeader );
2461 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2462 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2463
2464 /* Initialize IP layer. */
2465 pxIPHeader->ucVersionHeaderLength = 0x45;
2466 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2467 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2468
2469 /* Initialize UDP layer. */
2470 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( sizeof( UDPPacket_t ) );
2471
2472 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2473 xProcessReceivedUDPPacket_ExpectAndReturn( pxNetworkBuffer, pxUDPPacket->xUDPHeader.usDestinationPort, NULL, pdFAIL );
2474 xProcessReceivedUDPPacket_IgnoreArg_pxIsWaitingForARPResolution();
2475 xProcessReceivedUDPPacket_ReturnThruPtr_pxIsWaitingForARPResolution( &xReturnValue );
2476
2477 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2478
2479 TEST_ASSERT_EQUAL( eWaitingARPResolution, eResult );
2480 TEST_ASSERT_EQUAL( FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) - sizeof( UDPHeader_t ) + sizeof( UDPPacket_t ), pxNetworkBuffer->xDataLength );
2481 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usSourcePort );
2482 TEST_ASSERT_EQUAL( pxNetworkBuffer->xIPAddress.ulIP_IPv4, pxUDPPacket->xIPHeader.ulSourceIPAddress );
2483 }
2484
2485 /**
2486 * @brief test_prvProcessIPPacket_ARPResolutionNotReqd_UDPProcessFail
2487 * To validate the flow to handle a valid UDPv4 packet but got failure while calling xProcessReceivedUDPPacket()
2488 * because of waiting ARP resolution. And the network buffer size is small than UDP header.
2489 */
test_prvProcessIPPacket_ARPResolutionReqd_UDP1(void)2490 void test_prvProcessIPPacket_ARPResolutionReqd_UDP1( void )
2491 {
2492 eFrameProcessingResult_t eResult;
2493 IPPacket_t * pxIPPacket;
2494 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2495 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2496 IPHeader_t * pxIPHeader;
2497 UDPPacket_t * pxUDPPacket;
2498 BaseType_t xReturnValue = pdTRUE;
2499
2500 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2501
2502 /* Initialize network buffer descriptor. */
2503 pxNetworkBuffer = &xNetworkBuffer;
2504 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2505 pxNetworkBuffer->xDataLength = sizeof( UDPPacket_t );
2506
2507 /* Initialize ethernet layer. */
2508 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2509 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2510 pxIPHeader = &( pxIPPacket->xIPHeader );
2511 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2512 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2513
2514 /* Initialize IP layer. */
2515 pxIPHeader->ucVersionHeaderLength = 0x45;
2516 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2517 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2518
2519 /* Initialize UDP layer. */
2520 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( sizeof( UDPPacket_t ) );
2521
2522 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2523 xProcessReceivedUDPPacket_ExpectAndReturn( pxNetworkBuffer, pxUDPPacket->xUDPHeader.usDestinationPort, NULL, pdFAIL );
2524 xProcessReceivedUDPPacket_IgnoreArg_pxIsWaitingForARPResolution();
2525 xProcessReceivedUDPPacket_ReturnThruPtr_pxIsWaitingForARPResolution( &xReturnValue );
2526
2527 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2528
2529 TEST_ASSERT_EQUAL( eWaitingARPResolution, eResult );
2530 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usSourcePort );
2531 TEST_ASSERT_EQUAL( pxNetworkBuffer->xIPAddress.ulIP_IPv4, pxUDPPacket->xIPHeader.ulSourceIPAddress );
2532 }
2533
2534 /**
2535 * @brief test_prvProcessIPPacket_TCP
2536 * To validate the flow to handle a valid TCPv4 packet and no ARP resolution needed.
2537 */
test_prvProcessIPPacket_TCP(void)2538 void test_prvProcessIPPacket_TCP( void )
2539 {
2540 eFrameProcessingResult_t eResult;
2541 IPPacket_t * pxIPPacket;
2542 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2543 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2544 IPHeader_t * pxIPHeader;
2545 BaseType_t xReturnValue = pdTRUE;
2546 uint32_t backup = xProcessedTCPMessage;
2547
2548 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2549
2550 /* Initialize network buffer descriptor. */
2551 pxNetworkBuffer = &xNetworkBuffer;
2552 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2553 pxNetworkBuffer->xDataLength = sizeof( UDPPacket_t );
2554
2555 /* Initialize ethernet layer. */
2556 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2557 pxIPHeader = &( pxIPPacket->xIPHeader );
2558 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2559 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2560
2561 /* Initialize IP layer. */
2562 pxIPHeader->ucVersionHeaderLength = 0x45;
2563 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2564 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
2565
2566 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2567 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2568 vARPRefreshCacheEntryAge_ExpectAnyArgs();
2569 xProcessReceivedTCPPacket_ExpectAndReturn( pxNetworkBuffer, pdPASS );
2570
2571 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2572
2573 TEST_ASSERT_EQUAL( eFrameConsumed, eResult );
2574 TEST_ASSERT_EQUAL( backup + 1, xProcessedTCPMessage );
2575 }
2576
2577 /**
2578 * @brief test_prvProcessIPPacket_TCPProcessFail
2579 * To validate the flow to handle a valid TCPv4 packet and no ARP resolution needed.
2580 * Got failure while calling xProcessReceivedTCPPacket().
2581 */
test_prvProcessIPPacket_TCPProcessFail(void)2582 void test_prvProcessIPPacket_TCPProcessFail( void )
2583 {
2584 eFrameProcessingResult_t eResult;
2585 IPPacket_t * pxIPPacket;
2586 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2587 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2588 IPHeader_t * pxIPHeader;
2589 BaseType_t xReturnValue = pdTRUE;
2590 uint32_t backup = xProcessedTCPMessage;
2591 NetworkEndPoint_t xEndPoint = { 0 };
2592
2593 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2594
2595 /* Initialize network buffer descriptor. */
2596 pxNetworkBuffer = &xNetworkBuffer;
2597 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2598 pxNetworkBuffer->xDataLength = sizeof( UDPPacket_t );
2599
2600 /* Initialize ethernet layer. */
2601 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2602 pxIPHeader = &( pxIPPacket->xIPHeader );
2603 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2604 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2605
2606 /* Initialize IP layer. */
2607 pxIPHeader->ucVersionHeaderLength = 0x45;
2608 pxIPHeader->usLength = FreeRTOS_htons( ipconfigTCP_MSS );
2609 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
2610
2611 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2612 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2613 vARPRefreshCacheEntryAge_ExpectAnyArgs();
2614 xProcessReceivedTCPPacket_ExpectAndReturn( pxNetworkBuffer, pdFAIL );
2615
2616 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2617
2618 TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
2619 TEST_ASSERT_EQUAL( backup + 1, xProcessedTCPMessage );
2620 }
2621
2622 /**
2623 * @brief test_prvProcessIPPacket_UDP_ExternalLoopback
2624 * To validate the flow to handle a UDPv4 packet but the destination IP address
2625 * is loop-back address.
2626 */
test_prvProcessIPPacket_UDP_ExternalLoopback(void)2627 void test_prvProcessIPPacket_UDP_ExternalLoopback( void )
2628 {
2629 eFrameProcessingResult_t eResult;
2630 IPPacket_t * pxIPPacket;
2631 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2632 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2633 IPHeader_t * pxIPHeader;
2634
2635 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2636
2637 /* Initialize network buffer descriptor. */
2638 pxNetworkBuffer = &xNetworkBuffer;
2639 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2640 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2641
2642 /* Initialize ethernet layer. */
2643 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2644 pxIPHeader = &( pxIPPacket->xIPHeader );
2645 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2646 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2647
2648 /* Initialize IP layer. */
2649 pxIPHeader->ucVersionHeaderLength = 0x45;
2650 pxIPHeader->ulDestinationIPAddress = FreeRTOS_htonl( ipFIRST_LOOPBACK_IPv4 );
2651 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2652
2653 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2654
2655 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2656
2657 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2658 }
2659
2660 /**
2661 * @brief test_prvProcessIPPacket_UDP_GreaterLoopbackAddress
2662 * To validate the flow to handle a UDPv4 packet but the destination IP address
2663 * is greater than loop-back address.
2664 */
test_prvProcessIPPacket_UDP_GreaterLoopbackAddress(void)2665 void test_prvProcessIPPacket_UDP_GreaterLoopbackAddress( void )
2666 {
2667 eFrameProcessingResult_t eResult;
2668 IPPacket_t * pxIPPacket;
2669 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2670 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2671 IPHeader_t * pxIPHeader;
2672
2673 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2674
2675 /* Initialize network buffer descriptor. */
2676 pxNetworkBuffer = &xNetworkBuffer;
2677 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2678 pxNetworkBuffer->xDataLength = 0;
2679
2680 /* Initialize ethernet layer. */
2681 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2682 pxIPHeader = &( pxIPPacket->xIPHeader );
2683 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2684 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2685
2686 /* Initialize IP layer. */
2687 pxIPHeader->ucVersionHeaderLength = 0x45;
2688 pxIPHeader->ulDestinationIPAddress = FreeRTOS_htonl( ipLAST_LOOPBACK_IPv4 );
2689 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2690
2691 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2692
2693 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2694
2695 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2696 }
2697
2698 /**
2699 * @brief test_prvProcessIPPacket_UDP_LessLoopbackAddress
2700 * To validate the flow to handle a UDPv4 packet but the destination IP address
2701 * is less than loop-back address.
2702 */
test_prvProcessIPPacket_UDP_LessLoopbackAddress(void)2703 void test_prvProcessIPPacket_UDP_LessLoopbackAddress( void )
2704 {
2705 eFrameProcessingResult_t eResult;
2706 IPPacket_t * pxIPPacket;
2707 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2708 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2709 IPHeader_t * pxIPHeader;
2710
2711 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2712
2713 /* Initialize network buffer descriptor. */
2714 pxNetworkBuffer = &xNetworkBuffer;
2715 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2716 pxNetworkBuffer->xDataLength = 0;
2717
2718 /* Initialize ethernet layer. */
2719 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2720 pxIPHeader = &( pxIPPacket->xIPHeader );
2721 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2722 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
2723
2724 /* Initialize IP layer. */
2725 pxIPHeader->ucVersionHeaderLength = 0x45;
2726 pxIPHeader->ulDestinationIPAddress = FreeRTOS_htonl( ipFIRST_LOOPBACK_IPv4 - 1 );
2727 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2728
2729 prvAllowIPPacketIPv4_ExpectAndReturn( pxIPPacket, pxNetworkBuffer, ( pxIPHeader->ucVersionHeaderLength & 0x0FU ) << 2, eProcessBuffer );
2730
2731 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2732
2733 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2734 }
2735
2736 /**
2737 * @brief test_prvProcessIPPacket_UDP_IPHeaderLengthTooLarge
2738 * To validate the flow to handle a UDPv4 packet but the header length in
2739 * IP header is greater than buffer size.
2740 */
test_prvProcessIPPacket_UDP_IPHeaderLengthTooLarge(void)2741 void test_prvProcessIPPacket_UDP_IPHeaderLengthTooLarge( void )
2742 {
2743 eFrameProcessingResult_t eResult;
2744 IPPacket_t * pxIPPacket;
2745 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2746 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2747 IPHeader_t * pxIPHeader;
2748
2749 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2750
2751 /* Initialize network buffer descriptor. */
2752 pxNetworkBuffer = &xNetworkBuffer;
2753 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2754 pxNetworkBuffer->xDataLength = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER;
2755
2756 /* Initialize ethernet layer. */
2757 pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
2758 pxIPHeader = &( pxIPPacket->xIPHeader );
2759 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
2760
2761 /* Initialize IP layer. */
2762 /* The length in IP header is larger than buffer size. */
2763 pxIPHeader->ucVersionHeaderLength = 0x4F;
2764 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
2765
2766 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2767
2768 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2769 }
2770
2771 /**
2772 * @brief test_prvProcessIPPacket_UDP_IPv6_HappyPath
2773 * To validate the flow to handle a UDPv6 packet successfully.
2774 */
test_prvProcessIPPacket_UDP_IPv6_HappyPath(void)2775 void test_prvProcessIPPacket_UDP_IPv6_HappyPath( void )
2776 {
2777 eFrameProcessingResult_t eResult;
2778 IPPacket_IPv6_t * pxIPPacket;
2779 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2780 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2781 IPHeader_IPv6_t * pxIPHeader;
2782 UDPPacket_IPv6_t * pxUDPPacket;
2783 BaseType_t xReturnValue = pdTRUE;
2784
2785 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2786
2787 /* Initialize network buffer descriptor. */
2788 pxNetworkBuffer = &xNetworkBuffer;
2789 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2790 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2791
2792 /* Initialize ethernet layer. */
2793 pxUDPPacket = ( UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2794 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2795 pxIPHeader = &( pxIPPacket->xIPHeader );
2796 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2797 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
2798
2799 /* Initialize IP layer. */
2800 pxIPHeader->ucVersionTrafficClass = 0x60;
2801 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
2802 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_UDP;
2803
2804 /* Initialize UDP layer. */
2805 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( UDPPacket_IPv6_t ) );
2806
2807 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
2808 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_UDP, 0U, 0 );
2809 xProcessReceivedUDPPacket_ExpectAnyArgsAndReturn( pdPASS );
2810
2811 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2812
2813 TEST_ASSERT_EQUAL( eFrameConsumed, eResult );
2814 }
2815
2816 /**
2817 * @brief test_prvProcessIPPacket_UDP_IPv6_ExtensionHappyPath
2818 * To validate the flow to handle a UDPv6 packet with extension header successfully.
2819 */
test_prvProcessIPPacket_UDP_IPv6_ExtensionHappyPath(void)2820 void test_prvProcessIPPacket_UDP_IPv6_ExtensionHappyPath( void )
2821 {
2822 eFrameProcessingResult_t eResult;
2823 IPPacket_IPv6_t * pxIPPacket;
2824 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2825 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2826 IPHeader_IPv6_t * pxIPHeader;
2827 UDPPacket_IPv6_t * pxUDPPacket;
2828 BaseType_t xReturnValue = pdTRUE;
2829
2830 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2831
2832 /* Initialize network buffer descriptor. */
2833 pxNetworkBuffer = &xNetworkBuffer;
2834 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2835 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2836
2837 /* Initialize ethernet layer. */
2838 pxUDPPacket = ( UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2839 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2840 pxIPHeader = &( pxIPPacket->xIPHeader );
2841 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2842 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
2843
2844 pxIPHeader->ucVersionTrafficClass = 0x60;
2845
2846 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
2847
2848 /* Packet not meant for this node. */
2849 memcpy( pxIPHeader->xSourceAddress.ucBytes, xIPAddressTen.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2850 memcpy( pxIPHeader->xDestinationAddress.ucBytes, xIPAddressFive.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2851
2852 /* Set the protocol to be IPv6 UDP. */
2853 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_UDP;
2854
2855 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( UDPPacket_IPv6_t ) );
2856
2857 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
2858 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_UDP, 0U, 1 );
2859 eHandleIPv6ExtensionHeaders_ExpectAndReturn( pxNetworkBuffer, pdTRUE, eProcessBuffer );
2860 xProcessReceivedUDPPacket_ExpectAnyArgsAndReturn( pdPASS );
2861
2862 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2863
2864 TEST_ASSERT_EQUAL( eFrameConsumed, eResult );
2865 }
2866
2867 /**
2868 * @brief test_prvProcessIPPacket_UDP_IPv6_ExtensionHandleFail
2869 * To validate the flow to handle a UDPv6 packet with extension header but got failure
2870 * while handling extension header.
2871 */
test_prvProcessIPPacket_UDP_IPv6_ExtensionHandleFail(void)2872 void test_prvProcessIPPacket_UDP_IPv6_ExtensionHandleFail( void )
2873 {
2874 eFrameProcessingResult_t eResult;
2875 IPPacket_IPv6_t * pxIPPacket;
2876 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2877 UBaseType_t uxHeaderLength = 0;
2878 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2879 IPHeader_IPv6_t * pxIPHeader;
2880 UDPPacket_IPv6_t * pxUDPPacket;
2881 BaseType_t xReturnValue = pdTRUE;
2882
2883 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2884
2885 pxNetworkBuffer = &xNetworkBuffer;
2886 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2887 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2888
2889 pxUDPPacket = ( UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2890
2891 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2892 pxIPHeader = &( pxIPPacket->xIPHeader );
2893 pxIPHeader->ucVersionTrafficClass = 0x60;
2894
2895 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
2896
2897 /* Packet not meant for this node. */
2898 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
2899 memcpy( pxIPHeader->xSourceAddress.ucBytes, xIPAddressTen.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2900 memcpy( pxIPHeader->xDestinationAddress.ucBytes, xIPAddressFive.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2901
2902 /* Set the protocol to be IPv6 UDP. */
2903 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2904 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_UDP;
2905
2906 pxUDPPacket->xUDPHeader.usLength = FreeRTOS_ntohs( FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( UDPPacket_IPv6_t ) );
2907
2908 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
2909 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_UDP, 0U, 1 );
2910 eHandleIPv6ExtensionHeaders_ExpectAndReturn( pxNetworkBuffer, pdTRUE, eReleaseBuffer );
2911
2912 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2913
2914 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
2915 }
2916
2917 /**
2918 * @brief test_prvProcessIPPacket_TCP_IPv6_HappyPath
2919 * To validate the flow to handle a TCPv6 packet successfully.
2920 */
test_prvProcessIPPacket_TCP_IPv6_HappyPath(void)2921 void test_prvProcessIPPacket_TCP_IPv6_HappyPath( void )
2922 {
2923 eFrameProcessingResult_t eResult;
2924 IPPacket_IPv6_t * pxIPPacket;
2925 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2926 UBaseType_t uxHeaderLength = 0;
2927 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2928 IPHeader_IPv6_t * pxIPHeader;
2929 TCPPacket_IPv6_t * pxTCPPacket;
2930 BaseType_t xReturnValue = pdTRUE;
2931
2932 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2933
2934 pxNetworkBuffer = &xNetworkBuffer;
2935 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2936 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2937
2938 pxTCPPacket = ( TCPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2939
2940 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2941 pxIPHeader = &( pxIPPacket->xIPHeader );
2942 pxIPHeader->ucVersionTrafficClass = 0x60;
2943
2944 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
2945
2946 /* Packet not meant for this node. */
2947 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
2948 memcpy( pxIPHeader->xSourceAddress.ucBytes, xIPAddressTen.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2949 memcpy( pxIPHeader->xDestinationAddress.ucBytes, xIPAddressFive.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2950
2951 /* Set the protocol to be IPv6 UDP. */
2952 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2953 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_TCP;
2954
2955 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
2956 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_TCP, 0U, 0 );
2957 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
2958 vNDRefreshCacheEntry_Ignore();
2959 xProcessReceivedTCPPacket_ExpectAnyArgsAndReturn( pdPASS );
2960
2961 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
2962
2963 TEST_ASSERT_EQUAL( eFrameConsumed, eResult );
2964 }
2965
2966 /**
2967 * @brief test_prvProcessIPPacket_TCP_IPv6_HappyPath
2968 * To validate the flow to handle a TCPv6 packet successfully.
2969 * Then it needs to update ND resolution.
2970 */
test_prvProcessIPPacket_TCP_IPv6_ARPResolution(void)2971 void test_prvProcessIPPacket_TCP_IPv6_ARPResolution( void )
2972 {
2973 eFrameProcessingResult_t eResult;
2974 IPPacket_IPv6_t * pxIPPacket;
2975 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
2976 UBaseType_t uxHeaderLength = 0;
2977 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
2978 IPHeader_IPv6_t * pxIPHeader;
2979 TCPPacket_IPv6_t * pxTCPPacket;
2980 BaseType_t xReturnValue = pdTRUE;
2981
2982 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
2983
2984 pxNetworkBuffer = &xNetworkBuffer;
2985 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
2986 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
2987
2988 pxTCPPacket = ( TCPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2989
2990 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
2991 pxIPHeader = &( pxIPPacket->xIPHeader );
2992 pxIPHeader->ucVersionTrafficClass = 0x60;
2993
2994 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
2995
2996 /* Packet not meant for this node. */
2997 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
2998 memcpy( pxIPHeader->xSourceAddress.ucBytes, xIPAddressTen.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2999 memcpy( pxIPHeader->xDestinationAddress.ucBytes, xIPAddressFive.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3000
3001 /* Set the protocol to be IPv6 UDP. */
3002 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
3003 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_TCP;
3004
3005 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
3006 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_TCP, 0U, 0 );
3007 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdTRUE );
3008
3009 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
3010
3011 TEST_ASSERT_EQUAL( eWaitingARPResolution, eResult );
3012 }
3013
3014 /**
3015 * @brief test_prvProcessIPPacket_ICMP_IPv6_HappyPath
3016 * To validate the flow to handle a ICMPv6 packet successfully.
3017 */
test_prvProcessIPPacket_ICMP_IPv6_HappyPath(void)3018 void test_prvProcessIPPacket_ICMP_IPv6_HappyPath( void )
3019 {
3020 eFrameProcessingResult_t eResult;
3021 IPPacket_IPv6_t * pxIPPacket;
3022 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3023 UBaseType_t uxHeaderLength = 0;
3024 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3025 IPHeader_IPv6_t * pxIPHeader;
3026 ICMPPacket_IPv6_t * pxICMPPacket;
3027 BaseType_t xReturnValue = pdTRUE;
3028
3029 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
3030
3031 pxNetworkBuffer = &xNetworkBuffer;
3032 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3033 pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
3034
3035 pxICMPPacket = ( ICMPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
3036
3037 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
3038 pxIPHeader = &( pxIPPacket->xIPHeader );
3039 pxIPHeader->ucVersionTrafficClass = 0x60;
3040
3041 pxIPHeader->usPayloadLength = FreeRTOS_htons( ipconfigTCP_MSS ) - sizeof( IPPacket_IPv6_t );
3042
3043 /* Packet not meant for this node. */
3044 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucMACAddress, sizeof( MACAddress_t ) );
3045 memcpy( pxIPHeader->xSourceAddress.ucBytes, xIPAddressTen.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3046 memcpy( pxIPHeader->xDestinationAddress.ucBytes, xIPAddressFive.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
3047
3048 /* Set the protocol to be IPv6 UDP. */
3049 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
3050 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_ICMP_IPv6;
3051
3052 prvAllowIPPacketIPv6_ExpectAndReturn( pxIPHeader, pxNetworkBuffer, ipSIZE_OF_IPv6_HEADER, eProcessBuffer );
3053 xGetExtensionOrder_ExpectAndReturn( ipPROTOCOL_ICMP_IPv6, 0U, 0 );
3054 xCheckRequiresARPResolution_ExpectAndReturn( pxNetworkBuffer, pdFALSE );
3055 vNDRefreshCacheEntry_Ignore();
3056 prvProcessICMPMessage_IPv6_ExpectAnyArgsAndReturn( eReleaseBuffer );
3057
3058 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
3059
3060 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
3061 }
3062
3063 /**
3064 * @brief The packet size is less than IPv6 minimum packet size.
3065 */
test_prvProcessIPPacket_IPv6_LessPacketSize(void)3066 void test_prvProcessIPPacket_IPv6_LessPacketSize( void )
3067 {
3068 eFrameProcessingResult_t eResult;
3069 IPPacket_IPv6_t * pxIPPacket;
3070 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3071 UBaseType_t uxHeaderLength = 0;
3072 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3073 IPHeader_IPv6_t * pxIPHeader;
3074 BaseType_t xReturnValue = pdTRUE;
3075
3076 memset( ucEthBuffer, 0, ipconfigTCP_MSS );
3077
3078 pxNetworkBuffer = &xNetworkBuffer;
3079 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3080 pxNetworkBuffer->xDataLength = sizeof( IPPacket_IPv6_t ) - 1;
3081
3082 pxIPPacket = ( IPHeader_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer;
3083 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
3084
3085 eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
3086
3087 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
3088 }
3089
3090 /**
3091 * @brief test_vReturnEthernetFrame
3092 * To validate if vReturnEthernetFrame changes the source/destination MAC addresses correctly
3093 * and transmits though network interface.
3094 */
test_vReturnEthernetFrame(void)3095 void test_vReturnEthernetFrame( void )
3096 {
3097 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3098 BaseType_t xReleaseAfterSend = pdFALSE;
3099 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3100 EthernetHeader_t * pxEthernetHeader;
3101 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
3102
3103 pxNetworkBuffer = &xNetworkBuffer;
3104 pxNetworkBuffer->pxEndPoint = &xEndPoint;
3105
3106 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3107
3108 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3109 pxNetworkBuffer->pxEndPoint = pxEndPoint;
3110 xEndPoint.pxNetworkInterface = &xInterfaces;
3111 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
3112 memset( pxEndPoint->xMACAddress.ucBytes, 0x11, sizeof( pxEndPoint->xMACAddress ) );
3113 NetworkInterfaceOutputFunction_Stub_Called = 0;
3114
3115 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3116
3117 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3118 memset( &pxEthernetHeader->xDestinationAddress, 0, sizeof( pxEthernetHeader->xDestinationAddress ) );
3119 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3120
3121 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10;
3122
3123 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( pxNetworkBuffer->pxEndPoint );
3124
3125 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
3126
3127 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3128
3129 TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
3130 TEST_ASSERT_EACH_EQUAL_UINT8( 0, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
3131 TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
3132 TEST_ASSERT_EACH_EQUAL_UINT8( 0x11, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
3133 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pxEndPoint->xMACAddress.ucBytes, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
3134 TEST_ASSERT_EQUAL( 1, NetworkInterfaceOutputFunction_Stub_Called );
3135 }
3136
3137 /**
3138 * @brief test_vReturnEthernetFrame_DataLenMoreThanRequired
3139 * To validate if vReturnEthernetFrame changes the source/destination MAC addresses correctly
3140 * and transmits though network interface. And the buffer length is equal to ipconfigETHERNET_MINIMUM_PACKET_BYTES.
3141 */
test_vReturnEthernetFrame_DataLenMoreThanRequired(void)3142 void test_vReturnEthernetFrame_DataLenMoreThanRequired( void )
3143 {
3144 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3145 BaseType_t xReleaseAfterSend = pdFALSE;
3146 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3147 EthernetHeader_t * pxEthernetHeader;
3148 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
3149
3150 pxNetworkBuffer = &xNetworkBuffer;
3151 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3152
3153 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3154 pxNetworkBuffer->pxEndPoint = pxEndPoint;
3155 xEndPoint.pxNetworkInterface = &xInterfaces;
3156 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
3157 NetworkInterfaceOutputFunction_Stub_Called = 0;
3158 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3159
3160 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3161 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3162 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3163
3164 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
3165
3166 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( pxNetworkBuffer->pxEndPoint );
3167
3168 xIsCallingFromIPTask_ExpectAndReturn( pdTRUE );
3169
3170 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3171
3172 TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
3173 TEST_ASSERT_EACH_EQUAL_UINT8( 0xAA, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
3174 TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
3175 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pxEndPoint->xMACAddress.ucBytes, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
3176 TEST_ASSERT_EQUAL( 1, NetworkInterfaceOutputFunction_Stub_Called );
3177 }
3178
3179 /**
3180 * @brief test_vReturnEthernetFrame_ReleaseAfterSend
3181 * To validate if vReturnEthernetFrame changes the source/destination MAC addresses correctly
3182 * and send the event to IP task.
3183 */
test_vReturnEthernetFrame_ReleaseAfterSend(void)3184 void test_vReturnEthernetFrame_ReleaseAfterSend( void )
3185 {
3186 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3187 BaseType_t xReleaseAfterSend = pdTRUE;
3188 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3189 EthernetHeader_t * pxEthernetHeader;
3190 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
3191
3192 pxNetworkBuffer = &xNetworkBuffer;
3193 pxNetworkBuffer->pxEndPoint = &xEndPoint;
3194
3195 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3196
3197 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3198 pxNetworkBuffer->pxEndPoint = pxEndPoint;
3199 xEndPoint.pxNetworkInterface = &xInterfaces;
3200 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
3201 NetworkInterfaceOutputFunction_Stub_Called = 0;
3202
3203 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3204
3205 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3206 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3207 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3208
3209 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
3210
3211 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( pxNetworkBuffer->pxEndPoint );
3212
3213 xIPTaskInitialised = pdTRUE;
3214 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
3215 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
3216 xQueueGenericSend_IgnoreAndReturn( pdPASS );
3217
3218 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3219
3220 TEST_ASSERT_EACH_EQUAL_UINT8( 0xAA, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
3221 TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
3222 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pxEndPoint->xMACAddress.ucBytes, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
3223 TEST_ASSERT_EQUAL( 0, NetworkInterfaceOutputFunction_Stub_Called );
3224 }
3225
3226 /**
3227 * @brief test_vReturnEthernetFrame_ReleaseAfterSendFail
3228 * To validate if vReturnEthernetFrame changes the source/destination MAC addresses correctly
3229 * but fail to send the event to IP task.
3230 */
test_vReturnEthernetFrame_ReleaseAfterSendFail(void)3231 void test_vReturnEthernetFrame_ReleaseAfterSendFail( void )
3232 {
3233 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3234 BaseType_t xReleaseAfterSend = pdTRUE;
3235 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3236 EthernetHeader_t * pxEthernetHeader;
3237 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
3238
3239 pxNetworkBuffer = &xNetworkBuffer;
3240 pxNetworkBuffer->pxEndPoint = &xEndPoint;
3241
3242 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3243
3244 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3245 pxNetworkBuffer->pxEndPoint = pxEndPoint;
3246 xEndPoint.pxNetworkInterface = &xInterfaces;
3247 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
3248 NetworkInterfaceOutputFunction_Stub_Called = 0;
3249
3250 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3251
3252 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3253 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3254 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3255
3256 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
3257
3258 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( pxNetworkBuffer->pxEndPoint );
3259
3260 xIPTaskInitialised = pdTRUE;
3261 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
3262 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
3263 xQueueGenericSend_IgnoreAndReturn( pdFAIL );
3264 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
3265
3266 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3267
3268 TEST_ASSERT_EACH_EQUAL_UINT8( 0xAA, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
3269 TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
3270 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pxEndPoint->xMACAddress.ucBytes, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
3271 TEST_ASSERT_EQUAL( 0, NetworkInterfaceOutputFunction_Stub_Called );
3272 }
3273
3274 /**
3275 * @brief test_vReturnEthernetFrame_NeitherIPTaskNorReleaseAfterSend
3276 * To validate if vReturnEthernetFrame triggers assertion when it's neither called from IP task
3277 * nor ReleaseAfterSend.
3278 */
test_vReturnEthernetFrame_NeitherIPTaskNorReleaseAfterSend(void)3279 void test_vReturnEthernetFrame_NeitherIPTaskNorReleaseAfterSend( void )
3280 {
3281 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3282 BaseType_t xReleaseAfterSend = pdFALSE;
3283 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3284 EthernetHeader_t * pxEthernetHeader;
3285 NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
3286
3287 pxNetworkBuffer = &xNetworkBuffer;
3288 pxNetworkBuffer->pxEndPoint = &xEndPoint;
3289
3290 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3291
3292 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3293 pxNetworkBuffer->pxEndPoint = pxEndPoint;
3294 xEndPoint.pxNetworkInterface = &xInterfaces;
3295 xEndPoint.pxNetworkInterface->pfOutput = &NetworkInterfaceOutputFunction_Stub;
3296 NetworkInterfaceOutputFunction_Stub_Called = 0;
3297
3298 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3299
3300 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3301 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3302 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3303
3304 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10;
3305
3306 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( pxNetworkBuffer->pxEndPoint );
3307
3308 xIPTaskInitialised = pdTRUE;
3309 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
3310
3311 catch_assert( vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend ) );
3312 }
3313
3314 /**
3315 * @brief test_vReturnEthernetFrame_UnknownFrameType
3316 * To validate if vReturnEthernetFrame handles unknown ethernet frame type.
3317 */
test_vReturnEthernetFrame_UnknownFrameType(void)3318 void test_vReturnEthernetFrame_UnknownFrameType( void )
3319 {
3320 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3321 BaseType_t xReleaseAfterSend = pdFALSE;
3322 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3323 EthernetHeader_t * pxEthernetHeader;
3324
3325 pxNetworkBuffer = &xNetworkBuffer;
3326 pxNetworkBuffer->pxEndPoint = NULL;
3327
3328 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3329
3330 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3331 pxNetworkBuffer->pxEndPoint = NULL;
3332
3333 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3334
3335 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3336 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3337 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3338 pxEthernetHeader->usFrameType = 0xFF;
3339
3340 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
3341
3342 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( NULL );
3343
3344 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3345 }
3346
3347 /**
3348 * @brief test_vReturnEthernetFrame_IPv6NoEndpoint
3349 * To validate if vReturnEthernetFrame handles IPv6 ethernet frame without endpoint.
3350 */
test_vReturnEthernetFrame_IPv6NoEndpoint(void)3351 void test_vReturnEthernetFrame_IPv6NoEndpoint( void )
3352 {
3353 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
3354 BaseType_t xReleaseAfterSend = pdFALSE;
3355 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
3356 EthernetHeader_t * pxEthernetHeader;
3357
3358 pxNetworkBuffer = &xNetworkBuffer;
3359 pxNetworkBuffer->pxEndPoint = NULL;
3360
3361 memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
3362
3363 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
3364 pxNetworkBuffer->pxEndPoint = NULL;
3365
3366 memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
3367
3368 pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
3369 memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
3370 memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
3371 pxEthernetHeader->usFrameType = ipIPv6_FRAME_TYPE;
3372
3373 pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
3374
3375 vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
3376 }
3377
3378 /**
3379 * @brief test_FreeRTOS_GetIPAddress
3380 * To validate if FreeRTOS_GetIPAddress returns correct IP address stored in first endpoint.
3381 */
test_FreeRTOS_GetIPAddress(void)3382 void test_FreeRTOS_GetIPAddress( void )
3383 {
3384 uint32_t ulIPAddress;
3385
3386 NetworkEndPoint_t xEndPoint = { 0 };
3387
3388 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
3389
3390 xEndPoint.ipv4_settings.ulIPAddress = 0xAB12CD34;
3391
3392 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
3393
3394 ulIPAddress = FreeRTOS_GetIPAddress();
3395
3396 TEST_ASSERT_EQUAL( 0xAB12CD34, ulIPAddress );
3397 }
3398
3399 /**
3400 * @brief test_FreeRTOS_GetIPAddress
3401 * To validate if FreeRTOS_GetIPAddress returns correct IP address
3402 * in ipv4_defaults instead of ipv4_settings.
3403 */
test_FreeRTOS_GetIPAddress_DefaultSetting(void)3404 void test_FreeRTOS_GetIPAddress_DefaultSetting( void )
3405 {
3406 uint32_t ulIPAddress;
3407
3408 NetworkEndPoint_t xEndPoint = { 0 };
3409
3410 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
3411
3412 xEndPoint.ipv4_settings.ulIPAddress = 0;
3413 xEndPoint.ipv4_defaults.ulIPAddress = 0xAB12CD34;
3414
3415 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
3416
3417 ulIPAddress = FreeRTOS_GetIPAddress();
3418
3419 TEST_ASSERT_EQUAL( 0xAB12CD34, ulIPAddress );
3420 }
3421
3422 /**
3423 * @brief test_FreeRTOS_GetIPAddress_NullEndpoint
3424 * To validate if FreeRTOS_GetIPAddress returns 0 when no endpoint.
3425 */
test_FreeRTOS_GetIPAddress_NullEndpoint(void)3426 void test_FreeRTOS_GetIPAddress_NullEndpoint( void )
3427 {
3428 uint32_t ulIPAddress;
3429
3430 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( NULL );
3431
3432 ulIPAddress = FreeRTOS_GetIPAddress();
3433
3434 TEST_ASSERT_EQUAL( 0, ulIPAddress );
3435 }
3436
3437 /**
3438 * @brief test_FreeRTOS_GetIPAddress_MultipleEndpoints
3439 * To validate if FreeRTOS_GetIPAddress returns IP address of first IPv4 endpoint.
3440 */
test_FreeRTOS_GetIPAddress_MultipleEndpoints(void)3441 void test_FreeRTOS_GetIPAddress_MultipleEndpoints( void )
3442 {
3443 uint32_t ulIPAddress;
3444 NetworkEndPoint_t xEndPoints[ 2 ]; /* IPv6->IPv4 */
3445
3446 memset( &xEndPoints[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
3447 xEndPoints[ 0 ].bits.bIPv6 = pdTRUE;
3448 memset( &xEndPoints[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
3449 xEndPoints[ 1 ].bits.bIPv6 = pdFALSE;
3450 xEndPoints[ 1 ].ipv4_settings.ulIPAddress = 0xAB12CD34;
3451
3452 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoints[ 0 ] );
3453 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoints[ 0 ], &xEndPoints[ 1 ] );
3454
3455 ulIPAddress = FreeRTOS_GetIPAddress();
3456
3457 TEST_ASSERT_EQUAL( 0xAB12CD34, ulIPAddress );
3458 }
3459
3460 /**
3461 * @brief test_FreeRTOS_GetIPAddress_NoValidEndpoints
3462 * To validate if FreeRTOS_GetIPAddress returns 0 when no IPv4 endpoint.
3463 */
test_FreeRTOS_GetIPAddress_NoValidEndpoints(void)3464 void test_FreeRTOS_GetIPAddress_NoValidEndpoints( void )
3465 {
3466 uint32_t ulIPAddress;
3467 NetworkEndPoint_t xEndPoints[ 2 ]; /* IPv6->IPv6 */
3468
3469 memset( &xEndPoints[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
3470 xEndPoints[ 0 ].bits.bIPv6 = pdTRUE;
3471 memset( &xEndPoints[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
3472 xEndPoints[ 1 ].bits.bIPv6 = pdTRUE;
3473
3474 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoints[ 0 ] );
3475 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoints[ 0 ], &xEndPoints[ 1 ] );
3476 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoints[ 1 ], NULL );
3477
3478 ulIPAddress = FreeRTOS_GetIPAddress();
3479
3480 TEST_ASSERT_EQUAL( 0, ulIPAddress );
3481 }
3482
3483 /**
3484 * @brief test_CastingFunctions
3485 * Casting.
3486 */
test_CastingFunctions(void)3487 void test_CastingFunctions( void )
3488 {
3489 void * pvPtr;
3490
3491 const IPPacket_t * pxIPPacket = ( ( const IPPacket_t * ) pvPtr );
3492 const IPHeader_t * pxIPHeader = ( ( const IPHeader_t * ) pvPtr );
3493 const TCPPacket_t * pxConstTCPPacket = ( ( const TCPPacket_t * ) pvPtr );
3494 TCPPacket_t * pxTCPPacket = ( ( TCPPacket_t * ) pvPtr );
3495 ProtocolPacket_t * pxProtPacket = ( ( ProtocolPacket_t * ) pvPtr );
3496 const ProtocolPacket_t * pxConstProtPacket = ( ( const ProtocolPacket_t * ) pvPtr );
3497 const SocketSelect_t * pxSockSelPtr = ( ( const SocketSelect_t * ) pvPtr );
3498 const SocketSelectMessage_t * pxConstSockSelMsgPtr = ( ( const SocketSelectMessage_t * ) pvPtr );
3499 SocketSelectMessage_t * pxSockSelMsgPtr = ( ( SocketSelectMessage_t * ) pvPtr );
3500 NetworkBufferDescriptor_t * pxNetworkBuffer = ( ( NetworkBufferDescriptor_t * ) pvPtr );
3501 ListItem_t * pxList = ( ( ListItem_t * ) pvPtr );
3502 const ListItem_t * pxConstList = ( ( const ListItem_t * ) pvPtr );
3503 const FreeRTOS_Socket_t * pxSocket = ( ( const FreeRTOS_Socket_t * ) pvPtr );
3504 const ProtocolHeaders_t * pxConstProtHeader = ( ( const ProtocolHeaders_t * ) pvPtr );
3505 ProtocolHeaders_t * pxProtHeader = ( ( ProtocolHeaders_t * ) pvPtr );
3506 }
3507
3508 /**
3509 * @brief test_FreeRTOS_IPInit_Multi_NoInterface
3510 * To validate if FreeRTOS_IPInit_Multi() triggers assertion when no endpoint.
3511 */
test_FreeRTOS_IPInit_Multi_NoInterface(void)3512 void test_FreeRTOS_IPInit_Multi_NoInterface( void )
3513 {
3514 FreeRTOS_FirstNetworkInterface_IgnoreAndReturn( NULL );
3515 catch_assert( FreeRTOS_IPInit_Multi() );
3516 }
3517
3518 /**
3519 * @brief test_FreeRTOS_GetEndPointConfiguration_AllSettings
3520 * To validate if FreeRTOS_GetEndPointConfiguration() returns all settings in endpoint.
3521 */
test_FreeRTOS_GetEndPointConfiguration_AllSettings(void)3522 void test_FreeRTOS_GetEndPointConfiguration_AllSettings( void )
3523 {
3524 uint32_t ulIPAddress;
3525 uint32_t ulNetMask;
3526 uint32_t ulGatewayAddress;
3527 uint32_t ulDNSServerAddress;
3528 NetworkEndPoint_t xEndPoint;
3529
3530 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3531
3532 xEndPoint.ipv4_settings.ulIPAddress = 1;
3533 xEndPoint.ipv4_settings.ulNetMask = 2;
3534 xEndPoint.ipv4_settings.ulGatewayAddress = 3;
3535 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 4;
3536
3537 FreeRTOS_GetEndPointConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress, &xEndPoint );
3538 TEST_ASSERT_EQUAL( 1, ulIPAddress );
3539 TEST_ASSERT_EQUAL( 2, ulNetMask );
3540 TEST_ASSERT_EQUAL( 3, ulGatewayAddress );
3541 TEST_ASSERT_EQUAL( 4, ulDNSServerAddress );
3542 }
3543
3544 /**
3545 * @brief test_FreeRTOS_GetEndPointConfiguration_AllSettings
3546 * To validate if FreeRTOS_GetEndPointConfiguration() supports NULL pointers in API.
3547 */
test_FreeRTOS_GetEndPointConfiguration_AllNull(void)3548 void test_FreeRTOS_GetEndPointConfiguration_AllNull( void )
3549 {
3550 NetworkEndPoint_t xEndPoint;
3551
3552 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3553
3554 xEndPoint.ipv4_settings.ulIPAddress = 1;
3555 xEndPoint.ipv4_settings.ulNetMask = 2;
3556 xEndPoint.ipv4_settings.ulGatewayAddress = 3;
3557 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 4;
3558
3559 FreeRTOS_GetEndPointConfiguration( NULL, NULL, NULL, NULL, &xEndPoint );
3560 }
3561
3562 /**
3563 * @brief test_FreeRTOS_GetEndPointConfiguration_IPv6Endpoint
3564 * To validate if FreeRTOS_GetEndPointConfiguration() skips IPv6 endpoint.
3565 */
test_FreeRTOS_GetEndPointConfiguration_IPv6Endpoint(void)3566 void test_FreeRTOS_GetEndPointConfiguration_IPv6Endpoint( void )
3567 {
3568 uint32_t ulIPAddress = 0;
3569 uint32_t ulNetMask = 0;
3570 uint32_t ulGatewayAddress = 0;
3571 uint32_t ulDNSServerAddress = 0;
3572 NetworkEndPoint_t xEndPoint;
3573
3574 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3575 xEndPoint.bits.bIPv6 = pdTRUE;
3576
3577 FreeRTOS_GetEndPointConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress, &xEndPoint );
3578 TEST_ASSERT_EQUAL( 0, ulIPAddress );
3579 TEST_ASSERT_EQUAL( 0, ulNetMask );
3580 TEST_ASSERT_EQUAL( 0, ulGatewayAddress );
3581 TEST_ASSERT_EQUAL( 0, ulDNSServerAddress );
3582 }
3583
3584 /**
3585 * @brief test_FreeRTOS_GetEndPointConfiguration_IPv6Endpoint
3586 * To validate if FreeRTOS_GetEndPointConfiguration() supports NULL endpoint.
3587 */
test_FreeRTOS_GetEndPointConfiguration_NullEndpoint(void)3588 void test_FreeRTOS_GetEndPointConfiguration_NullEndpoint( void )
3589 {
3590 uint32_t ulIPAddress = 0;
3591 uint32_t ulNetMask = 0;
3592 uint32_t ulGatewayAddress = 0;
3593 uint32_t ulDNSServerAddress = 0;
3594
3595 FreeRTOS_GetEndPointConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress, NULL );
3596 TEST_ASSERT_EQUAL( 0, ulIPAddress );
3597 TEST_ASSERT_EQUAL( 0, ulNetMask );
3598 TEST_ASSERT_EQUAL( 0, ulGatewayAddress );
3599 TEST_ASSERT_EQUAL( 0, ulDNSServerAddress );
3600 }
3601
3602 /**
3603 * @brief test_FreeRTOS_SetEndPointConfiguration_AllSettings
3604 * To validate if FreeRTOS_SetEndPointConfiguration() sets all settings in endpoint correctly.
3605 */
test_FreeRTOS_SetEndPointConfiguration_AllSettings(void)3606 void test_FreeRTOS_SetEndPointConfiguration_AllSettings( void )
3607 {
3608 uint32_t ulIPAddress = 1;
3609 uint32_t ulNetMask = 2;
3610 uint32_t ulGatewayAddress = 3;
3611 uint32_t ulDNSServerAddress = 4;
3612 NetworkEndPoint_t xEndPoint;
3613
3614 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3615
3616 FreeRTOS_SetEndPointConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress, &xEndPoint );
3617 TEST_ASSERT_EQUAL( 1, xEndPoint.ipv4_settings.ulIPAddress );
3618 TEST_ASSERT_EQUAL( 2, xEndPoint.ipv4_settings.ulNetMask );
3619 TEST_ASSERT_EQUAL( 3, xEndPoint.ipv4_settings.ulGatewayAddress );
3620 TEST_ASSERT_EQUAL( 4, xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] );
3621 }
3622
3623 /**
3624 * @brief test_FreeRTOS_SetEndPointConfiguration_AllNull
3625 * To validate if FreeRTOS_SetEndPointConfiguration() supports NULL input.
3626 */
test_FreeRTOS_SetEndPointConfiguration_AllNull(void)3627 void test_FreeRTOS_SetEndPointConfiguration_AllNull( void )
3628 {
3629 NetworkEndPoint_t xEndPoint;
3630
3631 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3632
3633 FreeRTOS_SetEndPointConfiguration( NULL, NULL, NULL, NULL, &xEndPoint );
3634 }
3635
3636 /**
3637 * @brief test_FreeRTOS_SetEndPointConfiguration_IPv6Endpoint
3638 * To validate if FreeRTOS_SetEndPointConfiguration() returns 0 when endpoint is not IPv4.
3639 */
test_FreeRTOS_SetEndPointConfiguration_IPv6Endpoint(void)3640 void test_FreeRTOS_SetEndPointConfiguration_IPv6Endpoint( void )
3641 {
3642 uint32_t ulIPAddress = 1;
3643 uint32_t ulNetMask = 2;
3644 uint32_t ulGatewayAddress = 3;
3645 uint32_t ulDNSServerAddress = 4;
3646 NetworkEndPoint_t xEndPoint;
3647
3648 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
3649 xEndPoint.bits.bIPv6 = pdTRUE;
3650
3651 FreeRTOS_SetEndPointConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress, &xEndPoint );
3652 TEST_ASSERT_EQUAL( 0, xEndPoint.ipv4_settings.ulIPAddress );
3653 TEST_ASSERT_EQUAL( 0, xEndPoint.ipv4_settings.ulNetMask );
3654 TEST_ASSERT_EQUAL( 0, xEndPoint.ipv4_settings.ulGatewayAddress );
3655 TEST_ASSERT_EQUAL( 0, xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] );
3656 }
3657
3658 /**
3659 * @brief test_FreeRTOS_SetEndPointConfiguration_NullEndpoint
3660 * To validate if FreeRTOS_SetEndPointConfiguration() supports NULL endpoint.
3661 */
test_FreeRTOS_SetEndPointConfiguration_NullEndpoint(void)3662 void test_FreeRTOS_SetEndPointConfiguration_NullEndpoint( void )
3663 {
3664 FreeRTOS_SetEndPointConfiguration( NULL, NULL, NULL, NULL, NULL );
3665 }
3666
3667 /**
3668 * @brief test_FreeRTOS_IsNetworkUp
3669 * To validate if FreeRTOS_IsNetworkUp() returns pdTRUE when
3670 * the endpoint in global endpoint list is up.
3671 */
test_FreeRTOS_IsNetworkUp()3672 void test_FreeRTOS_IsNetworkUp()
3673 {
3674 BaseType_t xReturn;
3675 NetworkEndPoint_t xEndpoint, * pxEndpoint = &xEndpoint;
3676
3677 memset( pxEndpoint, 0, sizeof( xEndpoint ) );
3678 pxEndpoint->bits.bEndPointUp = pdTRUE;
3679
3680 pxNetworkEndPoints = pxEndpoint;
3681
3682 xReturn = FreeRTOS_IsNetworkUp();
3683
3684 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
3685 }
3686
3687 /**
3688 * @brief test_FreeRTOS_IsEndPointUp
3689 * To validate if FreeRTOS_IsEndPointUp() returns pdTRUE when
3690 * input endpoint is up.
3691 */
test_FreeRTOS_IsEndPointUp()3692 void test_FreeRTOS_IsEndPointUp()
3693 {
3694 BaseType_t xReturn;
3695 NetworkEndPoint_t xEndpoint, * pxEndpoint = &xEndpoint;
3696
3697 memset( pxEndpoint, 0, sizeof( xEndpoint ) );
3698 pxEndpoint->bits.bEndPointUp = pdTRUE;
3699
3700 xReturn = FreeRTOS_IsEndPointUp( pxEndpoint );
3701
3702 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
3703 }
3704
3705 /**
3706 * @brief test_FreeRTOS_AllEndPointsUp_NoEndpoints
3707 * To validate if FreeRTOS_AllEndPointsUp() returns pdTRUE when
3708 * no endpoint stored in global endpoint list.
3709 */
test_FreeRTOS_AllEndPointsUp_NoEndpoints()3710 void test_FreeRTOS_AllEndPointsUp_NoEndpoints()
3711 {
3712 BaseType_t xReturn;
3713
3714 xReturn = FreeRTOS_AllEndPointsUp( NULL );
3715
3716 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
3717 }
3718
3719 /**
3720 * @brief test_FreeRTOS_AllEndPointsUp_SpecificInterface
3721 * To validate if FreeRTOS_AllEndPointsUp() returns correctly
3722 * with input interface pointer.
3723 */
test_FreeRTOS_AllEndPointsUp_SpecificInterface()3724 void test_FreeRTOS_AllEndPointsUp_SpecificInterface()
3725 {
3726 BaseType_t xReturn;
3727 NetworkEndPoint_t xEndpoint[ 3 ];
3728 NetworkInterface_t xInterface[ 2 ];
3729
3730 /* Three endpoints: e0, e1, e2. And 2 interfaces: i0, i1.
3731 * - e0: Attach to i0
3732 * - e1: Attach to i1, and it's up.
3733 * - e2: Attach to i1, and it's down.
3734 * */
3735 memset( &xInterface[ 0 ], 0, sizeof( NetworkInterface_t ) );
3736 memset( &xInterface[ 1 ], 0, sizeof( NetworkInterface_t ) );
3737
3738 memset( &xEndpoint[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
3739 memset( &xEndpoint[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
3740 memset( &xEndpoint[ 2 ], 0, sizeof( NetworkEndPoint_t ) );
3741
3742 xEndpoint[ 0 ].pxNetworkInterface = &xInterface[ 0 ];
3743 xEndpoint[ 0 ].bits.bEndPointUp = pdTRUE;
3744
3745 xEndpoint[ 1 ].pxNetworkInterface = &xInterface[ 1 ];
3746 xEndpoint[ 1 ].bits.bEndPointUp = pdTRUE;
3747
3748 xEndpoint[ 2 ].pxNetworkInterface = &xInterface[ 1 ];
3749 xEndpoint[ 2 ].bits.bEndPointUp = pdFALSE;
3750
3751 /* Append e0~e2 into global endpoint list. */
3752 pxNetworkEndPoints = &xEndpoint[ 0 ];
3753 pxNetworkEndPoints->pxNext = &xEndpoint[ 1 ];
3754 pxNetworkEndPoints->pxNext->pxNext = &xEndpoint[ 2 ];
3755
3756 xReturn = FreeRTOS_AllEndPointsUp( &xInterface[ 1 ] );
3757
3758 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
3759 }
3760
3761 /**
3762 * @brief test_uxIPHeaderSizeSocket_IPv4
3763 * To validate if uxIPHeaderSizeSocket() returns ipSIZE_OF_IPv4_HEADER
3764 * when the socket is an IPv4 socket handler.
3765 */
test_uxIPHeaderSizeSocket_IPv4()3766 void test_uxIPHeaderSizeSocket_IPv4()
3767 {
3768 size_t xReturn;
3769 FreeRTOS_Socket_t xSocket;
3770
3771 memset( &xSocket, 0, sizeof( xSocket ) );
3772 xSocket.bits.bIsIPv6 = pdFALSE;
3773
3774 xReturn = uxIPHeaderSizeSocket( &xSocket );
3775 TEST_ASSERT_EQUAL( ipSIZE_OF_IPv4_HEADER, xReturn );
3776 }
3777
3778 /**
3779 * @brief test_uxIPHeaderSizeSocket_NullSocket
3780 * To validate if uxIPHeaderSizeSocket() returns ipSIZE_OF_IPv4_HEADER
3781 * when input socket is NULL.
3782 */
test_uxIPHeaderSizeSocket_NullSocket()3783 void test_uxIPHeaderSizeSocket_NullSocket()
3784 {
3785 size_t xReturn;
3786
3787 xReturn = uxIPHeaderSizeSocket( NULL );
3788 TEST_ASSERT_EQUAL( ipSIZE_OF_IPv4_HEADER, xReturn );
3789 }
3790
3791 /**
3792 * @brief test_uxIPHeaderSizeSocket_IPv6
3793 * To validate if uxIPHeaderSizeSocket() returns ipSIZE_OF_IPv6_HEADER
3794 * when input socket is an IPv6 handler.
3795 */
test_uxIPHeaderSizeSocket_IPv6()3796 void test_uxIPHeaderSizeSocket_IPv6()
3797 {
3798 size_t xReturn;
3799 FreeRTOS_Socket_t xSocket;
3800
3801 memset( &xSocket, 0, sizeof( xSocket ) );
3802 xSocket.bits.bIsIPv6 = pdTRUE;
3803
3804 xReturn = uxIPHeaderSizeSocket( &xSocket );
3805 TEST_ASSERT_EQUAL( ipSIZE_OF_IPv6_HEADER, xReturn );
3806 }
3807
