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_Utils_list_macros.h"
43 #include "mock_queue.h"
44 #include "mock_event_groups.h"
45
46 #include "mock_FreeRTOS_IP.h"
47 #include "mock_FreeRTOS_IP_Private.h"
48 #include "mock_FreeRTOS_IP_Timers.h"
49 #include "mock_FreeRTOS_ARP.h"
50 #include "mock_FreeRTOS_DHCP.h"
51 #include "mock_FreeRTOS_DHCPv6.h"
52 #include "mock_FreeRTOS_Routing.h"
53 #include "mock_FreeRTOS_IPv4_Utils.h"
54 #include "mock_FreeRTOS_IPv6_Utils.h"
55 #include "mock_NetworkBufferManagement.h"
56
57 #include "FreeRTOS_IP_Utils.h"
58
59 #include "FreeRTOS_IP_Utils_stubs.c"
60 #include "catch_assert.h"
61
62 #include "FreeRTOSIPConfig.h"
63
64 /* =========================== EXTERN VARIABLES =========================== */
65
66 #define TEST_UDP_PAYLOAD_LENGTH ( 10U )
67
68 extern NetworkInterface_t xInterfaces[ 1 ];
69
70 #if ( ipconfigUSE_NETWORK_EVENT_HOOK == 1 )
71 extern BaseType_t xCallEventHook;
72 #endif
73
74 extern UBaseType_t uxLastMinBufferCount;
75 extern size_t uxMinLastSize;
76
77 extern NetworkBufferDescriptor_t * prvPacketBuffer_to_NetworkBuffer( const void * pvBuffer,
78 size_t uxOffset );
79 extern uint16_t prvGetChecksumFromPacket( const struct xPacketSummary * pxSet );
80 extern void prvSetChecksumInPacket( const struct xPacketSummary * pxSet,
81 uint16_t usChecksum );
82
83 /* ============================== Test Cases ============================== */
84
85 /**
86 * @brief test_xSendDHCPEvent
87 * To validate if xSendDHCPEvent returns correct result.
88 */
test_xSendDHCPEvent(void)89 void test_xSendDHCPEvent( void )
90 {
91 BaseType_t xReturn, xResult = 0x123;
92 struct xNetworkEndPoint xEndPoint = { 0 };
93
94 eGetDHCPState_ExpectAnyArgsAndReturn( 12 );
95
96 xSendEventStructToIPTask_ExpectAnyArgsAndReturn( xResult );
97
98 xReturn = xSendDHCPEvent( &xEndPoint );
99
100 TEST_ASSERT_EQUAL( xResult, xReturn );
101 }
102
103 /**
104 * @brief test_pxDuplicateNetworkBufferWithDescriptor_NULLReturned
105 * To validate if pxDuplicateNetworkBufferWithDescriptor returns NULL when
106 * it's not able to allocate a new network buffer.
107 */
test_pxDuplicateNetworkBufferWithDescriptor_NULLReturned(void)108 void test_pxDuplicateNetworkBufferWithDescriptor_NULLReturned( void )
109 {
110 NetworkBufferDescriptor_t * pxReturn;
111 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
112 size_t uxNewLength;
113
114 pxNetworkBuffer = &xNetworkBuffer;
115
116 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNewLength, 0, NULL );
117
118 pxReturn = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, uxNewLength );
119
120 TEST_ASSERT_EQUAL( NULL, pxReturn );
121 }
122
123 /**
124 * @brief test_pxDuplicateNetworkBufferWithDescriptor_LargerBufferReturned
125 * To validate if pxDuplicateNetworkBufferWithDescriptor returns a network buffer
126 * with larger content size.
127 */
test_pxDuplicateNetworkBufferWithDescriptor_LargerBufferReturned(void)128 void test_pxDuplicateNetworkBufferWithDescriptor_LargerBufferReturned( void )
129 {
130 NetworkBufferDescriptor_t * pxReturn;
131 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
132 size_t uxNewLength = 0x345;
133 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
134 uint8_t ucEthBuffer2[ ipconfigTCP_MSS ];
135
136 pxNetworkBuffer = &xNetworkBuffer;
137 memset( &xNetworkBuffer2, 0, sizeof( NetworkBufferDescriptor_t ) );
138
139 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
140 memset( ucEthBuffer, 0xAB, ipconfigTCP_MSS );
141 xNetworkBuffer2.pucEthernetBuffer = ucEthBuffer2;
142 memset( ucEthBuffer2, 0x00, ipconfigTCP_MSS );
143
144 pxNetworkBuffer->xDataLength = 0x123;
145 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = 0xABCDEF56;
146 pxNetworkBuffer->usPort = 0x1234;
147 pxNetworkBuffer->usBoundPort = 0xFFAA;
148
149 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNewLength, 0, &xNetworkBuffer2 );
150 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
151
152 pxReturn = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, uxNewLength );
153
154 TEST_ASSERT_EQUAL( &xNetworkBuffer2, pxReturn );
155 TEST_ASSERT_EQUAL( xNetworkBuffer2.xDataLength, uxNewLength );
156 TEST_ASSERT_EQUAL( xNetworkBuffer2.xIPAddress.ulIP_IPv4, pxNetworkBuffer->xIPAddress.ulIP_IPv4 );
157 TEST_ASSERT_EQUAL( xNetworkBuffer2.usPort, pxNetworkBuffer->usPort );
158 TEST_ASSERT_EQUAL( xNetworkBuffer2.usBoundPort, pxNetworkBuffer->usBoundPort );
159 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pucEthernetBuffer, xNetworkBuffer2.pucEthernetBuffer, pxNetworkBuffer->xDataLength );
160 }
161
162 /**
163 * @brief test_pxDuplicateNetworkBufferWithDescriptor_SmallerBufferReturned
164 * To validate if pxDuplicateNetworkBufferWithDescriptor returns a network buffer
165 * with smaller content size.
166 */
test_pxDuplicateNetworkBufferWithDescriptor_SmallerBufferReturned(void)167 void test_pxDuplicateNetworkBufferWithDescriptor_SmallerBufferReturned( void )
168 {
169 NetworkBufferDescriptor_t * pxReturn;
170 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
171 size_t uxNewLength = 0x34;
172 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
173 uint8_t ucEthBuffer2[ ipconfigTCP_MSS ];
174
175 pxNetworkBuffer = &xNetworkBuffer;
176 memset( &xNetworkBuffer2, 0, sizeof( NetworkBufferDescriptor_t ) );
177
178 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
179 memset( ucEthBuffer, 0xAB, ipconfigTCP_MSS );
180 xNetworkBuffer2.pucEthernetBuffer = ucEthBuffer2;
181 memset( ucEthBuffer2, 0x00, ipconfigTCP_MSS );
182
183 pxNetworkBuffer->xDataLength = 0x123;
184 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = 0xABCDEF56;
185 pxNetworkBuffer->usPort = 0x1234;
186 pxNetworkBuffer->usBoundPort = 0xFFAA;
187
188 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNewLength, 0, &xNetworkBuffer2 );
189 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
190
191 pxReturn = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, uxNewLength );
192
193 TEST_ASSERT_EQUAL( &xNetworkBuffer2, pxReturn );
194 TEST_ASSERT_EQUAL( xNetworkBuffer2.xDataLength, uxNewLength );
195 TEST_ASSERT_EQUAL( xNetworkBuffer2.xIPAddress.ulIP_IPv4, pxNetworkBuffer->xIPAddress.ulIP_IPv4 );
196 TEST_ASSERT_EQUAL( xNetworkBuffer2.usPort, pxNetworkBuffer->usPort );
197 TEST_ASSERT_EQUAL( xNetworkBuffer2.usBoundPort, pxNetworkBuffer->usBoundPort );
198 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pucEthernetBuffer, xNetworkBuffer2.pucEthernetBuffer, uxNewLength );
199 }
200
201 /**
202 * @brief test_pxDuplicateNetworkBufferWithDescriptor_NullBufferReturned
203 * To validate if pxDuplicateNetworkBufferWithDescriptor returns a network buffer
204 * with NULL content pointer.
205 */
test_pxDuplicateNetworkBufferWithDescriptor_NullBufferReturned(void)206 void test_pxDuplicateNetworkBufferWithDescriptor_NullBufferReturned( void )
207 {
208 NetworkBufferDescriptor_t * pxReturn;
209 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
210 size_t uxNewLength = 0x34;
211
212 pxNetworkBuffer = &xNetworkBuffer;
213 memset( &xNetworkBuffer2, 0, sizeof( NetworkBufferDescriptor_t ) );
214
215 pxNetworkBuffer->pucEthernetBuffer = NULL;
216
217 pxNetworkBuffer->xDataLength = uxNewLength;
218 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = 0xABCDEF56;
219 pxNetworkBuffer->usPort = 0x1234;
220 pxNetworkBuffer->usBoundPort = 0xFFAA;
221
222 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNewLength, 0, pxNetworkBuffer );
223 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
224
225 catch_assert( pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, uxNewLength ) );
226 }
227
228 /**
229 * @brief test_pxDuplicateNetworkBufferWithDescriptor_IPv6
230 * To validate if pxDuplicateNetworkBufferWithDescriptor returns a network buffer
231 * for IPv6 packet.
232 */
test_pxDuplicateNetworkBufferWithDescriptor_IPv6(void)233 void test_pxDuplicateNetworkBufferWithDescriptor_IPv6( void )
234 {
235 NetworkBufferDescriptor_t * pxReturn;
236 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
237 size_t uxNewLength = ipconfigTCP_MSS;
238 uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
239 uint8_t ucEthBuffer2[ ipconfigTCP_MSS ];
240 IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
241
242 pxNetworkBuffer = &xNetworkBuffer;
243 memset( &xNetworkBuffer2, 0, sizeof( NetworkBufferDescriptor_t ) );
244
245 pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
246 memset( ucEthBuffer, 0xAB, ipconfigTCP_MSS );
247 xNetworkBuffer2.pucEthernetBuffer = ucEthBuffer2;
248 memset( ucEthBuffer2, 0x00, ipconfigTCP_MSS );
249
250 pxNetworkBuffer->xDataLength = uxNewLength;
251 memcpy( pxNetworkBuffer->xIPAddress.xIP_IPv6.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
252 pxNetworkBuffer->usPort = 0x1234;
253 pxNetworkBuffer->usBoundPort = 0xFFAA;
254
255 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( uxNewLength, 0, &xNetworkBuffer2 );
256 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv6_HEADER );
257
258 pxReturn = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, uxNewLength );
259
260 TEST_ASSERT_EQUAL( &xNetworkBuffer2, pxReturn );
261 TEST_ASSERT_EQUAL( xNetworkBuffer2.xDataLength, uxNewLength );
262 TEST_ASSERT_EQUAL_MEMORY( &xIPv6Address, &pxNetworkBuffer->xIPAddress.xIP_IPv6, ipSIZE_OF_IPv6_ADDRESS );
263 TEST_ASSERT_EQUAL( xNetworkBuffer2.usPort, pxNetworkBuffer->usPort );
264 TEST_ASSERT_EQUAL( xNetworkBuffer2.usBoundPort, pxNetworkBuffer->usBoundPort );
265 TEST_ASSERT_EQUAL_MEMORY( pxNetworkBuffer->pucEthernetBuffer, xNetworkBuffer2.pucEthernetBuffer, pxNetworkBuffer->xDataLength );
266 }
267
268 /**
269 * @brief test_prvPacketBuffer_to_NetworkBuffer_NULLParam
270 * To validate if prvPacketBuffer_to_NetworkBuffer returns NULL
271 * when input buffer pointer is NULL.
272 */
test_prvPacketBuffer_to_NetworkBuffer_NULLParam(void)273 void test_prvPacketBuffer_to_NetworkBuffer_NULLParam( void )
274 {
275 NetworkBufferDescriptor_t * pxNetworkBuffer;
276 const void * pvBuffer = NULL;
277 size_t uxOffset;
278
279 pxNetworkBuffer = prvPacketBuffer_to_NetworkBuffer( pvBuffer, uxOffset );
280
281 TEST_ASSERT_EQUAL( NULL, pxNetworkBuffer );
282 }
283
284 /**
285 * @brief test_prvPacketBuffer_to_NetworkBuffer_Unalligned
286 * To validate if prvPacketBuffer_to_NetworkBuffer returns NULL when byte not aligned.
287 */
test_prvPacketBuffer_to_NetworkBuffer_Unalligned(void)288 void test_prvPacketBuffer_to_NetworkBuffer_Unalligned( void )
289 {
290 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetBufferToReturn;
291 const void * pvBuffer;
292 size_t uxOffset = 12;
293 uint8_t ucEthBuf[ ipconfigTCP_MSS ];
294 uintptr_t uxAddrOfNetBuffer = ( uintptr_t ) &xNetBufferToReturn;
295
296 memcpy( ucEthBuf, &uxAddrOfNetBuffer, sizeof( uintptr_t ) );
297 pvBuffer = ( const void * ) ( uxAddrOfNetBuffer + uxOffset + ipBUFFER_PADDING + 1 );
298
299 pxNetworkBuffer = prvPacketBuffer_to_NetworkBuffer( pvBuffer, uxOffset );
300
301 TEST_ASSERT_EQUAL( NULL, pxNetworkBuffer );
302 }
303
304 /**
305 * @brief test_prvPacketBuffer_to_NetworkBuffer_Unalligned
306 * To validate if prvPacketBuffer_to_NetworkBuffer moves offset&padding correctly.
307 */
test_prvPacketBuffer_to_NetworkBuffer_Alligned(void)308 void test_prvPacketBuffer_to_NetworkBuffer_Alligned( void )
309 {
310 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetBufferToReturn;
311 const void * pvBuffer;
312 size_t uxOffset = 20;
313 uint8_t ucEthBuf[ ipBUFFER_PADDING + ipconfigTCP_MSS ];
314 NetworkBufferDescriptor_t * pxAddrOfNetBuffer = &xNetBufferToReturn;
315
316 pxAddrOfNetBuffer->pucEthernetBuffer = ucEthBuf;
317
318 *( ( NetworkBufferDescriptor_t ** ) pxAddrOfNetBuffer->pucEthernetBuffer ) = pxAddrOfNetBuffer;
319
320 pxAddrOfNetBuffer->pucEthernetBuffer += ( uxOffset + ipBUFFER_PADDING );
321
322 pxNetworkBuffer = prvPacketBuffer_to_NetworkBuffer( pxAddrOfNetBuffer->pucEthernetBuffer, uxOffset );
323
324 TEST_ASSERT_EQUAL_PTR( pxAddrOfNetBuffer, pxNetworkBuffer );
325 }
326
327 /**
328 * @brief test_pxUDPPayloadBuffer_to_NetworkBuffer
329 * To validate if pxUDPPayloadBuffer_to_NetworkBuffer returns correct network buffer pointer
330 * for an IPv4 UDP packet.
331 */
test_pxUDPPayloadBuffer_to_NetworkBuffer(void)332 void test_pxUDPPayloadBuffer_to_NetworkBuffer( void )
333 {
334 NetworkBufferDescriptor_t * pxNetworkBuffer, xNetBufferToReturn;
335 const void * pvBuffer;
336 size_t uxOffset = sizeof( UDPPacket_t );
337 uint8_t ucEthBuf[ ipBUFFER_PADDING + ipconfigTCP_MSS ];
338 uint8_t * pucIPType;
339 NetworkBufferDescriptor_t * pxAddrOfNetBuffer = &xNetBufferToReturn;
340
341 pxAddrOfNetBuffer->pucEthernetBuffer = ucEthBuf;
342
343 *( ( NetworkBufferDescriptor_t ** ) pxAddrOfNetBuffer->pucEthernetBuffer ) = pxAddrOfNetBuffer;
344
345 pxAddrOfNetBuffer->pucEthernetBuffer += ( uxOffset + ipBUFFER_PADDING );
346
347 pucIPType = ( pxAddrOfNetBuffer->pucEthernetBuffer ) - ipUDP_PAYLOAD_IP_TYPE_OFFSET;
348 *pucIPType = ( uint8_t ) ipTYPE_IPv4;
349
350 pxNetworkBuffer = pxUDPPayloadBuffer_to_NetworkBuffer( pxAddrOfNetBuffer->pucEthernetBuffer );
351
352 TEST_ASSERT_EQUAL_PTR( pxAddrOfNetBuffer, pxNetworkBuffer );
353 }
354
355 /**
356 * @brief test_pxUDPPayloadBuffer_to_NetworkBuffer_NullInput
357 * To validate if pxUDPPayloadBuffer_to_NetworkBuffer returns NULL when input is NULL.
358 */
test_pxUDPPayloadBuffer_to_NetworkBuffer_NullInput(void)359 void test_pxUDPPayloadBuffer_to_NetworkBuffer_NullInput( void )
360 {
361 NetworkBufferDescriptor_t * pxNetworkBuffer;
362
363 pxNetworkBuffer = pxUDPPayloadBuffer_to_NetworkBuffer( NULL );
364
365 TEST_ASSERT_EQUAL( NULL, pxNetworkBuffer );
366 }
367
368 /**
369 * @brief test_pxUDPPayloadBuffer_to_NetworkBuffer_UnknownIPType
370 * To validate if pxUDPPayloadBuffer_to_NetworkBuffer triggers assertion when IP type of buffer is unknown.
371 */
test_pxUDPPayloadBuffer_to_NetworkBuffer_UnknownIPType(void)372 void test_pxUDPPayloadBuffer_to_NetworkBuffer_UnknownIPType( void )
373 {
374 NetworkBufferDescriptor_t * pxNetBufferToReturn, xNetBufferToReturn;
375 size_t uxOffset = sizeof( UDPPacket_t );
376 uint8_t ucEthBuf[ ipBUFFER_PADDING + ipconfigTCP_MSS ];
377 uint8_t * pucIPType;
378
379 memset( ucEthBuf, 0, sizeof( ucEthBuf ) );
380 memset( &xNetBufferToReturn, 0, sizeof( xNetBufferToReturn ) );
381
382 pxNetBufferToReturn = &xNetBufferToReturn;
383
384 pxNetBufferToReturn->pucEthernetBuffer = ucEthBuf;
385
386 *( ( NetworkBufferDescriptor_t ** ) pxNetBufferToReturn->pucEthernetBuffer ) = pxNetBufferToReturn;
387
388 pxNetBufferToReturn->pucEthernetBuffer += ( uxOffset + ipBUFFER_PADDING );
389
390 pucIPType = ( pxNetBufferToReturn->pucEthernetBuffer ) - ipUDP_PAYLOAD_IP_TYPE_OFFSET;
391 *pucIPType = 0xFF;
392
393 catch_assert( pxUDPPayloadBuffer_to_NetworkBuffer( pxNetBufferToReturn->pucEthernetBuffer ) );
394 }
395
396 /**
397 * @brief test_pxUDPPayloadBuffer_to_NetworkBuffer_IPv6
398 * To validate if pxUDPPayloadBuffer_to_NetworkBuffer returns correct pointer to the network buffer.
399 */
test_pxUDPPayloadBuffer_to_NetworkBuffer_IPv6(void)400 void test_pxUDPPayloadBuffer_to_NetworkBuffer_IPv6( void )
401 {
402 NetworkBufferDescriptor_t * pxNetBufferToReturn, xNetBufferToReturn;
403 size_t uxOffset = sizeof( UDPPacket_IPv6_t );
404 uint8_t ucEthBuf[ ipBUFFER_PADDING + ipconfigTCP_MSS ];
405 uint8_t * pucIPType;
406 uint8_t * pucPayloadBuffer;
407 NetworkBufferDescriptor_t * pxNetworkBuffer;
408
409 memset( ucEthBuf, 0, sizeof( ucEthBuf ) );
410 memset( &xNetBufferToReturn, 0, sizeof( xNetBufferToReturn ) );
411
412 pxNetBufferToReturn = &xNetBufferToReturn;
413
414 pxNetBufferToReturn->pucEthernetBuffer = ucEthBuf;
415
416 *( ( NetworkBufferDescriptor_t ** ) pxNetBufferToReturn->pucEthernetBuffer ) = pxNetBufferToReturn;
417
418 pucPayloadBuffer = &ucEthBuf[ uxOffset + ipBUFFER_PADDING ];
419
420 pucIPType = pucPayloadBuffer - ipUDP_PAYLOAD_IP_TYPE_OFFSET;
421 *pucIPType = ipTYPE_IPv6;
422
423 pxNetworkBuffer = pxUDPPayloadBuffer_to_NetworkBuffer( pucPayloadBuffer );
424
425 TEST_ASSERT_EQUAL( pxNetBufferToReturn, pxNetworkBuffer );
426 }
427
428 /**
429 * @brief test_xIsCallingFromIPTask_NotCallingFromIPTask
430 * To validate if xIsCallingFromIPTask returns pdFALSE when task handles are different.
431 */
test_xIsCallingFromIPTask_NotCallingFromIPTask(void)432 void test_xIsCallingFromIPTask_NotCallingFromIPTask( void )
433 {
434 BaseType_t xReturn;
435 TaskHandle_t xHandleOfIPTask = ( TaskHandle_t ) 0xAABBCCDD, xHandleOfNotIPTask = ( TaskHandle_t ) 0xAABBCCDE;
436
437 xTaskGetCurrentTaskHandle_ExpectAndReturn( xHandleOfNotIPTask );
438 FreeRTOS_GetIPTaskHandle_ExpectAndReturn( xHandleOfIPTask );
439
440 xReturn = xIsCallingFromIPTask();
441
442 TEST_ASSERT_EQUAL( pdFALSE, xReturn );
443 }
444
445 /**
446 * @brief test_xIsCallingFromIPTask_IsCallingFromIPTask
447 * To validate if xIsCallingFromIPTask returns pdTRUE when task handles are same.
448 */
test_xIsCallingFromIPTask_IsCallingFromIPTask(void)449 void test_xIsCallingFromIPTask_IsCallingFromIPTask( void )
450 {
451 BaseType_t xReturn;
452 TaskHandle_t xHandleOfIPTask = ( TaskHandle_t ) 0xAABBCCDD;
453
454 xTaskGetCurrentTaskHandle_ExpectAndReturn( xHandleOfIPTask );
455 FreeRTOS_GetIPTaskHandle_ExpectAndReturn( xHandleOfIPTask );
456
457 xReturn = xIsCallingFromIPTask();
458
459 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
460 }
461
462 /**
463 * @brief test_prvProcessNetworkDownEvent_Pass
464 * First prvProcessNetworkDownEvent call to validate if network down event reset
465 * endpoint's state. And second prvProcessNetworkDownEvent call to validate if it calls
466 * user's hook.
467 */
test_prvProcessNetworkDownEvent_Pass(void)468 void test_prvProcessNetworkDownEvent_Pass( void )
469 {
470 NetworkInterface_t xInterface;
471 NetworkEndPoint_t xEndPoint = { 0 };
472
473 xCallEventHook = pdFALSE;
474 xInterfaces[ 0 ].pfInitialise = &xNetworkInterfaceInitialise_returnTrue;
475 xEndPoint.bits.bWantDHCP = pdTRUE_UNSIGNED;
476 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
477
478 vIPSetARPTimerEnableState_Expect( pdFALSE );
479
480 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
481 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
482
483 FreeRTOS_ClearARP_ExpectAnyArgs();
484
485 vDHCPProcess_Expect( pdTRUE, &xEndPoint );
486
487 prvProcessNetworkDownEvent( &xInterfaces[ 0 ] );
488
489 /* Run again to trigger a different path in the code. */
490
491 vIPSetARPTimerEnableState_Expect( pdFALSE );
492
493 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
494 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
495
496 vApplicationIPNetworkEventHook_Multi_Expect( eNetworkDown, &xEndPoint );
497
498 FreeRTOS_ClearARP_Expect( &xEndPoint );
499
500 vDHCPProcess_Expect( pdTRUE, &xEndPoint );
501
502 prvProcessNetworkDownEvent( &xInterfaces[ 0 ] );
503 }
504
505 /**
506 * @brief test_prvProcessNetworkDownEvent_Fail
507 * To validate if prvProcessNetworkDownEvent skips hook and DHCP
508 * when bCallDownHook & bWantDHCP are both disabled.
509 */
test_prvProcessNetworkDownEvent_Fail(void)510 void test_prvProcessNetworkDownEvent_Fail( void )
511 {
512 NetworkInterface_t xInterface;
513 NetworkEndPoint_t xEndPoint = { 0 };
514
515 xCallEventHook = pdFALSE;
516 xInterfaces[ 0 ].pfInitialise = &xNetworkInterfaceInitialise_returnTrue;
517 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
518 xEndPoint.bits.bWantDHCP = pdFALSE_UNSIGNED;
519
520 vIPSetARPTimerEnableState_Expect( pdFALSE );
521
522 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
523 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
524
525 FreeRTOS_ClearARP_Expect( &xEndPoint );
526
527 vIPNetworkUpCalls_Expect( &xEndPoint );
528
529 prvProcessNetworkDownEvent( &xInterfaces[ 0 ] );
530 }
531
532 /**
533 * @brief test_prvProcessNetworkDownEvent_NullInterface
534 * To validate if prvProcessNetworkDownEvent triggers assertion when
535 * input interface is NULL pointer.
536 */
test_prvProcessNetworkDownEvent_NullInterface(void)537 void test_prvProcessNetworkDownEvent_NullInterface( void )
538 {
539 catch_assert( prvProcessNetworkDownEvent( NULL ) );
540 }
541
542 /**
543 * @brief test_prvProcessNetworkDownEvent_NullInitialFunction
544 * To validate if prvProcessNetworkDownEvent triggers assertion when
545 * initialize function pointer of input interface is NULL.
546 */
test_prvProcessNetworkDownEvent_NullInitialFunction(void)547 void test_prvProcessNetworkDownEvent_NullInitialFunction( void )
548 {
549 NetworkInterface_t xInterface;
550
551 xInterface.pfInitialise = NULL;
552
553 catch_assert( prvProcessNetworkDownEvent( &xInterface ) );
554 }
555
556 /**
557 * @brief test_prvProcessNetworkDownEvent_InterfaceInitFail
558 * To validate if prvProcessNetworkDownEvent skips the following calls
559 * after interface initialization when it returns false.
560 */
test_prvProcessNetworkDownEvent_InterfaceInitFail(void)561 void test_prvProcessNetworkDownEvent_InterfaceInitFail( void )
562 {
563 NetworkInterface_t xInterface;
564 NetworkEndPoint_t xEndPoint = { 0 };
565
566 xCallEventHook = pdFALSE;
567 xInterface.pfInitialise = &xNetworkInterfaceInitialise_returnFalse;
568 xEndPoint.bits.bWantDHCP = pdTRUE_UNSIGNED;
569 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
570
571 vIPSetARPTimerEnableState_Expect( pdFALSE );
572
573 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
574 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
575
576 FreeRTOS_ClearARP_ExpectAnyArgs();
577
578 prvProcessNetworkDownEvent( &xInterface );
579 }
580
581 /**
582 * @brief test_prvProcessNetworkDownEvent_PassDHCPv6
583 * To validate if prvProcessNetworkDownEvent runs DHCPv6 flow when
584 * the endpoint is configured for it.
585 */
test_prvProcessNetworkDownEvent_PassDHCPv6(void)586 void test_prvProcessNetworkDownEvent_PassDHCPv6( void )
587 {
588 NetworkInterface_t xInterface;
589 NetworkEndPoint_t xEndPoint = { 0 };
590
591 xCallEventHook = pdFALSE;
592 xInterface.pfInitialise = &xNetworkInterfaceInitialise_returnTrue;
593 xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
594 xEndPoint.bits.bWantDHCP = pdTRUE_UNSIGNED;
595 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
596
597 vIPSetARPTimerEnableState_Expect( pdFALSE );
598
599 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
600 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
601
602 FreeRTOS_ClearARP_ExpectAnyArgs();
603
604 vDHCPv6Process_Expect( pdTRUE, &xEndPoint );
605
606 prvProcessNetworkDownEvent( &xInterface );
607 }
608
609 /**
610 * @brief test_prvProcessNetworkDownEvent_PassRA
611 * To validate if prvProcessNetworkDownEvent runs RA flow when
612 * the endpoint is configured for it.
613 */
test_prvProcessNetworkDownEvent_PassRA(void)614 void test_prvProcessNetworkDownEvent_PassRA( void )
615 {
616 NetworkInterface_t xInterface;
617 NetworkEndPoint_t xEndPoint = { 0 };
618
619 xCallEventHook = pdFALSE;
620 xInterface.pfInitialise = &xNetworkInterfaceInitialise_returnTrue;
621 xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
622 xEndPoint.bits.bWantRA = pdTRUE_UNSIGNED;
623 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
624
625 vIPSetARPTimerEnableState_Expect( pdFALSE );
626
627 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
628 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
629
630 FreeRTOS_ClearARP_ExpectAnyArgs();
631
632 vRAProcess_Expect( pdTRUE, &xEndPoint );
633
634 prvProcessNetworkDownEvent( &xInterface );
635 }
636
637 /**
638 * @brief test_prvProcessNetworkDownEvent_PassStaticIP
639 * To validate if prvProcessNetworkDownEvent sets static IP address to endpoint.
640 */
test_prvProcessNetworkDownEvent_PassStaticIP(void)641 void test_prvProcessNetworkDownEvent_PassStaticIP( void )
642 {
643 NetworkInterface_t xInterface;
644 NetworkEndPoint_t xEndPoint = { 0 };
645 IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
646
647 xCallEventHook = pdFALSE;
648 xInterface.pfInitialise = &xNetworkInterfaceInitialise_returnTrue;
649 xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
650 xEndPoint.bits.bWantRA = pdFALSE_UNSIGNED;
651 xEndPoint.bits.bWantDHCP = pdFALSE_UNSIGNED;
652 xEndPoint.bits.bCallDownHook = pdFALSE_UNSIGNED;
653 memcpy( xEndPoint.ipv6_defaults.xIPAddress.ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
654
655 vIPSetARPTimerEnableState_Expect( pdFALSE );
656
657 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
658 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
659
660 FreeRTOS_ClearARP_ExpectAnyArgs();
661
662 vIPNetworkUpCalls_Expect( &xEndPoint );
663
664 prvProcessNetworkDownEvent( &xInterface );
665
666 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, xEndPoint.ipv6_settings.xIPAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
667 }
668
669 /**
670 * @brief test_vPreCheckConfigs_CatchAssertTaskNotReady
671 * To validate if vPreCheckConfigs triggers assertion when IP task is not ready.
672 */
test_vPreCheckConfigs_CatchAssertTaskNotReady(void)673 void test_vPreCheckConfigs_CatchAssertTaskNotReady( void )
674 {
675 xIPIsNetworkTaskReady_ExpectAndReturn( pdTRUE );
676
677 catch_assert( vPreCheckConfigs() );
678 }
679
680 /**
681 * @brief test_vPreCheckConfigs_CatchAssertNonEmptyEventQueue
682 * To validate if vPreCheckConfigs triggers assertion when network event queue is not NULL.
683 */
test_vPreCheckConfigs_CatchAssertNonEmptyEventQueue(void)684 void test_vPreCheckConfigs_CatchAssertNonEmptyEventQueue( void )
685 {
686 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
687 xNetworkEventQueue = ( QueueHandle_t ) 0xAABBCCDD;
688
689 catch_assert( vPreCheckConfigs() );
690 }
691
692 /**
693 * @brief test_vPreCheckConfigs_CatchAssertNonNullTaskHandle
694 * To validate if vPreCheckConfigs triggers assertion when task handle is not NULL.
695 */
test_vPreCheckConfigs_CatchAssertNonNullTaskHandle(void)696 void test_vPreCheckConfigs_CatchAssertNonNullTaskHandle( void )
697 {
698 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
699 xNetworkEventQueue = NULL;
700 FreeRTOS_GetIPTaskHandle_ExpectAndReturn( ( TaskHandle_t ) 0xAABBCCDD );
701
702 catch_assert( vPreCheckConfigs() );
703 }
704
705 /**
706 * @brief test_vPreCheckConfigs
707 * To validate vPreCheckConfigs pass path.
708 */
test_vPreCheckConfigs(void)709 void test_vPreCheckConfigs( void )
710 {
711 xIPIsNetworkTaskReady_ExpectAndReturn( pdFALSE );
712 xNetworkEventQueue = NULL;
713 FreeRTOS_GetIPTaskHandle_ExpectAndReturn( ( TaskHandle_t ) 0x00 );
714
715 vPreCheckConfigs();
716 }
717
718 /**
719 * @brief test_usGenerateProtocolChecksum_UnknownProtocol
720 * To validate usGenerateProtocolChecksum returns ipUNHANDLED_PROTOCOL if no valid protocol in IP header.
721 */
test_usGenerateProtocolChecksum_UnknownProtocol(void)722 void test_usGenerateProtocolChecksum_UnknownProtocol( void )
723 {
724 uint16_t usReturn;
725 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
726 BaseType_t xOutgoingPacket = pdFALSE;
727 uint8_t ucVersionHeaderLength = 20;
728 IPPacket_t * pxIPPacket;
729 uint16_t usLength = 100;
730 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
731 ProtocolPacket_t * pxProtPack;
732
733 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
734
735 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
736 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
737
738 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
739 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
740 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
741
742 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
743
744 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
745
746 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_UnknownProtocol );
747
748 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
749
750 TEST_ASSERT_EQUAL( ipUNHANDLED_PROTOCOL, usReturn );
751 }
752
753 /**
754 * @brief test_usGenerateProtocolChecksum_InvalidLength
755 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if prvChecksumIPv4Checks returns non-zero.
756 */
test_usGenerateProtocolChecksum_InvalidLength(void)757 void test_usGenerateProtocolChecksum_InvalidLength( void )
758 {
759 uint16_t usReturn;
760 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
761 size_t uxBufferLength = sizeof( IPPacket_t ) - 1;
762 BaseType_t xOutgoingPacket;
763
764 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
765 ( ( IPPacket_t * ) pucEthernetBuffer )->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
766
767 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_InvalidLength );
768
769 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
770
771 TEST_ASSERT_EQUAL( usReturn, ipINVALID_LENGTH );
772 }
773
774 /**
775 * @brief test_usGenerateProtocolChecksum_UDPInvalidLength
776 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
777 * length in IP header is less than UDP header size.
778 */
test_usGenerateProtocolChecksum_UDPInvalidLength(void)779 void test_usGenerateProtocolChecksum_UDPInvalidLength( void )
780 {
781 uint16_t usReturn;
782 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
783 BaseType_t xOutgoingPacket = pdFALSE;
784 uint8_t ucVersionHeaderLength = 20;
785 IPPacket_t * pxIPPacket;
786 uint16_t usLength = ucVersionHeaderLength;
787 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER - 1;
788
789 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
790
791 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
792 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
793 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
794 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
795
796 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
797
798 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
799
800 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
801
802 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
803 }
804
805 /**
806 * @brief test_usGenerateProtocolChecksum_UDPWrongCRCIncomingPacket
807 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
808 * UDP checksum is zero and ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS is 0.
809 */
test_usGenerateProtocolChecksum_UDPWrongCRCIncomingPacket(void)810 void test_usGenerateProtocolChecksum_UDPWrongCRCIncomingPacket( void )
811 {
812 uint16_t usReturn;
813 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
814 BaseType_t xOutgoingPacket = pdFALSE;
815 uint8_t ucVersionHeaderLength = 20;
816 IPPacket_t * pxIPPacket;
817 uint16_t usLength = ucVersionHeaderLength + ipSIZE_OF_UDP_HEADER + TEST_UDP_PAYLOAD_LENGTH;
818 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER;
819
820 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
821
822 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
823 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
824 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
825 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
826
827 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
828
829 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
830
831 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
832
833 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
834 }
835
836 /**
837 * @brief test_usGenerateProtocolChecksum_UDPOutgoingPacketLessProtocolLength
838 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
839 * length in IP header is less than UDP header size.
840 */
test_usGenerateProtocolChecksum_UDPOutgoingPacketLessProtocolLength(void)841 void test_usGenerateProtocolChecksum_UDPOutgoingPacketLessProtocolLength( void )
842 {
843 uint16_t usReturn;
844 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
845 BaseType_t xOutgoingPacket = pdTRUE;
846 uint8_t ucVersionHeaderLength = 20;
847 IPPacket_t * pxIPPacket;
848 uint16_t usLength = 10;
849 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER;
850
851 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
852
853 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
854 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
855 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
856 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
857
858 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
859
860 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
861
862 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
863
864 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
865 }
866
867 /**
868 * @brief test_usGenerateProtocolChecksum_UDPNonZeroChecksum
869 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
870 * CRC in UDP header is wrong.
871 */
test_usGenerateProtocolChecksum_UDPNonZeroChecksum(void)872 void test_usGenerateProtocolChecksum_UDPNonZeroChecksum( void )
873 {
874 uint16_t usReturn;
875 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
876 BaseType_t xOutgoingPacket = pdFALSE;
877 uint8_t ucVersionHeaderLength = 20;
878 IPPacket_t * pxIPPacket;
879 uint16_t usLength = ucVersionHeaderLength + ipSIZE_OF_UDP_HEADER + TEST_UDP_PAYLOAD_LENGTH;
880 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER;
881 ProtocolPacket_t * pxProtPack;
882
883 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
884
885 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
886
887 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
888 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
889 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
890 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
891
892 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
893
894 pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0x1234;
895
896 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
897
898 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
899
900 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
901 }
902
903 /**
904 * @brief test_usGenerateProtocolChecksum_UDPCorrectCRCOutgoingPacket
905 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
906 * it's a outgoing packet. And set the checksum to 0xFFFF because the calculated checksum was zero.
907 */
test_usGenerateProtocolChecksum_UDPCorrectCRCOutgoingPacket(void)908 void test_usGenerateProtocolChecksum_UDPCorrectCRCOutgoingPacket( void )
909 {
910 uint16_t usReturn;
911 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
912 BaseType_t xOutgoingPacket = pdTRUE;
913 uint8_t ucVersionHeaderLength = 20;
914 IPPacket_t * pxIPPacket;
915 uint16_t usLength = 100;
916 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
917 ProtocolPacket_t * pxProtPack;
918
919 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
920
921 /* This is the checksum with zeroed out data. Fill it in to make the checksum 0. */
922 *( ( uint32_t * ) &pucEthernetBuffer[ usLength - sizeof( uint32_t ) ] ) = FreeRTOS_htonl( 0xFF9E );
923
924 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
925
926 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
927 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
928 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
929 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
930
931 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
932
933 pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0x00;
934
935 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
936
937 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
938
939 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
940 TEST_ASSERT_EQUAL( 0xFFFF, pxProtPack->xUDPPacket.xUDPHeader.usChecksum );
941 }
942
943 /**
944 * @brief test_usGenerateProtocolChecksum_UDPLessBufferSizeOutgoingPacket
945 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
946 * buffer size is less than minimum requirement.
947 */
test_usGenerateProtocolChecksum_UDPLessBufferSizeOutgoingPacket(void)948 void test_usGenerateProtocolChecksum_UDPLessBufferSizeOutgoingPacket( void )
949 {
950 uint16_t usReturn;
951 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
952 BaseType_t xOutgoingPacket = pdTRUE;
953 uint8_t ucVersionHeaderLength = 20;
954 IPPacket_t * pxIPPacket;
955 uint16_t usLength = 100;
956 size_t uxBufferLength = ipSIZE_OF_ETH_HEADER + ucVersionHeaderLength + ipSIZE_OF_UDP_HEADER - 1;
957 ProtocolPacket_t * pxProtPack;
958
959 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
960
961 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
962
963 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
964 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
965 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
966 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
967
968 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
969
970 pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0x00;
971
972 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
973
974 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
975
976 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
977 }
978
979 /**
980 * @brief test_usGenerateProtocolChecksum_UDPCorrectCRC
981 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
982 * it's a incoming packet.
983 */
test_usGenerateProtocolChecksum_UDPCorrectCRC(void)984 void test_usGenerateProtocolChecksum_UDPCorrectCRC( void )
985 {
986 uint16_t usReturn;
987 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
988 BaseType_t xOutgoingPacket = pdFALSE;
989 uint8_t ucVersionHeaderLength = 20;
990 IPPacket_t * pxIPPacket;
991 uint16_t usLength = 100;
992 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
993 ProtocolPacket_t * pxProtPack;
994
995 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
996
997 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
998
999 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1000 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1001 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1002 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1003
1004 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
1005
1006 pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0x9EFF;
1007
1008 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1009
1010 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1011
1012 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1013 }
1014
1015 /**
1016 * @brief test_usGenerateProtocolChecksum_UDPIncorrectCRC
1017 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1018 * checksum in UDP header is wrong.
1019 */
test_usGenerateProtocolChecksum_UDPIncorrectCRC(void)1020 void test_usGenerateProtocolChecksum_UDPIncorrectCRC( void )
1021 {
1022 uint16_t usReturn;
1023 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1024 BaseType_t xOutgoingPacket = pdFALSE;
1025 uint8_t ucVersionHeaderLength = 20;
1026 IPPacket_t * pxIPPacket;
1027 uint16_t usLength = 100;
1028 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1029 ProtocolPacket_t * pxProtPack;
1030
1031 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1032
1033 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1034
1035 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1036 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1037 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1038 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1039
1040 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_UDP;
1041
1042 pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0x01;
1043
1044 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1045
1046 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1047
1048 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1049 }
1050
1051 /**
1052 * @brief test_usGenerateProtocolChecksum_TCPCorrectCRC
1053 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1054 * checksum in TCP header is correct.
1055 */
test_usGenerateProtocolChecksum_TCPCorrectCRC(void)1056 void test_usGenerateProtocolChecksum_TCPCorrectCRC( void )
1057 {
1058 uint16_t usReturn;
1059 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1060 BaseType_t xOutgoingPacket = pdFALSE;
1061 uint8_t ucVersionHeaderLength = 20;
1062 IPPacket_t * pxIPPacket;
1063 uint16_t usLength = 100;
1064 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1065 ProtocolPacket_t * pxProtPack;
1066
1067 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1068
1069 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1070
1071 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1072 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1073 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1074 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1075
1076 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1077
1078 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1079 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0xA9AF;
1080
1081 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1082
1083 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1084
1085 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1086 }
1087
1088 /**
1089 * @brief test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacket
1090 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC when it
1091 * generates correct CRC in TCP checksum.
1092 */
test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacket(void)1093 void test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacket( void )
1094 {
1095 uint16_t usReturn;
1096 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1097 BaseType_t xOutgoingPacket = pdTRUE;
1098 uint8_t ucVersionHeaderLength = 20;
1099 IPPacket_t * pxIPPacket;
1100 uint16_t usLength = 100;
1101 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1102 ProtocolPacket_t * pxProtPack;
1103
1104 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1105
1106 /* This is the checksum with zeroed out data. Fill it in to make the checksum 0. */
1107 *( ( uint32_t * ) &pucEthernetBuffer[ usLength - sizeof( uint32_t ) ] ) = FreeRTOS_htonl( 0xFFA9 );
1108
1109 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1110
1111 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1112 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1113 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1114 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1115
1116 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1117
1118 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1119 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1120
1121 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1122
1123 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1124
1125 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1126 }
1127
1128 /**
1129 * @brief test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacketZeroChecksum
1130 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1131 * it's a TCP outgoing packet. And the checksum is zero.
1132 */
test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacketZeroChecksum(void)1133 void test_usGenerateProtocolChecksum_TCPCorrectCRCOutgoingPacketZeroChecksum( void )
1134 {
1135 uint16_t usReturn;
1136 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1137 BaseType_t xOutgoingPacket = pdTRUE;
1138 uint8_t ucVersionHeaderLength = 20;
1139 IPPacket_t * pxIPPacket;
1140 uint16_t usLength = 100;
1141 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1142 ProtocolPacket_t * pxProtPack;
1143
1144 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1145
1146 /* This is the checksum with zeroed out data. Fill it in to make the checksum 0. */
1147 *( ( uint32_t * ) &pucEthernetBuffer[ usLength - sizeof( uint32_t ) ] ) = FreeRTOS_htonl( 0xAFA9 );
1148
1149 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1150
1151 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1152 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1153 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1154 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1155
1156 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1157
1158 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1159 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x00;
1160
1161 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1162
1163 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1164
1165 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1166 TEST_ASSERT_EQUAL( 0, pxProtPack->xTCPPacket.xTCPHeader.usChecksum );
1167 }
1168
1169 /**
1170 * @brief test_usGenerateProtocolChecksum_TCPIncorrectCRC_IncomingPacket
1171 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1172 * checksum in TCP header is incorrect.
1173 */
test_usGenerateProtocolChecksum_TCPIncorrectCRC_IncomingPacket(void)1174 void test_usGenerateProtocolChecksum_TCPIncorrectCRC_IncomingPacket( void )
1175 {
1176 uint16_t usReturn;
1177 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1178 BaseType_t xOutgoingPacket = pdFALSE;
1179 uint8_t ucVersionHeaderLength = 20;
1180 IPPacket_t * pxIPPacket;
1181 uint16_t usLength = 100;
1182 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1183 ProtocolPacket_t * pxProtPack;
1184
1185 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1186
1187 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1188
1189 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1190 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1191 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1192 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1193
1194 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1195
1196 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1197 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1198
1199 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1200
1201 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1202
1203 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1204 }
1205
1206 /**
1207 * @brief test_usGenerateProtocolChecksum_TCPLessBufferSize_OutgoingPacket
1208 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1209 * buffer size is less than TCP minimum requirement.
1210 */
test_usGenerateProtocolChecksum_TCPLessBufferSize_OutgoingPacket(void)1211 void test_usGenerateProtocolChecksum_TCPLessBufferSize_OutgoingPacket( void )
1212 {
1213 uint16_t usReturn;
1214 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1215 BaseType_t xOutgoingPacket = pdTRUE;
1216 uint8_t ucVersionHeaderLength = 20;
1217 IPPacket_t * pxIPPacket;
1218 uint16_t usLength = 100;
1219 size_t uxBufferLength = ipSIZE_OF_ETH_HEADER + ucVersionHeaderLength + ipSIZE_OF_TCP_HEADER - 1;
1220 ProtocolPacket_t * pxProtPack;
1221
1222 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1223
1224 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1225
1226 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1227 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1228 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1229 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1230
1231 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1232
1233 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1234 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1235
1236 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1237
1238 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1239
1240 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1241 }
1242
1243 /**
1244 * @brief test_usGenerateProtocolChecksum_TCPLessOffset_OutgoingPacket
1245 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1246 * offset in TCP header is less than minimum requirement.
1247 */
test_usGenerateProtocolChecksum_TCPLessOffset_OutgoingPacket(void)1248 void test_usGenerateProtocolChecksum_TCPLessOffset_OutgoingPacket( void )
1249 {
1250 uint16_t usReturn;
1251 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1252 BaseType_t xOutgoingPacket = pdTRUE;
1253 uint8_t ucVersionHeaderLength = 20;
1254 IPPacket_t * pxIPPacket;
1255 uint16_t usLength = 100;
1256 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1257 ProtocolPacket_t * pxProtPack;
1258
1259 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1260
1261 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1262
1263 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1264 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1265 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1266 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1267
1268 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1269
1270 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x40;
1271 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1272
1273 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1274
1275 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1276
1277 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1278 }
1279
1280 /**
1281 * @brief test_usGenerateProtocolChecksum_TCPLessBufferSize
1282 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1283 * buffer size is less than TCP minimum requirement.
1284 */
test_usGenerateProtocolChecksum_TCPLessBufferSize(void)1285 void test_usGenerateProtocolChecksum_TCPLessBufferSize( void )
1286 {
1287 uint16_t usReturn;
1288 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1289 BaseType_t xOutgoingPacket = pdTRUE;
1290 uint8_t ucVersionHeaderLength = 20;
1291 IPPacket_t * pxIPPacket;
1292 uint16_t usLength = ucVersionHeaderLength + ipSIZE_OF_TCP_HEADER - 1;
1293 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_TCP_HEADER - 1;
1294 ProtocolPacket_t * pxProtPack;
1295
1296 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1297
1298 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1299
1300 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1301 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1302 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1303 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1304
1305 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1306
1307 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1308 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1309
1310 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1311
1312 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1313
1314 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1315 }
1316
1317 /**
1318 * @brief test_usGenerateProtocolChecksum_TCPLessHeaderLength
1319 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1320 * length in IP header is less than TCP minimum requirement.
1321 */
test_usGenerateProtocolChecksum_TCPLessHeaderLength(void)1322 void test_usGenerateProtocolChecksum_TCPLessHeaderLength( void )
1323 {
1324 uint16_t usReturn;
1325 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1326 BaseType_t xOutgoingPacket = pdTRUE;
1327 uint8_t ucVersionHeaderLength = 20;
1328 IPPacket_t * pxIPPacket;
1329 uint16_t usLength = ucVersionHeaderLength;
1330 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_TCP_HEADER;
1331 ProtocolPacket_t * pxProtPack;
1332
1333 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1334
1335 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1336
1337 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1338 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1339 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1340 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1341
1342 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1343
1344 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1345 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1346
1347 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1348
1349 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1350
1351 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1352 }
1353
1354 /**
1355 * @brief test_usGenerateProtocolChecksum_TCPLargeBufferSize
1356 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1357 * buffer size is larger than MTU.
1358 */
test_usGenerateProtocolChecksum_TCPLargeBufferSize(void)1359 void test_usGenerateProtocolChecksum_TCPLargeBufferSize( void )
1360 {
1361 uint16_t usReturn;
1362 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1363 BaseType_t xOutgoingPacket = pdTRUE;
1364 uint8_t ucVersionHeaderLength = 20;
1365 IPPacket_t * pxIPPacket;
1366 uint16_t usLength = ipconfigNETWORK_MTU * 2;
1367 size_t uxBufferLength = ipSIZE_OF_ETH_HEADER + usLength;
1368 ProtocolPacket_t * pxProtPack;
1369
1370 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1371
1372 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1373
1374 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1375 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1376 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1377 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1378
1379 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_TCP;
1380
1381 pxProtPack->xTCPPacket.xTCPHeader.ucTCPOffset = 0x50;
1382 pxProtPack->xTCPPacket.xTCPHeader.usChecksum = 0x0000;
1383
1384 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1385
1386 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1387
1388 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1389 }
1390
1391 /**
1392 * @brief test_usGenerateProtocolChecksum_ICMPLargeBufferSize
1393 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1394 * buffer size is larger than MTU.
1395 */
test_usGenerateProtocolChecksum_ICMPLargeBufferSize(void)1396 void test_usGenerateProtocolChecksum_ICMPLargeBufferSize( void )
1397 {
1398 uint16_t usReturn;
1399 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1400 BaseType_t xOutgoingPacket = pdTRUE;
1401 uint8_t ucVersionHeaderLength = 20;
1402 IPPacket_t * pxIPPacket;
1403 uint16_t usLength = ipconfigNETWORK_MTU * 2;
1404 size_t uxBufferLength = ipSIZE_OF_ETH_HEADER + usLength;
1405 ProtocolPacket_t * pxProtPack;
1406
1407 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1408
1409 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1410
1411 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1412 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1413 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1414 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1415
1416 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
1417
1418 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = 0x0000;
1419
1420 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1421
1422 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1423
1424 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1425 }
1426
1427 /**
1428 * @brief test_usGenerateProtocolChecksum_ICMPLessBufferSize
1429 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1430 * buffer size is less than ICMP minimum requirement.
1431 */
test_usGenerateProtocolChecksum_ICMPLessBufferSize(void)1432 void test_usGenerateProtocolChecksum_ICMPLessBufferSize( void )
1433 {
1434 uint16_t usReturn;
1435 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1436 BaseType_t xOutgoingPacket = pdTRUE;
1437 uint8_t ucVersionHeaderLength = 20;
1438 IPPacket_t * pxIPPacket;
1439 uint16_t usLength = ucVersionHeaderLength + ipSIZE_OF_ICMPv4_HEADER;
1440 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMPv4_HEADER - 1;
1441 ProtocolPacket_t * pxProtPack;
1442
1443 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1444
1445 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1446
1447 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1448 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1449 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1450 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1451
1452 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
1453
1454 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = 0x0000;
1455
1456 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1457
1458 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1459
1460 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1461 }
1462
1463 /**
1464 * @brief test_usGenerateProtocolChecksum_ICMPOutgoingChecksum
1465 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC when it
1466 * generates correct CRC in ICMP checksum.
1467 */
test_usGenerateProtocolChecksum_ICMPOutgoingChecksum(void)1468 void test_usGenerateProtocolChecksum_ICMPOutgoingChecksum( void )
1469 {
1470 uint16_t usReturn;
1471 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1472 BaseType_t xOutgoingPacket = pdTRUE;
1473 uint8_t ucVersionHeaderLength = 20;
1474 IPPacket_t * pxIPPacket;
1475 uint16_t usLength = 100;
1476 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1477 ProtocolPacket_t * pxProtPack;
1478
1479 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1480
1481 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1482
1483 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1484 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1485 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1486 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1487
1488 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
1489
1490 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = 0x0000;
1491
1492 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1493
1494 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1495
1496 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1497 TEST_ASSERT_EQUAL( 65535, pxProtPack->xICMPPacket.xICMPHeader.usChecksum );
1498 }
1499
1500 /**
1501 * @brief test_usGenerateProtocolChecksum_ICMPIncomingIncorrectCRC
1502 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1503 * checksum in ICMP header is incorrect.
1504 */
test_usGenerateProtocolChecksum_ICMPIncomingIncorrectCRC(void)1505 void test_usGenerateProtocolChecksum_ICMPIncomingIncorrectCRC( void )
1506 {
1507 uint16_t usReturn;
1508 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1509 BaseType_t xOutgoingPacket = pdFALSE;
1510 uint8_t ucVersionHeaderLength = 20;
1511 IPPacket_t * pxIPPacket;
1512 uint16_t usLength = 100;
1513 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1514 ProtocolPacket_t * pxProtPack;
1515
1516 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1517
1518 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1519
1520 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1521 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1522 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1523 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1524
1525 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
1526
1527 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = 0x0000;
1528
1529 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1530
1531 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1532
1533 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1534 TEST_ASSERT_EQUAL( 0, pxProtPack->xICMPPacket.xICMPHeader.usChecksum );
1535 }
1536
1537 /**
1538 * @brief test_usGenerateProtocolChecksum_ICMPIncomingCorrectCRC
1539 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1540 * checksum in ICMP header is correct.
1541 */
test_usGenerateProtocolChecksum_ICMPIncomingCorrectCRC(void)1542 void test_usGenerateProtocolChecksum_ICMPIncomingCorrectCRC( void )
1543 {
1544 uint16_t usReturn;
1545 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1546 BaseType_t xOutgoingPacket = pdFALSE;
1547 uint8_t ucVersionHeaderLength = 20;
1548 IPPacket_t * pxIPPacket;
1549 uint16_t usLength = 100;
1550 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1551 ProtocolPacket_t * pxProtPack;
1552
1553 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1554
1555 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1556
1557 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1558 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1559 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1560 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1561
1562 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_ICMP;
1563
1564 /* Fill in the checksum. */
1565 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = FreeRTOS_htons( 0xFFFF );
1566
1567 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1568
1569 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1570
1571 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1572 }
1573
1574 /**
1575 * @brief test_usGenerateProtocolChecksum_IGMPLargeBufferSize
1576 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1577 * buffer size is larger than MTU.
1578 */
test_usGenerateProtocolChecksum_IGMPLargeBufferSize(void)1579 void test_usGenerateProtocolChecksum_IGMPLargeBufferSize( void )
1580 {
1581 uint16_t usReturn;
1582 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1583 BaseType_t xOutgoingPacket = pdTRUE;
1584 uint8_t ucVersionHeaderLength = 20;
1585 IPPacket_t * pxIPPacket;
1586 uint16_t usLength = ipconfigNETWORK_MTU * 2;
1587 size_t uxBufferLength = ipSIZE_OF_ETH_HEADER + usLength;
1588 ProtocolPacket_t * pxProtPack;
1589
1590 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1591
1592 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1593
1594 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1595 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1596 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1597 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1598
1599 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_IGMP;
1600
1601 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1602
1603 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1604
1605 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1606 }
1607
1608 /**
1609 * @brief test_usGenerateProtocolChecksum_IGMPLessBufferSize
1610 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1611 * buffer size is less than IGMP minimum requirement.
1612 */
test_usGenerateProtocolChecksum_IGMPLessBufferSize(void)1613 void test_usGenerateProtocolChecksum_IGMPLessBufferSize( void )
1614 {
1615 uint16_t usReturn;
1616 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1617 BaseType_t xOutgoingPacket = pdTRUE;
1618 uint8_t ucVersionHeaderLength = 20;
1619 IPPacket_t * pxIPPacket;
1620 uint16_t usLength = ucVersionHeaderLength;
1621 size_t uxBufferLength = ucVersionHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMPv4_HEADER - 1;
1622 ProtocolPacket_t * pxProtPack;
1623
1624 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1625
1626 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1627
1628 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1629 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1630 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1631 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1632
1633 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_IGMP;
1634
1635 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1636
1637 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1638
1639 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
1640 }
1641
1642 /**
1643 * @brief test_usGenerateProtocolChecksum_IGMPOutgoingChecksum
1644 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
1645 * buffer size is less than IGMP minimum requirement.
1646 */
test_usGenerateProtocolChecksum_IGMPOutgoingChecksum(void)1647 void test_usGenerateProtocolChecksum_IGMPOutgoingChecksum( void )
1648 {
1649 uint16_t usReturn;
1650 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1651 BaseType_t xOutgoingPacket = pdTRUE;
1652 uint8_t ucVersionHeaderLength = 20;
1653 IPPacket_t * pxIPPacket;
1654 uint16_t usLength = 100;
1655 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1656 ProtocolPacket_t * pxProtPack;
1657
1658 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1659
1660 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1661
1662 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1663 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1664 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1665 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1666
1667 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_IGMP;
1668
1669 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1670
1671 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1672
1673 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1674 TEST_ASSERT_EQUAL( 65535, pxProtPack->xICMPPacket.xICMPHeader.usChecksum );
1675 }
1676
1677 /**
1678 * @brief test_usGenerateProtocolChecksum_IGMPIncomingIncorrectCRC
1679 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1680 * checksum in IGMP header is incorrect.
1681 */
test_usGenerateProtocolChecksum_IGMPIncomingIncorrectCRC(void)1682 void test_usGenerateProtocolChecksum_IGMPIncomingIncorrectCRC( void )
1683 {
1684 uint16_t usReturn;
1685 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1686 BaseType_t xOutgoingPacket = pdFALSE;
1687 uint8_t ucVersionHeaderLength = 20;
1688 IPPacket_t * pxIPPacket;
1689 uint16_t usLength = 100;
1690 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1691 ProtocolPacket_t * pxProtPack;
1692
1693 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1694
1695 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1696
1697 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1698 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1699 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1700 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1701
1702 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_IGMP;
1703 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = 0U;
1704
1705 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1706
1707 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1708
1709 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1710 TEST_ASSERT_EQUAL( 0, pxProtPack->xICMPPacket.xICMPHeader.usChecksum );
1711 }
1712
1713 /**
1714 * @brief test_usGenerateProtocolChecksum_IGMPIncomingCorrectCRC
1715 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1716 * checksum in IGMP header is correct.
1717 */
test_usGenerateProtocolChecksum_IGMPIncomingCorrectCRC(void)1718 void test_usGenerateProtocolChecksum_IGMPIncomingCorrectCRC( void )
1719 {
1720 uint16_t usReturn;
1721 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1722 BaseType_t xOutgoingPacket = pdFALSE;
1723 uint8_t ucVersionHeaderLength = 20;
1724 IPPacket_t * pxIPPacket;
1725 uint16_t usLength = 100;
1726 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1727 ProtocolPacket_t * pxProtPack;
1728
1729 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1730
1731 pxProtPack = ( ProtocolPacket_t * ) &( pucEthernetBuffer[ ucVersionHeaderLength - ipSIZE_OF_IPv4_HEADER ] );
1732
1733 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1734 pxIPPacket->xIPHeader.ucVersionHeaderLength = ( ucVersionHeaderLength >> 2 );
1735 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
1736 pxIPPacket->xIPHeader.usLength = FreeRTOS_htons( usLength );
1737
1738 pxIPPacket->xIPHeader.ucProtocol = ipPROTOCOL_IGMP;
1739
1740 /* Fill in the checksum. */
1741 pxProtPack->xICMPPacket.xICMPHeader.usChecksum = FreeRTOS_htons( 0xFFFF );
1742
1743 prvChecksumIPv4Checks_Stub( prvChecksumIPv4Checks_Valid );
1744
1745 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1746
1747 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1748 }
1749
1750 /**
1751 * @brief test_usGenerateProtocolChecksum_UnknownEthernetType
1752 * To validate usGenerateProtocolChecksum triggers assertion when frame type in
1753 * ethernet header is unknown.
1754 */
test_usGenerateProtocolChecksum_UnknownEthernetType(void)1755 void test_usGenerateProtocolChecksum_UnknownEthernetType( void )
1756 {
1757 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1758 BaseType_t xOutgoingPacket = pdFALSE;
1759 IPPacket_t * pxIPPacket;
1760 ProtocolPacket_t * pxProtPack;
1761
1762 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1763
1764 pxProtPack = ( ProtocolPacket_t * ) pucEthernetBuffer;
1765
1766 pxIPPacket = ( IPPacket_t * ) pucEthernetBuffer;
1767 pxIPPacket->xEthernetHeader.usFrameType = 0xFF;
1768
1769 catch_assert( usGenerateProtocolChecksum( pucEthernetBuffer, ipconfigTCP_MSS, xOutgoingPacket ) );
1770 }
1771
1772 /**
1773 * @brief test_usGenerateProtocolChecksum_ICMPv6IncomingCorrectCRC
1774 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1775 * checksum in ICMPv6 header is correct.
1776 */
test_usGenerateProtocolChecksum_ICMPv6IncomingCorrectCRC(void)1777 void test_usGenerateProtocolChecksum_ICMPv6IncomingCorrectCRC( void )
1778 {
1779 uint16_t usReturn;
1780 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1781 BaseType_t xOutgoingPacket = pdFALSE;
1782 IPPacket_IPv6_t * pxIPPacket;
1783 ICMPPacket_IPv6_t * pxICMPv6Packet;
1784 uint16_t usLength = 100;
1785 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1786
1787 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1788
1789 pxICMPv6Packet = ( ICMPPacket_IPv6_t * ) pucEthernetBuffer;
1790
1791 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1792 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1793
1794 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1795 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_ICMP_IPv6;
1796 pxICMPv6Packet->xICMPHeaderIPv6.usChecksum = 0x89FF;
1797
1798 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1799 prvChecksumICMPv6Checks_Stub( prvChecksumICMPv6Checks_Valid );
1800
1801 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1802
1803 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1804 }
1805
1806 /**
1807 * @brief test_usGenerateProtocolChecksum_ICMPv6IncomingIncorrectCRC
1808 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1809 * checksum in ICMPv6 header is incorrect.
1810 */
test_usGenerateProtocolChecksum_ICMPv6IncomingIncorrectCRC(void)1811 void test_usGenerateProtocolChecksum_ICMPv6IncomingIncorrectCRC( void )
1812 {
1813 uint16_t usReturn;
1814 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1815 BaseType_t xOutgoingPacket = pdFALSE;
1816 IPPacket_IPv6_t * pxIPPacket;
1817 ICMPPacket_IPv6_t * pxICMPv6Packet;
1818 uint16_t usLength = 100;
1819 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1820
1821 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1822
1823 pxICMPv6Packet = ( ICMPPacket_IPv6_t * ) pucEthernetBuffer;
1824
1825 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1826 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1827
1828 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1829 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_ICMP_IPv6;
1830 pxICMPv6Packet->xICMPHeaderIPv6.usChecksum = 0;
1831
1832 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1833 prvChecksumICMPv6Checks_Stub( prvChecksumICMPv6Checks_Valid );
1834
1835 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1836
1837 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1838 TEST_ASSERT_EQUAL( 0, pxICMPv6Packet->xICMPHeaderIPv6.usChecksum );
1839 }
1840
1841 /**
1842 * @brief test_usGenerateProtocolChecksum_UDPv6IncomingCorrectCRC
1843 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1844 * checksum in UDPv6 header is correct.
1845 */
test_usGenerateProtocolChecksum_UDPv6IncomingCorrectCRC(void)1846 void test_usGenerateProtocolChecksum_UDPv6IncomingCorrectCRC( void )
1847 {
1848 uint16_t usReturn;
1849 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1850 BaseType_t xOutgoingPacket = pdFALSE;
1851 IPPacket_IPv6_t * pxIPPacket;
1852 UDPPacket_IPv6_t * pxUDPv6Packet;
1853 uint16_t usLength = 100;
1854 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1855
1856 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1857
1858 pxUDPv6Packet = ( UDPPacket_IPv6_t * ) pucEthernetBuffer;
1859
1860 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1861 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1862
1863 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1864 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_UDP;
1865 pxUDPv6Packet->xUDPHeader.usChecksum = 0xB2FF;
1866
1867 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1868
1869 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1870
1871 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1872 }
1873
1874 /**
1875 * @brief test_usGenerateProtocolChecksum_UDPv6IncomingIncorrectCRC
1876 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1877 * checksum in UDPv6 header is incorrect.
1878 */
test_usGenerateProtocolChecksum_UDPv6IncomingIncorrectCRC(void)1879 void test_usGenerateProtocolChecksum_UDPv6IncomingIncorrectCRC( void )
1880 {
1881 uint16_t usReturn;
1882 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1883 BaseType_t xOutgoingPacket = pdFALSE;
1884 IPPacket_IPv6_t * pxIPPacket;
1885 UDPPacket_IPv6_t * pxUDPv6Packet;
1886 uint16_t usLength = 100;
1887 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1888
1889 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1890
1891 pxUDPv6Packet = ( UDPPacket_IPv6_t * ) pucEthernetBuffer;
1892
1893 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1894 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1895
1896 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1897 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_UDP;
1898 pxUDPv6Packet->xUDPHeader.usChecksum = 0x1111;
1899
1900 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1901
1902 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1903
1904 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1905 TEST_ASSERT_EQUAL( 0x1111, pxUDPv6Packet->xUDPHeader.usChecksum );
1906 }
1907
1908 /**
1909 * @brief test_usGenerateProtocolChecksum_TCPv6IncomingCorrectCRC
1910 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC if
1911 * checksum in TCPv6 header is correct.
1912 */
test_usGenerateProtocolChecksum_TCPv6IncomingCorrectCRC(void)1913 void test_usGenerateProtocolChecksum_TCPv6IncomingCorrectCRC( void )
1914 {
1915 uint16_t usReturn;
1916 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1917 BaseType_t xOutgoingPacket = pdFALSE;
1918 IPPacket_IPv6_t * pxIPPacket;
1919 TCPPacket_IPv6_t * pxTCPv6Packet;
1920 uint16_t usLength = 100;
1921 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1922
1923 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1924
1925 pxTCPv6Packet = ( TCPPacket_IPv6_t * ) pucEthernetBuffer;
1926
1927 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1928 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1929
1930 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1931 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_TCP;
1932 pxTCPv6Packet->xTCPHeader.ucTCPOffset = 0x50;
1933 pxTCPv6Packet->xTCPHeader.usChecksum = 0xBDAF;
1934
1935 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1936
1937 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1938
1939 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
1940 }
1941
1942 /**
1943 * @brief test_usGenerateProtocolChecksum_TCPv6IncomingIncorrectCRC
1944 * To validate usGenerateProtocolChecksum returns ipWRONG_CRC if
1945 * checksum in UDPv6 header is incorrect.
1946 */
test_usGenerateProtocolChecksum_TCPv6IncomingIncorrectCRC(void)1947 void test_usGenerateProtocolChecksum_TCPv6IncomingIncorrectCRC( void )
1948 {
1949 uint16_t usReturn;
1950 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1951 BaseType_t xOutgoingPacket = pdFALSE;
1952 IPPacket_IPv6_t * pxIPPacket;
1953 TCPPacket_IPv6_t * pxTCPv6Packet;
1954 uint16_t usLength = 100;
1955 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1956
1957 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1958
1959 pxTCPv6Packet = ( TCPPacket_IPv6_t * ) pucEthernetBuffer;
1960
1961 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1962 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1963
1964 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
1965 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_TCP;
1966 pxTCPv6Packet->xTCPHeader.ucTCPOffset = 0x50;
1967 pxTCPv6Packet->xTCPHeader.usChecksum = 0x1111;
1968
1969 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
1970
1971 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
1972
1973 TEST_ASSERT_EQUAL( ipWRONG_CRC, usReturn );
1974 TEST_ASSERT_EQUAL( 0x1111, pxTCPv6Packet->xTCPHeader.usChecksum );
1975 }
1976
1977 /**
1978 * @brief test_usGenerateProtocolChecksum_TCPv6OutgoingCorrectCRC
1979 * To validate usGenerateProtocolChecksum returns ipCORRECT_CRC when it
1980 * generates correct CRC in TCP checksum.
1981 */
test_usGenerateProtocolChecksum_TCPv6OutgoingCorrectCRC(void)1982 void test_usGenerateProtocolChecksum_TCPv6OutgoingCorrectCRC( void )
1983 {
1984 uint16_t usReturn;
1985 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1986 BaseType_t xOutgoingPacket = pdTRUE;
1987 IPPacket_IPv6_t * pxIPPacket;
1988 TCPPacket_IPv6_t * pxTCPv6Packet;
1989 uint16_t usLength = 100;
1990 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
1991
1992 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
1993
1994 pxTCPv6Packet = ( TCPPacket_IPv6_t * ) pucEthernetBuffer;
1995
1996 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
1997 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
1998
1999 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
2000 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_TCP;
2001 pxTCPv6Packet->xTCPHeader.ucTCPOffset = 0x50;
2002
2003 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
2004
2005 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
2006
2007 TEST_ASSERT_EQUAL( ipCORRECT_CRC, usReturn );
2008 }
2009
2010 /**
2011 * @brief test_usGenerateProtocolChecksum_IPv6UnknownProtocol
2012 * To validate usGenerateProtocolChecksum returns ipUNHANDLED_PROTOCOL when
2013 * the protocol is unknown in IPv6 packet.
2014 */
test_usGenerateProtocolChecksum_IPv6UnknownProtocol(void)2015 void test_usGenerateProtocolChecksum_IPv6UnknownProtocol( void )
2016 {
2017 uint16_t usReturn;
2018 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
2019 BaseType_t xOutgoingPacket = pdFALSE;
2020 IPPacket_IPv6_t * pxIPPacket;
2021 TCPPacket_IPv6_t * pxTCPv6Packet;
2022 uint16_t usLength = 100;
2023 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
2024
2025 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
2026
2027 pxTCPv6Packet = ( TCPPacket_IPv6_t * ) pucEthernetBuffer;
2028
2029 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
2030 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2031
2032 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
2033 pxIPPacket->xIPHeader.ucNextHeader = 0xFF;
2034
2035 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
2036
2037 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
2038
2039 TEST_ASSERT_EQUAL( ipUNHANDLED_PROTOCOL, usReturn );
2040 }
2041
2042 /**
2043 * @brief test_usGenerateProtocolChecksum_ICMPv6LessHeaderLength
2044 * To validate usGenerateProtocolChecksum returns ipINVALID_LENGTH if
2045 * remaining bytes in packets is less than header size.
2046 */
test_usGenerateProtocolChecksum_ICMPv6LessHeaderLength(void)2047 void test_usGenerateProtocolChecksum_ICMPv6LessHeaderLength( void )
2048 {
2049 uint16_t usReturn;
2050 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
2051 BaseType_t xOutgoingPacket = pdTRUE;
2052 IPPacket_IPv6_t * pxIPPacket;
2053 ICMPPacket_IPv6_t * pxICMPv6Packet;
2054 uint16_t usLength = 100;
2055 size_t uxBufferLength = usLength + ipSIZE_OF_ETH_HEADER;
2056
2057 memset( pucEthernetBuffer, 0, ipconfigTCP_MSS );
2058
2059 pxICMPv6Packet = ( ICMPPacket_IPv6_t * ) pucEthernetBuffer;
2060
2061 pxIPPacket = ( IPPacket_IPv6_t * ) pucEthernetBuffer;
2062 pxIPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
2063
2064 pxIPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( usLength - ipSIZE_OF_IPv6_HEADER );
2065 pxIPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_ICMP_IPv6;
2066 pxICMPv6Packet->xICMPHeaderIPv6.usChecksum = 0;
2067
2068 prvChecksumIPv6Checks_Stub( prvChecksumIPv6Checks_Valid );
2069 prvChecksumICMPv6Checks_Stub( prvChecksumICMPv6Checks_BigHeaderLength );
2070
2071 usReturn = usGenerateProtocolChecksum( pucEthernetBuffer, uxBufferLength, xOutgoingPacket );
2072
2073 TEST_ASSERT_EQUAL( ipINVALID_LENGTH, usReturn );
2074 }
2075
2076 /**
2077 * @brief test_usGenerateChecksum_UnallignedAccess
2078 * To toggle address that is not aligned in usGenerateChecksum.
2079 */
test_usGenerateChecksum_UnallignedAccess(void)2080 void test_usGenerateChecksum_UnallignedAccess( void )
2081 {
2082 uint16_t usResult;
2083 uint16_t usSum = 0;
2084 uint8_t pucNextData[ ipconfigTCP_MSS ];
2085 size_t uxByteCount = 10;
2086 size_t uxUnalligned = 0;
2087
2088 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2089
2090 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2091 {
2092 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x01U )
2093 {
2094 break;
2095 }
2096 }
2097
2098 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2099
2100 TEST_ASSERT_EQUAL( 0x5A5A, usResult );
2101 }
2102
2103 /**
2104 * @brief test_usGenerateChecksum_OneByteToChecksum
2105 * To toggle address that is not aligned in usGenerateChecksum with one byte length.
2106 */
test_usGenerateChecksum_OneByteToChecksum(void)2107 void test_usGenerateChecksum_OneByteToChecksum( void )
2108 {
2109 uint16_t usResult;
2110 uint16_t usSum = 0;
2111 uint8_t pucNextData[ ipconfigTCP_MSS ];
2112 size_t uxByteCount = 1;
2113 size_t uxUnalligned = 0;
2114
2115 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2116
2117 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2118 {
2119 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x01U )
2120 {
2121 break;
2122 }
2123 }
2124
2125 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2126
2127 TEST_ASSERT_EQUAL( 0xAB00, usResult );
2128 }
2129
2130 /**
2131 * @brief test_usGenerateChecksum_OneByteAllignedButZeroLength
2132 * To validate usGenerateChecksum with one byte align but zero length.
2133 */
test_usGenerateChecksum_OneByteAllignedButZeroLength(void)2134 void test_usGenerateChecksum_OneByteAllignedButZeroLength( void )
2135 {
2136 uint16_t usResult;
2137 uint16_t usSum = 0;
2138 uint8_t pucNextData[ ipconfigTCP_MSS ];
2139 size_t uxByteCount = 0;
2140 size_t uxUnalligned = 0;
2141
2142 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2143
2144 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2145 {
2146 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x01U )
2147 {
2148 break;
2149 }
2150 }
2151
2152 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2153
2154 TEST_ASSERT_EQUAL( 0, usResult );
2155 }
2156
2157 /**
2158 * @brief test_usGenerateChecksum_TwoByteAlligned
2159 * To validate usGenerateChecksum with two byte align and 1 length.
2160 */
test_usGenerateChecksum_TwoByteAlligned(void)2161 void test_usGenerateChecksum_TwoByteAlligned( void )
2162 {
2163 uint16_t usResult;
2164 uint16_t usSum = 0;
2165 uint8_t pucNextData[ ipconfigTCP_MSS ];
2166 size_t uxByteCount = 1;
2167 size_t uxUnalligned = 0;
2168
2169 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2170
2171 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2172 {
2173 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x02U )
2174 {
2175 break;
2176 }
2177 }
2178
2179 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2180
2181 TEST_ASSERT_EQUAL( 43776, usResult );
2182 }
2183
2184 /**
2185 * @brief test_usGenerateChecksum_TwoByteAllignedTwoLength
2186 * To validate usGenerateChecksum with two byte align and 2 length.
2187 */
test_usGenerateChecksum_TwoByteAllignedTwoLength(void)2188 void test_usGenerateChecksum_TwoByteAllignedTwoLength( void )
2189 {
2190 uint16_t usResult;
2191 uint16_t usSum = 0;
2192 uint8_t pucNextData[ ipconfigTCP_MSS ];
2193 size_t uxByteCount = 2;
2194 size_t uxUnalligned = 0;
2195
2196 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2197
2198 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2199 {
2200 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x02U )
2201 {
2202 break;
2203 }
2204 }
2205
2206 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2207
2208 TEST_ASSERT_EQUAL( 43947, usResult );
2209 }
2210
2211 /**
2212 * @brief test_usGenerateChecksum_FourByteAlligned
2213 * To validate usGenerateChecksum with four byte align and 2 length.
2214 */
test_usGenerateChecksum_FourByteAlligned(void)2215 void test_usGenerateChecksum_FourByteAlligned( void )
2216 {
2217 uint16_t usResult;
2218 uint16_t usSum = 0;
2219 uint8_t pucNextData[ ipconfigTCP_MSS ];
2220 size_t uxByteCount = 2;
2221 size_t uxUnalligned = 0;
2222
2223 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2224
2225 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2226 {
2227 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x04U )
2228 {
2229 break;
2230 }
2231 }
2232
2233 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2234
2235 TEST_ASSERT_EQUAL( 43947, usResult );
2236 }
2237
2238 /**
2239 * @brief test_usGenerateChecksum_FourByteAllignedSumOverflow
2240 * To validate usGenerateChecksum with four byte align and sum overflow.
2241 */
test_usGenerateChecksum_FourByteAllignedSumOverflow(void)2242 void test_usGenerateChecksum_FourByteAllignedSumOverflow( void )
2243 {
2244 uint16_t usResult;
2245 uint16_t usSum = FreeRTOS_htons( 0xFFFF - 0xAB );
2246 uint8_t pucNextData[ ipconfigTCP_MSS ];
2247 size_t uxByteCount = 20;
2248 size_t uxUnalligned = 0;
2249
2250 memset( pucNextData, 0xAB, ipconfigTCP_MSS );
2251
2252 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2253 {
2254 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x04U )
2255 {
2256 break;
2257 }
2258 }
2259
2260 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2261
2262 TEST_ASSERT_EQUAL( 2484, usResult );
2263 }
2264
2265 /**
2266 * @brief test_usGenerateChecksum_FourByteAllignedSumOverflow2
2267 * To validate usGenerateChecksum with four byte align and sum overflow.
2268 */
test_usGenerateChecksum_FourByteAllignedSumOverflow2(void)2269 void test_usGenerateChecksum_FourByteAllignedSumOverflow2( void )
2270 {
2271 uint16_t usResult;
2272 uint16_t usSum = FreeRTOS_htons( 0xFFFF - 0xAB );
2273 uint8_t pucNextData[ ipconfigTCP_MSS ];
2274 size_t uxByteCount = 20;
2275 size_t uxUnalligned = 0;
2276
2277 memset( pucNextData, 0xFF, ipconfigTCP_MSS );
2278
2279 for( uxUnalligned = 0; uxUnalligned < 4; uxUnalligned++ )
2280 {
2281 if( ( ( uintptr_t ) &pucNextData[ uxUnalligned ] ) & 0x04U )
2282 {
2283 break;
2284 }
2285 }
2286
2287 usResult = usGenerateChecksum( usSum, &pucNextData[ uxUnalligned ], uxByteCount );
2288
2289 TEST_ASSERT_EQUAL( 21759, usResult );
2290 }
2291
2292 /**
2293 * @brief test_vPrintResourceStats_BufferCountMore
2294 * To validate vPrintResourceStats when minimum free network buffer
2295 * is greater than last record.
2296 */
test_vPrintResourceStats_BufferCountMore(void)2297 void test_vPrintResourceStats_BufferCountMore( void )
2298 {
2299 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS + 2 );
2300 xPortGetMinimumEverFreeHeapSize_ExpectAndReturn( 2 );
2301
2302 vPrintResourceStats();
2303 }
2304
2305 /**
2306 * @brief test_vPrintResourceStats_BufferCountMore
2307 * To validate vPrintResourceStats when minimum free network buffer
2308 * is less than last record.
2309 */
test_vPrintResourceStats_BufferCountLess(void)2310 void test_vPrintResourceStats_BufferCountLess( void )
2311 {
2312 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS - 2 );
2313 xPortGetMinimumEverFreeHeapSize_ExpectAndReturn( 2 );
2314
2315 vPrintResourceStats();
2316 TEST_ASSERT_EQUAL( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS - 2, uxLastMinBufferCount );
2317 }
2318
2319 /**
2320 * @brief test_vPrintResourceStats_LastBuffer_NE_0
2321 * To validate vPrintResourceStats when minimum ever free heap size
2322 * is less than last record.
2323 */
test_vPrintResourceStats_LastBuffer_NE_0(void)2324 void test_vPrintResourceStats_LastBuffer_NE_0( void )
2325 {
2326 uxLastMinBufferCount = ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS;
2327 uxMinLastSize = 10u;
2328
2329 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS - 2 );
2330 xPortGetMinimumEverFreeHeapSize_ExpectAndReturn( 2 );
2331
2332 vPrintResourceStats();
2333
2334 TEST_ASSERT_EQUAL( 2, uxMinLastSize );
2335 }
2336
2337 /**
2338 * @brief test_vPrintResourceStats_LastBuffer_NE_0
2339 * To validate vPrintResourceStats when minimum ever free heap size
2340 * is greater than last record.
2341 */
test_vPrintResourceStats_MinSizeIsBigger(void)2342 void test_vPrintResourceStats_MinSizeIsBigger( void )
2343 {
2344 uxLastMinBufferCount = ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS;
2345 uxMinLastSize = 10u;
2346
2347 uxGetMinimumFreeNetworkBuffers_ExpectAndReturn( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS - 2 );
2348 xPortGetMinimumEverFreeHeapSize_ExpectAndReturn( 1024U * 1025U );
2349
2350 vPrintResourceStats();
2351
2352 TEST_ASSERT_EQUAL( 10, uxMinLastSize );
2353 }
2354
2355 /**
2356 * @brief test_FreeRTOS_strerror_r_Invalid
2357 * To validate FreeRTOS_strerror_r with invalid errno.
2358 */
test_FreeRTOS_strerror_r_Invalid(void)2359 void test_FreeRTOS_strerror_r_Invalid( void )
2360 {
2361 const char * pucResult;
2362 BaseType_t xErrnum = 0;
2363 char pcBuffer[ 100 ];
2364 size_t uxLength = sizeof( pcBuffer );
2365
2366 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2367
2368 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2369
2370 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2371 TEST_ASSERT_EQUAL_STRING( "Errno 0x0", pcBuffer );
2372 }
2373
2374 /**
2375 * @brief test_FreeRTOS_strerror_r_EADDRINUSE
2376 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EADDRINUSE.
2377 */
test_FreeRTOS_strerror_r_EADDRINUSE(void)2378 void test_FreeRTOS_strerror_r_EADDRINUSE( void )
2379 {
2380 const char * pucResult;
2381 BaseType_t xErrnum = pdFREERTOS_ERRNO_EADDRINUSE;
2382 char pcBuffer[ 100 ];
2383 size_t uxLength = sizeof( pcBuffer );
2384
2385 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2386
2387 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2388
2389 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2390 TEST_ASSERT_EQUAL_STRING( "EADDRINUSE", pcBuffer );
2391 }
2392
2393 /**
2394 * @brief test_FreeRTOS_strerror_r_ENOMEM
2395 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ENOMEM.
2396 */
test_FreeRTOS_strerror_r_ENOMEM(void)2397 void test_FreeRTOS_strerror_r_ENOMEM( void )
2398 {
2399 const char * pucResult;
2400 BaseType_t xErrnum = pdFREERTOS_ERRNO_ENOMEM;
2401 char pcBuffer[ 100 ];
2402 size_t uxLength = sizeof( pcBuffer );
2403
2404 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2405
2406 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2407
2408 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2409 TEST_ASSERT_EQUAL_STRING( "ENOMEM", pcBuffer );
2410 }
2411
2412 /**
2413 * @brief test_FreeRTOS_strerror_r_EADDRNOTAVAIL
2414 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EADDRNOTAVAIL.
2415 */
test_FreeRTOS_strerror_r_EADDRNOTAVAIL(void)2416 void test_FreeRTOS_strerror_r_EADDRNOTAVAIL( void )
2417 {
2418 const char * pucResult;
2419 BaseType_t xErrnum = pdFREERTOS_ERRNO_EADDRNOTAVAIL;
2420 char pcBuffer[ 100 ];
2421 size_t uxLength = sizeof( pcBuffer );
2422
2423 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2424
2425 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2426
2427 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2428 TEST_ASSERT_EQUAL_STRING( "EADDRNOTAVAIL", pcBuffer );
2429 }
2430
2431 /**
2432 * @brief test_FreeRTOS_strerror_r_ENOPROTOOPT
2433 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ENOPROTOOPT.
2434 */
test_FreeRTOS_strerror_r_ENOPROTOOPT(void)2435 void test_FreeRTOS_strerror_r_ENOPROTOOPT( void )
2436 {
2437 const char * pucResult;
2438 BaseType_t xErrnum = pdFREERTOS_ERRNO_ENOPROTOOPT;
2439 char pcBuffer[ 100 ];
2440 size_t uxLength = sizeof( pcBuffer );
2441
2442 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2443
2444 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2445
2446 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2447 TEST_ASSERT_EQUAL_STRING( "ENOPROTOOPT", pcBuffer );
2448 }
2449
2450 /**
2451 * @brief test_FreeRTOS_strerror_r_EBADF
2452 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EBADF.
2453 */
test_FreeRTOS_strerror_r_EBADF(void)2454 void test_FreeRTOS_strerror_r_EBADF( void )
2455 {
2456 const char * pucResult;
2457 BaseType_t xErrnum = pdFREERTOS_ERRNO_EBADF;
2458 char pcBuffer[ 100 ];
2459 size_t uxLength = sizeof( pcBuffer );
2460
2461 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2462
2463 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2464
2465 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2466 TEST_ASSERT_EQUAL_STRING( "EBADF", pcBuffer );
2467 }
2468
2469 /**
2470 * @brief test_FreeRTOS_strerror_r_ENOSPC
2471 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ENOSPC.
2472 */
test_FreeRTOS_strerror_r_ENOSPC(void)2473 void test_FreeRTOS_strerror_r_ENOSPC( void )
2474 {
2475 const char * pucResult;
2476 BaseType_t xErrnum = pdFREERTOS_ERRNO_ENOSPC;
2477 char pcBuffer[ 100 ];
2478 size_t uxLength = sizeof( pcBuffer );
2479
2480 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2481
2482 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2483
2484 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2485 TEST_ASSERT_EQUAL_STRING( "ENOSPC", pcBuffer );
2486 }
2487
2488 /**
2489 * @brief test_FreeRTOS_strerror_r_ECANCELED
2490 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ECANCELED.
2491 */
test_FreeRTOS_strerror_r_ECANCELED(void)2492 void test_FreeRTOS_strerror_r_ECANCELED( void )
2493 {
2494 const char * pucResult;
2495 BaseType_t xErrnum = pdFREERTOS_ERRNO_ECANCELED;
2496 char pcBuffer[ 100 ];
2497 size_t uxLength = sizeof( pcBuffer );
2498
2499 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2500
2501 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2502
2503 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2504 TEST_ASSERT_EQUAL_STRING( "ECANCELED", pcBuffer );
2505 }
2506
2507 /**
2508 * @brief test_FreeRTOS_strerror_r_ENOTCONN
2509 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ENOTCONN.
2510 */
test_FreeRTOS_strerror_r_ENOTCONN(void)2511 void test_FreeRTOS_strerror_r_ENOTCONN( void )
2512 {
2513 const char * pucResult;
2514 BaseType_t xErrnum = pdFREERTOS_ERRNO_ENOTCONN;
2515 char pcBuffer[ 100 ];
2516 size_t uxLength = sizeof( pcBuffer );
2517
2518 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2519
2520 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2521
2522 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2523 TEST_ASSERT_EQUAL_STRING( "ENOTCONN", pcBuffer );
2524 }
2525
2526 /**
2527 * @brief test_FreeRTOS_strerror_r_EINPROGRESS
2528 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EINPROGRESS.
2529 */
test_FreeRTOS_strerror_r_EINPROGRESS(void)2530 void test_FreeRTOS_strerror_r_EINPROGRESS( void )
2531 {
2532 const char * pucResult;
2533 BaseType_t xErrnum = pdFREERTOS_ERRNO_EINPROGRESS;
2534 char pcBuffer[ 100 ];
2535 size_t uxLength = sizeof( pcBuffer );
2536
2537 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2538
2539 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2540
2541 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2542 TEST_ASSERT_EQUAL_STRING( "EINPROGRESS", pcBuffer );
2543 }
2544
2545 /**
2546 * @brief test_FreeRTOS_strerror_r_EOPNOTSUPP
2547 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EOPNOTSUPP.
2548 */
test_FreeRTOS_strerror_r_EOPNOTSUPP(void)2549 void test_FreeRTOS_strerror_r_EOPNOTSUPP( void )
2550 {
2551 const char * pucResult;
2552 BaseType_t xErrnum = pdFREERTOS_ERRNO_EOPNOTSUPP;
2553 char pcBuffer[ 100 ];
2554 size_t uxLength = sizeof( pcBuffer );
2555
2556 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2557
2558 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2559
2560 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2561 TEST_ASSERT_EQUAL_STRING( "EOPNOTSUPP", pcBuffer );
2562 }
2563
2564 /**
2565 * @brief test_FreeRTOS_strerror_r_EINTR
2566 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EINTR.
2567 */
test_FreeRTOS_strerror_r_EINTR(void)2568 void test_FreeRTOS_strerror_r_EINTR( void )
2569 {
2570 const char * pucResult;
2571 BaseType_t xErrnum = pdFREERTOS_ERRNO_EINTR;
2572 char pcBuffer[ 100 ];
2573 size_t uxLength = sizeof( pcBuffer );
2574
2575 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2576
2577 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2578
2579 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2580 TEST_ASSERT_EQUAL_STRING( "EINTR", pcBuffer );
2581 }
2582
2583 /**
2584 * @brief test_FreeRTOS_strerror_r_ETIMEDOUT
2585 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_ETIMEDOUT.
2586 */
test_FreeRTOS_strerror_r_ETIMEDOUT(void)2587 void test_FreeRTOS_strerror_r_ETIMEDOUT( void )
2588 {
2589 const char * pucResult;
2590 BaseType_t xErrnum = pdFREERTOS_ERRNO_ETIMEDOUT;
2591 char pcBuffer[ 100 ];
2592 size_t uxLength = sizeof( pcBuffer );
2593
2594 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2595
2596 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2597
2598 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2599 TEST_ASSERT_EQUAL_STRING( "ETIMEDOUT", pcBuffer );
2600 }
2601
2602 /**
2603 * @brief test_FreeRTOS_strerror_r_EINVAL
2604 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EINVAL.
2605 */
test_FreeRTOS_strerror_r_EINVAL(void)2606 void test_FreeRTOS_strerror_r_EINVAL( void )
2607 {
2608 const char * pucResult;
2609 BaseType_t xErrnum = pdFREERTOS_ERRNO_EINVAL;
2610 char pcBuffer[ 100 ];
2611 size_t uxLength = sizeof( pcBuffer );
2612
2613 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2614
2615 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2616
2617 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2618 TEST_ASSERT_EQUAL_STRING( "EINVAL", pcBuffer );
2619 }
2620
2621 /**
2622 * @brief test_FreeRTOS_strerror_r_EWOULDBLOCK
2623 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EWOULDBLOCK.
2624 */
test_FreeRTOS_strerror_r_EWOULDBLOCK(void)2625 void test_FreeRTOS_strerror_r_EWOULDBLOCK( void )
2626 {
2627 const char * pucResult;
2628 BaseType_t xErrnum = pdFREERTOS_ERRNO_EWOULDBLOCK;
2629 char pcBuffer[ 100 ];
2630 size_t uxLength = sizeof( pcBuffer );
2631
2632 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2633
2634 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2635
2636 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2637 TEST_ASSERT_EQUAL_STRING( "EWOULDBLOCK", pcBuffer );
2638 }
2639
2640 /**
2641 * @brief test_FreeRTOS_strerror_r_EISCONN
2642 * To validate FreeRTOS_strerror_r with pdFREERTOS_ERRNO_EISCONN.
2643 */
test_FreeRTOS_strerror_r_EISCONN(void)2644 void test_FreeRTOS_strerror_r_EISCONN( void )
2645 {
2646 const char * pucResult;
2647 BaseType_t xErrnum = pdFREERTOS_ERRNO_EISCONN;
2648 char pcBuffer[ 100 ];
2649 size_t uxLength = sizeof( pcBuffer );
2650
2651 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2652
2653 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2654
2655 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2656 TEST_ASSERT_EQUAL_STRING( "EISCONN", pcBuffer );
2657 }
2658
2659 /**
2660 * @brief test_FreeRTOS_strerror_r_ZeroLengthBuffer
2661 * To validate FreeRTOS_strerror_r with zero length buffer.
2662 */
test_FreeRTOS_strerror_r_ZeroLengthBuffer(void)2663 void test_FreeRTOS_strerror_r_ZeroLengthBuffer( void )
2664 {
2665 const char * pucResult;
2666 BaseType_t xErrnum = pdFREERTOS_ERRNO_EISCONN;
2667 char pcBuffer[ 100 ];
2668 size_t uxLength = 0;
2669
2670 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2671
2672 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2673
2674 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2675 TEST_ASSERT_EQUAL_STRING( "", pcBuffer );
2676 }
2677
2678 /**
2679 * @brief test_FreeRTOS_strerror_r_NegativeErrno
2680 * To validate FreeRTOS_strerror_r with negative errno.
2681 */
test_FreeRTOS_strerror_r_NegativeErrno(void)2682 void test_FreeRTOS_strerror_r_NegativeErrno( void )
2683 {
2684 const char * pucResult;
2685 BaseType_t xErrnum = -pdFREERTOS_ERRNO_EISCONN;
2686 char pcBuffer[ 100 ];
2687 size_t uxLength = sizeof( pcBuffer );
2688
2689 memset( pcBuffer, 0, sizeof( pcBuffer ) );
2690
2691 pucResult = FreeRTOS_strerror_r( xErrnum, pcBuffer, uxLength );
2692
2693 TEST_ASSERT_EQUAL( pcBuffer, pucResult );
2694 TEST_ASSERT_EQUAL_STRING( "EISCONN", pcBuffer );
2695 }
2696
2697 /**
2698 * @brief test_FreeRTOS_max_int32
2699 * To validate FreeRTOS_max_int32.
2700 */
test_FreeRTOS_max_int32(void)2701 void test_FreeRTOS_max_int32( void )
2702 {
2703 int32_t lResult;
2704
2705 for( int i = -100; i < 100; i++ )
2706 {
2707 for( int j = -100; j <= i; j++ )
2708 {
2709 lResult = FreeRTOS_max_int32( i, j );
2710 TEST_ASSERT_EQUAL( i, lResult );
2711 }
2712 }
2713
2714 for( int i = ( 0x6FFFFFFF - 100 ); i < ( 0x6FFFFFFF + 100 ); i++ )
2715 {
2716 for( int j = ( 0x6FFFFFFF - 100 ); j <= i; j++ )
2717 {
2718 lResult = FreeRTOS_max_int32( i, j );
2719 TEST_ASSERT_EQUAL( i, lResult );
2720 }
2721 }
2722 }
2723
2724 /**
2725 * @brief test_FreeRTOS_max_uint32
2726 * To validate FreeRTOS_max_uint32.
2727 */
test_FreeRTOS_max_uint32(void)2728 void test_FreeRTOS_max_uint32( void )
2729 {
2730 uint32_t lResult;
2731
2732 for( uint32_t i = 0; i < 100; i++ )
2733 {
2734 for( uint32_t j = 0; j <= i; j++ )
2735 {
2736 lResult = FreeRTOS_max_uint32( i, j );
2737 TEST_ASSERT_EQUAL( i, lResult );
2738 }
2739 }
2740
2741 for( uint32_t i = ( 0xDFFFFFFF - 100 ); i < ( 0xDFFFFFFF + 100 ); i++ )
2742 {
2743 for( uint32_t j = ( 0xDFFFFFFF - 100 ); j <= i; j++ )
2744 {
2745 lResult = FreeRTOS_max_uint32( i, j );
2746 TEST_ASSERT_EQUAL( i, lResult );
2747 }
2748 }
2749 }
2750
2751 /**
2752 * @brief test_FreeRTOS_max_size_t
2753 * To validate FreeRTOS_max_size_t.
2754 */
test_FreeRTOS_max_size_t(void)2755 void test_FreeRTOS_max_size_t( void )
2756 {
2757 uint32_t lResult;
2758
2759 for( uint32_t i = 0; i < 100; i++ )
2760 {
2761 for( uint32_t j = 0; j <= i; j++ )
2762 {
2763 lResult = FreeRTOS_max_size_t( i, j );
2764 TEST_ASSERT_EQUAL( i, lResult );
2765 }
2766 }
2767
2768 for( uint32_t i = ( 0xDFFFFFFF - 100 ); i < ( 0xDFFFFFFF + 100 ); i++ )
2769 {
2770 for( uint32_t j = ( 0xDFFFFFFF - 100 ); j <= i; j++ )
2771 {
2772 lResult = FreeRTOS_max_size_t( i, j );
2773 TEST_ASSERT_EQUAL( i, lResult );
2774 }
2775 }
2776 }
2777
2778 /**
2779 * @brief test_FreeRTOS_min_int32
2780 * To validate FreeRTOS_min_int32.
2781 */
test_FreeRTOS_min_int32(void)2782 void test_FreeRTOS_min_int32( void )
2783 {
2784 int32_t lResult;
2785
2786 for( int i = -100; i < 100; i++ )
2787 {
2788 for( int j = -100; j <= i; j++ )
2789 {
2790 lResult = FreeRTOS_min_int32( i, j );
2791 TEST_ASSERT_EQUAL( j, lResult );
2792 }
2793 }
2794
2795 for( int i = ( 0x6FFFFFFF - 100 ); i < ( 0x6FFFFFFF + 100 ); i++ )
2796 {
2797 for( int j = ( 0x6FFFFFFF - 100 ); j <= i; j++ )
2798 {
2799 lResult = FreeRTOS_min_int32( i, j );
2800 TEST_ASSERT_EQUAL( j, lResult );
2801 }
2802 }
2803 }
2804
2805 /**
2806 * @brief test_FreeRTOS_min_uint32
2807 * To validate FreeRTOS_min_uint32.
2808 */
test_FreeRTOS_min_uint32(void)2809 void test_FreeRTOS_min_uint32( void )
2810 {
2811 uint32_t lResult;
2812
2813 for( uint32_t i = 0; i < 100; i++ )
2814 {
2815 for( uint32_t j = 0; j <= i; j++ )
2816 {
2817 lResult = FreeRTOS_min_uint32( i, j );
2818 TEST_ASSERT_EQUAL( j, lResult );
2819 }
2820 }
2821
2822 for( uint32_t i = ( 0xDFFFFFFF - 100 ); i < ( 0xDFFFFFFF + 100 ); i++ )
2823 {
2824 for( uint32_t j = ( 0xDFFFFFFF - 100 ); j <= i; j++ )
2825 {
2826 lResult = FreeRTOS_min_uint32( i, j );
2827 TEST_ASSERT_EQUAL( j, lResult );
2828 }
2829 }
2830 }
2831
2832 /**
2833 * @brief test_FreeRTOS_min_size_t
2834 * To validate FreeRTOS_min_size_t.
2835 */
test_FreeRTOS_min_size_t(void)2836 void test_FreeRTOS_min_size_t( void )
2837 {
2838 uint32_t lResult;
2839
2840 for( uint32_t i = 0; i < 100; i++ )
2841 {
2842 for( uint32_t j = 0; j <= i; j++ )
2843 {
2844 lResult = FreeRTOS_min_size_t( i, j );
2845 TEST_ASSERT_EQUAL( j, lResult );
2846 }
2847 }
2848
2849 for( uint32_t i = ( 0xDFFFFFFF - 100 ); i < ( 0xDFFFFFFF + 100 ); i++ )
2850 {
2851 for( uint32_t j = ( 0xDFFFFFFF - 100 ); j <= i; j++ )
2852 {
2853 lResult = FreeRTOS_min_size_t( i, j );
2854 TEST_ASSERT_EQUAL( j, lResult );
2855 }
2856 }
2857 }
2858
2859 /**
2860 * @brief test_FreeRTOS_round_up
2861 * To validate FreeRTOS_round_up.
2862 */
test_FreeRTOS_round_up(void)2863 void test_FreeRTOS_round_up( void )
2864 {
2865 uint32_t ulResult;
2866 uint32_t a, d;
2867
2868 a = 0;
2869 d = 0;
2870 catch_assert( FreeRTOS_round_up( a, d ) );
2871
2872 a = 32;
2873 d = 5;
2874 ulResult = FreeRTOS_round_up( a, d );
2875 TEST_ASSERT_EQUAL( 35, ulResult );
2876
2877 a = 0xFFFFFFF7;
2878 d = 3;
2879 ulResult = FreeRTOS_round_up( a, d );
2880 TEST_ASSERT_EQUAL( 0xFFFFFFF9, ulResult );
2881
2882 a = 0x123AB;
2883 d = 7;
2884 ulResult = FreeRTOS_round_up( a, d );
2885 TEST_ASSERT_EQUAL( 0x123AD, ulResult );
2886
2887 a = 0x123AD;
2888 d = 7;
2889 ulResult = FreeRTOS_round_up( a, d );
2890 TEST_ASSERT_EQUAL( 0x123AD, ulResult );
2891 }
2892
2893 /**
2894 * @brief test_FreeRTOS_round_down
2895 * To validate FreeRTOS_round_down.
2896 */
test_FreeRTOS_round_down(void)2897 void test_FreeRTOS_round_down( void )
2898 {
2899 uint32_t ulResult;
2900 uint32_t a, d;
2901
2902 a = 0;
2903 d = 0;
2904 catch_assert( FreeRTOS_round_down( a, d ) );
2905
2906 a = 32;
2907 d = 5;
2908 ulResult = FreeRTOS_round_down( a, d );
2909 TEST_ASSERT_EQUAL( 30, ulResult );
2910
2911 a = 0xFFFFFFF7;
2912 d = 3;
2913 ulResult = FreeRTOS_round_down( a, d );
2914 TEST_ASSERT_EQUAL( 0xFFFFFFF6, ulResult );
2915
2916 a = 0x123AB;
2917 d = 7;
2918 ulResult = FreeRTOS_round_down( a, d );
2919 TEST_ASSERT_EQUAL( 0x123A6, ulResult );
2920
2921 a = 0x123AD;
2922 d = 7;
2923 ulResult = FreeRTOS_round_down( a, d );
2924 TEST_ASSERT_EQUAL( 0x123AD, ulResult );
2925 }
2926
2927 /**
2928 * @brief test_ulChar2u32
2929 * To validate ulChar2u32.
2930 */
test_ulChar2u32(void)2931 void test_ulChar2u32( void )
2932 {
2933 uint32_t ulResult;
2934 uint8_t pucPtr[] = { 0xAA, 0x00, 0x12, 0xEF };
2935
2936 ulResult = ulChar2u32( pucPtr );
2937
2938 TEST_ASSERT_EQUAL_UINT32( 0xAA0012EF, ulResult );
2939 }
2940
2941 /**
2942 * @brief test_usChar2u16
2943 * To validate usChar2u16.
2944 */
test_usChar2u16(void)2945 void test_usChar2u16( void )
2946 {
2947 uint16_t usResult;
2948 uint8_t pucPtr[] = { 0xAA, 0x00, 0x12, 0xEF };
2949
2950 usResult = usChar2u16( pucPtr );
2951
2952 TEST_ASSERT_EQUAL_UINT16( 0xAA00, usResult );
2953
2954 usResult = usChar2u16( &pucPtr[ 2 ] );
2955
2956 TEST_ASSERT_EQUAL_UINT16( 0x12EF, usResult );
2957 }
2958
2959 /**
2960 * @brief test_prvGetChecksumFromPacket_UnhandledProtocol
2961 * To validate prvGetChecksumFromPacket returns ipUNHANDLED_PROTOCOL when
2962 * input set has unknown protocol.
2963 */
test_prvGetChecksumFromPacket_UnhandledProtocol()2964 void test_prvGetChecksumFromPacket_UnhandledProtocol()
2965 {
2966 struct xPacketSummary xSet;
2967 uint16_t usReturn;
2968
2969 memset( &xSet, 0, sizeof( xSet ) );
2970
2971 xSet.ucProtocol = 0xFF;
2972
2973 usReturn = prvGetChecksumFromPacket( &xSet );
2974 TEST_ASSERT_EQUAL( ipUNHANDLED_PROTOCOL, usReturn );
2975 }
2976
2977 /**
2978 * @brief test_prvGetChecksumFromPacket_IPv6UnhandledProtocol
2979 * To validate prvGetChecksumFromPacket returns ipUNHANDLED_PROTOCOL when
2980 * input set has unknown protocol.
2981 */
test_prvGetChecksumFromPacket_IPv6UnhandledProtocol()2982 void test_prvGetChecksumFromPacket_IPv6UnhandledProtocol()
2983 {
2984 struct xPacketSummary xSet;
2985 uint16_t usReturn;
2986
2987 memset( &xSet, 0, sizeof( xSet ) );
2988
2989 xSet.xIsIPv6 = pdTRUE;
2990 xSet.ucProtocol = 0xFF;
2991
2992 usReturn = prvGetChecksumFromPacket( &xSet );
2993 TEST_ASSERT_EQUAL( ipUNHANDLED_PROTOCOL, usReturn );
2994 }
2995
2996 /**
2997 * @brief test_prvSetChecksumInPacket_UnhandledProtocol
2998 * To validate prvSetChecksumInPacket returns ipUNHANDLED_PROTOCOL when
2999 * input set has unknown protocol.
3000 */
test_prvSetChecksumInPacket_UnhandledProtocol()3001 void test_prvSetChecksumInPacket_UnhandledProtocol()
3002 {
3003 struct xPacketSummary xSet;
3004
3005 memset( &xSet, 0, sizeof( xSet ) );
3006
3007 xSet.ucProtocol = 0xFF;
3008
3009 prvSetChecksumInPacket( &xSet, 0 );
3010 }
3011
3012 /**
3013 * @brief test_prvSetChecksumInPacket_IPv6UnhandledProtocol
3014 * To validate prvSetChecksumInPacket returns ipUNHANDLED_PROTOCOL when
3015 * input set has unknown protocol.
3016 */
test_prvSetChecksumInPacket_IPv6UnhandledProtocol()3017 void test_prvSetChecksumInPacket_IPv6UnhandledProtocol()
3018 {
3019 struct xPacketSummary xSet;
3020 uint16_t usReturn;
3021
3022 memset( &xSet, 0, sizeof( xSet ) );
3023
3024 xSet.xIsIPv6 = pdTRUE;
3025 xSet.ucProtocol = 0xFF;
3026
3027 prvSetChecksumInPacket( &xSet, 0 );
3028 }
3029
