espressif/FreeRTOS
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS.git synced 2025-06-22 00:50:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add tests for the length caps within xStreamBufferSend(). (#319)

Browse Source
This commit is contained in:
RichardBarry
2020-10-11 10:27:47 -07:00
committed by GitHub
parent 00247a7637
commit e07d681cc0
3 changed files with 142 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
FreeRTOS/Demo/Common/Minimal/MessageBufferDemo.c
View File

@ -193,6 +193,17 @@ UBaseType_t uxOriginalPriority;
( void ) xExpectedSpace; ( void ) xExpectedSpace;
( void ) xNextLength; ( void ) xNextLength;
/* Try sending more bytes than possible, first using the FromISR version, then
with an infinite block time to ensure this task does not lock up. */
xReturned = xMessageBufferSendFromISR( xMessageBuffer, ( void * ) pucData, mbMESSAGE_BUFFER_LENGTH_BYTES + sizeof( configMESSAGE_BUFFER_LENGTH_TYPE ), NULL );
configASSERT( xReturned == ( size_t ) 0 );
/* In case configASSERT() is not defined. */
( void ) xReturned;
xReturned = xMessageBufferSend( xMessageBuffer, ( void * ) pucData, mbMESSAGE_BUFFER_LENGTH_BYTES + sizeof( configMESSAGE_BUFFER_LENGTH_TYPE ), portMAX_DELAY );
configASSERT( xReturned == ( size_t ) 0 );
/* In case configASSERT() is not defined. */
( void ) xReturned;
/* The buffer is 50 bytes long. When an item is added to the buffer an /* The buffer is 50 bytes long. When an item is added to the buffer an
additional 4 bytes are added to hold the item's size. That means adding additional 4 bytes are added to hold the item's size. That means adding
6 bytes to the buffer will actually add 10 bytes to the buffer. Therefore, 6 bytes to the buffer will actually add 10 bytes to the buffer. Therefore,

148
FreeRTOS/Demo/Common/Minimal/StreamBufferDemo.c
View File

@ -124,6 +124,12 @@ static void prvInterruptTriggerLevelTest( void *pvParameters );
static void prvSenderTask( void *pvParameters ); static void prvSenderTask( void *pvParameters );
static StaticStreamBuffer_t xStaticStreamBuffers[ sbNUMBER_OF_ECHO_CLIENTS ]; static StaticStreamBuffer_t xStaticStreamBuffers[ sbNUMBER_OF_ECHO_CLIENTS ];
/* The +1 is to make the test logic easier as the function that calculates the
free space will return one less than the actual free space - adding a 1 to the
actual length makes it appear to the tests as if the free space is returned as
it might logically be expected. Returning 1 less than the actual free space is
fine as it can never result in an overrun. */
static uint8_t ucBufferStorage[ sbNUMBER_OF_SENDER_TASKS ][ sbSTREAM_BUFFER_LENGTH_BYTES + 1 ]; static uint8_t ucBufferStorage[ sbNUMBER_OF_SENDER_TASKS ][ sbSTREAM_BUFFER_LENGTH_BYTES + 1 ];
static uint32_t ulSenderLoopCounters[ sbNUMBER_OF_SENDER_TASKS ] = { 0 }; static uint32_t ulSenderLoopCounters[ sbNUMBER_OF_SENDER_TASKS ] = { 0 };
#endif /* configSUPPORT_STATIC_ALLOCATION */ #endif /* configSUPPORT_STATIC_ALLOCATION */
@ -221,8 +227,9 @@ static void prvCheckExpectedState( BaseType_t xState )
static void prvSingleTaskTests( StreamBufferHandle_t xStreamBuffer ) static void prvSingleTaskTests( StreamBufferHandle_t xStreamBuffer )
{ {
size_t xReturned, xItem, xExpectedSpace; size_t xReturned, xItem, xExpected, xExpectedSpaces, xExpectedBytes;
const size_t xMax6ByteMessages = sbSTREAM_BUFFER_LENGTH_BYTES / 6; const size_t xMax6ByteMessages = sbSTREAM_BUFFER_LENGTH_BYTES / 6;
const size_t xTrueSize = ( sizeof( ucBufferStorage ) / sbNUMBER_OF_SENDER_TASKS );
const size_t x6ByteLength = 6, x17ByteLength = 17, xFullBufferSize = sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2; const size_t x6ByteLength = 6, x17ByteLength = 17, xFullBufferSize = sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2;
uint8_t *pucFullBuffer, *pucData, *pucReadData; uint8_t *pucFullBuffer, *pucData, *pucReadData;
TickType_t xTimeBeforeCall, xTimeAfterCall; TickType_t xTimeBeforeCall, xTimeAfterCall;
@ -242,14 +249,122 @@ UBaseType_t uxOriginalPriority;
pucReadData = pucData + x17ByteLength; pucReadData = pucData + x17ByteLength;
/* Nothing has been added or removed yet, so expect the free space to be /* Nothing has been added or removed yet, so expect the free space to be
exactly as created. */ exactly as created. Head and tail are both at 0. */
xExpectedSpace = xStreamBufferSpacesAvailable( xStreamBuffer ); xExpectedSpaces = sbSTREAM_BUFFER_LENGTH_BYTES;
prvCheckExpectedState( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES ); xExpectedBytes = 0;
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE ); prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* Add a single item - number of bytes available should go up by one and spaces
available down by one. Head is in front of tail. */
xExpectedSpaces--;
xExpectedBytes++;
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* Now fill the buffer by adding another 29 bytes. Head is 30 tail is at 0. */
xExpectedSpaces -= 29;
xExpectedBytes += 29;
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, ( sbSTREAM_BUFFER_LENGTH_BYTES - 1 ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - 1 ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
/* Should not be able to add another byte now. */
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == ( size_t ) 0 );
/* Remove a byte so the tail pointer moves off 0. Head pointer remains at the
end of the buffer. */
xExpectedSpaces += 1;
xExpectedBytes -= 1;
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* Should be able to add another byte to fill the buffer again now. */
xExpectedSpaces -= 1;
xExpectedBytes += 1;
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
/* Now the head pointer is behind the tail pointer. Read another 29 bytes so
the tail pointer moves to the end of the buffer. */
xExpectedSpaces += 29;
xExpectedBytes -= 29;
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, ( size_t ) 29, ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == ( size_t ) 29 );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* Read out one more byte to wrap the tail back around to the start, to get back
to where we started. */
xExpectedSpaces += 1;
xExpectedBytes -= 1;
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedBytes );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* Try filling the message buffer in one write, blocking indefinitely. Expect to
have written one byte less. */
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, xTrueSize, portMAX_DELAY );
xExpectedSpaces = ( size_t ) 0;
prvCheckExpectedState( xReturned == ( xTrueSize - ( size_t ) 1 ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == xExpectedSpaces );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
/* Empty the buffer again ready for the rest of the tests. Again block
indefinitely to ensure reading more than there can possible be won't lock this
task up, so expect to actually receive one byte less than requested. */
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, xTrueSize, portMAX_DELAY );
prvCheckExpectedState( xReturned == ( xTrueSize - ( size_t ) 1 ) );
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == sbSTREAM_BUFFER_LENGTH_BYTES );
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpected == ( size_t ) 0 );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
/* The buffer is 30 bytes long. 6 5 byte messages should fit before the /* The buffer is 30 bytes long. 6 5 byte messages should fit before the
buffer is completely full. */ buffer is completely full. */
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
for( xItem = 0; xItem < xMax6ByteMessages; xItem++ ) for( xItem = 0; xItem < xMax6ByteMessages; xItem++ )
{ {
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE ); prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
@ -270,16 +385,15 @@ UBaseType_t uxOriginalPriority;
/* The space in the buffer will have reduced by the amount of user data /* The space in the buffer will have reduced by the amount of user data
written into the buffer. */ written into the buffer. */
xExpectedSpace -= x6ByteLength; xExpected -= x6ByteLength;
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer ); xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xReturned == xExpectedSpace ); prvCheckExpectedState( xReturned == xExpected );
xReturned = xStreamBufferBytesAvailable( xStreamBuffer ); xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
/* +1 as it is zero indexed. */ /* +1 as it is zero indexed. */
prvCheckExpectedState( xReturned == ( ( xItem + 1 ) * x6ByteLength ) ); prvCheckExpectedState( xReturned == ( ( xItem + 1 ) * x6ByteLength ) );
} }
/* Now the buffer should be full, and attempting to add anything will should /* Now the buffer should be full, and attempting to add anything should fail. */
fail. */
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE ); prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), sbDONT_BLOCK ); xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), sbDONT_BLOCK );
prvCheckExpectedState( xReturned == 0 ); prvCheckExpectedState( xReturned == 0 );
@ -321,17 +435,17 @@ UBaseType_t uxOriginalPriority;
/* The space in the buffer will have increased by the amount of user /* The space in the buffer will have increased by the amount of user
data removed from the buffer. */ data removed from the buffer. */
xExpectedSpace += x6ByteLength; xExpected += x6ByteLength;
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer ); xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xReturned == xExpectedSpace ); prvCheckExpectedState( xReturned == xExpected );
xReturned = xStreamBufferBytesAvailable( xStreamBuffer ); xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - xExpectedSpace ) ); prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - xExpected ) );
} }
/* The buffer should be empty again. */ /* The buffer should be empty again. */
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE ); prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
xExpectedSpace = xStreamBufferSpacesAvailable( xStreamBuffer ); xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES ); prvCheckExpectedState( xExpected == sbSTREAM_BUFFER_LENGTH_BYTES );
/* Reading with a timeout should also fail after the appropriate time. The /* Reading with a timeout should also fail after the appropriate time. The
priority is temporarily boosted in this part of the test to keep the priority is temporarily boosted in this part of the test to keep the
@ -348,7 +462,7 @@ UBaseType_t uxOriginalPriority;
/* In the next loop 17 bytes are written to then read out on each /* In the next loop 17 bytes are written to then read out on each
iteration. As 30 is not divisible by 17 the data will wrap around. */ iteration. As 30 is not divisible by 17 the data will wrap around. */
xExpectedSpace = sbSTREAM_BUFFER_LENGTH_BYTES - x17ByteLength; xExpected = sbSTREAM_BUFFER_LENGTH_BYTES - x17ByteLength;
for( xItem = 0; xItem < 100; xItem++ ) for( xItem = 0; xItem < 100; xItem++ )
{ {
@ -362,7 +476,7 @@ UBaseType_t uxOriginalPriority;
/* The space in the buffer will have reduced by the amount of user data /* The space in the buffer will have reduced by the amount of user data
written into the buffer. */ written into the buffer. */
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer ); xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
prvCheckExpectedState( xReturned == xExpectedSpace ); prvCheckExpectedState( xReturned == xExpected );
xReturned = xStreamBufferBytesAvailable( xStreamBuffer ); xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
prvCheckExpectedState( xReturned == x17ByteLength ); prvCheckExpectedState( xReturned == x17ByteLength );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE ); prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
@ -430,12 +544,8 @@ UBaseType_t uxOriginalPriority;
/* Try writing more bytes than there is space. */ /* Try writing more bytes than there is space. */
vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 ); vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
xTimeBeforeCall = xTaskGetTickCount();
xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime ); xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime );
xTimeAfterCall = xTaskGetTickCount();
vTaskPrioritySet( NULL, uxOriginalPriority ); vTaskPrioritySet( NULL, uxOriginalPriority );
prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) >= xMinimalBlockTime );
prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) < ( xMinimalBlockTime + xAllowableMargin ) );
prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES ); prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE ); prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE ); prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );

2
FreeRTOS/Source

Submodule FreeRTOS/Source updated: 3604527e3b...44aecd4e10