Make full demo exit on error

alfred2g · alfred2g · commit e84fc19966c0 · 2021-06-02T11:00:10.000-07:00
diff --git a/FreeRTOS/Demo/Posix_GCC/Makefile b/FreeRTOS/Demo/Posix_GCC/Makefile
@@ -97,7 +97,7 @@ ${BUILD_DIR}/${BIN} : ${OBJ_FILES}
 
 ${BUILD_DIR}/%.o : %.c Makefile
 	-mkdir -p $(@D)
-	$(CC) $(CPPFLAGS) $(CFLAGS) -MMD -c $< -o $@
+	$(CC) $(CFLAGS) ${INCLUDE_DIRS} -DUSER_DEMO= -MMD -c $< -o $@
 
 .PHONY: clean
 
@@ -110,7 +110,3 @@ profile:
 	gprof -a -p --all-lines $(GPROF_OPTIONS) $(BUILD_DIR)/$(BIN) $(BUILD_DIR)/gmon.out > $(BUILD_DIR)/prof_flat.txt
 	gprof -a --graph $(GPROF_OPTIONS) $(BUILD_DIR)/$(BIN) $(BUILD_DIR)/gmon.out > $(BUILD_DIR)/prof_call_graph.txt
 
-
-
-
-
diff --git a/FreeRTOS/Demo/Posix_GCC/main.c b/FreeRTOS/Demo/Posix_GCC/main.c
@@ -65,16 +65,18 @@
 /* Local includes. */
 #include "console.h"
 
-#define    BLINKY_DEMO              0
-#define    FULL_DEMO                1
-
-#define mainSELECTED_APPLICATION    BLINKY_DEMO
-
 #ifdef BUILD_DIR
     #define BUILD                   BUILD_DIR
 #else
     #define BUILD                   "./"
 #endif
+#ifdef USER_DEMO
+#define     mainSELECTED_APPLICATION USER_DEMO
+#else
+    #define    BLINKY_DEMO       0
+    #define    FULL_DEMO         1
+    #define    mainSELECTED_APPLICATION FULL_DEMO
+#endif
 
 /* This demo uses heap_3.c (the libc provided malloc() and free()). */
 
@@ -132,8 +134,6 @@ static BaseType_t xTraceRunning = pdTRUE;
 
 /*-----------------------------------------------------------*/
 
-
-
 int main( void )
 {
     /* SIGINT is not blocked by the posix port */
@@ -418,6 +418,5 @@ void handle_sigint( int signal )
     {
         printf( "chdir into %s error is %d\n", BUILD,  errno );
     }
-
-    exit( 1 );
+    exit( 2 );
 }
diff --git a/FreeRTOS/Demo/Posix_GCC/main_full.c b/FreeRTOS/Demo/Posix_GCC/main_full.c
@@ -185,6 +185,7 @@ static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer );
 
 /* The variable into which error messages are latched. */
 static char * pcStatusMessage = "OK: No errors";
+int xErrorCount = 0;
 
 /* This semaphore is created purely to test using the vSemaphoreDelete() and
  * semaphore tracing API functions.  It has no other purpose. */
@@ -287,113 +288,139 @@ static void prvCheckTask( void * pvParameters )
                 if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE )
                 {
                     pcStatusMessage = "Error: TimerDemo";
+                    xErrorCount++;
                 }
             }
         #endif
 
         if( xAreStreamBufferTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error:  StreamBuffer";
+            xErrorCount++;
         }
         else if( xAreMessageBufferTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error:  MessageBuffer";
+            xErrorCount++;
         }
         else if( xAreTaskNotificationTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error:  Notification";
+            xErrorCount++;
         }
-        /* else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE ) */
-        /* { */
-        /*  pcStatusMessage = "Error:  NotificationArray"; */
-        /* } */
+        /* else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE )
+         {
+         pcStatusMessage = "Error:  NotificationArray";
+            xErrorCount++;
+        } */
         else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: IntSem";
+            xErrorCount++;
         }
         else if( xAreEventGroupTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: EventGroup";
+            xErrorCount++;
         }
         else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: IntMath";
+            xErrorCount++;
         }
         else if( xAreGenericQueueTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: GenQueue";
+            xErrorCount++;
         }
         else if( xAreQueuePeekTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: QueuePeek";
+            xErrorCount++;
         }
         else if( xAreBlockingQueuesStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: BlockQueue";
+            xErrorCount++;
         }
         else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: SemTest";
+            xErrorCount++;
         }
         else if( xArePollingQueuesStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: PollQueue";
+            xErrorCount++;
         }
         else if( xAreMathsTaskStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Flop";
+            xErrorCount++;
         }
         else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: RecMutex";
+            xErrorCount++;
         }
         else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: CountSem";
+            xErrorCount++;
         }
         else if( xIsCreateTaskStillRunning() != pdTRUE )
         {
             pcStatusMessage = "Error: Death";
+            xErrorCount++;
         }
         else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Dynamic";
+            xErrorCount++;
         }
         else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Queue overwrite";
+            xErrorCount++;
         }
         else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Block time";
+            xErrorCount++;
         }
         else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Abort delay";
+            xErrorCount++;
         }
         else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Stream buffer interrupt";
+            xErrorCount++;
         }
         else if( xAreMessageBufferAMPTasksStillRunning() != pdPASS )
         {
             pcStatusMessage = "Error: Message buffer AMP";
+            xErrorCount++;
         }
 
         #if ( configUSE_QUEUE_SETS == 1 )
             else if( xAreQueueSetTasksStillRunning() != pdPASS )
             {
                 pcStatusMessage = "Error: Queue set";
+                xErrorCount++;
             }
             else if( xAreQueueSetPollTasksStillRunning() != pdPASS )
             {
                 pcStatusMessage = "Error: Queue set polling";
+                xErrorCount++;
             }
         #endif
 
         #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
             else if( xAreStaticAllocationTasksStillRunning() != pdPASS )
             {
+                xErrorCount++;
                 pcStatusMessage = "Error: Static allocation";
             }
         #endif /* configSUPPORT_STATIC_ALLOCATION */
@@ -402,6 +429,11 @@ static void prvCheckTask( void * pvParameters )
                 pcStatusMessage,
                 xTaskGetTickCount() );
 
+        if( xErrorCount != 0 )
+        {
+            exit( 1 );
+        }
+
         /* Reset the error condition */
         pcStatusMessage = "OK: No errors";
     }
@@ -490,6 +522,7 @@ void vFullDemoIdleFunction( void )
             if( xRunCodeCoverageTestAdditions() != pdPASS )
             {
                 pcStatusMessage = "Code coverage additions failed.\r\n";
+                xErrorCount++;
             }
 
             if( ( xTaskGetTickCount() - configINITIAL_TICK_COUNT ) >= xMaxRunTime )
@@ -656,18 +689,21 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
     if( xTaskGetCurrentTaskHandle() != xIdleTaskHandle )
     {
         pcStatusMessage = "Error:  Returned idle task handle was incorrect";
+        xErrorCount++;
     }
 
     /* Check the same handle is obtained using the idle task's name.  First try
      * with the wrong name, then the right name. */
     if( xTaskGetHandle( "Idle" ) == xIdleTaskHandle )
     {
         pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
+        xErrorCount++;
     }
 
     if( xTaskGetHandle( "IDLE" ) != xIdleTaskHandle )
     {
         pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
+        xErrorCount++;
     }
 
     /* Check the timer task handle was returned correctly. */
@@ -676,23 +712,27 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
     if( strcmp( pcTaskName, "Tmr Svc" ) != 0 )
     {
         pcStatusMessage = "Error:  Returned timer task handle was incorrect";
+        xErrorCount++;
     }
 
     if( xTaskGetHandle( "Tmr Svc" ) != xTimerTaskHandle )
     {
         pcStatusMessage = "Error:  Returned handle for name Tmr Svc was incorrect";
+        xErrorCount++;
     }
 
     /* This task is running, make sure it's state is returned as running. */
     if( eTaskStateGet( xIdleTaskHandle ) != eRunning )
     {
         pcStatusMessage = "Error:  Returned idle task state was incorrect";
+        xErrorCount++;
     }
 
     /* If this task is running, then the timer task must be blocked. */
     if( eTaskStateGet( xTimerTaskHandle ) != eBlocked )
     {
         pcStatusMessage = "Error:  Returned timer task state was incorrect";
+        xErrorCount++;
     }
 
     /* Also with the vTaskGetInfo() function. */
@@ -709,6 +749,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
         ( xTaskInfo.xHandle != xTimerTaskHandle ) )
     {
         pcStatusMessage = "Error:  vTaskGetInfo() returned incorrect information about the timer task";
+        xErrorCount++;
     }
 
     /* Other tests that should only be performed once follow.  The test task
@@ -726,6 +767,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
             if( eTaskStateGet( xTestTask ) != eReady )
             {
                 pcStatusMessage = "Error: Returned test task state was incorrect 1";
+                xErrorCount++;
             }
 
             /* Now suspend the test task and check its state is reported correctly. */
@@ -734,6 +776,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
             if( eTaskStateGet( xTestTask ) != eSuspended )
             {
                 pcStatusMessage = "Error: Returned test task state was incorrect 2";
+                xErrorCount++;
             }
 
             /* Now delete the task and check its state is reported correctly. */
@@ -742,6 +785,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
             if( eTaskStateGet( xTestTask ) != eDeleted )
             {
                 pcStatusMessage = "Error: Returned test task state was incorrect 3";
+                xErrorCount++;
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -185,6 +185,7 @@ static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer );`
`185`	`185`
`186`	`186`	`/* The variable into which error messages are latched. */`
`187`	`187`	`static char * pcStatusMessage = "OK: No errors";`
	`188`	`+int xErrorCount = 0;`
`188`	`189`
`189`	`190`	`/* This semaphore is created purely to test using the vSemaphoreDelete() and`
`190`	`191`	`* semaphore tracing API functions. It has no other purpose. */`
`@@ -287,113 +288,139 @@ static void prvCheckTask( void * pvParameters )`
`287`	`288`	`if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE )`
`288`	`289`	`{`
`289`	`290`	`pcStatusMessage = "Error: TimerDemo";`
	`291`	`+ xErrorCount++;`
`290`	`292`	`}`
`291`	`293`	`}`
`292`	`294`	`#endif`
`293`	`295`
`294`	`296`	`if( xAreStreamBufferTasksStillRunning() != pdTRUE )`
`295`	`297`	`{`
`296`	`298`	`pcStatusMessage = "Error: StreamBuffer";`
	`299`	`+ xErrorCount++;`
`297`	`300`	`}`
`298`	`301`	`else if( xAreMessageBufferTasksStillRunning() != pdTRUE )`
`299`	`302`	`{`
`300`	`303`	`pcStatusMessage = "Error: MessageBuffer";`
	`304`	`+ xErrorCount++;`
`301`	`305`	`}`
`302`	`306`	`else if( xAreTaskNotificationTasksStillRunning() != pdTRUE )`
`303`	`307`	`{`
`304`	`308`	`pcStatusMessage = "Error: Notification";`
	`309`	`+ xErrorCount++;`
`305`	`310`	`}`
`306`		`- /* else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE ) */`
`307`		`- /* { */`
`308`		`- /* pcStatusMessage = "Error: NotificationArray"; */`
`309`		`- /* } */`
	`311`	`+ /* else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE )`
	`312`	`+ {`
	`313`	`+ pcStatusMessage = "Error: NotificationArray";`
	`314`	`+ xErrorCount++;`
	`315`	`+ } */`
`310`	`316`	`else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )`
`311`	`317`	`{`
`312`	`318`	`pcStatusMessage = "Error: IntSem";`
	`319`	`+ xErrorCount++;`
`313`	`320`	`}`
`314`	`321`	`else if( xAreEventGroupTasksStillRunning() != pdTRUE )`
`315`	`322`	`{`
`316`	`323`	`pcStatusMessage = "Error: EventGroup";`
	`324`	`+ xErrorCount++;`
`317`	`325`	`}`
`318`	`326`	`else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )`
`319`	`327`	`{`
`320`	`328`	`pcStatusMessage = "Error: IntMath";`
	`329`	`+ xErrorCount++;`
`321`	`330`	`}`
`322`	`331`	`else if( xAreGenericQueueTasksStillRunning() != pdTRUE )`
`323`	`332`	`{`
`324`	`333`	`pcStatusMessage = "Error: GenQueue";`
	`334`	`+ xErrorCount++;`
`325`	`335`	`}`
`326`	`336`	`else if( xAreQueuePeekTasksStillRunning() != pdTRUE )`
`327`	`337`	`{`
`328`	`338`	`pcStatusMessage = "Error: QueuePeek";`
	`339`	`+ xErrorCount++;`
`329`	`340`	`}`
`330`	`341`	`else if( xAreBlockingQueuesStillRunning() != pdTRUE )`
`331`	`342`	`{`
`332`	`343`	`pcStatusMessage = "Error: BlockQueue";`
	`344`	`+ xErrorCount++;`
`333`	`345`	`}`
`334`	`346`	`else if( xAreSemaphoreTasksStillRunning() != pdTRUE )`
`335`	`347`	`{`
`336`	`348`	`pcStatusMessage = "Error: SemTest";`
	`349`	`+ xErrorCount++;`
`337`	`350`	`}`
`338`	`351`	`else if( xArePollingQueuesStillRunning() != pdTRUE )`
`339`	`352`	`{`
`340`	`353`	`pcStatusMessage = "Error: PollQueue";`
	`354`	`+ xErrorCount++;`
`341`	`355`	`}`
`342`	`356`	`else if( xAreMathsTaskStillRunning() != pdPASS )`
`343`	`357`	`{`
`344`	`358`	`pcStatusMessage = "Error: Flop";`
	`359`	`+ xErrorCount++;`
`345`	`360`	`}`
`346`	`361`	`else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )`
`347`	`362`	`{`
`348`	`363`	`pcStatusMessage = "Error: RecMutex";`
	`364`	`+ xErrorCount++;`
`349`	`365`	`}`
`350`	`366`	`else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )`
`351`	`367`	`{`
`352`	`368`	`pcStatusMessage = "Error: CountSem";`
	`369`	`+ xErrorCount++;`
`353`	`370`	`}`
`354`	`371`	`else if( xIsCreateTaskStillRunning() != pdTRUE )`
`355`	`372`	`{`
`356`	`373`	`pcStatusMessage = "Error: Death";`
	`374`	`+ xErrorCount++;`
`357`	`375`	`}`
`358`	`376`	`else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )`
`359`	`377`	`{`
`360`	`378`	`pcStatusMessage = "Error: Dynamic";`
	`379`	`+ xErrorCount++;`
`361`	`380`	`}`
`362`	`381`	`else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )`
`363`	`382`	`{`
`364`	`383`	`pcStatusMessage = "Error: Queue overwrite";`
	`384`	`+ xErrorCount++;`
`365`	`385`	`}`
`366`	`386`	`else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )`
`367`	`387`	`{`
`368`	`388`	`pcStatusMessage = "Error: Block time";`
	`389`	`+ xErrorCount++;`
`369`	`390`	`}`
`370`	`391`	`else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )`
`371`	`392`	`{`
`372`	`393`	`pcStatusMessage = "Error: Abort delay";`
	`394`	`+ xErrorCount++;`
`373`	`395`	`}`
`374`	`396`	`else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS )`
`375`	`397`	`{`
`376`	`398`	`pcStatusMessage = "Error: Stream buffer interrupt";`
	`399`	`+ xErrorCount++;`
`377`	`400`	`}`
`378`	`401`	`else if( xAreMessageBufferAMPTasksStillRunning() != pdPASS )`
`379`	`402`	`{`
`380`	`403`	`pcStatusMessage = "Error: Message buffer AMP";`
	`404`	`+ xErrorCount++;`
`381`	`405`	`}`
`382`	`406`
`383`	`407`	`#if ( configUSE_QUEUE_SETS == 1 )`
`384`	`408`	`else if( xAreQueueSetTasksStillRunning() != pdPASS )`
`385`	`409`	`{`
`386`	`410`	`pcStatusMessage = "Error: Queue set";`
	`411`	`+ xErrorCount++;`
`387`	`412`	`}`
`388`	`413`	`else if( xAreQueueSetPollTasksStillRunning() != pdPASS )`
`389`	`414`	`{`
`390`	`415`	`pcStatusMessage = "Error: Queue set polling";`
	`416`	`+ xErrorCount++;`
`391`	`417`	`}`
`392`	`418`	`#endif`
`393`	`419`
`394`	`420`	`#if ( configSUPPORT_STATIC_ALLOCATION == 1 )`
`395`	`421`	`else if( xAreStaticAllocationTasksStillRunning() != pdPASS )`
`396`	`422`	`{`
	`423`	`+ xErrorCount++;`
`397`	`424`	`pcStatusMessage = "Error: Static allocation";`
`398`	`425`	`}`
`399`	`426`	`#endif /* configSUPPORT_STATIC_ALLOCATION */`
`@@ -402,6 +429,11 @@ static void prvCheckTask( void * pvParameters )`
`402`	`429`	`pcStatusMessage,`
`403`	`430`	`xTaskGetTickCount() );`
`404`	`431`
	`432`	`+ if( xErrorCount != 0 )`
	`433`	`+ {`
	`434`	`+ exit( 1 );`
	`435`	`+ }`
	`436`	`+`
`405`	`437`	`/* Reset the error condition */`
`406`	`438`	`pcStatusMessage = "OK: No errors";`
`407`	`439`	`}`
`@@ -490,6 +522,7 @@ void vFullDemoIdleFunction( void )`
`490`	`522`	`if( xRunCodeCoverageTestAdditions() != pdPASS )`
`491`	`523`	`{`
`492`	`524`	`pcStatusMessage = "Code coverage additions failed.\r\n";`
	`525`	`+ xErrorCount++;`
`493`	`526`	`}`
`494`	`527`
`495`	`528`	`if( ( xTaskGetTickCount() - configINITIAL_TICK_COUNT ) >= xMaxRunTime )`
`@@ -656,18 +689,21 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`656`	`689`	`if( xTaskGetCurrentTaskHandle() != xIdleTaskHandle )`
`657`	`690`	`{`
`658`	`691`	`pcStatusMessage = "Error: Returned idle task handle was incorrect";`
	`692`	`+ xErrorCount++;`
`659`	`693`	`}`
`660`	`694`
`661`	`695`	`/* Check the same handle is obtained using the idle task's name. First try`
`662`	`696`	`* with the wrong name, then the right name. */`
`663`	`697`	`if( xTaskGetHandle( "Idle" ) == xIdleTaskHandle )`
`664`	`698`	`{`
`665`	`699`	`pcStatusMessage = "Error: Returned handle for name Idle was incorrect";`
	`700`	`+ xErrorCount++;`
`666`	`701`	`}`
`667`	`702`
`668`	`703`	`if( xTaskGetHandle( "IDLE" ) != xIdleTaskHandle )`
`669`	`704`	`{`
`670`	`705`	`pcStatusMessage = "Error: Returned handle for name Idle was incorrect";`
	`706`	`+ xErrorCount++;`
`671`	`707`	`}`
`672`	`708`
`673`	`709`	`/* Check the timer task handle was returned correctly. */`
`@@ -676,23 +712,27 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`676`	`712`	`if( strcmp( pcTaskName, "Tmr Svc" ) != 0 )`
`677`	`713`	`{`
`678`	`714`	`pcStatusMessage = "Error: Returned timer task handle was incorrect";`
	`715`	`+ xErrorCount++;`
`679`	`716`	`}`
`680`	`717`
`681`	`718`	`if( xTaskGetHandle( "Tmr Svc" ) != xTimerTaskHandle )`
`682`	`719`	`{`
`683`	`720`	`pcStatusMessage = "Error: Returned handle for name Tmr Svc was incorrect";`
	`721`	`+ xErrorCount++;`
`684`	`722`	`}`
`685`	`723`
`686`	`724`	`/* This task is running, make sure it's state is returned as running. */`
`687`	`725`	`if( eTaskStateGet( xIdleTaskHandle ) != eRunning )`
`688`	`726`	`{`
`689`	`727`	`pcStatusMessage = "Error: Returned idle task state was incorrect";`
	`728`	`+ xErrorCount++;`
`690`	`729`	`}`
`691`	`730`
`692`	`731`	`/* If this task is running, then the timer task must be blocked. */`
`693`	`732`	`if( eTaskStateGet( xTimerTaskHandle ) != eBlocked )`
`694`	`733`	`{`
`695`	`734`	`pcStatusMessage = "Error: Returned timer task state was incorrect";`
	`735`	`+ xErrorCount++;`
`696`	`736`	`}`
`697`	`737`
`698`	`738`	`/* Also with the vTaskGetInfo() function. */`
`@@ -709,6 +749,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`709`	`749`	`( xTaskInfo.xHandle != xTimerTaskHandle ) )`
`710`	`750`	`{`
`711`	`751`	`pcStatusMessage = "Error: vTaskGetInfo() returned incorrect information about the timer task";`
	`752`	`+ xErrorCount++;`
`712`	`753`	`}`
`713`	`754`
`714`	`755`	`/* Other tests that should only be performed once follow. The test task`
`@@ -726,6 +767,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`726`	`767`	`if( eTaskStateGet( xTestTask ) != eReady )`
`727`	`768`	`{`
`728`	`769`	`pcStatusMessage = "Error: Returned test task state was incorrect 1";`
	`770`	`+ xErrorCount++;`
`729`	`771`	`}`
`730`	`772`
`731`	`773`	`/* Now suspend the test task and check its state is reported correctly. */`
`@@ -734,6 +776,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`734`	`776`	`if( eTaskStateGet( xTestTask ) != eSuspended )`
`735`	`777`	`{`
`736`	`778`	`pcStatusMessage = "Error: Returned test task state was incorrect 2";`
	`779`	`+ xErrorCount++;`
`737`	`780`	`}`
`738`	`781`
`739`	`782`	`/* Now delete the task and check its state is reported correctly. */`
`@@ -742,6 +785,7 @@ static void prvDemonstrateTaskStateAndHandleGetFunctions( void )`
`742`	`785`	`if( eTaskStateGet( xTestTask ) != eDeleted )`
`743`	`786`	`{`
`744`	`787`	`pcStatusMessage = "Error: Returned test task state was incorrect 3";`
	`788`	`+ xErrorCount++;`
`745`	`789`	`}`
`746`	`790`	`}`
`747`	`791`	`}`