From: rtel <rtel@1d2547de-c912-0410-9cb9-b8ca96c0e9e2>
Date: Wed, 14 Mar 2018 15:58:47 +0000 (+0000)
Subject: Import the code coverage test additions from the (unpublished) Visual Studio project... 
X-Git-Tag: V10.1.0~31
X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=cd1ad55ff8962389a69bcdcf56f129a017cd6bac;p=freertos

Import the code coverage test additions from the (unpublished) Visual Studio project to the (published) MingW/Eclipse project.
Update the MingW/Eclipse project to add a code coverage build configuration in addition to the existing Debug build configuration.
Update StreamBufferDemo.c so functions are called directly, rather than via configASSERT(), so their code coverage can be measured when configASSERT() is not defined.
In the Win32 port, replace the call to TerminateProcess() in vPortEndScheduler() with exit( 0 ) - which triggers the writing of the code coverage data to the disk.
Fix bug in ucStreamBufferGetStreamBufferType() - which is only used by the Percepio trace tool.
Update the line within vTaskStartScheduler() that was setting xTickCount to 0 to instead set it to configINITIAL_TICK_COUNT.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2534 1d2547de-c912-0410-9cb9-b8ca96c0e9e2
---

diff --git a/FreeRTOS/Demo/Common/Minimal/EventGroupsDemo.c b/FreeRTOS/Demo/Common/Minimal/EventGroupsDemo.c
index 22b7fb81d..abd72e878 100644
--- a/FreeRTOS/Demo/Common/Minimal/EventGroupsDemo.c
+++ b/FreeRTOS/Demo/Common/Minimal/EventGroupsDemo.c
@@ -78,6 +78,7 @@ that synchronise with the xEventGroupSync() function. */
 
 /* A block time of zero simply means "don't block". */
 #define ebDONT_BLOCK	( 0 )
+#define ebONE_TICK		( ( TickType_t ) 1 )
 
 /* A 5ms delay. */
 #define ebSHORT_DELAY	pdMS_TO_TICKS( ( TickType_t ) 5 )
@@ -281,7 +282,29 @@ EventBits_t uxSynchronisationBit, uxReturned;
 		/* Set the bit that indicates this task is at the synchronisation
 		point.  The first time this is done the 'test master' task has a lower
 		priority than this task so this task will get to the sync point before
-		the set bits task. */
+		the set bits task - test this by first calling xEventGroupSync() with
+		a zero block time, and a block time that is too short for the other
+		task, before calling again with a max delay - the first two calls should
+		return before the rendezvous completes, the third only after the
+		rendezvous is complete. */
+		uxReturned = xEventGroupSync( xEventGroup,	/* The event group used for the synchronisation. */
+									  uxSynchronisationBit, /* The bit to set in the event group to indicate this task is at the sync point. */
+									  ebALL_SYNC_BITS,/* The bits to wait for - these bits are set by the other tasks taking part in the sync. */
+									  ebDONT_BLOCK ); /* The maximum time to wait for the sync condition to be met before giving up. */
+
+		/* No block time was specified, so as per the comments above, the
+		rendezvous is not expected to have completed yet. */
+		configASSERT( ( uxReturned & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS );
+
+		uxReturned = xEventGroupSync( xEventGroup,	/* The event group used for the synchronisation. */
+									  uxSynchronisationBit, /* The bit to set in the event group to indicate this task is at the sync point. */
+									  ebALL_SYNC_BITS, /* The bits to wait for - these bits are set by the other tasks taking part in the sync. */
+									  ebONE_TICK ); /* The maximum time to wait for the sync condition to be met before giving up. */
+
+		/* A short block time was specified, so as per the comments above, the
+		rendezvous is not expected to have completed yet. */
+		configASSERT( ( uxReturned & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS );
+
 		uxReturned = xEventGroupSync( xEventGroup,	/* The event group used for the synchronisation. */
 									uxSynchronisationBit, /* The bit to set in the event group to indicate this task is at the sync point. */
 									ebALL_SYNC_BITS,/* The bits to wait for - these bits are set by the other tasks taking part in the sync. */
diff --git a/FreeRTOS/Demo/Common/Minimal/GenQTest.c b/FreeRTOS/Demo/Common/Minimal/GenQTest.c
index 4d146054c..66be41733 100644
--- a/FreeRTOS/Demo/Common/Minimal/GenQTest.c
+++ b/FreeRTOS/Demo/Common/Minimal/GenQTest.c
@@ -433,11 +433,20 @@ QueueHandle_t xQueue;
 		/* The tests in this function are very similar, the slight variations
 		are for code coverage purposes. */
 
-		/* Take the mutex.  It should be available now. */
+		/* Take the mutex.  It should be available now.  Check before and after
+		taking that the holder is reported correctly. */
+		if( xSemaphoreGetMutexHolder( xMutex ) != NULL )
+		{
+			xErrorDetected = pdTRUE;
+		}
 		if( xSemaphoreTake( xMutex, intsemNO_BLOCK ) != pdPASS )
 		{
 			xErrorDetected = pdTRUE;
 		}
+		if( xSemaphoreGetMutexHolder( xMutex ) != xTaskGetCurrentTaskHandle() )
+		{
+			xErrorDetected = pdTRUE;
+		}
 
 		/* This task's priority should be as per that assigned when the task was
 		created. */
@@ -524,8 +533,17 @@ QueueHandle_t xQueue;
 			vTaskDelay( genqSHORT_BLOCK );
 		}
 
-		/* Give the semaphore back ready for the next test. */
+		/* Give the semaphore back ready for the next test.  Check the mutex
+		holder before and after using the "FromISR" version for code coverage. */
+		if( xSemaphoreGetMutexHolderFromISR( xMutex ) != xTaskGetCurrentTaskHandle() )
+		{
+			xErrorDetected = pdTRUE;
+		}
 		xSemaphoreGive( xMutex );
+		if( xSemaphoreGetMutexHolderFromISR( xMutex ) != NULL )
+		{
+			xErrorDetected = pdTRUE;
+		}
 
 		configASSERT( xErrorDetected == pdFALSE );
 
diff --git a/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c b/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
index 013503a7b..dc5c85407 100644
--- a/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
+++ b/FreeRTOS/Demo/Common/Minimal/StaticAllocation.c
@@ -695,8 +695,7 @@ StaticEventGroup_t xEventGroupBuffer;
 	/* Create the event group.  xEventGroupCreateStatic() has an extra parameter
 	than the normal xEventGroupCreate() API function.  The parameter is a
 	pointer to the StaticEventGroup_t structure that will hold the event group
-	structure.  If the parameter is passed as NULL then the structure will be
-	allocated dynamically, just as if xEventGroupCreate() had been called. */
+	structure. */
 	xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
 
 	/* The event group handle should equal the static event group structure
diff --git a/FreeRTOS/Demo/Common/Minimal/StreamBufferDemo.c b/FreeRTOS/Demo/Common/Minimal/StreamBufferDemo.c
index a0cdda6c4..8250b13d9 100644
--- a/FreeRTOS/Demo/Common/Minimal/StreamBufferDemo.c
+++ b/FreeRTOS/Demo/Common/Minimal/StreamBufferDemo.c
@@ -92,6 +92,10 @@ static void prvEchoServer( void *pvParameters );
 static void prvNonBlockingReceiverTask( void *pvParameters );
 static void prvNonBlockingSenderTask( void *pvParameters );
 
+/* Performs an assert() like check in a way that won't get removed when
+performing a code coverage analysis. */
+static void prvCheckExpectedState( BaseType_t xState );
+
 /*
  * A task that creates a stream buffer with a specific trigger level, then
  * receives a string from an interrupt (the RTOS tick hook) byte by byte to
@@ -151,6 +155,10 @@ accidentally read out of the buffer. */
 static const char *pc55ByteString = "One two three four five six seven eight nine ten eleven";
 static const char *pc54ByteString = "01234567891abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQ";
 
+/* Used to log the status of the tests contained within this file for reporting
+to a monitoring task ('check' task). */
+static BaseType_t xErrorStatus = pdPASS;
+
 /*-----------------------------------------------------------*/
 
 void vStartStreamBufferTasks( void )
@@ -188,6 +196,16 @@ StreamBufferHandle_t xStreamBuffer;
 }
 /*-----------------------------------------------------------*/
 
+static void prvCheckExpectedState( BaseType_t xState )
+{
+	configASSERT( xState );
+	if( xState == pdFAIL )
+	{
+		xErrorStatus = pdFAIL;
+	}
+}
+/*-----------------------------------------------------------*/
+
 static void prvSingleTaskTests( StreamBufferHandle_t xStreamBuffer )
 {
 size_t xReturned, xItem, xExpectedSpace;
@@ -213,15 +231,15 @@ UBaseType_t uxOriginalPriority;
 	/* Nothing has been added or removed yet, so expect the free space to be
 	exactly as created. */
 	xExpectedSpace = xStreamBufferSpacesAvailable( xStreamBuffer );
-	configASSERT( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES );
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
 
 
 	/* The buffer is 30 bytes long.  6 5 byte messages should fit before the
 	buffer is completely full. */
 	for( xItem = 0; xItem < xMax6ByteMessages; xItem++ )
 	{
-		configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
+		prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
 
 		/* Generate recognisable data to write to the buffer.  This is just
 		ascii characters that shows which loop iteration the data was written
@@ -235,27 +253,23 @@ UBaseType_t uxOriginalPriority;
 			xReturned = xStreamBufferSendFromISR( xStreamBuffer, ( void * ) pucData, x6ByteLength, NULL );
 		}
 		taskEXIT_CRITICAL();
-		configASSERT( xReturned == x6ByteLength );
-		( void ) xReturned; /* In case configASSERT() is not defined. */
+		prvCheckExpectedState( xReturned == x6ByteLength );
 
 		/* The space in the buffer will have reduced by the amount of user data
 		written into the buffer. */
 		xExpectedSpace -= x6ByteLength;
 		xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
-		configASSERT( xReturned == xExpectedSpace );
-		( void ) xReturned; /* In case configASSERT() is not defined. */
+		prvCheckExpectedState( xReturned == xExpectedSpace );
 		xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
 		/* +1 as it is zero indexed. */
-		configASSERT( xReturned == ( ( xItem + 1 ) * x6ByteLength ) );
-		( void ) xReturned; /* In case configASSERT() is not defined. */
+		prvCheckExpectedState( xReturned == ( ( xItem + 1 ) * x6ByteLength ) );
 	}
 
 	/* Now the buffer should be full, and attempting to add anything will should
 	fail. */
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
 	xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), sbDONT_BLOCK );
-	configASSERT( xReturned == 0 );
-	( void ) xReturned; /* In case configASSERT() is not defined. */
+	prvCheckExpectedState( xReturned == 0 );
 
 	/* Adding with a timeout should also fail after the appropriate time.  The
 	priority is temporarily boosted in this part of the test to keep the
@@ -266,12 +280,9 @@ UBaseType_t uxOriginalPriority;
 	xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), xBlockTime );
 	xTimeAfterCall = xTaskGetTickCount();
 	vTaskPrioritySet( NULL, uxOriginalPriority );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) >= xBlockTime );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) < ( xBlockTime + xAllowableMargin ) );
-	configASSERT( xReturned == 0 ); /* In case configASSERT() is not defined. */
-	( void ) xTimeAfterCall;
-	( void ) xTimeBeforeCall;
-
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) >= xBlockTime );
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) < ( xBlockTime + xAllowableMargin ) );
+	prvCheckExpectedState( xReturned == 0 );
 
 	/* The buffer is now full of data in the form "000000", "111111", etc.  Make
 	sure the data is read out as expected. */
@@ -290,24 +301,24 @@ UBaseType_t uxOriginalPriority;
 			xReturned = xStreamBufferReceiveFromISR( xStreamBuffer, ( void * ) pucReadData, x6ByteLength, NULL );
 		}
 		taskEXIT_CRITICAL();
-		configASSERT( xReturned == x6ByteLength );
+		prvCheckExpectedState( xReturned == x6ByteLength );
 
 		/* Does the data read out match that expected? */
-		configASSERT( memcmp( ( void * ) pucData, ( void * ) pucReadData, x6ByteLength ) == 0 );
+		prvCheckExpectedState( memcmp( ( void * ) pucData, ( void * ) pucReadData, x6ByteLength ) == 0 );
 
 		/* The space in the buffer will have increased by the amount of user
 		data removed from the buffer. */
 		xExpectedSpace += x6ByteLength;
 		xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
-		configASSERT( xReturned == xExpectedSpace );
+		prvCheckExpectedState( xReturned == xExpectedSpace );
 		xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
-		configASSERT( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - xExpectedSpace ) );
+		prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - xExpectedSpace ) );
 	}
 
 	/* The buffer should be empty again. */
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
 	xExpectedSpace = xStreamBufferSpacesAvailable( xStreamBuffer );
-	configASSERT( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( xExpectedSpace == sbSTREAM_BUFFER_LENGTH_BYTES );
 
 	/* 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
@@ -317,9 +328,9 @@ UBaseType_t uxOriginalPriority;
 	xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucReadData, x6ByteLength, xBlockTime );
 	xTimeAfterCall = xTaskGetTickCount();
 	vTaskPrioritySet( NULL, uxOriginalPriority );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) >= xBlockTime );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) < ( xBlockTime + xAllowableMargin ) );
-	configASSERT( xReturned == 0 );
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) >= xBlockTime );
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) < ( xBlockTime + xAllowableMargin ) );
+	prvCheckExpectedState( xReturned == 0 );
 
 
 	/* In the next loop 17 bytes are written to then read out on each
@@ -333,38 +344,38 @@ UBaseType_t uxOriginalPriority;
 		in. */
 		memset( ( void * ) pucData, ( ( int ) '0' ) + ( int ) xItem, x17ByteLength );
 		xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, x17ByteLength, sbDONT_BLOCK );
-		configASSERT( xReturned == x17ByteLength );
+		prvCheckExpectedState( xReturned == x17ByteLength );
 
 		/* The space in the buffer will have reduced by the amount of user data
 		written into the buffer. */
 		xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
-		configASSERT( xReturned == xExpectedSpace );
+		prvCheckExpectedState( xReturned == xExpectedSpace );
 		xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
-		configASSERT( xReturned == x17ByteLength );
-		configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
-		configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
+		prvCheckExpectedState( xReturned == x17ByteLength );
+		prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
+		prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
 
 		/* Read the 17 bytes out again. */
 		xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucReadData, x17ByteLength, sbDONT_BLOCK );
-		configASSERT( xReturned == x17ByteLength );
+		prvCheckExpectedState( xReturned == x17ByteLength );
 
 		/* Does the data read out match that expected? */
-		configASSERT( memcmp( ( void * ) pucData, ( void * ) pucReadData, x17ByteLength ) == 0 );
+		prvCheckExpectedState( memcmp( ( void * ) pucData, ( void * ) pucReadData, x17ByteLength ) == 0 );
 
 		/* Full buffer space available again. */
 		xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
-		configASSERT( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
+		prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
 		xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
-		configASSERT( xReturned == 0 );
-		configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
-		configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
+		prvCheckExpectedState( xReturned == 0 );
+		prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
+		prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
 	}
 
 	/* Fill the buffer with one message, check it is full, then read it back
 	again and check the correct data is received. */
 	xStreamBufferSend( xStreamBuffer, ( const void * ) pc55ByteString, sbSTREAM_BUFFER_LENGTH_BYTES, sbDONT_BLOCK );
 	xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES, sbDONT_BLOCK );
-	configASSERT( memcmp( pc55ByteString, pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
+	prvCheckExpectedState( memcmp( pc55ByteString, pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
 
 	/* Fill the buffer one bytes at a time. */
 	for( xItem = 0; xItem < sbSTREAM_BUFFER_LENGTH_BYTES; xItem++ )
@@ -375,23 +386,23 @@ UBaseType_t uxOriginalPriority;
 	}
 
 	/* The buffer should now be full. */
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
 
 	/* Read the message out in one go, even though it was written in individual
 	bytes.  Try reading much more data than is actually available to ensure only
 	the available bytes are returned (otherwise this read will write outside of
 	the memory allocated anyway!). */
 	xReturned = xStreamBufferReceive( xStreamBuffer, pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, sbRX_TX_BLOCK_TIME );
-	configASSERT( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
-	configASSERT( memcmp( ( const void * ) pc54ByteString, ( const void * ) pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
+	prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( memcmp( ( const void * ) pc54ByteString, ( const void * ) pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
 
 	/* Now do the opposite, write in one go and read out in single bytes. */
 	xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc55ByteString, sbSTREAM_BUFFER_LENGTH_BYTES, sbRX_TX_BLOCK_TIME );
-	configASSERT( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
-	configASSERT( xStreamBufferBytesAvailable( xStreamBuffer ) == sbSTREAM_BUFFER_LENGTH_BYTES );
-	configASSERT( xStreamBufferSpacesAvailable( xStreamBuffer ) == 0 );
+	prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
+	prvCheckExpectedState( xStreamBufferBytesAvailable( xStreamBuffer ) == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( xStreamBufferSpacesAvailable( xStreamBuffer ) == 0 );
 
 	/* Read from the buffer one byte at a time. */
 	for( xItem = 0; xItem < sbSTREAM_BUFFER_LENGTH_BYTES; xItem++ )
@@ -399,10 +410,10 @@ UBaseType_t uxOriginalPriority;
 		/* Block time is only for test coverage, the task should never actually
 		block here. */
 		xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, sizeof( char ), sbRX_TX_BLOCK_TIME );
-		configASSERT( pc55ByteString[ xItem ] == pucFullBuffer[ 0 ] );
+		prvCheckExpectedState( pc55ByteString[ xItem ] == pucFullBuffer[ 0 ] );
 	}
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
 
 	/* Try writing more bytes than there is space. */
 	vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
@@ -410,23 +421,23 @@ UBaseType_t uxOriginalPriority;
 	xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime );
 	xTimeAfterCall = xTaskGetTickCount();
 	vTaskPrioritySet( NULL, uxOriginalPriority );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) >= xMinimalBlockTime );
-	configASSERT( ( xTimeAfterCall - xTimeBeforeCall ) < ( xMinimalBlockTime + xAllowableMargin ) );
-	configASSERT( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) >= xMinimalBlockTime );
+	prvCheckExpectedState( ( xTimeAfterCall - xTimeBeforeCall ) < ( xMinimalBlockTime + xAllowableMargin ) );
+	prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
 
 	/* No space now though. */
 	xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime );
-	configASSERT( xReturned == 0 );
+	prvCheckExpectedState( xReturned == 0 );
 
 	/* Ensure data was written as expected even when there was an attempt to
 	write more than was available.  This also tries to read more bytes than are
 	available. */
 	xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, xFullBufferSize, xMinimalBlockTime );
-	configASSERT( memcmp( ( const void * ) pucFullBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
-	configASSERT( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
-	configASSERT( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
+	prvCheckExpectedState( memcmp( ( const void * ) pucFullBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
+	prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
+	prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
 
 	/* Clean up with data in the buffer to ensure the tests that follow don't
 	see the data (the data should be discarded). */
@@ -458,12 +469,12 @@ const size_t xStringLength = strlen( pc54ByteString );
 
 		/* Attempt to send right up to the end of the string. */
 		xBytesActuallySent = xStreamBufferSend( xStreamBuffer, ( const void * ) &( pc54ByteString[ xNextChar ] ), xBytesToSend, sbDONT_BLOCK );
-		configASSERT( xBytesActuallySent <= xBytesToSend );
+		prvCheckExpectedState( xBytesActuallySent <= xBytesToSend );
 
 		/* Move the index up the string to the next character to be sent,
 		wrapping if the end of the string has been reached. */
 		xNextChar += xBytesActuallySent;
-		configASSERT( xNextChar <= xStringLength );
+		prvCheckExpectedState( xNextChar <= xStringLength );
 
 		if( xNextChar == xStringLength )
 		{
@@ -565,7 +576,7 @@ BaseType_t xNonBlockingReceiveError = pdFALSE;
 
 		/* Make sure a change in priority does not inadvertently result in an
 		invalid array index. */
-		configASSERT( uxIndex < sbNUMBER_OF_ECHO_CLIENTS );
+		prvCheckExpectedState( uxIndex < sbNUMBER_OF_ECHO_CLIENTS );
 
 		/* Avoid compiler warnings about unused parameters. */
 		( void ) pvParameters;
@@ -601,12 +612,12 @@ BaseType_t xNonBlockingReceiveError = pdFALSE;
 
 			/* Attempt to send right up to the end of the string. */
 			xBytesActuallySent = xStreamBufferSend( xStreamBuffer, ( const void * ) &( pc55ByteString[ xNextChar ] ), xBytesToSend, xTicksToWait );
-			configASSERT( xBytesActuallySent <= xBytesToSend );
+			prvCheckExpectedState( xBytesActuallySent <= xBytesToSend );
 
 			/* Move the index up the string to the next character to be sent,
 			wrapping if the end of the string has been reached. */
 			xNextChar += xBytesActuallySent;
-			configASSERT( xNextChar <= xStringLength );
+			prvCheckExpectedState( xNextChar <= xStringLength );
 
 			if( xNextChar == xStringLength )
 			{
@@ -661,7 +672,7 @@ BaseType_t xNonBlockingReceiveError = pdFALSE;
 			} while( xReceivedLength == 0 );
 
 			/* Ensure the received string matches the expected string. */
-			configASSERT( memcmp( ( void * ) cRxString, ( const void * ) &( pc55ByteString[ xNextChar ] ), xReceivedLength ) == 0 );
+			prvCheckExpectedState( memcmp( ( void * ) cRxString, ( const void * ) &( pc55ByteString[ xNextChar ] ), xReceivedLength ) == 0 );
 
 			/* Move the index into the string up to the end of the bytes
 			received so far - wrapping if the end of the string has been
@@ -743,7 +754,7 @@ EchoStreamBuffers_t *pxStreamBuffers = ( EchoStreamBuffers_t * ) pvParameters;
 		memset( pcStringReceived, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
 		xStreamBufferReceive( pxStreamBuffers->xEchoServerBuffer, ( void * ) pcStringReceived, xSendLength, portMAX_DELAY );
 
-		configASSERT( strcmp( pcStringToSend, pcStringReceived ) == 0 );
+		prvCheckExpectedState( strcmp( pcStringToSend, pcStringReceived ) == 0 );
 
 		/* Maintain a count of the number of times this code executes so a
 		check task can determine if this task is still functioning as
@@ -787,9 +798,8 @@ const TickType_t xTicksToBlock = pdMS_TO_TICKS( 350UL );
 	/* Don't expect to receive anything yet! */
 	xTimeOnEntering = xTaskGetTickCount();
 	xReceivedLength = xStreamBufferReceive( xStreamBuffers.xEchoClientBuffer, ( void * ) pcReceivedString, sbSTREAM_BUFFER_LENGTH_BYTES, xTicksToBlock );
-	configASSERT( ( xTaskGetTickCount() - xTimeOnEntering ) >= xTicksToBlock );
-	configASSERT( xReceivedLength == 0 );
-	( void ) xTimeOnEntering;
+	prvCheckExpectedState( ( xTaskGetTickCount() - xTimeOnEntering ) >= xTicksToBlock );
+	prvCheckExpectedState( xReceivedLength == 0 );
 
 	/* Now the stream buffers have been created the echo client task can be
 	created.  If this server task has the higher priority then the client task
@@ -815,7 +825,7 @@ const TickType_t xTicksToBlock = pdMS_TO_TICKS( 350UL );
 		xReceivedLength = xStreamBufferReceive( xStreamBuffers.xEchoClientBuffer, ( void * ) pcReceivedString, sbSTREAM_BUFFER_LENGTH_BYTES, xTicksToBlock );
 
 		/* Should always receive data as a delay was used. */
-		configASSERT( xReceivedLength > 0 );
+		prvCheckExpectedState( xReceivedLength > 0 );
 
 		/* Echo the received data back to the client. */
 		xStreamBufferSend( xStreamBuffers.xEchoServerBuffer, ( void * ) pcReceivedString, xReceivedLength, portMAX_DELAY );
@@ -946,13 +956,13 @@ BaseType_t xAreStreamBufferTasksStillRunning( void )
 static uint32_t ulLastEchoLoopCounters[ sbNUMBER_OF_ECHO_CLIENTS ] = { 0 };
 static uint32_t ulLastNonBlockingRxCounter = 0;
 static uint32_t ulLastInterruptTriggerCounter = 0;
-BaseType_t xReturn = pdPASS, x;
+BaseType_t x;
 
 	for( x = 0; x < sbNUMBER_OF_ECHO_CLIENTS; x++ )
 	{
 		if( ulLastEchoLoopCounters[ x ] == ulEchoLoopCounters[ x ] )
 		{
-			xReturn = pdFAIL;
+			xErrorStatus = pdFAIL;
 		}
 		else
 		{
@@ -962,7 +972,7 @@ BaseType_t xReturn = pdPASS, x;
 
 	if( ulNonBlockingRxCounter == ulLastNonBlockingRxCounter )
 	{
-		xReturn = pdFAIL;
+		xErrorStatus = pdFAIL;
 	}
 	else
 	{
@@ -971,7 +981,7 @@ BaseType_t xReturn = pdPASS, x;
 
 	if( ulLastInterruptTriggerCounter == ulInterruptTriggerCounter )
 	{
-		xReturn = pdFAIL;
+		xErrorStatus = pdFAIL;
 	}
 	else
 	{
@@ -986,7 +996,7 @@ BaseType_t xReturn = pdPASS, x;
 		{
 			if( ulLastSenderLoopCounters[ x ] == ulSenderLoopCounters[ x ] )
 			{
-				xReturn = pdFAIL;
+				xErrorStatus = pdFAIL;
 			}
 			else
 			{
@@ -996,7 +1006,7 @@ BaseType_t xReturn = pdPASS, x;
 	}
 	#endif /* configSUPPORT_STATIC_ALLOCATION */
 
-	return xReturn;
+	return xErrorStatus;
 }
 /*-----------------------------------------------------------*/
 
diff --git a/FreeRTOS/Demo/WIN32-MSVC/.vs/WIN32/v14/.suo b/FreeRTOS/Demo/WIN32-MSVC/.vs/WIN32/v14/.suo
index bb4718846..b50bd108f 100644
Binary files a/FreeRTOS/Demo/WIN32-MSVC/.vs/WIN32/v14/.suo and b/FreeRTOS/Demo/WIN32-MSVC/.vs/WIN32/v14/.suo differ
diff --git a/FreeRTOS/Demo/WIN32-MingW/.cproject b/FreeRTOS/Demo/WIN32-MingW/.cproject
index c2bd401d5..0cc3eaa93 100644
--- a/FreeRTOS/Demo/WIN32-MingW/.cproject
+++ b/FreeRTOS/Demo/WIN32-MingW/.cproject
@@ -42,6 +42,7 @@
 								<option id="gnu.c.compiler.option.debugging.gprof.444112294" name="Generate gprof information (-pg)" superClass="gnu.c.compiler.option.debugging.gprof" useByScannerDiscovery="false" value="false" valueType="boolean"/>
 								<option id="gnu.c.compiler.option.preprocessor.def.symbols.1757027831" name="Defined symbols (-D)" superClass="gnu.c.compiler.option.preprocessor.def.symbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="_WIN32_WINNT=0x0601"/>
+									<listOptionValue builtIn="false" value="projCOVERAGE_TEST=0"/>
 								</option>
 								<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.974248912" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
 							</tool>
@@ -112,6 +113,7 @@
 								<option id="gnu.c.compiler.option.debugging.gprof.1677007018" name="Generate gprof information (-pg)" superClass="gnu.c.compiler.option.debugging.gprof" useByScannerDiscovery="false" value="false" valueType="boolean"/>
 								<option id="gnu.c.compiler.option.preprocessor.def.symbols.175065197" name="Defined symbols (-D)" superClass="gnu.c.compiler.option.preprocessor.def.symbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="_WIN32_WINNT=0x0601"/>
+									<listOptionValue builtIn="false" value="projCOVERAGE_TEST=1"/>
 								</option>
 								<option id="gnu.c.compiler.option.debugging.codecov.1668225592" name="Generate gcov information (-ftest-coverage -fprofile-arcs)" superClass="gnu.c.compiler.option.debugging.codecov" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 								<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.132282928" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
@@ -137,7 +139,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="FreeRTOS+Trace Recorder/streamports" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="FreeRTOS+Trace Recorder|FreeRTOS+Trace Recorder/streamports" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
diff --git a/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h b/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
index b73d97524..f66e45389 100644
--- a/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
+++ b/FreeRTOS/Demo/WIN32-MingW/FreeRTOSConfig.h
@@ -47,7 +47,7 @@
 #define configUSE_DAEMON_TASK_STARTUP_HOOK		1
 #define configTICK_RATE_HZ						( 1000 ) /* In this non-real time simulated environment the tick frequency has to be at least a multiple of the Win32 tick frequency, and therefore very slow. */
 #define configMINIMAL_STACK_SIZE				( ( unsigned short ) 70 ) /* In this simulated case, the stack only has to hold one small structure as the real stack is part of the win32 thread. */
-#define configTOTAL_HEAP_SIZE					( ( size_t ) ( 45 * 1024 ) )
+#define configTOTAL_HEAP_SIZE					( ( size_t ) ( 65 * 1024 ) )
 #define configMAX_TASK_NAME_LEN					( 12 )
 #define configUSE_TRACE_FACILITY				1
 #define configUSE_16_BIT_TICKS					0
@@ -56,7 +56,6 @@
 #define configCHECK_FOR_STACK_OVERFLOW			0
 #define configUSE_RECURSIVE_MUTEXES				1
 #define configQUEUE_REGISTRY_SIZE				20
-#define configUSE_MALLOC_FAILED_HOOK			1
 #define configUSE_APPLICATION_TASK_TAG			1
 #define configUSE_COUNTING_SEMAPHORES			1
 #define configUSE_ALTERNATIVE_API				0
@@ -64,7 +63,10 @@
 #define configUSE_TASK_NOTIFICATIONS			1
 #define configSUPPORT_STATIC_ALLOCATION			1
 
-/* Software timer related configuration options. */
+/* Software timer related configuration options.  The maximum possible task
+priority is configMAX_PRIORITIES - 1.  The priority of the timer task is
+deliberately set higher to ensure it is correctly capped back to
+configMAX_PRIORITIES - 1. */
 #define configUSE_TIMERS						1
 #define configTIMER_TASK_PRIORITY				( configMAX_PRIORITIES - 1 )
 #define configTIMER_QUEUE_LENGTH				20
@@ -80,14 +82,18 @@ void vConfigureTimerForRunTimeStats( void );	/* Prototype of function that initi
 #define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue()
 
 /* Co-routine related configuration options. */
-#define configUSE_CO_ROUTINES 					1
+#define configUSE_CO_ROUTINES 					0
 #define configMAX_CO_ROUTINE_PRIORITIES			( 2 )
 
-/* This demo makes use of one or more example stats formatting functions.  These
+/* This demo can use of one or more example stats formatting functions.  These
 format the raw data provided by the uxTaskGetSystemState() function in to human
 readable ASCII form.  See the notes in the implementation of vTaskList() within
 FreeRTOS/Source/tasks.c for limitations. */
-#define configUSE_STATS_FORMATTING_FUNCTIONS	1
+#define configUSE_STATS_FORMATTING_FUNCTIONS	0
+
+/* Enables the test whereby a stack larger than the total heap size is
+requested. */
+#define configSTACK_DEPTH_TYPE uint32_t
 
 /* Set the following definitions to 1 to include the API function, or zero
 to exclude the API function.  In most cases the linker will remove unused
@@ -116,11 +122,24 @@ functions anyway. */
 #endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */
 
 extern void vAssertCalled( unsigned long ulLine, const char * const pcFileName );
-#define configCOVERAGE_TEST 1
-#if( configCOVERAGE_TEST == 1 )
+
+/* projCOVERAGE_TEST should be defined on the command line so this file can be
+used with multiple project configurations.  If it is
+ */
+#ifndef projCOVERAGE_TEST
+	#error projCOVERAGE_TEST should be defined to 1 or 0 on the command line.
+#endif
+
+#if( projCOVERAGE_TEST == 1 )
 	/* Insert NOPs in empty decision paths to ensure both true and false paths
 	are being tested. */
 	#define mtCOVERAGE_TEST_MARKER() __asm volatile( "NOP" )
+
+	/* Ensure the tick count overflows during the coverage test. */
+	#define configINITIAL_TICK_COUNT 0xffffd800UL
+
+	/* Allows tests of trying to allocate more than the heap has free. */
+	#define configUSE_MALLOC_FAILED_HOOK			0
 #else
 	/* It is a good idea to define configASSERT() while developing.  configASSERT()
 	uses the same semantics as the standard C assert() macro.  Don't define
@@ -128,9 +147,12 @@ extern void vAssertCalled( unsigned long ulLine, const char * const pcFileName )
 	intended to asserts() to fail, some some code is intended not to run if no
 	errors are present. */
 	#define configASSERT( x ) if( ( x ) == 0 ) vAssertCalled( __LINE__, __FILE__ )
+
+	#define configUSE_MALLOC_FAILED_HOOK			1
+
+	/* Include the FreeRTOS+Trace FreeRTOS trace macro definitions. */
+	#include "trcRecorder.h"
 #endif
 
-/* Include the FreeRTOS+Trace FreeRTOS trace macro definitions. */
-#include "trcRecorder.h"
 
 #endif /* FREERTOS_CONFIG_H */
diff --git a/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c b/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c
new file mode 100644
index 000000000..86dc02981
--- /dev/null
+++ b/FreeRTOS/Demo/WIN32-MingW/code_coverage_additions.c
@@ -0,0 +1,594 @@
+/*
+ * FreeRTOS Kernel V10.0.1
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://www.FreeRTOS.org
+ * http://aws.amazon.com/freertos
+ *
+ * 1 tab == 4 spaces!
+ */
+
+/*
+ * Contains sundry tests to exercise code that is not touched by the standard
+ * demo tasks (which are predominantly test tasks).  Some tests are incldued
+ * here because they can only be executed when configASSERT() is not defined.
+ */
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+#include "event_groups.h"
+#include "semphr.h"
+#include "stream_buffer.h"
+#include "message_buffer.h"
+
+/*-----------------------------------------------------------*/
+
+/*
+ * Try creating static objects with one of the mandatory parameters set to NULL.
+ * This can't be done in the standard demos as asserts() will get hit.
+ */
+static BaseType_t prvStaticAllocationsWithNullBuffers( void );
+
+/*
+ * Code coverage analysis is performed with tracing turned off, so this
+ * function executes the trace specific utility functions that would not
+ * otherwise be executed..
+ */
+static BaseType_t prvTraceUtils( void );
+
+/*
+ * The queue peek standard demo does not cover the case where an attempt to peek
+ * times out, so test that case.
+ */
+static BaseType_t prvPeekTimeout( void );
+
+/*
+ * Calls various interrupt safe functions designed to query the state of a
+ * queue.
+ */
+static BaseType_t prvQueueQueryFromISR( void );
+
+/*
+ * Hits a few paths in tasks state and status query functions not otherwise hit
+ * by standard demo and test files.
+ */
+static BaseType_t prvTaskQueryFunctions( void );
+
+/*
+ * None of the standard demo tasks use the task tags - exercise them here.
+ */
+static BaseType_t prvTaskTags( void );
+
+/*
+ * Exercises a few of the query functions that are not otherwise exercised in
+ * the standard demo and test functions.
+ */
+static BaseType_t prvTimerQuery( void );
+
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvStaticAllocationsWithNullBuffers( void )
+{
+uint32_t ulReturned = 0;
+BaseType_t xReturn = pdPASS;
+UBaseType_t uxDummy = 10;
+
+	/* Don't expect to create any of the objects as a NULL parameter is always
+	passed in place of a required buffer.  Hence if all passes then none of the
+	|= will be against 0, and ulReturned will still be zero at the end of this
+	function. */
+	ulReturned |= ( uint32_t ) xEventGroupCreateStatic( NULL );
+
+	/* Try creating a task twice, once with puxStackBuffer NULL, and once with
+	pxTaskBuffer NULL. */
+	ulReturned |= ( uint32_t ) xTaskCreateStatic( NULL, /* Task to run, not needed as the task is not created. */
+											   	  "Dummy", /* Task name. */
+												  configMINIMAL_STACK_SIZE,
+												  NULL,
+												  tskIDLE_PRIORITY,
+												  NULL,
+												  ( StaticTask_t * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
+
+	ulReturned |= ( uint32_t ) xTaskCreateStatic( NULL, /* Task to run, not needed as the task is not created. */
+											   	  "Dummy", /* Task name. */
+												  configMINIMAL_STACK_SIZE,
+												  NULL,
+												  tskIDLE_PRIORITY,
+												  ( StackType_t  * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+												  NULL );
+
+	ulReturned |= ( uint32_t ) xQueueCreateStatic( uxDummy,
+												   uxDummy,
+												   ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+												   NULL );
+
+	/* Try creating a stream buffer twice, once with pucStreamBufferStorageArea
+	set to NULL, and once with pxStaticStreamBuffer set to NULL. */
+	ulReturned |= ( uint32_t ) xStreamBufferCreateStatic( uxDummy,
+														  uxDummy,
+														  NULL,
+														  ( StaticStreamBuffer_t  * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
+
+	ulReturned |= ( uint32_t ) xStreamBufferCreateStatic( uxDummy,
+														  uxDummy,
+														  ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+														  NULL );
+
+	/* Try to create a task with a stack that is too large to be allocated. */
+	if( xTaskCreate( NULL, "TooLarge", configTOTAL_HEAP_SIZE, NULL, tskIDLE_PRIORITY, NULL ) != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY )
+	{
+		xReturn = pdFAIL;
+	}
+
+	if( ulReturned != 0 )
+	{
+		/* Something returned a non-NULL value. */
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvTraceUtils( void )
+{
+EventGroupHandle_t xEventGroup;
+QueueHandle_t xQueue;
+BaseType_t xReturn = pdPASS;
+const UBaseType_t xNumber = ( UBaseType_t ) 100, xQueueLength = ( UBaseType_t ) 1;
+UBaseType_t uxValue;
+TaskHandle_t xTaskHandle;
+StreamBufferHandle_t xStreamBuffer;
+MessageBufferHandle_t xMessageBuffer;
+
+	/* Exercise the event group trace utilities. */
+	xEventGroup = xEventGroupCreate();
+
+	if( xEventGroup != NULL )
+	{
+		vEventGroupSetNumber( xEventGroup, xNumber );
+		if( uxEventGroupGetNumber( NULL ) != 0 )
+		{
+			xReturn = pdFAIL;
+		}
+		if( uxEventGroupGetNumber( xEventGroup ) != xNumber )
+		{
+			xReturn = pdFAIL;
+		}
+
+		vEventGroupDelete( xEventGroup );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Exercise the queue trace utilities. */
+	xQueue = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( uxValue ) );
+	if( xQueue != NULL )
+	{
+		vQueueSetQueueNumber( xQueue, xNumber );
+		if( uxQueueGetQueueNumber( xQueue ) != xNumber )
+		{
+			xReturn = pdFAIL;
+		}
+		if( ucQueueGetQueueType( xQueue ) != queueQUEUE_TYPE_BASE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		vQueueDelete( xQueue );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Exercise the task trace utilities.  Value of 100 is arbitrary, just want
+	to check the value that is set is also read back. */
+	uxValue = 100;
+	xTaskHandle = xTaskGetCurrentTaskHandle();
+	vTaskSetTaskNumber( xTaskHandle, uxValue );
+	if( uxTaskGetTaskNumber( xTaskHandle ) != uxValue )
+	{
+		xReturn = pdFAIL;
+	}
+	if( uxTaskGetTaskNumber( NULL ) != 0 )
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Timer trace util functions are exercised in prvTimerQuery(). */
+
+
+	/* Exercise the stream buffer utilities.  Try creating with a trigger level
+	of 0, it should then get capped to 1. */
+	xStreamBuffer = xStreamBufferCreate( sizeof( uint32_t ), 0 );
+	if( xStreamBuffer != NULL )
+	{
+		vStreamBufferSetStreamBufferNumber( xStreamBuffer, uxValue );
+		if( uxStreamBufferGetStreamBufferNumber( xStreamBuffer ) != uxValue )
+		{
+			xReturn = pdFALSE;
+		}
+		if( ucStreamBufferGetStreamBufferType( xStreamBuffer ) != 0 )
+		{
+			/* "Is Message Buffer" flag should have been 0. */
+			xReturn = pdFALSE;
+		}
+
+		vStreamBufferDelete( xStreamBuffer );
+	}
+	else
+	{
+		xReturn = pdFALSE;
+	}
+
+	xMessageBuffer = xMessageBufferCreate( sizeof( uint32_t ) );
+	if( xMessageBuffer != NULL )
+	{
+		if( ucStreamBufferGetStreamBufferType( xMessageBuffer ) == 0 )
+		{
+			/* "Is Message Buffer" flag should have been 1. */
+			xReturn = pdFALSE;
+		}
+
+		vMessageBufferDelete( xMessageBuffer );
+	}
+	else
+	{
+		xReturn = pdFALSE;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvPeekTimeout( void )
+{
+QueueHandle_t xHandle;
+const UBaseType_t xQueueLength = 1;
+BaseType_t xReturn = pdPASS;
+TickType_t xBlockTime = ( TickType_t ) 2;
+UBaseType_t uxReceived;
+
+	/* Create the queue just to try peeking it while it is empty. */
+	xHandle = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( xQueueLength ) );
+
+	if( xHandle != NULL )
+	{
+		if( uxQueueMessagesWaiting( xHandle ) != 0 )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Ensure peeking from the queue times out as the queue is empty. */
+		if( xQueuePeek( xHandle, &uxReceived, xBlockTime ) != pdFALSE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		vQueueDelete( xHandle );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvQueueQueryFromISR( void )
+{
+BaseType_t xReturn = pdPASS, xValue = 1;
+const UBaseType_t xISRQueueLength = ( UBaseType_t ) 1;
+const char *pcISRQueueName = "ISRQueue";
+QueueHandle_t xISRQueue = NULL;
+
+	xISRQueue = xQueueCreate( xISRQueueLength, ( UBaseType_t ) sizeof( BaseType_t ) );
+
+	if( xISRQueue != NULL )
+	{
+		vQueueAddToRegistry( xISRQueue, pcISRQueueName );
+		if( strcmp( pcQueueGetName( xISRQueue ), pcISRQueueName ) )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Expect the queue to be empty here. */
+		if(	uxQueueMessagesWaitingFromISR( xISRQueue ) != 0 )
+		{
+			xReturn = pdFAIL;
+		}
+
+		if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdTRUE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		if( xQueueIsQueueFullFromISR( xISRQueue ) != pdFALSE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Now fill the queue - it only has one space. */
+		if( xQueueSendFromISR( xISRQueue, &xValue, NULL ) != pdPASS )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Check it now reports as full. */
+		if(	uxQueueMessagesWaitingFromISR( xISRQueue ) != 1 )
+		{
+			xReturn = pdFAIL;
+		}
+
+		if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdFALSE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		if( xQueueIsQueueFullFromISR( xISRQueue ) != pdTRUE )
+		{
+			xReturn = pdFAIL;
+		}
+
+		vQueueDelete( xISRQueue );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvTaskQueryFunctions( void )
+{
+static TaskStatus_t xStatus, *pxStatusArray;
+TaskHandle_t xTimerTask, xIdleTask;
+BaseType_t xReturn = pdPASS;
+UBaseType_t uxNumberOfTasks, uxReturned, ux;
+uint32_t ulTotalRunTime1, ulTotalRunTime2;
+const uint32_t ulRunTimeTollerance = ( uint32_t ) 0xfff;
+
+	/* Obtain task status with the stack high water mark and without the
+	state. */
+	vTaskGetInfo( NULL, &xStatus, pdTRUE, eRunning );
+
+	if( uxTaskGetStackHighWaterMark( NULL ) != xStatus.usStackHighWaterMark )
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Now obtain a task status without the high water mark but with the state,
+	which in the case of the idle task should be Read. */
+	xTimerTask = xTimerGetTimerDaemonTaskHandle();
+	vTaskSuspend( xTimerTask ); /* Should never suspend Timer task normally!. */
+	vTaskGetInfo( xTimerTask, &xStatus, pdFALSE, eInvalid );
+	if( xStatus.eCurrentState != eSuspended )
+	{
+		xReturn = pdFAIL;
+	}
+	if( xStatus.uxBasePriority != uxTaskPriorityGetFromISR( xTimerTask ) )
+	{
+		xReturn = pdFAIL;
+	}
+	if( xStatus.uxBasePriority != ( configMAX_PRIORITIES - 1 ) )
+	{
+		xReturn = pdFAIL;
+	}
+	xTaskResumeFromISR( xTimerTask );
+	vTaskGetInfo( xTimerTask, &xStatus, pdTRUE, eInvalid );
+	if( ( xStatus.eCurrentState != eReady ) && ( xStatus.eCurrentState != eBlocked ) )
+	{
+		xReturn = pdFAIL;
+	}
+	if( uxTaskGetStackHighWaterMark( xTimerTask ) != xStatus.usStackHighWaterMark )
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Attempting to abort a delay in the idle task should be guaranteed to
+	fail as the idle task should never block. */
+	xIdleTask = xTaskGetIdleTaskHandle();
+	if( xTaskAbortDelay( xIdleTask ) != pdFAIL )
+	{
+		xReturn = pdFAIL;
+	}
+
+	/* Create an array of task status objects large enough to hold information
+	on the number of tasks at this time - note this may change at any time if
+	higher priority tasks are executing and creating tasks. */
+	uxNumberOfTasks = uxTaskGetNumberOfTasks();
+	pxStatusArray = ( TaskStatus_t * ) pvPortMalloc( uxNumberOfTasks * sizeof( TaskStatus_t ) );
+
+	if( pxStatusArray != NULL )
+	{
+		/* Pass part of the array into uxTaskGetSystemState() to ensure it doesn't
+		try using more space than there is available. */
+		uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks / ( UBaseType_t ) 2, NULL );
+		if( uxReturned != ( UBaseType_t ) 0 )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Now do the same but passing in the complete array size, this is done
+		twice to check for a difference in the total run time. */
+		uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime1 );
+		memset( ( void * ) pxStatusArray, 0xaa, uxNumberOfTasks * sizeof( TaskStatus_t ) );
+		uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime2 );
+		if( ( ulTotalRunTime2 - ulTotalRunTime1 ) > ulRunTimeTollerance )
+		{
+			xReturn = pdFAIL;
+		}
+
+		/* Basic santity check of array contents. */
+		for( ux = 0; ux < uxReturned; ux++ )
+		{
+			if( pxStatusArray[ ux ].eCurrentState >= ( UBaseType_t ) eInvalid )
+			{
+				xReturn = pdFAIL;
+			}
+			if( pxStatusArray[ ux ].uxCurrentPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
+			{
+				xReturn = pdFAIL;
+			}
+		}
+
+		vPortFree( pxStatusArray );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvDummyTagFunction( void *pvParameter )
+{
+	return ( BaseType_t ) pvParameter;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvTaskTags( void )
+{
+BaseType_t xReturn = pdPASS, xParameter = ( BaseType_t ) 0xDEADBEEF;
+TaskHandle_t xTask;
+
+	/* First try with the handle of a different task.  Use the timer task for
+	convenience. */
+	xTask = xTimerGetTimerDaemonTaskHandle();
+
+	vTaskSetApplicationTaskTag( xTask, prvDummyTagFunction );
+	if( xTaskGetApplicationTaskTag( xTask ) != prvDummyTagFunction )
+	{
+		xReturn = pdFAIL;
+	}
+	else
+	{
+		if( xTaskCallApplicationTaskHook( xTask, ( void * ) xParameter ) != xParameter )
+		{
+			xReturn = pdFAIL;
+		}
+		if( xTaskCallApplicationTaskHook( xTask, ( void * ) NULL ) != pdFAIL )
+		{
+			xReturn = pdFAIL;
+		}
+	}
+
+	/* Now try with a NULL handle, so using this task. */
+	vTaskSetApplicationTaskTag( NULL, NULL );
+	if( xTaskGetApplicationTaskTag( NULL ) != NULL )
+	{
+		xReturn = pdFAIL;
+	}
+
+	vTaskSetApplicationTaskTag( NULL, prvDummyTagFunction );
+	if( xTaskGetApplicationTaskTag( NULL ) != prvDummyTagFunction )
+	{
+		xReturn = pdFAIL;
+	}
+	else
+	{
+		if( xTaskCallApplicationTaskHook( NULL, ( void * ) xParameter ) != xParameter )
+		{
+			xReturn = pdFAIL;
+		}
+		if( xTaskCallApplicationTaskHook( NULL, ( void * ) NULL ) != pdFAIL )
+		{
+			xReturn = pdFAIL;
+		}
+	}
+
+	vTaskSetApplicationTaskTag( NULL, NULL );
+	if( xTaskGetApplicationTaskTag( NULL ) != NULL )
+	{
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static BaseType_t prvTimerQuery( void )
+{
+TimerHandle_t xTimer;
+BaseType_t xReturn = pdPASS;
+const char *pcTimerName = "TestTimer";
+const TickType_t xTimerPeriod = ( TickType_t ) 100;
+const UBaseType_t uxTimerNumber = ( UBaseType_t ) 55;
+
+	xTimer = xTimerCreate(  pcTimerName,
+							xTimerPeriod,
+							pdFALSE,
+							( void * ) xTimerPeriod,
+							NULL ); /* Not actually going to start timer so NULL callback is ok. */
+
+	if( xTimer != NULL )
+	{
+		if( xTimerGetPeriod( xTimer ) != xTimerPeriod )
+		{
+			xReturn = pdFAIL;
+		}
+
+		if( strcmp( pcTimerGetName( xTimer ), pcTimerName ) != 0 )
+		{
+			xReturn = pdFAIL;
+		}
+
+		vTimerSetTimerNumber( xTimer, uxTimerNumber );
+		if( uxTimerGetTimerNumber( xTimer ) != uxTimerNumber )
+		{
+			xReturn = pdFAIL;
+		}
+
+		xTimerDelete( xTimer, portMAX_DELAY );
+	}
+	else
+	{
+		xReturn = pdFAIL;
+	}
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+BaseType_t xRunCodeCoverageTestAdditions( void )
+{
+BaseType_t xReturn = pdPASS;
+
+	xReturn &= prvStaticAllocationsWithNullBuffers();
+	xReturn &= prvTraceUtils();
+	xReturn &= prvPeekTimeout();
+	xReturn &= prvQueueQueryFromISR();
+	xReturn &= prvTaskQueryFunctions();
+	xReturn &= prvTaskTags();
+	xReturn &= prvTimerQuery();
+
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
diff --git a/FreeRTOS/Demo/WIN32-MingW/main.c b/FreeRTOS/Demo/WIN32-MingW/main.c
index cfb16a4b0..96a51cabe 100644
--- a/FreeRTOS/Demo/WIN32-MingW/main.c
+++ b/FreeRTOS/Demo/WIN32-MingW/main.c
@@ -75,7 +75,7 @@ that make up the total heap.  heap_5 is only used for test and example purposes
 as this demo could easily create one large heap region instead of multiple
 smaller heap regions - in which case heap_4.c would be the more appropriate
 choice.  See http://www.freertos.org/a00111.html for an explanation. */
-#define mainREGION_1_SIZE	8201
+#define mainREGION_1_SIZE	10801
 #define mainREGION_2_SIZE	29905
 #define mainREGION_3_SIZE	6007
 
@@ -141,10 +141,6 @@ int main( void )
 	http://www.freertos.org/a00111.html for an explanation. */
 	prvInitialiseHeap();
 
-	/* Initialise the trace recorder.  Use of the trace recorder is optional.
-	See http://www.FreeRTOS.org/trace for more information. */
-	vTraceEnable( TRC_START );
-
 	/* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top
 	of this file. */
 	#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
@@ -153,11 +149,20 @@ int main( void )
 	}
 	#else
 	{
-		/* Start the trace recording - the recording is written to a file if
-		configASSERT() is called. */
-		printf( "\r\nTrace started.\r\nThe trace will be dumped to disk if a call to configASSERT() fails.\r\n" );
-		printf( "Uncomment the call to kbhit() in this file to also dump trace with a key press.\r\n" );
-		uiTraceStart();
+		/* Do not include trace code when performing a code coverage analysis. */
+		#if( projCOVERAGE_TEST != 1 )
+		{
+			/* Initialise the trace recorder.  Use of the trace recorder is optional.
+			See http://www.FreeRTOS.org/trace for more information. */
+			vTraceEnable( TRC_START );
+
+			/* Start the trace recording - the recording is written to a file if
+			configASSERT() is called. */
+			printf( "\r\nTrace started.\r\nThe trace will be dumped to disk if a call to configASSERT() fails.\r\n" );
+			printf( "Uncomment the call to kbhit() in this file to also dump trace with a key press.\r\n" );
+			uiTraceStart();
+		}
+		#endif
 
 		main_full();
 	}
@@ -282,7 +287,6 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
 			xPrinted = pdTRUE;
 			if( xTraceRunning == pdTRUE )
 			{
-				vTraceStop();
 				prvSaveTraceFile();
 			}
 		}
@@ -302,20 +306,27 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
 
 static void prvSaveTraceFile( void )
 {
-FILE* pxOutputFile;
+	/* Tracing is not used when code coverage analysis is being performed. */
+	#if( projCOVERAGE_TEST != 1 )
+	{
+		FILE* pxOutputFile;
 
-	pxOutputFile = fopen( "Trace.dump", "wb");
+		vTraceStop();
 
-	if( pxOutputFile != NULL )
-	{
-		fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
-		fclose( pxOutputFile );
-		printf( "\r\nTrace output saved to Trace.dump\r\n" );
-	}
-	else
-	{
-		printf( "\r\nFailed to create trace dump file\r\n" );
+		pxOutputFile = fopen( "Trace.dump", "wb");
+
+		if( pxOutputFile != NULL )
+		{
+			fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
+			fclose( pxOutputFile );
+			printf( "\r\nTrace output saved to Trace.dump\r\n" );
+		}
+		else
+		{
+			printf( "\r\nFailed to create trace dump file\r\n" );
+		}
 	}
+	#endif
 }
 /*-----------------------------------------------------------*/
 
diff --git a/FreeRTOS/Demo/WIN32-MingW/main_full.c b/FreeRTOS/Demo/WIN32-MingW/main_full.c
index 96f02c452..b8e06d184 100644
--- a/FreeRTOS/Demo/WIN32-MingW/main_full.c
+++ b/FreeRTOS/Demo/WIN32-MingW/main_full.c
@@ -120,6 +120,12 @@
 
 #define mainTIMER_TEST_PERIOD			( 50 )
 
+/*
+ * Exercises code that is not otherwise covered by the standard demo/test
+ * tasks.
+ */
+extern BaseType_t xRunCodeCoverageTestAdditions( void );
+
 /* Task function prototypes. */
 static void prvCheckTask( void *pvParameters );
 
@@ -420,7 +426,6 @@ void *pvAllocated;
 	timer. */
 	prvDemonstrateTimerQueryFunctions();
 
-
 	/* If xMutexToDelete has not already been deleted, then delete it now.
 	This is done purely to demonstrate the use of, and test, the
 	vSemaphoreDelete() macro.  Care must be taken not to delete a semaphore
@@ -448,13 +453,19 @@ void *pvAllocated;
 
 	/* Exit after a fixed time so code coverage results are written to the
 	disk. */
-	#if( configCOVERAGE_TEST == 1 )
+	#if( projCOVERAGE_TEST == 1 )
 	{
-		const TickType_t xMaxRunTime = pdMS_TO_TICKS( 60000UL );
+		const TickType_t xMaxRunTime = pdMS_TO_TICKS( 30000UL );
+
+		/* Exercise code not otherwise executed by standard demo/test tasks. */
+		if( xRunCodeCoverageTestAdditions() != pdPASS )
+		{
+			pcStatusMessage = "Code coverage additions failed.\r\n";
+		}
 
-		if( xTaskGetTickCount() >= xMaxRunTime )
+		if( ( xTaskGetTickCount() - configINITIAL_TICK_COUNT ) >= xMaxRunTime )
 		{
-			exit( 0 );
+			vTaskEndScheduler();
 		}
 	}
 	#endif
diff --git a/FreeRTOS/Source/portable/MSVC-MingW/port.c b/FreeRTOS/Source/portable/MSVC-MingW/port.c
index 081eece5e..a755621ed 100644
--- a/FreeRTOS/Source/portable/MSVC-MingW/port.c
+++ b/FreeRTOS/Source/portable/MSVC-MingW/port.c
@@ -508,8 +508,7 @@ uint32_t ulErrorCode;
 
 void vPortEndScheduler( void )
 {
-	/* This function IS NOT TESTED! */
-	TerminateProcess( GetCurrentProcess(), 0 );
+	exit( 0 );
 }
 /*-----------------------------------------------------------*/
 
diff --git a/FreeRTOS/Source/queue.c b/FreeRTOS/Source/queue.c
index 80c976bd3..a580ae7dc 100644
--- a/FreeRTOS/Source/queue.c
+++ b/FreeRTOS/Source/queue.c
@@ -301,7 +301,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 
 	QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )
 	{
-	Queue_t *pxNewQueue;
+	Queue_t *pxNewQueue = NULL;
 
 		configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
 
@@ -345,6 +345,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 		else
 		{
 			traceQUEUE_CREATE_FAILED( ucQueueType );
+			mtCOVERAGE_TEST_MARKER();
 		}
 
 		return pxNewQueue;
@@ -397,6 +398,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 		else
 		{
 			traceQUEUE_CREATE_FAILED( ucQueueType );
+			mtCOVERAGE_TEST_MARKER();
 		}
 
 		return pxNewQueue;
diff --git a/FreeRTOS/Source/stream_buffer.c b/FreeRTOS/Source/stream_buffer.c
index 963a35593..9e518907a 100644
--- a/FreeRTOS/Source/stream_buffer.c
+++ b/FreeRTOS/Source/stream_buffer.c
@@ -1234,7 +1234,7 @@ static void prvInitialiseNewStreamBuffer( StreamBuffer_t * const pxStreamBuffer,
 
 	uint8_t ucStreamBufferGetStreamBufferType( StreamBufferHandle_t xStreamBuffer )
 	{
-		return ( ( StreamBuffer_t * )xStreamBuffer )->ucFlags | sbFLAGS_IS_MESSAGE_BUFFER;
+		return ( ( StreamBuffer_t * )xStreamBuffer )->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER;
 	}
 
 #endif /* configUSE_TRACE_FACILITY */
diff --git a/FreeRTOS/Source/tasks.c b/FreeRTOS/Source/tasks.c
index 3a0cbf4e9..129439cab 100644
--- a/FreeRTOS/Source/tasks.c
+++ b/FreeRTOS/Source/tasks.c
@@ -1984,7 +1984,7 @@ BaseType_t xReturn;
 
 		xNextTaskUnblockTime = portMAX_DELAY;
 		xSchedulerRunning = pdTRUE;
-		xTickCount = ( TickType_t ) 0U;
+		xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT;
 
 		/* If configGENERATE_RUN_TIME_STATS is defined then the following
 		macro must be defined to configure the timer/counter used to generate
@@ -2782,7 +2782,9 @@ BaseType_t xSwitchRequired = pdFALSE;
 		/* Save the hook function in the TCB.  A critical section is required as
 		the value can be accessed from an interrupt. */
 		taskENTER_CRITICAL();
+		{
 			xTCB->pxTaskTag = pxHookFunction;
+		}
 		taskEXIT_CRITICAL();
 	}