diff --git a/FreeRTOS/Source b/FreeRTOS/Source index 99295c9ae..71f5af4e0 160000 --- a/FreeRTOS/Source +++ b/FreeRTOS/Source @@ -1 +1 @@ -Subproject commit 99295c9ae8f40a1be7fd23de9171f820b6a42db6 +Subproject commit 71f5af4e0f8d5fad2c4d83c43aa6748eb6cfaaf9 diff --git a/FreeRTOS/Test/CMock/Makefile b/FreeRTOS/Test/CMock/Makefile index fe942bc3b..3c77051cf 100644 --- a/FreeRTOS/Test/CMock/Makefile +++ b/FreeRTOS/Test/CMock/Makefile @@ -8,7 +8,7 @@ export LD ?= /usr/local/bin/ld # Add units here when adding a new unit test directory with the same name UNITS += list -#UNITS += queue +UNITS += queue #UNITS += timers UNITS += stream_buffer UNITS += message_buffer @@ -111,8 +111,7 @@ $(COVINFO) : $(LCOV_LIST) # Generate lcov for each suite $(LCOV_LIST) : zero_coverage - $(foreach unit,$(UNITS),\ - make -C $(unit) lcov;) + make -C $(subst .info,,$(@F)) lcov lcovhtml : $(COVINFO) mkdir -p $(COVERAGE_DIR) diff --git a/FreeRTOS/Test/CMock/config/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/config/FreeRTOSConfig.h index 3a923bd77..93855d01f 100644 --- a/FreeRTOS/Test/CMock/config/FreeRTOSConfig.h +++ b/FreeRTOS/Test/CMock/config/FreeRTOSConfig.h @@ -126,7 +126,7 @@ void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that in { \ vFakeAssert( false, __FILE__, __LINE__ ); \ } \ - } while ( 0 ); + } while ( 0 ) #define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) diff --git a/FreeRTOS/Test/CMock/makefile.in b/FreeRTOS/Test/CMock/makefile.in index ac56f4ba6..6ac5b8f8d 100644 --- a/FreeRTOS/Test/CMock/makefile.in +++ b/FreeRTOS/Test/CMock/makefile.in @@ -41,11 +41,13 @@ CPPFLAGS := # Compiler flags CFLAGS := $(INCLUDE_DIR) -O0 -ggdb -pthread --std=c99 -Werror -Wall -CFLAGS += -fstack-protector-all -CFLAGS += -Wformat -Werror=format-security -Werror=array-bounds -CFLAGS += -D_FORTIFY_SOURCE=2 ifeq ($(ENABLE_SANITIZER),1) + CFLAGS += -fstack-protector-all + CFLAGS += -Wformat -Werror=format-security -Werror=array-bounds + CFLAGS += -D_FORTIFY_SOURCE=2 CFLAGS += -fsanitize=address,undefined -fsanitize-recover=address +else + CFLAGS += -U_FORTIFY_SOURCE endif # Linker flags diff --git a/FreeRTOS/Test/CMock/queue/Makefile b/FreeRTOS/Test/CMock/queue/Makefile index 34deff580..cd11d1e74 100644 --- a/FreeRTOS/Test/CMock/queue/Makefile +++ b/FreeRTOS/Test/CMock/queue/Makefile @@ -5,7 +5,12 @@ MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) include ../makefile.in # SUITES lists the suites contained in subdirectories of this directory -SUITES += two_tests +SUITES += generic +SUITES += dynamic +SUITES += static +SUITES += semaphore +SUITES += sets +SUITES += tracing # PROJECT and SUITE variables are determined based on path like so: # $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) diff --git a/FreeRTOS/Test/CMock/queue/dynamic/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/dynamic/FreeRTOSConfig.h new file mode 100644 index 000000000..aa4968216 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/dynamic/FreeRTOSConfig.h @@ -0,0 +1,141 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 0 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#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 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 0 +#define configSUPPORT_DYNAMIC_ALLOCATION 1 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/dynamic/Makefile b/FreeRTOS/Test/CMock/queue/dynamic/Makefile new file mode 100644 index 000000000..2199e5374 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/dynamic/Makefile @@ -0,0 +1,48 @@ +# Indent with spaces +.RECIPEPREFIX := $(.RECIPEPREFIX) $(.RECIPEPREFIX) + +# Do not move this line below the include +MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) +include ../../makefile.in + +# PROJECT_SRC lists the .c files under test +PROJECT_SRC += queue.c + +# PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files +# Files in PROJECT_DEPS_SRC are excluded from coverage measurements +PROJECT_DEPS_SRC += list.c + +# PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. +PROJECT_HEADER_DEPS += FreeRTOS.h + +# SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) +SUITE_UT_SRC += queue_create_dynamic_utest.c +SUITE_UT_SRC += queue_delete_dynamic_utest.c + +# SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. +# Paths are relative to PROJECT_DIR +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c + +# List the headers used by PROJECT_SRC that you would like to mock +MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h + +# List any addiitonal flags needed by the preprocessor +CPPFLAGS += -DportUSING_MPU_WRAPPERS=0 + +# List any addiitonal flags needed by the compiler +CFLAGS += + +# Try not to edit beyond this line unless necessary. + +# Project / Suite are determined based on path: $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) +PROJECT := $(lastword $(subst /, ,$(dir $(abspath $(MAKEFILE_ABSPATH)/../)))) +SUITE := $(lastword $(subst /, ,$(dir $(MAKEFILE_ABSPATH)))) + +# Make variables available to included makefile +export + +include ../../testdir.mk diff --git a/FreeRTOS/Test/CMock/queue/dynamic/queue_create_dynamic_utest.c b/FreeRTOS/Test/CMock/queue/dynamic/queue_create_dynamic_utest.c new file mode 120000 index 000000000..36be2dd87 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/dynamic/queue_create_dynamic_utest.c @@ -0,0 +1 @@ +../generic/queue_create_dynamic_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/dynamic/queue_delete_dynamic_utest.c b/FreeRTOS/Test/CMock/queue/dynamic/queue_delete_dynamic_utest.c new file mode 120000 index 000000000..45ed1e093 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/dynamic/queue_delete_dynamic_utest.c @@ -0,0 +1 @@ +../generic/queue_delete_dynamic_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/generic/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/generic/FreeRTOSConfig.h new file mode 100644 index 000000000..aa75e8817 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/FreeRTOSConfig.h @@ -0,0 +1,140 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 0 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#define configCHECK_FOR_STACK_OVERFLOW 0 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configQUEUE_REGISTRY_SIZE 0 +#define configUSE_MALLOC_FAILED_HOOK 1 +#define configUSE_APPLICATION_TASK_TAG 1 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configUSE_ALTERNATIVE_API 0 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/generic/Makefile b/FreeRTOS/Test/CMock/queue/generic/Makefile new file mode 100644 index 000000000..a46ad250d --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/Makefile @@ -0,0 +1,56 @@ +# Indent with spaces +.RECIPEPREFIX := $(.RECIPEPREFIX) $(.RECIPEPREFIX) + +# Do not move this line below the include +MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) +include ../../makefile.in + +# PROJECT_SRC lists the .c files under test +PROJECT_SRC += queue.c + +# PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files +# Files in PROJECT_DEPS_SRC are excluded from coverage measurements +PROJECT_DEPS_SRC += list.c + +# PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. +PROJECT_HEADER_DEPS += FreeRTOS.h + +# SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) +SUITE_UT_SRC += queue_create_dynamic_utest.c +SUITE_UT_SRC += queue_create_static_utest.c +SUITE_UT_SRC += queue_delete_dynamic_utest.c +SUITE_UT_SRC += queue_delete_static_utest.c +SUITE_UT_SRC += queue_reset_utest.c +SUITE_UT_SRC += queue_receive_nonblocking_utest.c +SUITE_UT_SRC += queue_receive_blocking_utest.c +SUITE_UT_SRC += queue_send_nonblocking_utest.c +SUITE_UT_SRC += queue_send_blocking_utest.c +SUITE_UT_SRC += queue_status_utest.c + +# SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. +# Paths are relative to PROJECT_DIR +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c + +# List the headers used by PROJECT_SRC that you would like to mock +MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h + +# List any addiitonal flags needed by the preprocessor +CPPFLAGS += -DportUSING_MPU_WRAPPERS=0 + +# List any addiitonal flags needed by the compiler +CFLAGS += -O1 -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-exceptions + +# Try not to edit beyond this line unless necessary. + +# Project / Suite are determined based on path: $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) +PROJECT := $(lastword $(subst /, ,$(dir $(abspath $(MAKEFILE_ABSPATH)/../)))) +SUITE := $(lastword $(subst /, ,$(dir $(MAKEFILE_ABSPATH)))) + +# Make variables available to included makefile +export + +include ../../testdir.mk diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_create_dynamic_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_create_dynamic_utest.c new file mode 100644 index 000000000..e6cd54f01 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_create_dynamic_utest.c @@ -0,0 +1,324 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_create_dynamic_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +static void test_long_queue( QueueHandle_t xQueue, + uint32_t maxItems ) +{ + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + queue_common_add_sequential_to_queue( xQueue, maxItems ); + + /* Veify that queue is full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + queue_common_receive_sequential_from_queue( xQueue, maxItems, maxItems, 0 ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); +} + + +/* ========================== Test Cases =========================== */ + +/** + * @brief Test xQueueCreate when calls to malloc fail + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + QueueHandle_t xQueue = INVALID_PTR; + + xQueue = xQueueCreate( 1, 1 ); + + TEST_ASSERT_EQUAL( NULL, xQueue ); +} + +/** + * @brief Test xQueueCreate with uxQueueLength=0, uxItemSize=0 + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_zeroQueueLength_zeroItemSize() +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 0 ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Veify that queue is also full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueCreate with uxQueueLength=0, uxItemSize=1 + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_zeroQueueLength_oneItemSize( void ) +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 1 ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Valdiate that the queue is full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueCreate with uxQueueLength=1, uxItemSize=0 + * @details This configuration is equivalent to a binary semaphore. + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_oneItem_zeroLength( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Valdiate that the queue has 1 space remaining */ + TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueCreate with uxQueueLength=1, uxItemSize=1 + * @details This configuration is equivalent to a 1 byte mailbox. + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_oneItem_oneLength( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 1 ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + 1, getLastMallocSize() ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + uint8_t testval = ( uint8_t ) getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testval, 0 ) ); + + /* Veify that queue is full */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + uint8_t testVal2 = 0xFF; + + /* Receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal2, 0 ) ); + TEST_ASSERT_EQUAL( testval, testVal2 ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/*! + * @brief Test xQueueCreate with uxQueueLength=1, uxItemSize=[2,16] + * @details End to end test with varied mailbox sizes from 2 to 16 bytes. + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_oneItem_multiLength( void ) +{ + uint8_t testVal[ MAX_MULTI_LEN ]; + + /* Generate test pattern to send to the queue (re-used for each iteration) */ + for( int i = 0; i < MAX_MULTI_LEN; i++ ) + { + testVal[ i ] = ( uint8_t ) getNextMonotonicTestValue(); + } + + for( uint8_t i = 2; i <= MAX_MULTI_LEN; i++ ) + { + QueueHandle_t xQueue = xQueueCreate( 1, i ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + i, getLastMallocSize() ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Mask off the bytes we won't use */ + uint8_t testValCompare[ MAX_MULTI_LEN ]; + + for( int j = 0; j < MAX_MULTI_LEN; j++ ) + { + if( j < i ) + { + testValCompare[ j ] = testVal[ j ]; + } + else + { + testValCompare[ j ] = 0xFF; + } + } + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + /* Veify that queue is also full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + uint8_t testValCheck[ MAX_MULTI_LEN ]; + memset( testValCheck, 0xFF, MAX_MULTI_LEN ); + + /* Receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testValCheck, 0 ) ); + TEST_ASSERT_EQUAL_MEMORY( testValCompare, testValCheck, MAX_MULTI_LEN ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); + } +} + +/*! + * @brief xQueueCreate with a large queue. + * @coverage xQueueCreate + */ +void test_LargeQueueRunThrough( void ) +{ + QueueHandle_t xQueue = xQueueCreate( MAX_QUEUE_ITEMS, sizeof( uint32_t ) ); + + test_long_queue( xQueue, MAX_QUEUE_ITEMS ); + + vQueueDelete( xQueue ); +} + +/** + * @brief xQueueCreate where uxQueueLength * uxItemSize results in integer overflow + * @details In this test case xQueueSizeInBytes > MAX(size_t), but individually + * uxQueueLength and uxItemSize are each less than MAX(size_t). + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_multiplication_overflow( void ) +{ + /* Calculate a test value = 2^( sizeof(size_t) * 8 bits / 2) + * For a 64 bit size_t, this is 2^(8*8/2) = 2^(32) */ + size_t factor = 1ULL << ( sizeof( size_t ) * 4 ); + + EXPECT_ASSERT_BREAK( xQueueCreate( factor, factor ) ); +} + +/*! + * @brief xQueueCreate where adding xQueueSizeInBytes and sizeof(StaticQueue_t) + * results in integer overflow. + * @details This test case satisfies the following constraints given that: + * xQueueSizeInBytes = (uxQueueLength * uxItemSize), + * xQueueSizeInBytes <= MAX(size_t) and + * ( xQueueSizeInBytes + sizeof(StaticQueue_t) ) > MAX(size_t) + * @coverage xQueueGenericCreate + */ +void test_macro_xQueueCreate_addiiton_overflow( void ) +{ + /* Based on the formula: + * ( 2^x - 1 ) == ( 2^( x/2 ) + 1 ) * ( 2^( x/2 ) - 1 ) */ + size_t powTwo = 1ULL << ( sizeof( size_t ) * 4 ); + size_t factorA = powTwo - 1; + size_t factorB = powTwo + 1; + + EXPECT_ASSERT_BREAK( xQueueCreate( factorA, factorB ) ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_create_static_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_create_static_utest.c new file mode 100644 index 000000000..08655bc87 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_create_static_utest.c @@ -0,0 +1,232 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_create_static_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + + +static void test_long_queue( QueueHandle_t xQueue, + uint32_t maxItems ) +{ + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + queue_common_add_sequential_to_queue( xQueue, maxItems ); + + /* Veify that queue is full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + queue_common_receive_sequential_from_queue( xQueue, maxItems, maxItems, 0 ); + + /* Veify that queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); +} + + +/* ========================== Test Cases =========================== */ + +/** + * @brief xQueueCreateStatic with a NULL pointer for queueStorage + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_null_QueueStorage_fail( void ) +{ + /* Expect that xQueueCreate will assert */ + fakeAssertExpectFail(); + + StaticQueue_t queueBuffer; + QueueHandle_t xQueue = xQueueCreateStatic( MAX_QUEUE_ITEMS, sizeof( uint32_t ), NULL, &queueBuffer ); + + /* Validate the queue handle */ + TEST_ASSERT_EQUAL( &queueBuffer, xQueue ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); +} + +/** + * @brief xQueueCreateStatic with a NULL pointer for queueBuffer + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_null_queueBuffer_fail( void ) +{ + /* Expect that xQueueCreate will assert */ + fakeAssertExpectFail(); + + uint32_t queueStorage[ MAX_QUEUE_ITEMS ]; + QueueHandle_t xQueue = INVALID_PTR; + + xQueue = xQueueCreateStatic( MAX_QUEUE_ITEMS, sizeof( uint32_t ), ( void * ) queueStorage, NULL ); + + /* Validate that the queue handle is NULL */ + TEST_ASSERT_EQUAL( NULL, xQueue ); + + /* Check that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); +} + +/** + * @brief Test xQueueCreateStatic with a NULL buffer, uxQueueLength=1, uxItemSize=0 + * @details This configuration is equivalent to a binary semaphore. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_nullQueueStorage_oneItem_zeroLength( void ) +{ + StaticQueue_t queueBuffer; + QueueHandle_t xQueue = xQueueCreateStatic( 1, 0, NULL, &queueBuffer ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Valdiate that the queue has 1 space remaining */ + TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueue ) ); + + /* Send a test value */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) ); + + /* Test receive */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueCreateStatic with uxQueueLength=0, uxItemSize=0 + * @details This configuration is invalid and causes a configASSERT. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_validQueueStorage_zeroItem_zeroLength( void ) +{ + StaticQueue_t queueBuffer; + + /* Expect that xQueueCreateStatic will assert becasue a zero length queue is invalid */ + fakeAssertExpectFail(); + QueueHandle_t xQueue = xQueueCreateStatic( 0, 0, NULL, &queueBuffer ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Valdiate that the queue has 0 space remaining */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueCreateStatic with a valid buffer, uxQueueLength=1, uxItemSize=0 + * @details This configuration is equivalent to a binary semaphore. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_validQueueStorage_oneItem_zeroLength( void ) +{ + StaticQueue_t queueBuffer; + uint32_t queueData; + + /* Expect that xQueueCreateStatic will assert because data storage is not + * necessary for a zero itemLength queue */ + fakeAssertExpectFail(); + QueueHandle_t xQueue = xQueueCreateStatic( 1, 0, ( void * ) &queueData, &queueBuffer ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* validate returned queue handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); + + /* Veify that new queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Valdiate that the queue has 1 space remaining */ + TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueue ) ); + + /* Send a test value */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) ); + + /* Test receive */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief xQueueCreateStatic with a large queue. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xQueueCreateStatic_large( void ) +{ + uint32_t queueStorage[ MAX_QUEUE_ITEMS ]; + StaticQueue_t queueBuffer; + QueueHandle_t xQueue = xQueueCreateStatic( MAX_QUEUE_ITEMS, sizeof( uint32_t ), ( void * ) queueStorage, &queueBuffer ); + + test_long_queue( xQueue, MAX_QUEUE_ITEMS ); + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_delete_dynamic_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_delete_dynamic_utest.c new file mode 100644 index 000000000..3b40d91fc --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_delete_dynamic_utest.c @@ -0,0 +1,131 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_delete_dynamic_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* =========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* =========================== Helper functions ============================ */ + +/* ============================== Test Cases =============================== */ + +/** + * @brief Test vQueueDelete with an invalid QueueHandle + * @coverage vQueueDelete + */ +void test_vQueueDelete_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( vQueueDelete( NULL ) ); +} + +/** + * @brief Test vQueueDelete with a statically allocated queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_empty( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + ( 6 * 4 ), getLastMallocSize() ); + + vQueueDelete( xQueue ); + TEST_ASSERT_EQUAL_PTR( ( void * ) xQueue, getLastFreedAddress() ); +} + +/** + * @brief Test vQueueDelete with a half-full queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_half_full( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + ( 6 * 4 ), getLastMallocSize() ); + + for( uint32_t i = 0; i < 3; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + vQueueDelete( xQueue ); + TEST_ASSERT_EQUAL_PTR( ( void * ) xQueue, getLastFreedAddress() ); +} + +/** + * @brief Test vQueueDelete with a full queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_full( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + ( 6 * 4 ), getLastMallocSize() ); + + for( uint32_t i = 0; i < 6; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + vQueueDelete( xQueue ); + TEST_ASSERT_EQUAL_PTR( ( void * ) xQueue, getLastFreedAddress() ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_delete_static_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_delete_static_utest.c new file mode 100644 index 000000000..d87dc0189 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_delete_static_utest.c @@ -0,0 +1,151 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_delete_static_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test vQueueDelete with an invalid QueueHandle + * @coverage vQueueDelete + */ +void test_vQueueDelete_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( vQueueDelete( NULL ) ); +} + +/** + * @brief Test vQueueDelete with a statically allocated queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_empty( void ) +{ + void * queueBuffer = malloc( sizeof( StaticQueue_t ) ); + void * queueData = malloc( 6 * sizeof( uint32_t ) ); + QueueHandle_t xQueue = xQueueCreateStatic( 6, sizeof( uint32_t ), queueData, queueBuffer ); + + /* Verify that no call to malloc occured */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + vQueueDelete( xQueue ); + /* Veirfy that free was not called */ + TEST_ASSERT_EQUAL_PTR( NULL, getLastFreedAddress() ); + free( queueBuffer ); + free( queueData ); +} + +/** + * @brief Test vQueueDelete with a half-full queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_half_full( void ) +{ + void * queueBuffer = malloc( sizeof( StaticQueue_t ) ); + void * queueData = malloc( 6 * sizeof( uint32_t ) ); + QueueHandle_t xQueue = xQueueCreateStatic( 6, sizeof( uint32_t ), queueData, queueBuffer ); + + /* Verify that no call to malloc occured */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + for( uint32_t i = 0; i < 3; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + vQueueDelete( xQueue ); + + /* Veirfy that free was not called */ + TEST_ASSERT_EQUAL_PTR( NULL, getLastFreedAddress() ); + free( queueBuffer ); + free( queueData ); +} + +/** + * @brief Test vQueueDelete with a full queue of size 6 x 4 bytes + * @coverage vQueueDelete + */ +void test_vQueueDelete_full( void ) +{ + void * queueBuffer = malloc( sizeof( StaticQueue_t ) ); + void * queueData = malloc( 6 * sizeof( uint32_t ) ); + QueueHandle_t xQueue = xQueueCreateStatic( 6, sizeof( uint32_t ), queueData, queueBuffer ); + + /* Verify that no call to malloc occured */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + for( uint32_t i = 0; i < 6; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + vQueueDelete( xQueue ); + + /* Veirfy that free was not called */ + TEST_ASSERT_EQUAL_PTR( NULL, getLastFreedAddress() ); + free( queueBuffer ); + free( queueData ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_receive_blocking_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_receive_blocking_utest.c new file mode 100644 index 000000000..8455ba796 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_receive_blocking_utest.c @@ -0,0 +1,656 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_receive_blocking_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" +/* ============================ GLOBAL VARIABLES =========================== */ + +/* Used to share a QueueHandle_t between a test case and it's callbacks */ +static QueueHandle_t xQueueHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + xQueueHandleStatic = NULL; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Callback for test_xQueueReceive_blocking_success_locked_no_pending + * which adds an item to it's test queue. + */ +static BaseType_t xQueueReceive_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + TEST_ASSERT_TRUE( xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ) ); + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueReceive with a locked queue. + * @details Test a blocking call to xQueueReceive with a locked queue with no + * tasks in the queue WaitingToReceiveFrom event list. + * @coverage xQueueReceive prvUnlockQueue + */ +void test_xQueueReceive_blocking_success_locked_no_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueuePeek with a locked queue. + * @details Test a blocking call to xQueuePeek with a locked queue with no tasks + * in the queue WaitingToReceiveFrom event list. + * @coverage xQueuePeek prvUnlockQueue + */ +void test_xQueuePeek_blocking_success_locked_no_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Callback for xTaskResumeAll used by tests for blocking calls to + * xQueueReceive and xQueuePeek + */ +static BaseType_t xQueueReceive_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Receive from an ISR to block */ + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t checkValue = INVALID_UINT32; + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + TEST_ASSERT_TRUE( xQueueReceiveFromISR( xQueueHandleStatic, &checkValue, NULL ) ); + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkValue ); + } + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueReceive with a locked queue. + * @details Test a blocking call to xQueueReceive with a locked queue with a + * higher priority task in the queue WaitingToReceiveFrom event list. + * @coverage xQueueReceive prvUnlockQueue + */ +void test_xQueueReceive_blocking_timeout_locked_high_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + TEST_ASSERT_EQUAL( INVALID_UINT32, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueuePeek with a locked queue. + * @details Test a blocking call to xQueuePeek with a locked queue with a + * higher priority task in the queue WaitingToReceiveFrom event list. + * @coverage xQueuePeek prvUnlockQueue + */ +void test_xQueuePeek_blocking_timeout_locked_high_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + TEST_ASSERT_EQUAL( INVALID_UINT32, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueueReceive with a locked queue. + * @details Test a blocking call to xQueueReceive with a locked queue with a + * lower priority task in the queue WaitingToReceiveFrom event list. + * @coverage xQueueReceive prvUnlockQueue + */ +void test_xQueueReceive_blocking_success_locked_low_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueuePeek with a locked queue. + * @details Test a blocking call to xQueuePeek with a locked queue with a + * lower priority task in the queue WaitingToReceiveFrom event list. + * @coverage xQueuePeek prvUnlockQueue + */ +void test_xQueuePeek_blocking_success_locked_low_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with taskSCHEDULER_SUSPENDED and timeout=10 + * @details This should cause xQueuePeek to configASSERT becuase it would + * block forever when the queue is empty. + * @coverage xQueuePeek + */ +void test_xQueuePeek_blocking_suspended_assert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + vTaskSuspendAll_Stub( td_task_vTaskSuspendAllStubNoCheck ); + + uint32_t checkVal = INVALID_UINT32; + + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Callback which adds and item to it's test queue. + * @details Used in test_xQueuePeek_blocking_success and test_xQueueReceive_blocking_sucess. + */ +static BaseType_t blocking_success_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + xQueueSend( xQueueHandleStatic, &testVal, 0 ); + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test xQueuePeek in blocking mode with a queue that is initially empty, + * but later becomes full. + * @coverage xQueuePeek + */ +void test_xQueuePeek_blocking_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &blocking_success_xTaskCheckForTimeOut_cb ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + vQueueDelete( xQueue ); +} + +/** + * @brief Callback which adds and item to it's test queue. + * @details used in test_xQueuePeek_blocking_success_last_chance and + * test_xQueueReceive_blocking_success_last_chance. + */ +static BaseType_t blocking_success_last_chance_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == TICKS_TO_WAIT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + xQueueSend( xQueueHandleStatic, &testVal, 0 ); + } + + return xReturnValue; +} + +/** + * @brief Test xQueuePeek in blocking mode with a queue that is initially empty, + * but becomes full right before the last chance to remove data from the queue. + * @coverage xQueuePeek + */ +void test_xQueuePeek_blocking_success_last_chance( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &blocking_success_last_chance_xTaskCheckForTimeOut_cb ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek in blocking mode with an empty queue. + * @coverage xQueuePeek + */ +void test_xQueuePeek_blocking_timeout( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with taskSCHEDULER_SUSPENDED and timeout=10 + * @details This should cause xQueueReceive to configASSERT becuase it would + * block forever when the queue is empty. + * @coverage xQueueReceive + */ +void test_xQueueReceive_blocking_suspended_assert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + fakeAssertExpectFail(); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + vTaskSuspendAll_Stub( td_task_vTaskSuspendAllStubNoCheck ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive in blocking mode with an occupied queue + * @coverage xQueueReceive + */ +void test_xQueueReceive_blocking_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &blocking_success_xTaskCheckForTimeOut_cb ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + + +/** + * @brief Test xQueueReceive in blocking mode with a queue that is initially empty, + * but becomes full right before the last chance to remove data from the queue. + * @coverage xQueueReceive + */ +void test_xQueueReceive_blocking_success_last_chance( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &blocking_success_last_chance_xTaskCheckForTimeOut_cb ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive in blocking mode with an empty queue + * @coverage xQueueReceive + */ +void test_xQueueReceive_blocking_timeout( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive in blocking mode with an empty locked queue. + * @details This test case verifies a situation that should never occur + * ( xQueueReceive called on a locked queue ). + * @coverage xQueueReceive + */ +void test_xQueueReceive_blocking_locked( void ) +{ + /* Create a new binary Queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + uint32_t checkVal = INVALID_UINT32; + + /* Run xQueueReceive in blocking mode with the queue locked */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Verify that the queue is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xQueue ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek in blocking mode with an empty locked queue. + * @details This test case verifies a situation that should never occur + * ( xQueuePeek called on a locked queue ). + * @coverage xQueuePeek + */ +void test_xQueuePeek_blocking_locked( void ) +{ + /* Create a new binary Queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + uint32_t checkVal = INVALID_UINT32; + + /* Run xQueueReceive in blocking mode with the queue locked */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, TICKS_TO_WAIT ) ); + + + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Verify that the queue is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xQueue ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xQueue ) ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_receive_nonblocking_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_receive_nonblocking_utest.c new file mode 100644 index 000000000..5dcff09c9 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_receive_nonblocking_utest.c @@ -0,0 +1,1184 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_receive_nonblocking_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +#include "mock_fake_port.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* Used to share a QueueHandle_t between a test case and it's callbacks */ +static QueueHandle_t xQueueHandleStatic = NULL; +static BaseType_t xStubExpectedReturnValue = pdFALSE; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + xQueueHandleStatic = NULL; + xStubExpectedReturnValue = pdFALSE; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test xQueuePeek with an invalid QueueHandle + * @coverage xQueuePeek + */ +void test_xQueuePeek_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueuePeek( NULL, NULL, 0 ) ); +} + +/** + * @brief Test xQueuePeek with an empty queue + * @coverage xQueuePeek + */ +void test_xQueuePeek_fail_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + /* peek from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an empty queue of length 1, items size 0 + * @coverage xQueuePeek + */ +void test_xQueuePeek_zeroItemSize_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + /* peek from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with a full queue of length 1, items size 0 + * @coverage xQueuePeek + */ +void test_xQueuePeek_zeroItemSize_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + ( void ) xQueueSend( xQueue, NULL, 0 ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with a null pvBuffer on an empty queue of length 1, items size 4 + * @coverage xQueuePeek + */ +void test_xQueuePeek_fourItemSize_nullptr_assert_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + fakeAssertExpectFail(); + + /* peek from the queue with a nullptr storage location */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with a null pvBuffer on a full queue of length 1, items size 4 + * @coverage xQueuePeek + */ +void test_xQueuePeek_fourItemSize_nullptr_assert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* peek from the queue with a nullptr storage location */ + EXPECT_ASSERT_BREAK( xQueuePeek( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue + * @coverage xQueuePeek + */ +void test_xQueuePeek_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Peek from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + /* Verify that xQueuePeek did not remove the item from the queue */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Stub for vPortYieldWithinAPI which calls xQueueReceive + */ +static void vPortYieldWithinAPI_xQueueReceive_Stub( int cmock_num_calls ) +{ + td_task_vPortYieldWithinAPIStub( cmock_num_calls ); + + vFakePortExitCriticalSection(); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( xStubExpectedReturnValue == pdTRUE ? 1 : 0, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + + TEST_ASSERT_EQUAL( xStubExpectedReturnValue, xQueueReceive( xQueueHandleStatic, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + + if( pdTRUE == xStubExpectedReturnValue ) + { + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + } + else + { + TEST_ASSERT_EQUAL( INVALID_UINT32, checkVal ); + } + + vFakePortEnterCriticalSection(); +} + +/** + * @brief Stub for vPortYieldWithinAPI which calls xQueuePeek + */ +static void vPortYieldWithinAPI_xQueuePeek_Stub( int cmock_num_calls ) +{ + td_task_vPortYieldWithinAPIStub( cmock_num_calls ); + + vFakePortExitCriticalSection(); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( xStubExpectedReturnValue == pdTRUE ? 1 : 0, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + + TEST_ASSERT_EQUAL( xStubExpectedReturnValue, xQueuePeek( xQueueHandleStatic, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( xStubExpectedReturnValue == pdTRUE ? 1 : 0, uxQueueMessagesWaiting( xQueueHandleStatic ) ); + + if( pdTRUE == xStubExpectedReturnValue ) + { + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + } + else + { + TEST_ASSERT_EQUAL( INVALID_UINT32, checkVal ); + } + + vFakePortEnterCriticalSection(); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a higher priority task waiting that does not modify the queue. + * @coverage xQueuePeek + */ +void test_xQueuePeek_noop_waiting_higher_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + /* peek from the queue */ + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Veify that the task Yielded */ + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a higher priority xQueuePeek pending. + * @coverage xQueuePeek + */ +void test_xQueuePeek_xQueuePeek_waiting_higher_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + vFakePortYieldWithinAPI_Stub( &vPortYieldWithinAPI_xQueuePeek_Stub ); + + xStubExpectedReturnValue = pdTRUE; + + /* peek from the queue */ + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Veify that the task Yielded */ + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a higher priority xQueueReceive pending. + * @coverage xQueuePeek + */ +void test_xQueuePeek_xQueueReceive_waiting_higher_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + vFakePortYieldWithinAPI_Stub( &vPortYieldWithinAPI_xQueueReceive_Stub ); + + xStubExpectedReturnValue = pdTRUE; + + /* peek from the queue */ + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Veify that the task Yielded */ + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a lower priority task pending which does not modify the queue. + * @coverage xQueuePeek + */ +void test_xQueuePeek_noop_waiting_lower_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a lower priority xQueuePeek operation pending. + * @coverage xQueuePeek + */ +void test_xQueuePeek_xQueuePeek_waiting_lower_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + vFakePortYieldWithinAPI_Stub( &vPortYieldWithinAPI_xQueuePeek_Stub ); + + xStubExpectedReturnValue = pdFALSE; + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with an occupied queue with a lower priority xQueueReceive operation pending. + * @coverage xQueuePeek + */ +void test_xQueuePeek_xQueueReceive_waiting_lower_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callback */ + xQueueHandleStatic = xQueue; + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + vFakePortYieldWithinAPI_Stub( &vPortYieldWithinAPI_xQueueReceive_Stub ); + + xStubExpectedReturnValue = pdFALSE; + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeek with taskSCHEDULER_SUSPENDED and timeout=0 + * @details This should not cause xQueuePeek to configASSERT becuase + * xQueuePeek is non-blocking when timeout=0. + * @coverage xQueuePeek + */ +void test_xQueuePeek_nonblocking_suspended_noassert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeek( xQueue, &checkVal, 0 ) ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeekFromISR with an invalid QueueHandle + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueuePeekFromISR( NULL, NULL ) ); +} + +/** + * @brief Test xQueuePeekFromISR with a full queue of length 1, items size 0 + * @details xQueuePeekFromISR is not allowed on a semaphore (item size 0) and causes a configASSERT. + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_zeroItemSize_assert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + ( void ) xQueueSend( xQueue, NULL, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + ulFakePortSetInterruptMaskFromISR_ExpectAndReturn( getNextMonotonicTestValue() ); + vFakePortClearInterruptMaskFromISR_Expect( getLastMonotonicTestValue() ); + + /* Expect an assertion failure because xQueuePeekFromISR is not supported for semaphores? */ + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeekFromISR( xQueue, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeekFromISR with a null pvBuffer on an empty queue of length 1, items size 4 + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_fourItemSize_nullptr_assert_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + ulFakePortSetInterruptMaskFromISR_ExpectAndReturn( getNextMonotonicTestValue() ); + vFakePortClearInterruptMaskFromISR_Expect( getLastMonotonicTestValue() ); + + /* Expect an assertion failure due to the null pointer passed into xqueuePeekFromISR */ + fakeAssertExpectFail(); + + /* peek from the queue with a nullptr storage location */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeekFromISR( xQueue, NULL ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeekFromISR with a null pvBuffer on a full queue of length 1, items size 4 + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_fourItemSize_nullptr_assert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* peek from the queue with a nullptr storage location */ + EXPECT_ASSERT_BREAK( xQueuePeekFromISR( xQueue, NULL ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeekFromISR with an empty queue + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_fail_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + ulFakePortSetInterruptMaskFromISR_ExpectAndReturn( getNextMonotonicTestValue() ); + vFakePortClearInterruptMaskFromISR_Expect( getLastMonotonicTestValue() ); + + /* peek from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueuePeekFromISR( xQueue, &checkVal ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueuePeekFromISR with an occupied queue + * @coverage xQueuePeekFromISR + */ +void test_xQueuePeekFromISR_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + ulFakePortSetInterruptMaskFromISR_ExpectAndReturn( getNextMonotonicTestValue() ); + vFakePortClearInterruptMaskFromISR_Expect( getLastMonotonicTestValue() ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* peek from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeekFromISR( xQueue, &checkVal ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with an invalid QueueHandle + * @coverage xQueueReceive + */ +void test_xQueueReceive_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueReceive( NULL, NULL, 0 ) ); +} + +/** + * @brief Test xQueueReceive with an empty queue + * @coverage xQueueReceive + */ +void test_xQueueReceive_fail_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + /* receive from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with an empty queue of length 1, items size 0 + * @coverage xQueueReceive + */ +void test_xQueueReceive_zeroItemSize_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + /* receive from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with a full queue of length 1, items size 0 + * @coverage xQueueReceive + */ +void test_xQueueReceive_zeroItemSize_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + ( void ) xQueueSend( xQueue, NULL, 0 ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with a null pvBuffer on an empty queue of length 1, items size 4 + * @coverage xQueueReceive + */ +void test_xQueueReceive_fourItemSize_nullptr_assert_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + fakeAssertExpectFail(); + + /* receive from the queue with a nullptr storage location */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with a null pvBuffer on a full queue of length 1, items size 4 + * @coverage xQueueReceive + */ +void test_xQueueReceive_fourItemSize_nullptr_assert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* receive from the queue with a nullptr storage location */ + EXPECT_ASSERT_BREAK( xQueueReceive( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with an occupied queue + * @coverage xQueueReceive + */ +void test_xQueueReceive_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + /* receive from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with an occupied queue with a higher priority task + * pending which does not modify the queue. + * @coverage xQueueReceive + */ +void test_xQueueReceive_noop_waiting_higher_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with an occupied queue with a lower priority task waiting which does not modify the queue. + * @coverage xQueueReceive + */ +void test_xQueueReceive_noop_waiting_lower_priority( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceive with taskSCHEDULER_SUSPENDED and timeout=0 + * @details This should not cause xQueueReceive to configASSERT becuase + * xQueueReceive is non-blocking when timeout=0. + * @coverage xQueueReceive + */ +void test_xQueueReceive_nonblocking_suspended_noassert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceive( xQueue, &checkVal, 0 ) ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an invalid QueueHandle + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueReceiveFromISR( NULL, NULL, NULL ) ); +} + +/** + * @brief Test xQueueReceiveFromISR with a full queue of length 1, items size 0 + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_zeroItemSize_noassert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + ( void ) xQueueSend( xQueue, NULL, 0 ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, NULL, NULL ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with a null pvBuffer on an empty queue of length 1, items size 4 + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_fourItemSize_nullptr_assert_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Expect an assertion failure due to the null pointer passed into xqueuePeekFromISR */ + fakeAssertExpectFail(); + + /* receive from the queue with a nullptr storage location */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceiveFromISR( xQueue, NULL, NULL ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with a null pvBuffer on a full queue of length 1, items size 4 + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_fourItemSize_nullptr_assert_full( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* receive from the queue with a nullptr storage location */ + EXPECT_ASSERT_BREAK( xQueueReceiveFromISR( xQueue, NULL, NULL ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an empty queue + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_fail_empty( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t checkVal = INVALID_UINT32; + + /* receive from the queue while empty */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueReceiveFromISR( xQueue, &checkVal, NULL ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an occupied queue + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue while full */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, NULL ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR on a queue that is locked + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_locked( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Send a test value so the queue is not empty */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + /* Run xQueueReceiveFromISR with the queue locked */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, NULL ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Verify that the cRxLock counter has been incremented */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED + 1, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has not changed */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED, cGetQueueTxLock( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR on a queue that is locked and cRxLock overflows. + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_locked_overflow( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Send a test value so the queue is not empty */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, INT8_MAX ); + vSetQueueTxLock( xQueue, INT8_MAX ); + + uint32_t checkVal = INVALID_UINT32; + + /* Expect an assertion since the cRxLock value has overflowed */ + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Run xQueueReceiveFromISR with the queue locked */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, NULL ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + /* Verify that the cRxLock counter has been incremented and overflowed */ + TEST_ASSERT_EQUAL( INT8_MIN, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has not changed */ + TEST_ASSERT_EQUAL( INT8_MAX, cGetQueueTxLock( xQueue ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an occupied queue with higher priority tasks waiting. + * @details also verify that calling xQueueReceiveFromISR with a NULL pxHigherPriorityTaskWoken does not cause invalid memory access. + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_tasks_waiting_higher_priority_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* set up mocks for this test case */ + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, NULL ) ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldPending() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an occupied queue and verify that the returned pxHigherPriorityTaskWoken value has been set accordingly. + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_tasks_waiting_higher_priority_check_pxHigherPriorityTaskWoken( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* set up mocks for this test case */ + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + BaseType_t xHigherPriorityTaskWoken = false; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( true, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldPending() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReceiveFromISR with an occupied queue with a lower priority task waiting. + * @coverage xQueueReceiveFromISR + */ +void test_xQueueReceiveFromISR_tasks_waiting_lower_priority_success( void ) +{ + /* Create a new queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Add a value to the queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + ( void ) xQueueSend( xQueue, &testVal, 0 ); + + /* set up mocks for this test case */ + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + BaseType_t xHigherPriorityTaskWoken = false; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* receive from the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue, &checkVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( false, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_reset_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_reset_utest.c new file mode 100644 index 000000000..397bb87aa --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_reset_utest.c @@ -0,0 +1,201 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_reset_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ========================== Test Cases =========================== */ + +/** + * @brief Test xQueueReset with an invalid queue handle + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueReset( NULL ) ); +} + +/** + * @brief Test xQueueReset with an empty queue of size 6 x 4 bytes + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_empty( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdPASS, xQueueReset( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReset with a half-full queue of size 6 x 4 bytes + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_half_full( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + for( uint32_t i = 0; i < 3; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + TEST_ASSERT_EQUAL( 3, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdPASS, xQueueReset( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReset with a full queue of size 6 x 4 bytes + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_full( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + for( uint32_t i = 0; i < 6; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + TEST_ASSERT_EQUAL( 6, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdPASS, xQueueReset( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReset with a queue of size 6 x 4 bytes + * and a simulated higher priority task that is blocked waiting send to the queue. + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_tasks_waiting_higher_priority( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Fill the queue */ + for( uint32_t i = 0; i < 6; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReset( xQueue ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueReset with a queue of size 6 x 4 bytes + * and a simulated lower priority task that is blocked waiting to send to the queue. + * xTasksWaitingToSend + * @coverage xQueueGenericReset + */ +void test_macro_xQueueReset_tasks_waiting_lower_priority( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Fill the queue */ + for( uint32_t i = 0; i < 6; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + } + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReset( xQueue ) ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_send_blocking_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_send_blocking_utest.c new file mode 100644 index 000000000..4b1fff7e7 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_send_blocking_utest.c @@ -0,0 +1,339 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_send_blocking_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* Used to share a QueueHandle_t between a test case and it's callbacks */ +static QueueHandle_t xQueueHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + xQueueHandleStatic = NULL; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Callback for test_macro_xQueueSend_blocking_success which empties it's test queue. + */ +static BaseType_t xQueueSend_locked_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t checkVal = INVALID_UINT32; + ( void ) xQueueReceiveFromISR( xQueueHandleStatic, &checkVal, NULL ); + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + } + + return xReturnValue; +} + +/** + * @brief Test xQueueSend with timeout=10 on a full queue which is locked and + * has no tasks on it's WaitingToSend event list. + * @coverage prvUnlockQueue + */ +void test_macro_xQueueSend_blocking_success_locked_no_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + /* Check that vPortYieldWithinAPI was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was not called */ + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Callback used for xQueueSend blocking_locked tests. + */ +static BaseType_t xQueueSend_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Send from an ISR to block */ + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + ( void ) xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ); + } + } + + return xReturnValue; +} + +/** + * @brief Test xQueueSend with timeout=10 on a full queue which is locked and + * has a higher priority task on it's WaitingToSend event list. + * @coverage prvUnlockQueue + */ +void test_macro_xQueueSend_blocking_fail_locked_high_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); + + /* this task is lower priority than the pending task */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + /* Check that xTaskResumeAll was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + /* Check that vPortYieldWithinAPI was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with timeout=10 on a full queue which is locked and + * has a lower priority task on it's WaitingToSend event list. + * @coverage prvUnlockQueue + */ +void test_macro_xQueueSend_blocking_success_locked_low_prio_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); + + /* The pending task is lower priority */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + /* Check that vPortYieldWithinAPI was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was not called */ + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with taskSCHEDULER_SUSPENDED and timeout=10 + * @details This should cause xQueueSend to configASSERT becuase it would + * block forever when the queue is full. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_blocking_suspended_assert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + fakeAssertExpectFail(); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 10 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with taskSCHEDULER_RUNNING and timeout=10 on a full queue. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_blocking_timeout( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + /* Fill up the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( errQUEUE_FULL, xQueueSend( xQueue, &testVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + /* Check that vPortYieldWithinAPI was called and would have yielded */ + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was not called */ + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend in blocking mode with a full locked queue. + * @details This test case verifies a situation that should never occur ( xQueueSend called on a locked queue ). + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_blocking_locked( void ) +{ + /* Create a new binary Queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + /* Fill the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal1, TICKS_TO_WAIT ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Call xQueueSend in blocking mode with the queue locked */ + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Verify that the queue is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xQueue ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xQueue ) ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_send_nonblocking_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_send_nonblocking_utest.c new file mode 100644 index 000000000..5b33affde --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_send_nonblocking_utest.c @@ -0,0 +1,1295 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_send_nonblocking_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" + +/* =============================== CONSTANTS =============================== */ + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test xQueueSend with an invalid QueueHandle + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueSend( NULL, NULL, 0 ) ); +} + +/** + * @brief xQueueSend with an empty queue + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testval = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testval, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testval, checkVal ); + + vQueueDelete( xQueue ); +} + +/*! + * @brief xQueueSend with a full queue + * @details verify that the correct value is returned after a failed send operation. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_fail_full( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal1, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( errQUEUE_FULL, xQueueSend( xQueue, &testVal2, 0 ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with a queue of uxQueueLength=0, uxItemSize=0 + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_fail_zeroQueueLength_zeroItemSize() +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 0 ); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with a queue of uxQueueLength=0, uxItemSize=0 and NULL item. + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_fail_zeroQueueLength_zeroItemSize_null() +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 0 ); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with uxQueueLength=0, uxItemSize=1 + * @details xQueueSend should return pdFALSE because the queue is full. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_zeroQueueLength_oneItemSize( void ) +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 1 ); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + uint8_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with uxQueueLength=1, uxItemSize=0 + * @details xQueueSend should return pdTRUE because the queue is empty. + * This queue is eqivalent to a binary semaphore. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_oneQueueLength_zeroItemSize( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + uint8_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with uxQueueLength=1, uxItemSize=0 and null item. + * @details xQueueSend should return pdTRUE because the queue is empty. + * This queue is eqivalent to a binary semaphore. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_oneQueueLength_zeroItemSize_null( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with uxQueueLength=1, uxItemSize=1 + * @details xQueueSend should return pdTRUE because the queue is empty. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_oneQueueLength_oneItemSize( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 1 ); + + uint8_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with uxQueueLength=1, uxItemSize=1 and null item. + * @details xQueueSend should configASSERT becaause of the null item pointer. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_oneQueueLength_oneItemSize_null( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 1 ); + + EXPECT_ASSERT_BREAK( xQueueSend( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with an equal priority task waiting. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_task_waiting_equal_priority_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Insert an item into the event list. */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with a higher priority task waiting. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_task_waiting_higher_priority_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was not called */ + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with a lower priority task waiting. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_task_waiting_lower_priority_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Insert an item into the event list. */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend with taskSCHEDULER_SUSPENDED and timeout=0 + * @details This should not cause xQueueSend to configASSERT becuase + * xQueueSend is non-blocking when timeout=0. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_nonblocking_suspended_noassert( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with an invalid (null) QueueHandle + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueSendFromISR( NULL, &testVal, NULL ) ); +} + +/** + * @brief xQueueSendFromISR with an empty queue + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testval = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testval, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testval, checkVal ); + vQueueDelete( xQueue ); +} + +/*! + * @brief xQueueSendFromISR with a full queue + * @details verify that the correct value is returned after a failed send operation. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_fail( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal1, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t testVal2 = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + TEST_ASSERT_EQUAL( errQUEUE_FULL, xQueueSendFromISR( xQueue, &testVal2, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal1, checkVal ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a queue of uxQueueLength=0, uxItemSize=0 + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_fail_zeroQueueLength_zeroItemSize() +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 0 ); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSendFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a queue of uxQueueLength=0, uxItemSize=0 and NULL item. + * @details This is an invalid queue configuration and causes a failed configASSERT. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_fail_zeroQueueLength_zeroItemSize_null() +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSendFromISR( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with uxQueueLength=0, uxItemSize=1 + * @details xQueueSendFromISR should return pdFALSE because the queue is full. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_zeroQueueLength_oneItemSize( void ) +{ + /* Expect that xQueueCreate will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueHandle_t xQueue = xQueueCreate( 0, 1 ); + + /* Clear the assert flag*/ + fakeAssertGetFlagAndClear(); + + uint8_t testVal = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSendFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with uxQueueLength=1, uxItemSize=0 + * @details xQueueSendFromISR should return pdTRUE because the queue is empty. + * This queue is eqivalent to a binary semaphore. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_oneQueueLength_zeroItemSize( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + uint8_t testVal = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with uxQueueLength=1, uxItemSize=0 and null item. + * @details xQueueSendFromISR should return pdTRUE because the queue is empty. + * This queue is eqivalent to a binary semaphore. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_oneQueueLength_zeroItemSize_null( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with uxQueueLength=1, uxItemSize=1 + * @details xQueueSendFromISR should return pdTRUE because the queue is empty. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_oneQueueLength_oneItemSize( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 1 ); + + uint8_t testVal = getNextMonotonicTestValue(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with uxQueueLength=1, uxItemSize=1 and null item. + * @details xQueueSendFromISR should configASSERT becaause of the null item pointer. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_oneQueueLength_oneItemSize_null( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, 1 ); + + EXPECT_ASSERT_BREAK( xQueueSendFromISR( xQueue, NULL, 0 ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a null pxHigherPriorityTaskWoken. + * @details Test xQueueSendFromISR with a NULL pxHigherPriorityTaskWoken + * in a case where xHigherPriorityTaskWoken would otherwise be written to + * and cause a null pointer dereference. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_task_waiting_higher_priority_null_pxHigherPriorityTaskWoken( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list. */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a higher priority task waiting + * @details Test xQueueSendFromISR with a higher priority task waiting and + * verifies that xHigherPriorityTaskWoken is set accoridngly. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_task_waiting_higher_priority_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list. */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a lower priority task waiting + * @details Test xQueueSendFromISR with a lower priority task waiting and + * verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_task_waiting_lower_priority_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list. */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueue ); + + uint32_t testVal = getNextMonotonicTestValue(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, &xHigherPriorityTaskWoken ) ); + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR on a queue that is locked + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_locked( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testval = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testval, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED + 1, cGetQueueTxLock( xQueue ) ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + + TEST_ASSERT_EQUAL( testval, checkVal ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR on a queue that is locked and cRxLock overflows. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_locked_overflow( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, INT8_MAX ); + vSetQueueTxLock( xQueue, INT8_MAX ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Expect an assertion since the cTxLock value has overflowed */ + fakeAssertExpectFail(); + + uint32_t testval = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testval, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( INT8_MAX, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( INT8_MIN, cGetQueueTxLock( xQueue ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + uint32_t checkVal = INVALID_UINT32; + + ( void ) xQueueReceive( xQueue, &checkVal, 0 ); + + TEST_ASSERT_EQUAL( testval, checkVal ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendToFront with an invalid (NULL) handle + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSendToFront_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueSendToFront( NULL, &testVal, 0 ) ); +} + +/** + * @brief Test xQueueSendToFront with a queue of length 6 + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSendToFront( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + /* Add 5 sequential items to the queue */ + for( int i = 1; i <= 5; i++ ) + { + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &i, 0 ) ); + } + + TEST_ASSERT_EQUAL( 5, uxQueueMessagesWaiting( xQueue ) ); + + /* Add "random-ish" value to front of queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendToFront( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 6, uxQueueMessagesWaiting( xQueue ) ); + + /* receive the value added to the front */ + uint32_t testValCompare = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testValCompare, 0 ) ); + TEST_ASSERT_EQUAL( testVal, testValCompare ); + + /* verify the remaining items and remove from the queue */ + for( uint32_t i = 1; i <= 5; i++ ) + { + uint32_t testVal = INVALID_UINT32; + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal, 0 ) ); + TEST_ASSERT_EQUAL( i, testVal ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendToFrontFromISR with a queue of length 6 + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendToFrontFromISR_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueSendToFrontFromISR( NULL, &testVal, 0 ) ); +} + +/** + * @brief Test xQueueSendToFrontFromISR with a queue of length 6 + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendToFrontFromISR( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + /* Add 5 sequential items to the queue */ + for( int i = 1; i <= 5; i++ ) + { + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &i, 0 ) ); + } + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Add "random-ish" value to front of queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 5, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendToFrontFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 6, uxQueueMessagesWaiting( xQueue ) ); + + /* receive the value added to the front */ + uint32_t testValCompare = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testValCompare, 0 ) ); + TEST_ASSERT_EQUAL( testVal, testValCompare ); + + /* verify the remaining items and remove from the queue */ + for( uint32_t i = 1; i <= 5; i++ ) + { + uint32_t testVal = INVALID_UINT32; + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal, 0 ) ); + TEST_ASSERT_EQUAL( i, testVal ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendToBack with an invalid (NULL) handle + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSendToBack_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueSendToBack( NULL, &testVal, 0 ) ); +} + +/** + * @brief Test xQueueSendToBack with a queue of length 6 + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSendToBack( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + /* Add 5 sequential items to the queue */ + for( int i = 1; i <= 5; i++ ) + { + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &i, 0 ) ); + } + + TEST_ASSERT_EQUAL( 5, uxQueueMessagesWaiting( xQueue ) ); + + /* Add "random-ish" value to end of queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendToBack( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 6, uxQueueMessagesWaiting( xQueue ) ); + + /* verify the first 5 items and remove from the queue */ + for( uint32_t i = 1; i <= 5; i++ ) + { + uint32_t testVal = INVALID_UINT32; + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal, 0 ) ); + TEST_ASSERT_EQUAL( i, testVal ); + } + + /* receive the value added to the front */ + uint32_t testValCompare = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testValCompare, 0 ) ); + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), testValCompare ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendToBackFromISR with an invalid (NULL) handle. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendToBackFromISR_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueSendToBackFromISR( NULL, &testVal, 0 ) ); +} + +/** + * @brief Test xQueueSendToBackFromISR with a queue of length 6 + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendToBackFromISR( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 6, sizeof( uint32_t ) ); + + /* Add 5 sequential items to the queue */ + for( int i = 1; i <= 5; i++ ) + { + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &i, 0 ) ); + } + + /* Add "random-ish" value to end of queue */ + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 5, uxQueueMessagesWaiting( xQueue ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendToBackFromISR( xQueue, &testVal, 0 ) ); + + TEST_ASSERT_EQUAL( 6, uxQueueMessagesWaiting( xQueue ) ); + + /* verify the first 5 items and remove from the queue */ + for( uint32_t i = 1; i <= 5; i++ ) + { + uint32_t testVal = INVALID_UINT32; + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal, 0 ) ); + TEST_ASSERT_EQUAL( i, testVal ); + } + + /* receive the value added to the front */ + uint32_t testValCompare = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testValCompare, 0 ) ); + TEST_ASSERT_EQUAL( testVal, testValCompare ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwrite with an invalid (NULL) queue handle. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueOverwrite_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueOverwrite( NULL, &testVal ) ); +} + +/** + * @brief Test xQueueOverwrite on an empty queue of length 1 + * @details Test xQueueOverwrite with an empty queue, equivalent to xQueueSend. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueOverwrite_empty_queue_1_add_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Send a new value to the queue using xQueueOverwrite */ + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal1 ) ); + + /* Check that the queue is now full */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Receive from the queue and verify the received value */ + uint32_t checkVal1 = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwrite on a full queue of size (1,4) + * @details Test xQueueOverwrite with a full queue containing one item. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueOverwrite_overwrite_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* send a random value to the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal1, 0 ) ); + + /* Check that the queue now has a single message waiting */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Peek from the queue and verify that the returned value matches testVal1 */ + uint32_t checkVal1 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal1 ); + + /* Overwrite testVal1 with testVal2 in the queue */ + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal2 ) ); + + /* Receive from the queue */ + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal2, 0 ) ); + + /* Validate that checkVal2 was received from the queue */ + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( testVal1, checkVal2 ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwrite on a full queue of size (2,4) + * @details Test xQueueOverwrite with a full queue containing one item. + * @note Operation of xQueueOverwrite on queues larger than 1 in length is undefined. + * The behavior in this test is undefined. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueOverwrite_full_assert_undefined( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 2, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Expect that xQueueOverwrite will assert due to uxQueueLength > 1 */ + fakeAssertExpectFail(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal1 ) ); + + /* Check that xQueueOverwrite called configASSERT */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* Check that the queue now has a single message waiting */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Overwrite testVal1 with testVal2 in the queue */ + uint32_t testVal2 = getNextMonotonicTestValue(); + + /* Expect that xQueueOverwrite will assert due to uxQueueLength > 1 */ + fakeAssertExpectFail(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal2 ) ); + /* Check that xQueueOverwrite called configASSERT */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Receive from the queue */ + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal2, 0 ) ); + + /* Validate that checkVal2 was received from the queue */ + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal2 ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwriteFromISR with an invalid (NULL) queue handle. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueOverwriteFromISR_invalid_handle( void ) +{ + uint32_t testVal = INVALID_UINT32; + + EXPECT_ASSERT_BREAK( xQueueOverwriteFromISR( NULL, &testVal, NULL ) ); +} + +/** + * @brief Test xQueueOverwriteFromISR on an empty queue of length 1 + * @details Test xQueueOverwriteFromISR with an empty queue, equivalent to xQueueSend. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueOverwriteFromISR_empty_queue_1_add_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Send a new value to the queue using xQueueOverwriteFromISR */ + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal1, NULL ) ); + + /* Check that the queue is now full */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Receive from the queue and verify the received value */ + uint32_t checkVal1 = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwriteFromISR on a full queue of size (1,4) + * @details Test xQueueOverwriteFromISR with a full queue containing one item. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueOverwriteFromISR_overwrite_success( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + /* send a random value to the queue */ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal1, 0 ) ); + + /* Check that the queue now has a single message waiting */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Peek from the queue and verify that the returned value matches testVal1 */ + uint32_t checkVal1 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueuePeek( xQueue, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal1 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Overwrite testVal1 with testVal2 in the queue */ + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal2, NULL ) ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Receive from the queue */ + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal2, 0 ) ); + + /* Validate that checkVal2 was received from the queue */ + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( testVal1, checkVal2 ); + + /* Verify that the queue is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwriteFromISR on a full queue of size (2,4) + * @details Test xQueueOverwriteFromISR with a full queue containing one item. + * @note Operation of xQueueOverwriteFromISR on queues larger than 1 in length is undefined. + * The behavior in this test is undefined. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueOverwriteFromISR_full_assert_undefined( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 2, sizeof( uint32_t ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + /* Expect that xQueueOverwriteFromISR will assert due to uxQueueLength > 1 */ + fakeAssertExpectFail(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal1, NULL ) ); + + /* Check that xQueueOverwriteFromISR called configASSERT */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* Check that the queue now has a single message waiting */ + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Overwrite testVal1 with testVal2 in the queue */ + uint32_t testVal2 = getNextMonotonicTestValue(); + + /* Expect that xQueueOverwriteFromISR will assert due to uxQueueLength > 1 */ + fakeAssertExpectFail(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal2, NULL ) ); + /* Check that xQueueOverwriteFromISR called configASSERT */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xQueue ) ); + + /* Receive from the queue */ + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkVal2, 0 ) ); + + /* Validate that checkVal2 was received from the queue */ + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + TEST_ASSERT_NOT_EQUAL( 0, checkVal2 ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/generic/queue_status_utest.c b/FreeRTOS/Test/CMock/queue/generic/queue_status_utest.c new file mode 100644 index 000000000..f4dd98d3a --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/generic/queue_status_utest.c @@ -0,0 +1,328 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_status_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test uxQueueMessagesWaiting with an invalid QueueHandle + * @coverage uxQueueMessagesWaiting + */ +void test_uxQueueMessagesWaiting_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( uxQueueMessagesWaiting( NULL ) ); +} + +/** + * @brief Test uxQueueMessagesWaiting with a queue of size 5 x 4 bytes + * @details Test uxQueueMessagesWaiting with a typical queue when empty and occupied. + * @coverage uxQueueMessagesWaiting + */ +void test_uxQueueMessagesWaiting_empty_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueue ) ); + + for( uint32_t i = 0; i < 5; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + TEST_ASSERT_EQUAL( i + 1, uxQueueMessagesWaiting( xQueue ) ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test uxQueueMessagesWaitingFromISR with an invalid Queue Handle + * @coverage uxQueueMessagesWaitingFromISR + */ +void test_uxQueueMessagesWaitingFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( uxQueueMessagesWaitingFromISR( NULL ) ); +} + +/** + * @brief Test uxQueueMessagesWaitingFromISR with a queue of size 5 x 4 bytes + * @details Test uxQueueMessagesWaitingFromISR with a typical queue when empty and occupied. + * @coverage uxQueueMessagesWaitingFromISR + */ +void test_uxQueueMessagesWaitingFromISR_empty_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaitingFromISR( xQueue ) ); + + for( uint32_t i = 0; i < 5; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + TEST_ASSERT_EQUAL( i + 1, uxQueueMessagesWaitingFromISR( xQueue ) ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test uxQueueSpacesAvailable with an invalid QueueHandle + * @coverage uxQueueSpacesAvailable + */ +void test_uxQueueSpacesAvailable_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( uxQueueSpacesAvailable( NULL ) ); +} + +/** + * @brief Test uxQueueSpacesAvailable with a queue of size 5 x 4 bytes + * @details Test uxQueueSpacesAvailable with a typical queue when empty and occupied. + * @coverage uxQueueSpacesAvailable + */ +void test_uxQueueSpacesAvailable_empty_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( 5, uxQueueSpacesAvailable( xQueue ) ); + + for( uint32_t i = 0; i < 5; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + TEST_ASSERT_EQUAL( 4 - i, uxQueueSpacesAvailable( xQueue ) ); + } + + vQueueDelete( xQueue ); +} + + +/** + * @brief Test xQueueIsQueueEmptyFromISR with an invalid QueueHandle + * @coverage xQueueIsQueueEmptyFromISR + */ +void test_xQueueIsQueueEmptyFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueIsQueueEmptyFromISR( NULL ) ); +} + +/** + * @brief Test xQueueIsQueueEmptyFromISR with a queue of size 5 x 4 bytes + * @details Test xQueueIsQueueEmptyFromISR with a typical queue when empty and occupied. + * @coverage xQueueIsQueueEmptyFromISR + */ +void test_xQueueIsQueueEmptyFromISR_empty_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueIsQueueEmptyFromISR( xQueue ) ); + + for( uint32_t i = 0; i < 5; i++ ) + { + xQueueSend( xQueue, &i, 0 ); + TEST_ASSERT_EQUAL( pdFALSE, xQueueIsQueueEmptyFromISR( xQueue ) ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueIsQueueFullFromISR with an invalid QueueHandle + * @coverage xQueueIsQueueFullFromISR + */ +void test_xQueueIsQueueFullFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xQueueIsQueueFullFromISR( NULL ) ); +} + +/** + * @brief Test xQueueIsQueueFullFromISR with a queue of size 5 x 4 bytes + * @details Test xQueueIsQueueFullFromISR with a typical queue when empty and occupied. + * @coverage xQueueIsQueueFullFromISR + */ +void test_xQueueIsQueueFullFromISR_empty_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + for( uint32_t i = 0; i < 5; i++ ) + { + TEST_ASSERT_EQUAL( pdFALSE, xQueueIsQueueFullFromISR( xQueue ) ); + xQueueSend( xQueue, &i, 0 ); + } + + TEST_ASSERT_EQUAL( pdTRUE, xQueueIsQueueFullFromISR( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test vQueueWaitForMessageRestricted with an empty queue. + * @details Test vQueueWaitForMessageRestricted with various values for + * xTicksToWait and xWaitIndefinitely. + * @coverage vQueueWaitForMessageRestricted + */ +void test_vQueueWaitForMessageRestricted_empty( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + struct + { + TickType_t xTicksToWait; + BaseType_t xWaitIndefinitely; + } + xTestCaseArray[] = + { + { 0, pdFALSE }, + { 0, pdTRUE }, + { 1, pdFALSE }, + { 1, pdTRUE }, + { 10, pdFALSE }, + { 10, pdTRUE }, + { 65536, pdTRUE } + }; + + List_t * pxTasksWaitingToReceive = pxGetTasksWaitingToReceiveFromQueue( xQueue ); + + for( uint32_t i = 0; i < ( sizeof( xTestCaseArray ) / sizeof( xTestCaseArray[ 0 ] ) ); i++ ) + { + vTaskPlaceOnEventListRestricted_Expect( pxTasksWaitingToReceive, + xTestCaseArray[ i ].xTicksToWait, + xTestCaseArray[ i ].xWaitIndefinitely ); + /* call api function */ + vQueueWaitForMessageRestricted( xQueue, + xTestCaseArray[ i ].xTicksToWait, + xTestCaseArray[ i ].xWaitIndefinitely ); + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test vQueueWaitForMessageRestricted with an occupied queue. + * @details Test vQueueWaitForMessageRestricted with various values for + * xTicksToWait and xWaitIndefinitely. + * @coverage vQueueWaitForMessageRestricted + */ +void test_vQueueWaitForMessageRestricted_occupied( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 5, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + xQueueSend( xQueue, &testVal, 0 ); + + const struct + { + TickType_t xTicksToWait; + BaseType_t xWaitIndefinitely; + } + xTestCaseArray[] = + { + { 0, pdFALSE }, + { 0, pdTRUE }, + { 1, pdFALSE }, + { 1, pdTRUE }, + { 10, pdFALSE }, + { 10, pdTRUE }, + { 65536, pdTRUE } + }; + + for( uint32_t i = 0; i < ( sizeof( xTestCaseArray ) / sizeof( xTestCaseArray[ 0 ] ) ); i++ ) + { + /* call api function */ + vQueueWaitForMessageRestricted( xQueue, + xTestCaseArray[ i ].xTicksToWait, + xTestCaseArray[ i ].xWaitIndefinitely ); + /* Do not expect a call to vTaskPlaceOnEventListRestricted */ + } + + vQueueDelete( xQueue ); +} + +/** + * @brief Test vQueueWaitForMessageRestricted on an empty locked queue. + * @details This test case verifies a situation that should never occur ( vQueueWaitForMessageRestricted called on a locked queue ). + * @coverage vQueueWaitForMessageRestricted + */ +void test_vQueueWaitForMessageRestricted_locked( void ) +{ + /* Create a new binary Queue */ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueue, queueLOCKED_UNMODIFIED ); + + List_t * pxTasksWaitingToReceive = pxGetTasksWaitingToReceiveFromQueue( xQueue ); + + vTaskPlaceOnEventListRestricted_Expect( pxTasksWaitingToReceive, + 10, + pdFALSE ); + + /* Run vQueueWaitForMessageRestricted with the queue locked */ + vQueueWaitForMessageRestricted( xQueue, 10, pdFALSE ); + + /* Verify that the queue is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xQueue ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xQueue ) ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/queue.yml b/FreeRTOS/Test/CMock/queue/queue.yml index de9ad9be4..1ebd268bf 100644 --- a/FreeRTOS/Test/CMock/queue/queue.yml +++ b/FreeRTOS/Test/CMock/queue/queue.yml @@ -13,11 +13,13 @@ :callback_include_count: true # include a count arg when calling the callback :callback_after_arg_check: false # check arguments before calling the callback :treat_as: - uint8: HEX8 - uint16: HEX16 - uint32: UINT32 - int8: INT8 - bool: UINT8 + uint8: HEX8 + uint16: HEX16 + uint32: UINT32 + int8: INT8 + bool: UINT8 + UBaseType_t: UINT32 + BaseType_t: UINT32 :includes: # This will add these includes to each mock. - - "FreeRTOS.h" diff --git a/FreeRTOS/Test/CMock/queue/queue_utest.c b/FreeRTOS/Test/CMock/queue/queue_utest.c deleted file mode 100644 index 9db394f24..000000000 --- a/FreeRTOS/Test/CMock/queue/queue_utest.c +++ /dev/null @@ -1,113 +0,0 @@ -/* - * FreeRTOS V202012.00 - * Copyright (C) 2020 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. - * - * https://www.FreeRTOS.org - * https://github.com/FreeRTOS - * - */ -/*! @file queue_utest.c */ - -/* C runtime includes. */ -#include -#include - -/* Queue includes */ -#include "FreeRTOS.h" -#include "FreeRTOSConfig.h" -#include "queue.h" - -/* Test includes. */ -#include "unity.h" -#include "unity_memory.h" - -/* Mock includes. */ -#include "mock_task.h" -#include "mock_list.h" -#include "mock_fake_assert.h" -#include "mock_fake_port.h" - -/* ============================ GLOBAL VARIABLES =========================== */ - -/* ========================== CALLBACK FUNCTIONS =========================== */ - -void * pvPortMalloc( size_t xSize ) -{ - return unity_malloc( xSize ); -} -void vPortFree( void * pv ) -{ - return unity_free( pv ); -} - -/******************************************************************************* - * Unity fixtures - ******************************************************************************/ -void setUp( void ) -{ - mock_task_Init(); - mock_fake_assert_Init(); - mock_fake_port_Init(); - vFakeAssert_Ignore(); - vFakePortEnterCriticalSection_Ignore(); - vFakePortExitCriticalSection_Ignore(); - - /* Track calls to malloc / free */ - UnityMalloc_StartTest(); -} - -/*! called before each testcase */ -void tearDown( void ) -{ - UnityMalloc_EndTest(); - - mock_task_Verify(); - mock_task_Destroy(); - - mock_fake_assert_Verify(); - mock_fake_assert_Destroy(); - - mock_fake_port_Verify(); - mock_fake_port_Destroy(); -} - -/*! called at the beginning of the whole suite */ -void suiteSetUp() -{ -} - -/*! called at the end of the whole suite */ -int suiteTearDown( int numFailures ) -{ - return numFailures; -} - -/*! - * @brief xQueueCreate happy path. - * @coverage xQueueGenericCreate - */ -void test_xQueueCreate_Success( void ) -{ - vListInitialise_Ignore(); - QueueHandle_t xQueue = xQueueCreate( 1, 1 ); - - TEST_ASSERT_NOT_EQUAL( NULL, xQueue ); - vQueueDelete(xQueue); -} diff --git a/FreeRTOS/Test/CMock/queue/queue_utest_common.c b/FreeRTOS/Test/CMock/queue/queue_utest_common.c new file mode 100644 index 000000000..e6a1371d7 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/queue_utest_common.c @@ -0,0 +1,323 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_utest_common.c */ + +#include "queue_utest_common.h" + +/* C runtime includes. */ +#include +#include +#include + +/* Test includes. */ +#include "unity.h" +#include "unity_memory.h" + +/* Mock includes. */ +#include "mock_task.h" +#include "mock_fake_assert.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ +static uint32_t ulMonotonicTestValue = 0xFFFF; + +#if defined( configASSERT ) + static bool xMaskAssert = false; + static BaseType_t xNumAssertsMasked = 0; + bool xMaskAssertAndAbort = false; +#endif + +static size_t uxLastMallocSize = 0; +static void * pLastFreedAddress = 0; +static uint32_t ulNumMallocCalls = 0; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +void * pvPortMalloc( size_t xSize ) +{ + uxLastMallocSize = xSize; + ulNumMallocCalls++; + return unity_malloc( xSize ); +} + +void vPortFree( void * pv ) +{ + pLastFreedAddress = pv; + return unity_free( pv ); +} + + +#if defined( configASSERT ) + void fakeAssertCallback( bool assertion, + char * file, + int line, + int num_calls ) + { + if( !assertion && xMaskAssertAndAbort ) + { + Throw( configASSERT_E ); + } + else if( !assertion && !xMaskAssert ) + { + printf( "ASSERT: File: %s line: %d\n", file, line ); + TEST_FAIL(); + } + else if( !assertion ) + { + xNumAssertsMasked++; + } + } +#endif /* if defined( configASSERT ) */ + +/* ============================= Unity Fixtures ============================= */ + +void commonSetUp( void ) +{ + mock_task_Init(); + mock_fake_assert_Init(); + mock_fake_port_Init(); + + /* Map configAssert to a local callback */ + vFakeAssert_Stub( fakeAssertCallback ); + + /* Reset globals for vFakeAssert() */ + #if defined( configASSERT ) + xMaskAssert = false; + xNumAssertsMasked = 0; + xMaskAssertAndAbort = false; + #endif + + /* Reset malloc related globals */ + uxLastMallocSize = false; + pLastFreedAddress = false; + ulNumMallocCalls = 0; + + td_task_register_stubs(); + td_port_register_stubs(); + + /* Track calls to malloc / free */ + UnityMalloc_StartTest(); +} + +void commonTearDown( void ) +{ + #if defined( configASSERT ) + TEST_ASSERT_EQUAL_MESSAGE( 0, xNumAssertsMasked, + "An unexpected configASSERT was called in this test case." ); + #endif + + td_task_teardown_check(); + td_port_teardown_check(); + + mock_task_Verify(); + mock_task_Destroy(); + + mock_fake_assert_Verify(); + mock_fake_assert_Destroy(); + mock_fake_port_Verify(); + mock_fake_port_Destroy(); + + UnityMalloc_EndTest(); +} + +void commonSuiteSetUp() +{ +} + +int commonSuiteTearDown( int numFailures ) +{ + return numFailures; +} + +/* ========================== Helper functions =========================== */ +uint32_t getNextMonotonicTestValue() +{ + return ++ulMonotonicTestValue; +} + +uint32_t getLastMonotonicTestValue() +{ + return ulMonotonicTestValue; +} + +void fakeAssertExpectFail( void ) +{ + #if defined( configASSERT ) + /* Verify that there are no pending assertions */ + TEST_ASSERT_TRUE( xNumAssertsMasked == 0 ); + + /* Set flag */ + xMaskAssert = true; + #endif +} + +bool fakeAssertGetFlagAndClear( void ) +{ + #if defined( configASSERT ) + bool xRetVal = ( xNumAssertsMasked > 0 ); + + /* Verify that only one assertion failed since flags were last handled */ + TEST_ASSERT_TRUE_MESSAGE( xNumAssertsMasked <= 1, "Number of asserts > 1 in fakeAssertGetFlagAndClear." ); + + /* Reset globals */ + xMaskAssert = false; + xNumAssertsMasked = 0; + return xRetVal; + #else + return true; + #endif /* if defined( configASSERT ) */ +} + +BaseType_t fakeAssertGetNumAssertsAndClear( void ) +{ + #if defined( configASSERT ) + BaseType_t xRetVal = xNumAssertsMasked; + + /* Reset globals */ + xMaskAssert = false; + xNumAssertsMasked = 0; + return xRetVal; + #else + return 0; + #endif +} + +void fakeAssertVerifyNumAssertsAndClear( uint32_t ulNumAssertsExpected ) +{ + #if defined( configASSERT ) + TEST_ASSERT_EQUAL( ulNumAssertsExpected, xNumAssertsMasked ); + + /* Reset globals */ + xMaskAssert = false; + xNumAssertsMasked = 0; + #endif +} + +size_t getLastMallocSize( void ) +{ + return uxLastMallocSize; +} + +void * getLastFreedAddress( void ) +{ + return pLastFreedAddress; +} + +size_t getNumberMallocCalls( void ) +{ + return ulNumMallocCalls; +} + +List_t * pxGetTasksWaitingToSendToQueue( QueueHandle_t xQueue ) +{ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + List_t * pxTasksWaitingToSend = ( List_t * ) &( pxQueue->xDummy3[ 0 ] ); + + return pxTasksWaitingToSend; +} + +List_t * pxGetTasksWaitingToReceiveFromQueue( QueueHandle_t xQueue ) +{ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + List_t * pxTasksWaitingToReceive = ( List_t * ) &( pxQueue->xDummy3[ 1 ] ); + + return pxTasksWaitingToReceive; +} + +int8_t cGetQueueRxLock( QueueHandle_t xQueue ) +{ + /* Access private lock counter */ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + int8_t * pcRxLock = ( int8_t * ) &( pxQueue->ucDummy5[ 0 ] ); + + return *pcRxLock; +} + +int8_t cGetQueueTxLock( QueueHandle_t xQueue ) +{ + /* Access private lock counter */ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + int8_t * pcTxLock = ( int8_t * ) &( pxQueue->ucDummy5[ 1 ] ); + + return *pcTxLock; +} + +void vSetQueueRxLock( QueueHandle_t xQueue, + int8_t value ) +{ + /* Access private lock counter */ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + int8_t * pcRxLock = ( int8_t * ) &( pxQueue->ucDummy5[ 0 ] ); + + *pcRxLock = value; +} + +void vSetQueueTxLock( QueueHandle_t xQueue, + int8_t value ) +{ + /* Access private lock counter */ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + int8_t * pcTxLock = ( int8_t * ) &( pxQueue->ucDummy5[ 1 ] ); + + *pcTxLock = value; +} + +/** + * @brief Helper function to call xQueueSend with sequential values + * @param xQueue The handle to the queue to be tested + * @param numberOfItems Number of sequential items to add to the queue under test. + */ +void queue_common_add_sequential_to_queue( QueueHandle_t xQueue, + uint32_t numberOfItems ) +{ + for( uint32_t i = 0; i < numberOfItems; i++ ) + { + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &i, 0 ) ); + TEST_ASSERT_EQUAL_UINT32( i + 1, uxQueueMessagesWaiting( xQueue ) ); + } +} + +/** + * @brief Helper function to call xQueueReceive and verify sequential values are received + * @param xQueue The handle to the queue to be tested + * @param maxItems Maximum number of items the queue supports + * @param numberOfItems Number of sequential items to receive from the queue under test. + * @param expectedFirstValue The first value to expect to receive from the queue + */ +void queue_common_receive_sequential_from_queue( QueueHandle_t xQueue, + uint32_t maxItems, + uint32_t numberOfItems, + uint32_t expectedFirstValue ) +{ + for( uint32_t i = 0; i < numberOfItems; i++ ) + { + uint32_t testVal = 0xFFFFFFFF; + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &testVal, 0 ) ); + TEST_ASSERT_EQUAL( expectedFirstValue + i, testVal ); + TEST_ASSERT_EQUAL_UINT32( i + 1, uxQueueSpacesAvailable( xQueue ) ); + TEST_ASSERT_EQUAL_UINT32( maxItems - i - 1, uxQueueMessagesWaiting( xQueue ) ); + } +} diff --git a/FreeRTOS/Test/CMock/queue/queue_utest_common.h b/FreeRTOS/Test/CMock/queue/queue_utest_common.h new file mode 100644 index 000000000..511879e60 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/queue_utest_common.h @@ -0,0 +1,394 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_utest_common.h */ + +#ifndef QUEUE_UTEST_COMMON_H +#define QUEUE_UTEST_COMMON_H + +/* C runtime includes. */ +#include +#include +#include + +/* Test includes. */ +#include "unity.h" +#include "unity_memory.h" +#include "CException.h" + +/* FreeRTOS includes */ +#include "FreeRTOS.h" +#include "queue.h" + +/* Mock includes. */ +#include "mock_task.h" +#include "mock_fake_assert.h" + +/* ================================ CONSTANTS ===============================*/ + +#define MAX_MULTI_LEN 16 +#define MAX_QUEUE_ITEMS 500 +#define QUEUE_T_SIZE sizeof( StaticQueue_t ) + +#define B_SEMPHR_AVAILABLE 1 +#define B_SEMPHR_TAKEN 0 + +#define INVALID_UINT32 0xFFFFFFFF +#define INVALID_PTR ( ( void * ) INVALID_UINT32 ) + +#define configASSERT_E 0xAA101 + +#define queueUNLOCKED ( ( int8_t ) -1 ) +#define queueLOCKED_UNMODIFIED ( ( int8_t ) 0 ) + +#define DEFAULT_PRIORITY 5 + +#define TICKS_TO_WAIT 10 +#define NUM_CALLS_TO_INTERCEPT TICKS_TO_WAIT / 2 + +/* ============================ GLOBAL VARIABLES =========================== */ +bool xMaskAssertAndAbort; + +/* ================================= MACROS ================================ */ + +/** + * @brief Expect a configASSERT from the funciton called. + * Break out of the called function when this occurs. + * @details Use this macro when the call passsed in as a parameter is expected + * to cause invalid memory access. + */ +#define EXPECT_ASSERT_BREAK( call ) \ + do \ + { \ + xMaskAssertAndAbort = true; \ + CEXCEPTION_T e = CEXCEPTION_NONE; \ + Try \ + { \ + call; \ + TEST_FAIL(); \ + } \ + Catch( e ) \ + TEST_ASSERT_EQUAL( configASSERT_E, e ); \ + } while ( 0 ) + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/** + * @brief defines malloc() for this test and redirects it to unity_malloc + * @param xSize size of memory block to be allocated + * @return pointer to the allocated memory on success. + * @return NULL if the memory could not be allocated. + */ +void * pvPortMalloc( size_t xSize ); + +/** + * @brief defines free() for this test and redirects it to unity_free + * @param pv pointer to the block to be freed + */ +void vPortFree( void * pv ); + +/** + * @brief Callback function for calls to configASSERT + * @details This callback function will cause a unit test to fail if the + * provided assertion is false and the fakeAssertExpectFail() + * function was not called prior to the assertion. + * @param assertion Boolean assertion passed into the configASSERT() macro + * @param file Name of the file in which the assert occured + * @param line Line number of the assertion + * @param num_calls Number of times configASSERT() was called + */ +void fakeAssertCallback( bool assertion, + char * file, + int line, + int num_calls ); + +/* ========================== Unity fixtures =========================== */ + +/** + * @brief Setup function called before each test case. + */ +void setUp( void ); + +/** + * @brief Teardown function called after each test case. + */ +void tearDown( void ); + +/** + * @brief Setup function called before this test suite (file). + */ +void suiteSetUp(); + +/** + * @brief Setup function called afer this test suite (file) has completed. + */ +int suiteTearDown( int numFailures ); + +/* ========================== Helper functions =========================== */ + +/** + * @brief Common test case setup function for queue tests. + */ +void commonSetUp( void ); + +/** + * @brief Common test case teardown function for queue tests. + */ +void commonTearDown( void ); + +/** + * @brief Common test suite setup function for queue test suites. + */ +void commonSuiteSetUp(); + +/** + * @brief Common test suite teardown function for queue test suites. + */ +int commonSuiteTearDown( int numFailures ); + +/** + * @brief Get a monotonically increasing test value (somewhat random). + */ +uint32_t getNextMonotonicTestValue(); + +/** + * @brief Get the test value provided by the last call to getNextMonotonicTestValue(). + */ +uint32_t getLastMonotonicTestValue(); + +/** + * @brief Mask subsquent failing assertions until next test case. + */ +void fakeAssertExpectFail( void ); + +/** + * @brief Determine if a configASSERT occurred and clear the assertion flag. + * @return true if an assert occureed since the start of the test suite or + * the last call to fakeAssertGetFlagAndClear. + * @return false if no assert was triggered. + */ +bool fakeAssertGetFlagAndClear( void ); + +/** + * @brief get the size of the last heap memory allocation via pvPortMalloc() + * @return The parameter given during the last call to pvPortMalloc() + */ +size_t getLastMallocSize( void ); + +/** + * @brief get the address of the last heap memory deallocation via pvPortFree() + * @return The parameter given during the last call to pvPortFree() + */ +void * getLastFreedAddress( void ); + +/** + * @brief get the number of malloc calls made in the current test case. + * @return number of malloc calls made since the start of the test case. + */ +size_t getNumberMallocCalls( void ); + +/** + * @return A pointer to the given queue's xTasksWaitingToSend event list. + */ +List_t * pxGetTasksWaitingToSendToQueue( QueueHandle_t xQueue ); + +/** + * @return A pointer to the given queue's xTasksWaitingToReceive event list. + */ +List_t * pxGetTasksWaitingToReceiveFromQueue( QueueHandle_t xQueue ); + +/** + * @return The value of a given queue's cRxLock. + */ +int8_t cGetQueueRxLock( QueueHandle_t xQueue ); + +/** + * @return The value of a given queue's cTxLock. + */ +int8_t cGetQueueTxLock( QueueHandle_t xQueue ); + +/** + * @brief Set the value of a given queue's cRxLock to the specified value. + */ +void vSetQueueRxLock( QueueHandle_t xQueue, + int8_t value ); + +/** + * @brief Set the value of a given queue's cTxLock to the specified value. + */ +void vSetQueueTxLock( QueueHandle_t xQueue, + int8_t value ); + +/** + * @brief Get the number of asserts that have occurred since the last call to this function in a given test case. + */ +BaseType_t fakeAssertGetNumAssertsAndClear( void ); + +/** + * @brief Check that the number of failed configASSERTs that have occured in this test case equals the given number. + */ +void fakeAssertVerifyNumAssertsAndClear( uint32_t ulNumAssertsExpected ); + +/** + * @brief Receives a given number of items from the given queue and verifies that the items contain sequential values. + */ +void queue_common_receive_sequential_from_queue( QueueHandle_t xQueue, + uint32_t maxItems, + uint32_t numberOfItems, + uint32_t expectedFirstValue ); + +/** + * @brief Adds a given number of itesm to the given queue with sequential values in each item. + */ +void queue_common_add_sequential_to_queue( QueueHandle_t xQueue, + uint32_t numberOfItems ); + + +/** + * @brief Register the stubs contained in td_port.c using the relevant CMock _Stub calls. + * @details This function should be called before every test case. + */ +void td_port_register_stubs( void ); + +/** + * @brief Validate ending state of td_port related variables. + * @details This function should be called after every test case. + * It verifies the state of the variables used by td_port funcitons and + * frees resources used by CMock. + */ +void td_port_teardown_check( void ); + +/** + * @return pdTRUE if the simulated "port" a critical section/. + */ +BaseType_t td_port_isInCriticalSection( void ); + +/** + * @brief Register the stubs contained in td_task.c using the relevant CMock _Stub calls. + * @details This function should be called before every test case. + */ +void td_task_register_stubs( void ); + +/** + * @brief Validate ending state of td_task related variables. + * @details This function should be called after every test case. + * It verifies the state of the variables used by td_task functions and + * frees resources used by CMock. + */ +void td_task_teardown_check( void ); + +/** + * @brief Sets the scheduler state used by the task test double. + */ +void td_task_setSchedulerState( BaseType_t state ); + +/** + * @brief Sets the priority of the fake / simulated task used by td_task.c. + */ +void td_task_setFakeTaskPriority( TickType_t priority ); + +/** + * @brief Sets the priority of the fake / simulated task used by td_task.c. + */ +TickType_t td_task_getFakeTaskPriority( void ); + +/** + * @brief Adds the td_task.c fake task to the given queue's WaitingToSend event list. + */ +void td_task_addFakeTaskWaitingToSendToQueue( QueueHandle_t xQueue ); + +/** + * @brief Adds the td_task.c fake task to the given queue's WaitingToReceive event list. + */ +void td_task_addFakeTaskWaitingToReceiveFromQueue( QueueHandle_t xQueue ); + +/** + * @brief Test double for xTaskCheckForTimeOut + */ +BaseType_t td_task_xTaskCheckForTimeOutStub( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ); + +/** + * @brief Test double for xTaskResumeAll + */ +BaseType_t td_task_xTaskResumeAllStub( int cmock_num_calls ); + +/** + * @brief Test double for vTaskSuspendAll which does not check the scheduler state when called. + */ +void td_task_vTaskSuspendAllStubNoCheck( int cmock_num_calls ); + +/** + * @brief Test double for vPortYieldWithinAPI + */ +void td_task_vPortYieldWithinAPIStub( int cmock_num_calls ); + +/** + * @brief Get the number of calls to all yield related functions. + */ +BaseType_t td_task_getYieldCount( void ); + +/** + * @brief Get the number of times vPortYield was called and clear the counter. + * @return number of times vPortYield was called during the current test case. + */ +BaseType_t td_task_getCount_vPortYield( void ); + +/** + * @brief Get the number of times vPortYieldFromISR was called and clear the counter. + * @return number of times vPortYieldFromISR was called during the current test case. + */ +BaseType_t td_task_getCount_vPortYieldFromISR( void ); + +/** + * @brief Get the number of times vPortYieldWithinAPI was called and clear the counter. + * @return number of times vPortYieldWithinAPI was called during the current test case. + */ +BaseType_t td_task_getCount_vPortYieldWithinAPI( void ); + +/** + * @brief Get the number of times vTaskMissedYield was called and clear the counter. + * @return number of times vTaskMissedYield was called during the current test case. + */ +BaseType_t td_task_getCount_vTaskMissedYield( void ); + +/** + * @brief Get the number of times xTaskResumeAll and resulted in a yield. + * @return number of times xTaskResumeAll was called and resulted in a yield + * during the current test case. Also clears the counter before returning + * the previous value. + */ +BaseType_t td_task_getCount_YieldFromTaskResumeAll( void ); + +/** + * @brief Get the current state of the xYieldPending variable. + * @return pdTRUE when a yield is pending due to a call to vTaskMissedYield + * or xTaskRemoveFromEventList + */ +BaseType_t td_task_getYieldPending( void ); + + +#endif /* QUEUE_UTEST_COMMON_H */ diff --git a/FreeRTOS/Test/CMock/queue/semaphore/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/semaphore/FreeRTOSConfig.h new file mode 100644 index 000000000..aa75e8817 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/FreeRTOSConfig.h @@ -0,0 +1,140 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 0 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#define configCHECK_FOR_STACK_OVERFLOW 0 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configQUEUE_REGISTRY_SIZE 0 +#define configUSE_MALLOC_FAILED_HOOK 1 +#define configUSE_APPLICATION_TASK_TAG 1 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configUSE_ALTERNATIVE_API 0 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/semaphore/Makefile b/FreeRTOS/Test/CMock/queue/semaphore/Makefile new file mode 100644 index 000000000..56fb180ad --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/Makefile @@ -0,0 +1,52 @@ +# Indent with spaces +.RECIPEPREFIX := $(.RECIPEPREFIX) $(.RECIPEPREFIX) + +# Do not move this line below the include +MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) +include ../../makefile.in + +# PROJECT_SRC lists the .c files under test +PROJECT_SRC += queue.c + +# PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files +# Files in PROJECT_DEPS_SRC are excluded from coverage measurements +PROJECT_DEPS_SRC += list.c + +# PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. +PROJECT_HEADER_DEPS += FreeRTOS.h + +# SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) +SUITE_UT_SRC += semaphore_create_utest.c +SUITE_UT_SRC += binary_semaphore_utest.c +SUITE_UT_SRC += counting_semaphore_utest.c +SUITE_UT_SRC += semaphore_common_utest.c +SUITE_UT_SRC += mutex_utest.c +SUITE_UT_SRC += recursive_mutex_utest.c + +# SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. +# Paths are relative to PROJECT_DIR +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c + +# List the headers used by PROJECT_SRC that you would like to mock +MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h + +# List any addiitonal flags needed by the preprocessor +CPPFLAGS += -DportUSING_MPU_WRAPPERS=0 + +# List any addiitonal flags needed by the compiler +CFLAGS += + +# Try not to edit beyond this line unless necessary. + +# Project / Suite are determined based on path: $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) +PROJECT := $(lastword $(subst /, ,$(dir $(abspath $(MAKEFILE_ABSPATH)/../)))) +SUITE := $(lastword $(subst /, ,$(dir $(MAKEFILE_ABSPATH)))) + +# Make variables available to included makefile +export + +include ../../testdir.mk diff --git a/FreeRTOS/Test/CMock/queue/semaphore/binary_semaphore_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/binary_semaphore_utest.c new file mode 100644 index 000000000..99d4d11c7 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/binary_semaphore_utest.c @@ -0,0 +1,889 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file binary_semaphore_utest.c */ + +#include "../queue_utest_common.h" +#include "mock_fake_port.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" + +/* =============================== CONSTANTS =============================== */ + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* Used to share a semaphore handle between a test case and callback */ +static SemaphoreHandle_t xSemaphoreHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test xSemaphoreTake with a Binary Semaphore + * @details Create a binary semaphore using xSemaphoreCreateBinary + * and verify that an immediate call to xSemaphoreTake fails. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_xSemaphoreCreateBinary_fail( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreTake operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateBinary + * @details Create a binary semaphore using xSemaphoreCreateBinary + * and verify that an immediate call to xSemaphoreGive succeeds. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_xSemaphoreCreateBinary_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @deprecated + * @brief Test xSemaphoreTake with vSemaphoreCreateBinary + * @details Create a semaphore using vSemaphoreCreateBinary and verify that a + * subsequent call to xSemaphoreTake succeeds. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_vSemaphoreCreateBinary_success( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + + vSemaphoreCreateBinary( xSemaphore ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @deprecated + * @brief Test xSemaphoreGive with vSemaphoreCreateBinary + * @details Create a semaphore using vSemaphoreCreateBinary and verify that a + * subsequent call to xSemaphoreGive fails. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_vSemaphoreCreateBinary_fail( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + + vSemaphoreCreateBinary( xSemaphore ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive and xSemaphoreTake with xSemaphoreCreateBinary + * @details Create a binary semaphore using xSemaphoreCreateBinary + * and verify that an immediate call to xSemaphoreGive succeeds and a subsequent + * call to xSemaphoreTake succeeds. + * @coverage xQueueGenericSend xQueueSemaphoreTake + */ +void test_macro_xSemaphoreGive_xSemaphoreTake_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that a subsequent xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive multiple times on a Binary Semaphore + * @details Create a binary semaphore using xSemaphoreCreateBinary + * and verify that an immediate call to xSemaphoreGive succeeds and a subsequent + * call to xSemaphoreGive fails. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_multiple_fail( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that the second xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake multiple times on a Binary Semaphore + * @details Create a binary semaphore using xSemaphoreCreateBinary, + * verify that an immediate call to xSemaphoreGive succeeds, a subsequent + * call to xSemaphoreTake succeds, but a second call to xSemaphoreTake fails. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_multiple_fail( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that a subsequent xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that a second xSemaphoreTake operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test uxSemaphoreGetCount with a Binary Semaphore + * @details Create a binary semaphore using vSemaphoreCreateBinary. + * validate the return value of uxSemaphoreGetCount(), + * call xSemaphoreTake() and validate the return value of uxSemaphoreGetCount() + * @coverage uxQueueMessagesWaiting + */ +void test_macro_uxSemaphoreGetCount( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + + vSemaphoreCreateBinary( xSemaphore ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + ( void ) xSemaphoreTake( xSemaphore, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTakeFromISR with a Binary Semaphore + * @coverage xQueueReceiveFromISR + **/ +void test_macro_xSemaphoreTakeFromISR_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Give the Binary Semaphore */ + ( void ) xSemaphoreGive( xSemaphore ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTakeFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief xSemaphoreGiveFromISR with an empty queue + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/*! + * @brief xSemaphoreGiveFromISR with a full queue + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_fail( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + TEST_ASSERT_EQUAL( errQUEUE_FULL, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a higher priority task waiting and a null pointer for pxHigherPriorityTaskWoken + * @details Test xSemaphoreGiveFromISR with a higher priority task waiting and + * verifies that a null pxHigherPriorityTaskWoken is handled correctly. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_high_priority_pending_null_ptr( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + /* Give the Binary Semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a higher priority task waiting + * @details Test xSemaphoreGiveFromISR with a higher priority task waiting and + * verify that xHigherPriorityTaskWoken is set accoridngly. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_high_priority_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a lower priority task waiting + * @details Test xSemaphoreGiveFromISR with a lower priority task waiting and + * verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_low_priority_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdFALSE, td_task_getYieldPending() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with no tasks waiting + * @details Test xSemaphoreGiveFromISR with no tasks waiting and verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_no_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdFALSE, td_task_getYieldPending() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR on a semaphore that is locked + * @coverage xQueueGiveFromISR + */ +void test_xSemaphoreGiveFromISR_locked( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* Set private lock counters */ + vSetQueueRxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED, cGetQueueRxLock( xSemaphore ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED + 1, cGetQueueTxLock( xSemaphore ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR on a semaphore that is locked and cRxLock overflows. + * @coverage xQueueGiveFromISR + */ +void test_xSemaphoreGiveFromISR_locked_overflow( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* Set private lock counters */ + vSetQueueRxLock( xSemaphore, INT8_MAX ); + vSetQueueTxLock( xSemaphore, INT8_MAX ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Expect an assertion since the cTxLock value has overflowed */ + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( INT8_MAX, cGetQueueRxLock( xSemaphore ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( INT8_MIN, cGetQueueTxLock( xSemaphore ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with an occupied semaphore with higher priority tasks waiting + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_tasks_waiting_higher_priority( void ) +{ + /* Create a new binary semaphore */ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + ( void ) xSemaphoreGive( xSemaphore ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xSemaphore ); + + /* take the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with an occupied semaphore with an equal priority task waiting + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_tasks_waiting_equal_priority( void ) +{ + /* Create a new binary semaphore */ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + ( void ) xSemaphoreGive( xSemaphore ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY ); + td_task_addFakeTaskWaitingToSendToQueue( xSemaphore ); + + /* take the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 0, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with an occupied semaphore with lower priority tasks waiting. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_tasks_waiting_lower_priority( void ) +{ + /* Create a new binary semaphore */ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + ( void ) xSemaphoreGive( xSemaphore ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToSendToQueue( xSemaphore ); + + /* take the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 0, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with taskSCHEDULER_SUSPENDED and timeout=10 + * @details This should cause xSemaphoreTake to configASSERT becuase it would + * block forever when the semaphore is empty. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_suspended_assert( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + fakeAssertExpectFail(); + + vTaskSuspendAll_Stub( td_task_vTaskSuspendAllStubNoCheck ); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with taskSCHEDULER_SUSPENDED and timeout=0 + * @details This should not cause xSemaphoreTake to configASSERT becuase + * xSemaphoreTake is non-blocking when timeout=0. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_nonblocking_suspended_noassert( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback which calls xSemaphoreGive on xSemaphoreHandleStatic + */ +static BaseType_t blocking_success_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + ( void ) xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ); + } + + return xReturnValue; +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a taken Binary Semaphore + * which becomes available while a call to xSemaphoreTake is blocking. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_sucess( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xSemaphoreHandleStatic = xSemaphore; + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + xTaskCheckForTimeOut_Stub( &blocking_success_xTaskCheckForTimeOut_cb ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback which calls xSemaphoreGive on xSemaphoreHandleStatic when + * cmock_num_calls == TICKS_TO_WAIT + */ +static BaseType_t blocking_last_chance_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == TICKS_TO_WAIT ) + { + ( void ) xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ); + return pdTRUE; + } + + return xReturnValue; +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a Binary Semaphore that is initially taken, + * but becomes available at the end of the blocking time period. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_success_last_chance( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xSemaphoreHandleStatic = xSemaphore; + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + xTaskCheckForTimeOut_Stub( &blocking_last_chance_xTaskCheckForTimeOut_cb ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a taken binary semaphore + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_timeout( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a taken locked semaphore + * @details This test case verifies a situation that should never occur + * ( xSemaphoreTake called on a locked semaphore ). + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_locked( void ) +{ + /* Create a new binary semaphore */ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* Set private lock counters */ + vSetQueueRxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + + /* Run xSemaphoreTake in blocking mode with the semaphore locked */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Verify that the semaphore is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xSemaphore ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback for test_xSemaphoreTake_blocking_success_locked_no_pending + * which adds an item to it's test queue. + */ +static BaseType_t xSemaphoreTake_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + TEST_ASSERT_TRUE( xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ) ); + TEST_ASSERT_EQUAL( 1, uxQueueMessagesWaiting( xSemaphoreHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked binary semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked binary semaphore with no + * tasks in the binary semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_success_locked_no_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xSemaphore ); +} + + +/** + * @brief Callback for xTaskResumeAll used by tests for blocking calls to + * xSemaphoreTake + */ +static BaseType_t xSemaphoreTake_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Receive from an ISR to block */ + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphoreHandleStatic ) ); + TEST_ASSERT_TRUE( xSemaphoreTakeFromISR( xSemaphoreHandleStatic, NULL ) ); + } + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked binary semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked binary semaphore with a + * higher priority task in the binary semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_timeout_locked_high_prio_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xSemaphoreTake_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xSemaphore ); +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked binary semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked binary semaphore with a + * lower priority task in the semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_success_locked_low_prio_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xSemaphoreTake_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/semaphore/counting_semaphore_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/counting_semaphore_utest.c new file mode 100644 index 000000000..a96d46a20 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/counting_semaphore_utest.c @@ -0,0 +1,894 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file counting_semaphore_utest.c */ + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" +#include "mock_fake_port.h" + + +/* ============================ GLOBAL VARIABLES =========================== */ + +static SemaphoreHandle_t xSemaphoreHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + xSemaphoreHandleStatic = NULL; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* =========================== Helper functions ============================ */ + +/* ============================== Test Cases =============================== */ + + + +/** + * @brief Test xSemaphoreTake with an invalid counting semaphore + * @details Verify that a call to xSemaphoreTake fails on a counting + * semaphore created with uxMaxCount=0 and uxInitialCount=0 + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_CountingSemaphore_zero_zero_fail( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because uxMaxCount=0 is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 0, 0 ); + + fakeAssertGetNumAssertsAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreTake fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with an invalid counting semaphore + * @details Verify that a call to xSemaphoreGive fails on a counting + * semaphore created with uxMaxCount=0 and uxInitialCount=0 + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_zero_zero_fail( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because uxMaxCount=0 is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 0, 0 ); + + fakeAssertGetNumAssertsAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreGive fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateCounting( 1, 2 ) + * @details Test xSemaphoreGive with an invalid counting semaphore where + * uxInitialCount > xMaxCount + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_with_CountingSemaphore_one_two_fail( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 2 ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreGive fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with xSemaphoreCreateCounting( 1, 2 ) + * @details Test xSemaphoreTake with an invalid counting semaphore where + * uxInitialCount > xMaxCount + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_with_CountingSemaphore_one_two_success( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 2 ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreTake succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake and xSemaphoreGive with xSemaphoreCreateCounting( 1, 2 ) + * @details Test xSemaphoreTake and xSemaphoreGive with an invalid counting + * semaphore where uxInitialCount > xMaxCount. + * @coverage xQueueSemaphoreTake xQueueGenericSend + */ +void test_macro_xSemaphoreTake_xSemaphoreGive_with_CountingSemaphore_one_two_success( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 2 ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreTake succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that a second xSemaphoreTake succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that an xSemaphoreGive succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with xSemaphoreCreateCounting( 1, 0 ) + * @details Test xSemaphoreTake with a binary semaphore constructed with + * xSemaphoreCreateCounting. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_CountingSemaphore_one_zero_fail( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreTake fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateCounting( 1, 0 ) + * @details Test xSemaphoreGive with a binary semaphore constructed with + * xSemaphoreCreateCounting. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_one_zero_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreGive succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive and xSemaphoreTake with xSemaphoreCreateCounting( 1, 0 ) + * @details Test xSemaphoreGive and xSemaphoreTake with a binary semaphore + * constructed with xSemaphoreCreateCounting. + * @coverage xQueueGenericSend xQueueSemaphoreTake + */ +void test_macro_xSemaphoreGive_xSemaphoreTake_CountingSemaphore_one_zero_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an xSemaphoreGive succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that an xSemaphoreTake succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that an xSemaphoreGive succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateCounting( 100, 50 ) + * @details Test multiple xSemaphoreGive calls on a counting semaphore + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_100_50( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 100, 50 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Call xSemaphoreGive 50 times and verify success */ + for( int i = 0; i < 50; i++ ) + { + /* Verify that an xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + } + + /* Check the count */ + TEST_ASSERT_EQUAL( 100, uxSemaphoreGetCount( xSemaphore ) ); + + /* Veirfy that a subsequent call to xSemaphoreGive fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that an xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( 99, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with xSemaphoreCreateCounting( 100, 50 ) + * @details Test multiple xSemaphoreTake calls on a counting semaphore + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_CountingSemaphore_100_50( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 100, 50 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Call xSemaphoreTake 50 times and verify success */ + for( int i = 0; i < 50; i++ ) + { + /* Verify that an xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + } + + /* Check the count */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + /* Veirfy that a subsequent call to xSemaphoreGive fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that an xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Verify that this test case is running on a 64 bit platform. + */ +void test_size_of_UBaseType_is_64_bits( void ) +{ + if( TEST_PROTECT() ) + { + /* Check that UBaseType_t is 64 bits on this platform */ + TEST_ASSERT_EQUAL( sizeof( uint64_t ), sizeof( UBaseType_t ) ); + } +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX-1 ) + * @details Test xSemaphoreGive with a counting semaphore with uxMaxCount=UINT64_MAX and + * uxInitialCount=UINT64_MAX-1 + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_upper_bound( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX - 1 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( UINT64_MAX - 1, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that a xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( UINT64_MAX, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that the next xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX ) + * @details Test xSemaphoreTake with a counting semaphore with uxMaxCount=UINT64_MAX and + * uxInitialCount=UINT64_MAX + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_CountingSemaphore_upper_bound( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + /* Verify that a xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( UINT64_MAX - 1, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that a subsequent xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( UINT64_MAX, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that the next xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief xSemaphoreTake with xSemaphoreCreateCounting( UINT64_MAX, 1) + * @details Test xSemaphoreTake with a counting semaphore with uxMaxCount=UINT64_MAX and + * uxInitialCount=1 + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_CountingSemaphore_lower_bound( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, 1 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that a xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that the next xSemaphoreTake operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief xSemaphoreGive with xSemaphoreCreateCounting( UINT64_MAX, 0) + * @details Test xSemaphoreGive with a counting semaphore with uxMaxCount=UINT64_MAX and + * uxInitialCount=0 + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_lower_bound( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that a xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Check the count */ + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateCounting( UINT64_MAX - 1, UINT64_MAX ) + * @details Test xSemaphoreGive with a counting semaphore with uxMaxCount=UINT64_MAX-1 and + * uxInitialCount=UINT64_MAX + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_CountingSemaphore_over_upper_bound( void ) +{ + /* Expect that xSemaphoreCreateCounting will configASSERT because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX - 1, UINT64_MAX ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check the count */ + TEST_ASSERT_EQUAL( UINT64_MAX, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that an xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + /* Check that the count has not changed */ + TEST_ASSERT_EQUAL( UINT64_MAX, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with a counting semaphore where uxInitialCount > uxMaxCount + * @details Test xSemaphoreGive with a counting semaphore with uxMaxCount=1 and + * uxInitialCount=2 + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_count_higher_than_max( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 2 ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check that the count was initialized correctly */ + TEST_ASSERT_EQUAL( 2, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that an xSemaphoreGive fails (would cause the count to increase) */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that an xSemaphoreTake succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Check that the count has decreased */ + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that an xSemaphoreGive fails (would cause the count to increase beyond 2) */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that an xSemaphoreTake succeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Check that the count has decreased */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + /* Verify that an xSemaphoreGive succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Check that the count is now 1 */ + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with taskSCHEDULER_SUSPENDED and timeout=10 + * @details This should cause xSemaphoreTake to configASSERT becuase it would + * block forever when the semaphore is empty. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_suspended_assert( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + fakeAssertExpectFail(); + + vTaskSuspendAll_Stub( td_task_vTaskSuspendAllStubNoCheck ); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vSemaphoreDelete( xSemaphore ); +} + + +/** + * @brief Test xSemaphoreTake with taskSCHEDULER_SUSPENDED and timeout=0 + * @details This should not cause xSemaphoreTake to configASSERT becuase + * xSemaphoreTake is non-blocking when timeout=0. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_nonblocking_suspended_noassert( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + td_task_setSchedulerState( taskSCHEDULER_SUSPENDED ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + td_task_setSchedulerState( taskSCHEDULER_RUNNING ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback which calls xSemaphoreGive on xSemaphoreHandleStatic when + * cmock_num_calls == NUM_CALLS_TO_INTERCEPT + */ +static BaseType_t blocking_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + ( void ) xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ); + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphoreHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a fully taken Counting Semaphore + * which becomes available while a call to xSemaphoreTake is blocking. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_sucess( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xSemaphoreHandleStatic = xSemaphore; + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + xTaskCheckForTimeOut_Stub( &blocking_xTaskCheckForTimeOut_cb ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback which calls xSemaphoreGive on xSemaphoreHandleStatic when + * cmock_num_calls == TICKS_TO_WAIT + */ +static BaseType_t blocking_last_chance_xTaskCheckForTimeOut_cb( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == TICKS_TO_WAIT ) + { + ( void ) xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ); + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphoreHandleStatic ) ); + return pdTRUE; + } + + return xReturnValue; +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a Counting Semaphore that is + * initially fully taken, but becomes available at the end of the blocking time. + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_success_last_chance( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + /* Export for blocking_success_xTaskCheckForTimeOut_cb callback */ + xSemaphoreHandleStatic = xSemaphore; + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + xTaskCheckForTimeOut_Stub( &blocking_last_chance_xTaskCheckForTimeOut_cb ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/* + * @brief Test xSemaphoreTake in blocking mode with a taken binary semaphore + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_timeout( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake in blocking mode with a taken locked semaphore + * @details This test case verifies a situation that should never occur + * ( xSemaphoreTake called on a locked semaphore ). + * @coverage xQueueSemaphoreTake + */ +void test_xSemaphoreTake_blocking_locked( void ) +{ + /* Create a new binary semaphore */ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + /* Set private lock counters */ + vSetQueueRxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xSemaphore, queueLOCKED_UNMODIFIED ); + + /* Run xSemaphoreTake in blocking mode with the semaphore locked */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Verify that the semaphore is now unlocked */ + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueRxLock( xSemaphore ) ); + TEST_ASSERT_EQUAL( queueUNLOCKED, cGetQueueTxLock( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback for test_xSemaphoreTake_blocking_success_locked_no_pending + * which adds an item to it's test queue. + */ +static BaseType_t xSemaphoreTake_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + TEST_ASSERT_TRUE( xSemaphoreGiveFromISR( xSemaphoreHandleStatic, NULL ) ); + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphoreHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked counting semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked counting semaphore with no + * tasks in the counting semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_success_locked_no_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xSemaphore ); +} + + +/** + * @brief Callback for xTaskResumeAll used by tests for blocking calls to + * xSemaphoreTake + */ +static BaseType_t xSemaphoreTake_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Receive from an ISR to block */ + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + TEST_ASSERT_EQUAL( 1, uxSemaphoreGetCount( xSemaphoreHandleStatic ) ); + TEST_ASSERT_TRUE( xSemaphoreTakeFromISR( xSemaphoreHandleStatic, NULL ) ); + } + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked counting semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked counting semaphore with a + * higher priority task in the counting semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_timeout_locked_high_prio_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xSemaphoreTake_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + vQueueDelete( xSemaphore ); +} + +/** + * @brief Test a blocking call to xSemaphoreTake with a locked counting semaphore. + * @details Test a blocking call to xSemaphoreTake with a locked counting semaphore with a + * lower priority task in the semaphore WaitingToReceiveFrom event list. + * @coverage xQueueSemaphoreTake prvUnlockQueue + */ +void test_xSemaphoreTake_blocking_success_locked_low_prio_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 2, 0 ); + + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + + /* Export for callbacks */ + xSemaphoreHandleStatic = xSemaphore; + + xTaskCheckForTimeOut_Stub( &xSemaphoreTake_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xSemaphoreTake_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + vQueueDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/semaphore/mutex_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/mutex_utest.c new file mode 100644 index 000000000..b62be0396 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/mutex_utest.c @@ -0,0 +1,588 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file mutex_utest.c */ + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ +static SemaphoreHandle_t xSemaphoreHandleStatic = NULL; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ========================== Test Cases =========================== */ + + +/** + * @brief Test xSemaphoreCreateMutex where the call to malloc fails + * @coverage xQueueCreateMutex + */ +void test_macro_xSemaphoreCreateMutex_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateMutex + * @details Create a mutex using xSemaphoreCreateMutex + * @coverage xQueueCreateMutex + */ +void test_macro_xSemaphoreCreateMutex_success( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateMutexStatic with a null buffer + * @coverage xQueueCreateMutexStatic + */ +void test_macro_xSemaphoreCreateMutexStatic_nullptr( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + /* Expect that xQueueCreate will assert due to the NULL buffer */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateMutexStatic( NULL ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); +} + +/** + * @brief Test xSemaphoreCreateMutexStatic with a valid buffer. + * @details Create a semaphore using xSemaphoreCreateMutexStatic + * @coverage xQueueCreateMutexStatic + */ +void test_macro_xSemaphoreCreateMutexStatic_success( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + StaticSemaphore_t xSemaphoreBuffer; + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + xSemaphore = xSemaphoreCreateMutexStatic( &xSemaphoreBuffer ); + + /* Check that no call to malloc occurred */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake with a Mutex + * @details Create a mutex using xSemaphoreCreateMutex + * and verify that an immediate call to xSemaphoreTake succeeds. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_success( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + pvTaskIncrementMutexHeldCount_IgnoreAndReturn( NULL ); + + /* Verify that an immediate xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive with xSemaphoreCreateMutex + * @details Create a mutex using xSemaphoreCreateMutex + * and verify that an immediate call to xSemaphoreGive fails. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_fail( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Verify that an immediate xSemaphoreGive operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive and xSemaphoreTake with xSemaphoreCreateMutex + * @details Create a mutex using xSemaphoreCreateMutex + * and verify that an immediate call to xSemaphoreGive succeeds and a subsequent + * call to xSemaphoreTake succeeds. + * @coverage xQueueGenericSend xQueueSemaphoreTake + */ +void test_macro_xSemaphoreGive_xSemaphoreTake_success( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( 0 ); + + /* Verify that an immediate xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + /* Verify that a subsequent xSemaphoreGive operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGive multiple times on a Mutex. + * @details Create a mutex using xSemaphoreCreateMutex + * and verify that an immediate call to xSemaphoreGive succeeds and a subsequent + * call to xSemaphoreGive fails. + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_multiple_Mutex_fail( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( 0 ); + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + xSemaphoreTake( xSemaphore, 0 ); + + /* Verify that the first xSemaphoreGive call succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGive( xSemaphore ) ); + + /* Verify that a second xSemaphoreGive call fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGive( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake multiple times on a Mutex. + * @details Create a Mutex using xSemaphoreCreateMutex, + * verify that an immediate call to xSemaphoreTake succeeds, a subsequent + * call to xSemaphoreGive succeds, but a second call to xSemaphoreGive fails. + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_multiple_Mutex_fail( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( 0 ); + + /* Verify that an immediate xSemaphoreTake operation succeeds */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Verify that the second xSemaphoreTake operation fails */ + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test uxSemaphoreGetCount with a Mutex + * @details Create a Mutex using xSemaphoreCreateMutex. + * validate the return value of uxSemaphoreGetCount(), + * call xSemaphoreTake() and validate the return value of uxSemaphoreGetCount() + * @coverage uxQueueMessagesWaiting + */ +void test_macro_uxSemaphoreGetCount_Mutex( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( 0 ); + + xSemaphore = xSemaphoreCreateMutex(); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + xSemaphoreTake( xSemaphore, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGetMutexHolder with an invalid (null) SemaphoreHandle_t + * @coverage xQueueGetMutexHolder + */ +void test_macro_xSemaphoreGetMutexHolder_NULL( void ) +{ + /* This previously caused a segfault, but I patched queue.c */ + EXPECT_ASSERT_BREAK( xSemaphoreGetMutexHolder( NULL ) ); +} + +/** + * @brief Test xSemaphoreGetMutexHolder with a handle of a binary semaphore + * @details Verify that xSemaphoreGetMutexHolder returns NULL when given a handle to a binary semaphore rather than a mutex. + * @coverage xQueueGetMutexHolder + */ +void test_macro_xSemaphoreGetMutexHolder_binary_semaphore( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NULL, xSemaphoreGetMutexHolder( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGetMutexHolder with a valid SemaphoreHandle_t + * @coverage xQueueGetMutexHolder + */ +void test_macro_xSemaphoreGetMutexHolder_Mutex( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( xMutexHolder, xSemaphoreGetMutexHolder( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGetMutexHolderFromISR with an invalid (null) SemaphoreHandle_t + * @coverage xQueueGetMutexHolderFromISR + */ +void test_macro_xSemaphoreGetMutexHolderFromISR_Mutex_NULL( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreGetMutexHolderFromISR( NULL ) ); +} + +/** + * @brief Test xSemaphoreGetMutexHolderFromISR with a handle of a binary semaphore + * @details Verify that xSemaphoreGetMutexHolderFromISR returns NULL when given a handle to a binary semaphore rather than a mutex. + * @coverage xQueueGetMutexHolderFromISR + */ +void test_macro_xSemaphoreGetMutexHolderFromISR_binary_semaphore( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + TEST_ASSERT_EQUAL( NULL, xSemaphoreGetMutexHolderFromISR( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGetMutexHolderFromISR with a valid SemaphoreHandle_t + * @coverage xQueueGetMutexHolderFromISR + */ +void test_macro_xSemaphoreGetMutexHolderFromISR_Mutex( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( xMutexHolder, xSemaphoreGetMutexHolderFromISR( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a Mutex that has an owner. + * @details Verify that xSemaphoreGiveFromISR configASSERTs when an owned mutex is given as the xSemaphore argument. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_mutex_owned( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* Setup mocks for xSemaphoretake */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + xSemaphoreTake( xSemaphore, 0 ); + + /* Expect that xSemaphoreGiveFromISR will assert due to the mutex usage */ + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a Mutex that has a NULL owner. + * @details Verify that xSemaphoreGiveFromISR does not configASSERT when a mutex with a NULL owner is given in the xSemaphore argument. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_mutex_not_owned( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + /* Setup mocks for xSemaphoretake */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( NULL ); + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + xSemaphoreTake( xSemaphore, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake in blocking mode on an already owned mutex. + * @details Test xSemaphoreTake on a mutex owned by another task where the owning task has lower priority. + * @coverage xQueueSemaphoreTake prvGetDisinheritPriorityAfterTimeout + */ +void test_macro_xSemaphoreTake_blocking_mutex_inherit_timeout( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + BaseType_t xFakeMutexHolder = getNextMonotonicTestValue(); + + /* Return a test value from the call to pvTaskIncrementMutexHeldCount */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( ( void * ) xFakeMutexHolder ); + + /* Take the mutex */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + for( int i = 0; i < TICKS_TO_WAIT; i++ ) + { + /* Return pdTRUE to signify that priority inheritence occurred */ + xTaskPriorityInherit_ExpectAndReturn( ( void * ) xFakeMutexHolder, pdTRUE ); + } + + vTaskPriorityDisinheritAfterTimeout_Expect( ( void * ) ( BaseType_t ) getLastMonotonicTestValue(), tskIDLE_PRIORITY ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getCount_vPortYieldWithinAPI() ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTake in blocking mode on an already owned mutex. + * @details Test xSemaphoreTake on a mutex owned by another task with another high priority task waiting and the current task timing out. + * @coverage xQueueSemaphoreTake prvGetDisinheritPriorityAfterTimeout + */ +void test_macro_xSemaphoreTake_blocking_mutex_inherit_timeout_high_prio_waiting( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + TaskHandle_t xFakeMutexHolder = ( TaskHandle_t ) ( ( uint64_t ) 0 + getNextMonotonicTestValue() ); + + /* Return a test value from the call to pvTaskIncrementMutexHeldCount */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xFakeMutexHolder ); + + /* Take the mutex */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xSemaphore ); + + for( int i = 0; i < TICKS_TO_WAIT; i++ ) + { + /* Return pdTRUE to signify that priority inheritence occurred */ + xTaskPriorityInherit_ExpectAndReturn( xFakeMutexHolder, pdTRUE ); + } + + vTaskPriorityDisinheritAfterTimeout_Expect( xFakeMutexHolder, DEFAULT_PRIORITY + 1 ); + + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT + 1, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Callback for test_macro_xSemaphoreTake_blocking_mutex_inherit_disinherit + */ +static BaseType_t xSemaphoreTake_blocking_xTaskResumeAllStub( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + TEST_ASSERT_TRUE( xSemaphoreGive( xSemaphoreHandleStatic ) ); + } + + return xReturnValue; +} + +/** + * @brief Test priority inheritance during a successful blocking call to xSemaphoreTake + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_blocking_mutex_inherit_disinherit( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + xSemaphoreHandleStatic = xSemaphore; + + TaskHandle_t xFakeMutexHolder = ( TaskHandle_t ) ( ( uint64_t ) 0 + getNextMonotonicTestValue() ); + + xTaskResumeAll_Stub( &xSemaphoreTake_blocking_xTaskResumeAllStub ); + + /* Return a test value from the call to pvTaskIncrementMutexHeldCount */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xFakeMutexHolder ); + + /* Take the mutex */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, 0 ) ); + + for( int i = 0; i < NUM_CALLS_TO_INTERCEPT + 1; i++ ) + { + /* Return pdTRUE to signify that priority inheritence occurred */ + xTaskPriorityInherit_ExpectAndReturn( xFakeMutexHolder, pdTRUE ); + } + + xTaskPriorityDisinherit_ExpectAndReturn( xFakeMutexHolder, pdTRUE ); + + /* Return a test value from the call to pvTaskIncrementMutexHeldCount */ + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xFakeMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xSemaphore, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 2, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 2, td_task_getCount_vPortYieldWithinAPI() ); + + vSemaphoreDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/semaphore/recursive_mutex_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/recursive_mutex_utest.c new file mode 100644 index 000000000..b3c0438f5 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/recursive_mutex_utest.c @@ -0,0 +1,355 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file recursive_mutex_utest.c */ + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + xTaskPriorityDisinherit_IgnoreAndReturn( pdFALSE ); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + +/** + * @brief Test xSemaphoreCreateRecursiveMutex where the call to malloc fails + * @coverage xQueueCreateMutex + */ +void test_macro_xSemaphoreCreateRecursiveMutex_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateRecursiveMutex + * @details Create a mutex using xSemaphoreCreateRecursiveMutex + * @coverage xQueueCreateMutex + */ +void test_macro_xSemaphoreCreateRecursiveMutex_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateRecursiveMutexStatic with a null buffer + * @coverage xQueueCreateMutexStatic + */ +void test_macro_xSemaphoreCreateRecursiveMutexStatic_nullptr( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + /* Expect that xQueueCreate will assert due to the NULL buffer */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateRecursiveMutexStatic( NULL ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); +} + +/** + * @brief Verify that calling xSemaphoreTakeRecursive with a NULL mutex handle causes a configASSERT failure. + * @coverage xQueueTakeMutexRecursive + */ +void test_macro_xSemaphoreTakeRecursive_null_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreTakeRecursive( NULL, 0 ) ); +} + +/** + * @brief Test xSemaphoreTakeRecursive with a mutex that is not owned by any task. + * @coverage xQueueTakeMutexRecursive + */ +void test_macro_xSemaphoreTakeRecursive_not_owned_once( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTakeRecursive( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTakeRecursive with a mutex that is already owned by the current task + * @coverage xQueueTakeMutexRecursive + */ +void test_macro_xSemaphoreTakeRecursive_self_owned_twice( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTakeRecursive( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTakeRecursive( xSemaphore, 0 ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreTakeRecursive on a mutex that is already owned by a different task + * @coverage xQueueTakeMutexRecursive + */ +void test_macro_xSemaphoreTakeRecursive_owned_other_task( void ) +{ + TaskHandle_t xMutexHolder1 = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + TaskHandle_t xMutexHolder2 = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* Take the recursive mutex with task handle == xMutexHolder1 */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder1 ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder1 ); + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTakeRecursive( xSemaphore, 0 ) ); + + /* Attempt to take the recursive mutex with task handle == xMutexHolder2 */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder2 ); + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreTakeRecursive( xSemaphore, 0 ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Verify that calling xSemaphoreGiveRecursive with a NULL mutex handle causes a configASSERT failure. + * @coverage xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreGiveRecursive_null_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreGiveRecursive( NULL ) ); +} + +/** + * @brief Test xSemaphoreGiveRecursive with a mutex that is not already owned by any task. + * @coverage xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreGiveRecursive_unowned( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGiveRecursive( xSemaphore ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveRecursive with a mutex that is not owned by any task with a NULL TaskHandle returned by calls to xTaskGetCurrentTaskHandle. + * @coverage xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreGiveRecursive_unowned_null_taskhandle( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + xTaskGetCurrentTaskHandle_ExpectAndReturn( NULL ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveRecursive( xSemaphore ) ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveRecursive with a mutex that is already owned by the current task + * @coverage xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreGiveRecursive_self_owned( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* Take the Recursive Mutex from taskHandle == xMutexHolder */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + + xSemaphoreTakeRecursive( xSemaphore, 0 ); + + /* Verify that the Recursive Mutex is in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + /* call xSemaphoreGiveRecursive to release the Recursive Mutex */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveRecursive( xSemaphore ) ); + + /* Verify that the Recursive Mutex is now in the available state */ + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreGiveRecursive on a mutex that is already owned by a different task + * @coverage xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreGiveRecursive_owned_other_task( void ) +{ + TaskHandle_t xMutexHolder1 = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + TaskHandle_t xMutexHolder2 = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* Take the Recursive Mutex from taskHandle == xMutexHolder */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder1 ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder1 ); + + xSemaphoreTakeRecursive( xSemaphore, 0 ); + + /* Verify that the Recursive Mutex is in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + /* call xSemaphoreGiveRecursive to release the Recursive Mutex */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder2 ); + + TEST_ASSERT_EQUAL( pdFALSE, xSemaphoreGiveRecursive( xSemaphore ) ); + + /* Verify that the Recursive Mutex remains in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + + +/** + * @brief Call xSemaphoreTakeRecursive and xSemaphoreGiveRecursive each multiple times + * @coverage xQueueTakeMutexRecursive xQueueGiveMutexRecursive + */ +void test_macro_xSemaphoreTakeRecursive_xSemaphoreGiveRecursive_recursive( void ) +{ + TaskHandle_t xMutexHolder = ( void * ) ( BaseType_t ) getNextMonotonicTestValue(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + /* Take the Recursive Mutex */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + pvTaskIncrementMutexHeldCount_ExpectAndReturn( xMutexHolder ); + xSemaphoreTakeRecursive( xSemaphore, 0 ); + + /* Verify that the Recursive Mutex is in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + /* Take the Recursive Mutex a second time */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + xSemaphoreTakeRecursive( xSemaphore, 0 ); + + /* Verify that the Recursive Mutex remains in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + /* call xSemaphoreGiveRecursive to release the Recursive Mutex (first time) */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveRecursive( xSemaphore ) ); + + /* Verify that the Recursive Mutex remains in the taken state */ + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + /* call xSemaphoreGiveRecursive to release the Recursive Mutex (second time) */ + xTaskGetCurrentTaskHandle_ExpectAndReturn( xMutexHolder ); + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveRecursive( xSemaphore ) ); + + /* Verify that the Recursive Mutex is now in the available state */ + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/semaphore/semaphore_common_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/semaphore_common_utest.c new file mode 100644 index 000000000..c4f69a06e --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/semaphore_common_utest.c @@ -0,0 +1,169 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file semaphore_common_utest.c */ + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" + + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* =========================== Helper functions ============================ */ + +/* ============================== Test Cases =============================== */ + +/** + * @brief Test xSemaphoreTake with an invalid (NULL) handle + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreTake( NULL, 0 ) ); +} + +/** + * @brief Test xSemaphoreTake with a QueueHandle rather than a SemaphoreHandle + * @coverage xQueueSemaphoreTake + */ +void test_macro_xSemaphoreTake_queue_handle( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + xQueueSend( xQueue, &testVal, 0 ); + + /* Expect that xSemaphoreTake will assert because xQueue is not a semaphore */ + fakeAssertExpectFail(); + + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreTake( xQueue, 0 ) ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xSemaphoreGive with an invalid (NULL) handle + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreGive( NULL ) ); +} + +/** + * @brief Test xSemaphoreGive with a QueueHandle rather than a SemaphoreHandle + * @coverage xQueueGenericSend + */ +void test_macro_xSemaphoreGive_queue_handle( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + EXPECT_ASSERT_BREAK( xSemaphoreGive( xQueue ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xSemaphoreTakeFromISR with an invalid (NULL) handle + * @coverage xQueueReceiveFromISR + */ +void test_macro_xSemaphoreTakeFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreTakeFromISR( NULL, NULL ) ); +} + +/** + * @brief Test xSemaphoreTakeFromISR with a QueueHandle rather than a SemaphoreHandle + * @coverage xQueueReceiveFromISR + */ +void test_macro_xSemaphoreTakeFromISR_queue_handle( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + /* Expect that xSemaphoreTake will assert because xQueue is not a semaphore */ + fakeAssertExpectFail(); + + uint32_t testVal = getNextMonotonicTestValue(); + + xQueueSend( xQueue, &testVal, 0 ); + + EXPECT_ASSERT_BREAK( xSemaphoreTakeFromISR( xQueue, NULL ) ); + + vQueueDelete( xQueue ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with an invalid (NULL) handle + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_invalid_handle( void ) +{ + EXPECT_ASSERT_BREAK( xSemaphoreGiveFromISR( NULL, NULL ) ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a QueueHandle rather than a SemaphoreHandle + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_queue_handle( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + EXPECT_ASSERT_BREAK( xSemaphoreGiveFromISR( xQueue, NULL ) ); + + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/semaphore/semaphore_create_utest.c b/FreeRTOS/Test/CMock/queue/semaphore/semaphore_create_utest.c new file mode 100644 index 000000000..3a812c5f9 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/semaphore/semaphore_create_utest.c @@ -0,0 +1,434 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file semaphore_create_utest.c */ + +#include "../queue_utest_common.h" +#include "mock_fake_port.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" + +/* ================================ CONSTANTS ============================== */ + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ============================= Test Cases ============================== */ + + +/** + * @brief Test xSemaphoreCreateBinary where the call to malloc fails + * @coverage xQueueGenericCreate + */ +void test_macro_xSemaphoreCreateBinary_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateBinary + * @details Create a semaphore using xSemaphoreCreateBinary and verify that it + * is in the "taken" state upon creation. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xSemaphoreCreateBinary_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateBinaryStatic with a null buffer + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xSemaphoreCreateBinaryStatic_fail( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + /* Expect that xSemaphoreCreate will assert due to the NULL buffer */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateBinaryStatic( NULL ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); +} + +/** + * @brief Test xSemaphoreCreateBinaryStatic with a valid buffer. + * @details Create a semaphore using xSemaphoreCreateBinaryStatic and verify + * that it is in the "taken" state upon creation. + * @coverage xQueueGenericCreateStatic + */ +void test_macro_xSemaphoreCreateBinaryStatic_success( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + StaticSemaphore_t xSemaphoreBuffer; + + xSemaphore = xSemaphoreCreateBinaryStatic( &xSemaphoreBuffer ); + + /* Check that no call to malloc occurred */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_TAKEN, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @deprecated + * @brief Test vSemaphoreCreateBinary where the call to malloc fails + * @coverage xQueueGenericCreate + */ +void test_macro_vSemaphoreCreateBinary_malloc_fail( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + vSemaphoreCreateBinary( xSemaphore ); + + /* validate returned semaphore handle */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); +} + +/** + * @deprecated + * @brief Test vSemaphoreCreateBinary + * @details Create a semaphore using vSemaphoreCreateBinary and verify that it + * is in the "given" state upon creation + * @coverage xQueueGenericCreate xQueueGenericSend + */ +void test_macro_vSemaphoreCreateBinary_success( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + + vSemaphoreCreateBinary( xSemaphore ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting where the call to malloc fails + * @coverage + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + xSemaphore = xSemaphoreCreateCounting( 10, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting with uxMaxCount=1 and uxInitialCount=2 + * @details This is an invalid initial condition for a counting semaphore since + * uxMaxCount >= uxInitialCount. + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_one_two( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 2 ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check that the count was initialized correctly */ + TEST_ASSERT_EQUAL( 2, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting with uxMaxCount=1 and uxInitialCount=0 + * @details Create a binary semaphore using xSemaphoreCreateCounting. + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_one_zero( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 0 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting with uxMaxCount=0 and uxInitialCount=0 + * @details This is an invalid counting semaphore since the following condition + * is always true for a counting semaphore: uxMaxCount > 0 + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_zero_zero( void ) +{ + /* Expect that xSemaphoreCreateCounting will assert because uxMaxCount=0 is invalid */ + fakeAssertExpectFail(); + + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 0, 0 ); + + fakeAssertVerifyNumAssertsAndClear( 2 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting( 100, 50 ) + * @details Test xSemaphoreCreateCounting with uxMaxCount=100 and uxInitialCount=50 + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_100_50_success( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 100, 50 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( 50, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX-1 ) + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_upper_bound_1( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX - 1 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( UINT64_MAX - 1, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX ) + * @coverage xQueueCreateCountingSemaphore + */ +void test_macro_xSemaphoreCreateCounting_upper_bound_2( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( UINT64_MAX, UINT64_MAX ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + TEST_ASSERT_EQUAL( UINT64_MAX, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCountingStatic with a null buffer + * @details Calls xSemaphoreCreateCountingStatic with a null buffer and + * uxMaxCount=2 and uxInitialCount=1 + * @coverage xQueueCreateCountingSemaphoreStatic + */ +void test_macro_xSemaphoreCreateCountingStatic_null_fail( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + + /* Expect that xQueueCreate will assert due to the NULL buffer */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateCountingStatic( 2, 1, NULL ); + + /* Verify that configASSERT was called due to the null buffer */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* Verify that the returned handle is NULL */ + TEST_ASSERT_EQUAL( NULL, xSemaphore ); + + /* check that no call to malloc ocurred */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); +} + +/** + * @brief Test xSemaphoreCreateCountingStatic with uxMaxCount=0 and uxInitialCount=0 + * @details This is an invalid counting semaphore since uxMaxCount > 0 + * @coverage xQueueCreateCountingSemaphoreStatic + */ +void test_macro_xSemaphoreCreateCountingStatic_zero_zero_fail( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + StaticSemaphore_t xSemaphoreBuffer; + + /* Expect that xQueueCreate will assert due to the NULL buffer */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateCountingStatic( 0, 0, &xSemaphoreBuffer ); + + fakeAssertVerifyNumAssertsAndClear( 2 ); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + /* Check that no malloc occured */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + /* Check that the returned count is zero */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCountingStatic with uxMaxCount=1 and uxInitialCount=2 + * @details This is an invalid initial condition for a counting semaphore since + * uxMaxCount >= uxInitialCount. + * @coverage xQueueCreateCountingSemaphoreStatic + */ +void test_macro_xSemaphoreCreateCountingStatic_one_two( void ) +{ + SemaphoreHandle_t xSemaphore = NULL; + StaticSemaphore_t xSemaphoreBuffer; + + /* Expect that xSemaphoreCreateCountingStatic will assert because + * uxInitialCount > xMaxCount is invalid */ + fakeAssertExpectFail(); + + xSemaphore = xSemaphoreCreateCountingStatic( 1, 2, &xSemaphoreBuffer ); + + fakeAssertGetFlagAndClear(); + + /* validate returned semaphore handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + + /* verify that no heap memory allocation occurred */ + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + /* Check that the count was initialized correctly */ + TEST_ASSERT_EQUAL( 2, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test xSemaphoreCreateCountingStatic with uxMaxCount=1 and uxInitialCount=0 + * @details Create a binary semaphore using xSemaphoreCreateCountingStatic + * @coverage xQueueCreateCountingSemaphoreStatic + */ +void test_macro_xSemaphoreCreateCountingStatic_one_zero_success( void ) +{ + SemaphoreHandle_t xSemaphore = INVALID_PTR; + StaticSemaphore_t xSemaphoreBuffer; + + xSemaphore = xSemaphoreCreateCountingStatic( 1, 0, &xSemaphoreBuffer ); + + TEST_ASSERT_NOT_EQUAL( NULL, xSemaphore ); + TEST_ASSERT_EQUAL( 0, getLastMallocSize() ); + + /* Check the initial count */ + TEST_ASSERT_EQUAL( 0, uxSemaphoreGetCount( xSemaphore ) ); + + vSemaphoreDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/sets/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/sets/FreeRTOSConfig.h new file mode 100644 index 000000000..65727250f --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/FreeRTOSConfig.h @@ -0,0 +1,140 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 0 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#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 +#define configUSE_QUEUE_SETS 1 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/sets/Makefile b/FreeRTOS/Test/CMock/queue/sets/Makefile new file mode 100644 index 000000000..59661c751 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/Makefile @@ -0,0 +1,54 @@ +# Indent with spaces +.RECIPEPREFIX := $(.RECIPEPREFIX) $(.RECIPEPREFIX) + +# Do not move this line below the include +MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) +include ../../makefile.in + +# PROJECT_SRC lists the .c files under test +PROJECT_SRC += queue.c + +# PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files +# Files in PROJECT_DEPS_SRC are excluded from coverage measurements +PROJECT_DEPS_SRC += list.c + +# PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. +PROJECT_HEADER_DEPS += FreeRTOS.h + +# SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) +SUITE_UT_SRC += queue_set_utest.c +SUITE_UT_SRC += queue_in_set_utest.c +SUITE_UT_SRC += queue_send_nonblocking_utest.c +SUITE_UT_SRC += queue_send_blocking_utest.c +SUITE_UT_SRC += semaphore_in_set_utest.c +SUITE_UT_SRC += binary_semaphore_utest.c +SUITE_UT_SRC += mutex_utest.c + + +# SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. +# Paths are relative to PROJECT_DIR +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c + +# List the headers used by PROJECT_SRC that you would like to mock +MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h + +# List any addiitonal flags needed by the preprocessor +CPPFLAGS += -DportUSING_MPU_WRAPPERS=0 + +# List any addiitonal flags needed by the compiler +CFLAGS += + +# Try not to edit beyond this line unless necessary. + +# Project / Suite are determined based on path: $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) +PROJECT := $(lastword $(subst /, ,$(dir $(abspath $(MAKEFILE_ABSPATH)/../)))) +SUITE := $(lastword $(subst /, ,$(dir $(MAKEFILE_ABSPATH)))) + +# Make variables available to included makefile +export + +include ../../testdir.mk diff --git a/FreeRTOS/Test/CMock/queue/sets/binary_semaphore_utest.c b/FreeRTOS/Test/CMock/queue/sets/binary_semaphore_utest.c new file mode 120000 index 000000000..b2cbbd10d --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/binary_semaphore_utest.c @@ -0,0 +1 @@ +../semaphore/binary_semaphore_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/mutex_utest.c b/FreeRTOS/Test/CMock/queue/sets/mutex_utest.c new file mode 120000 index 000000000..f28b8367c --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/mutex_utest.c @@ -0,0 +1 @@ +../semaphore/mutex_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_in_set_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_in_set_utest.c new file mode 100644 index 000000000..0b03fdad7 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_in_set_utest.c @@ -0,0 +1,1040 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_in_set_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ +/* Share QueueHandle_t / QueueSetHandle_t between a test case and it's callbacks */ +static QueueHandle_t xQueueHandleStatic; +static QueueSetHandle_t xQueueSetHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + xQueueHandleStatic = NULL; + xQueueSetHandleStatic = NULL; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* =========================== Helper functions ============================ */ + +/* ============================== Test Cases =============================== */ + + +/** + * @brief Test xQueueSend on a member Queue (size 1) of a QueueSet (size 0) + * @details: In this case, sending to the queue causes a configASSERT, but returns pdTRUE. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_QueueSet_Fail( void ) +{ + /* Expect that xQueueCreateSet will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 0 ); + + fakeAssertGetFlagAndClear(); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + /* Expect that xQueueSend / prvNotifyQueueSetContainer will assert because + * a QueueSet length of 0 is invalid */ + fakeAssertExpectFail(); + + uint32_t testValue = getNextMonotonicTestValue(); + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testValue, 0 ) ); + + TEST_ASSERT_EQUAL( pdTRUE, fakeAssertGetFlagAndClear() ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( NULL, xQueue2 ); + + uint32_t checkValue = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue, &checkValue, 0 ) ); + + TEST_ASSERT_EQUAL( testValue, checkValue ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSend on a member Queue (size 1) of a QueueSet (size 1) + * @details: Send an item to a queue that is part of a QueueSet. + * Verify that the item can be received from the Queue via xQueueSelectFromSet. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_xQueueSelectFromSet_xQueueReceive_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + uint32_t testValue = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testValue, 0 ) ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + uint32_t checkValue = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue2, &checkValue, 0 ) ); + + TEST_ASSERT_EQUAL( testValue, checkValue ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR on a member Queue (size 1) of a QueueSet (size 1) + * @details: Send an item to a queue that is part of a QueueSet. + * Verify that the item can be received from the Queue via xQueueSelectFromSetFromISR and xQueueReceiveFromISR. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_xQueueSelectFromSetFromISR_xQueueReceiveFromISR_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testValue = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testValue, NULL ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + QueueHandle_t xQueue2 = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t checkValue = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue2, &checkValue, NULL ) ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwrite on an empty member Queue (size 1) of a QueueSet (size 1) + * @details: Perform an xQueueOverwrite operation to add a value to a queue. + * Verify that the item can be received from the Queue via xQueueSelectFromSet. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueOverwrite_xQueueSelectFromSet_xQueueReceive_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal ) ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue2, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwriteFromISR on an empty member Queue (size 1) of a QueueSet (size 1) + * @details: Perform an xQueueOverwriteFromISR operation to add a value to a queue. + * Verify that the item can be received from the Queue via xQueueSelectFromSetFromISR. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueOverwriteFromISR_xQueueSelectFromSetFromISR_xQueueReceive_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal, NULL ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + QueueHandle_t xQueue2 = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue2, &checkVal, NULL ) ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwrite on a full member Queue (size 1) of a QueueSet (size 1) + * @details: Send an item to a queue that is part of a QueueSet. Overwrite that same item. + * Verify that the item can be received from the Queue via xQueueSelectFromSet. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_xQueueOverwrite_xQueueSelectFromSet_xQueueReceive_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal1, 0 ) ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwrite( xQueue, &testVal2 ) ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue2, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testVal2, checkVal ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueOverwriteFromISR on a member Queue (size 1) of a QueueSet (size 1) + * @details: Send an item to a queue that is part of a QueueSet. Overwrite that same item. + * Verify that the item can be received from the Queue via xQueueSelectFromSetFromISR. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_xQueueOverwriteFromISR_in_set_success( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t testVal1 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal1, NULL ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + QueueHandle_t xQueue2 = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueue, xQueue2 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueOverwriteFromISR( xQueue, &testVal2, NULL ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueue2, &checkVal, NULL ) ); + + TEST_ASSERT_EQUAL( testVal2, checkVal ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSendFromISR with a higher priority task waiting and a null pointer for pxHigherPriorityTaskWoken + * @details Test xQueueSendFromISR on a queue that is in a Queue Set with a higher priority task waiting. + * Verify that a null pxHigherPriorityTaskWoken is handled correctly. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_in_set_high_priority_pending_null_ptr( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, NULL ) ); + + QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + /* Check that the xYieldPending flag was set + * (task would normally be added to the pending ready list) */ + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueueTemp, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueSendFromISR with a higher priority task waiting on a queue in and Queue Set + * @details Test xQueueSendFromISR with a higher priority task waiting and + * verifies that xHigherPriorityTaskWoken is set accoridngly. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_in_set_high_priority_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xHigherPriorityTaskWoken ); + + /* Check that the xYieldPending flag was set + * (task would normally be added to the pending ready list) */ + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueueTemp, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueSendFromISR with a lower priority task waiting on a queue in a Queue Set + * @details Test xQueueSendFromISR on a Queeu in a Queue Set with a lower priority task waiting and + * verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_in_set_low_priority_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + /* Check that the xYieldPending flag was not set */ + TEST_ASSERT_EQUAL( pdFALSE, td_task_getYieldPending() ); + + QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueueTemp, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueSendFromISR on a queue in a Queue Set with no tasks waiting + * @details Test xQueueSendFromISR on a Queue in a Queue Set no tasks waiting and verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGenericSendFromISR + */ +void test_macro_xQueueSendFromISR_in_set_no_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testVal = getNextMonotonicTestValue(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + /* Check that the xYieldPending flag was not set */ + TEST_ASSERT_EQUAL( pdFALSE, td_task_getYieldPending() ); + + QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueueTemp, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test a non-blocking call to xQueueSend on a queue in a Queue Set with a higher priority task pending. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_in_set_high_priority_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + /* Check that a yield occurred */ + TEST_ASSERT_EQUAL( 1, td_task_getYieldCount() ); + + /* Check that yield was generated by a call to vPortYieldWithinAPI */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vPortYieldWithinAPI() ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueue2, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test a non-blocking call to xQueueSend on a queue in a Queue Set with a lower priority task pending. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_in_set_low_priority_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + /* Check that no yield occurred */ + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueue2, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test a non-blocking call to xQueueSend on a queue in a Queue Set with no pending tasks. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_in_set_no_pending( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xQueue, xQueueSet ); + + uint32_t testVal = getNextMonotonicTestValue(); + + /* Add item to queue*/ + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + /* Check that no yield occurred */ + TEST_ASSERT_EQUAL( 0, td_task_getYieldCount() ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + uint32_t checkVal = INVALID_UINT32; + + xQueueReceive( xQueue2, &checkVal, 0 ); + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueSendFromISR on a queue that is locked + * @coverage prvNotifyQueueSetContainer + */ +void test_xQueueSendFromISR_locked( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 2, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 2 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + /* Set private lock counters on the queue and queueSet */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueueSet, queueLOCKED_UNMODIFIED ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testVal, NULL ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED + 1, cGetQueueTxLock( xQueueSet ) ); + + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueue2, xQueue ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue2, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testVal, checkVal ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueSendFromISR on a queue that is locked where cRxLock overflows. + * @coverage prvNotifyQueueSetContainer + */ +void test_xQueueSendFromISR_locked_overflow( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 2, sizeof( uint32_t ) ); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 2 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + /* Set private lock counters */ + vSetQueueRxLock( xQueue, queueLOCKED_UNMODIFIED ); + vSetQueueTxLock( xQueueSet, INT8_MAX ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Expect an assertion since the cTxLock value has overflowed */ + fakeAssertExpectFail(); + + uint32_t testval = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSendFromISR( xQueue, &testval, NULL ) ); + + /* Verify that the cRxLock counter has not changed */ + TEST_ASSERT_EQUAL( queueLOCKED_UNMODIFIED, cGetQueueRxLock( xQueue ) ); + + /* Verify that the cTxLock counter has been incremented */ + TEST_ASSERT_EQUAL( INT8_MIN, cGetQueueTxLock( xQueueSet ) ); + + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + + /* Call xQueueSend to trigger a call to prvUnlockQueue */ + uint32_t testVal2 = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, 0 ) ); + + /* Read back the first value sent to the queue */ + QueueHandle_t xQueue2 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_TRUE( xQueue2 ); + + uint32_t checkVal = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue2, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( testval, checkVal ); + + /* Read back the second value sent to the queue */ + QueueHandle_t xQueue3 = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_TRUE( xQueue3 ); + + uint32_t checkVal2 = INVALID_UINT32; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueue3, &checkVal2, 0 ) ); + + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Callback for xQueueSend blocking tests which empties the test queue. + */ +static BaseType_t xQueueSend_locked_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t checkVal = INVALID_UINT32; + QueueHandle_t xQueue = xQueueSelectFromSetFromISR( xQueueSetHandleStatic ); + TEST_ASSERT_NOT_NULL( xQueue ); + xQueueReceiveFromISR( xQueue, &checkVal, NULL ); + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueSend on a queue in a Queue Set with no pending tasks. + * @coverage xQueueGenericSend + */ +void test_macro_xQueueSend_in_set_blocking_success_locked_no_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Export for callbacks */ + xQueueSetHandleStatic = xQueueSet; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + /* Check that vPortYieldWithinAPI was called */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Callback for xQueueSend blocking tests which adds an item to the test queue. + */ +static BaseType_t xQueueSend_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Send from an ISR to block */ + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + ( void ) xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ); + } + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueSend on a queue in a Queue Set with a higher priority pending task. + * @coverage prvUnlockQueue + */ +void test_macro_xQueueSend_in_set_blocking_fail_locked_high_prio_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + xQueueSetHandleStatic = xQueueSet; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); + + /* this task is lower priority than the pending task */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + /* Check that xTaskResumeAll was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + /* Check that vPortYieldWithinAPI was called and would have yielded */ + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueueSend on a queue in a Queue Set with a lower priority pending task. + * @coverage prvUnlockQueue + */ +void test_macro_xQueueSend_in_set_blocking_success_locked_low_prio_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + xQueueSetHandleStatic = xQueueSet; + + uint32_t testVal = getNextMonotonicTestValue(); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); + + xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); + + /* this task is higher priority than the pending task */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToSendToQueue( xQueue ); + + uint32_t testVal2 = getLastMonotonicTestValue() + 12345; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Callback for test_xQueueReceive_blocking_success_locked_no_pending which adds an item to it's test queue. + */ +static BaseType_t xQueueReceive_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t testVal = getNextMonotonicTestValue(); + TEST_ASSERT_TRUE( xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ) ); + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueReceive on a queue in a Queue Set with no pending tasks. + * @coverage prvUnlockQueue + */ +void test_xQueueReceive_in_set_blocking_success_locked_no_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_TRUE( xQueueAddToSet( xQueue, xQueueSet ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t checkVal = INVALID_UINT32; + + QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSet, TICKS_TO_WAIT ); + + TEST_ASSERT_NOT_NULL( xQueueFromSet ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueFromSet, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + TEST_ASSERT_EQUAL( 0, td_task_getCount_vTaskMissedYield() ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Stub for xTaskResumeAll used in xQueueReceive tests where the queue under test is in a queue set. + */ +static BaseType_t xQueueReceive_xTaskResumeAllCallback( int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); + + /* If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending + * Receive from an ISR to block */ + + if( pdTRUE == xReturnValue ) + { + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT ) + { + uint32_t checkValue = INVALID_UINT32; + QueueHandle_t xQueue = xQueueSelectFromSetFromISR( xQueueSetHandleStatic ); + TEST_ASSERT_TRUE( xQueueReceiveFromISR( xQueue, &checkValue, NULL ) ); + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkValue ); + } + } + + return xReturnValue; +} + +/** + * @brief Test a blocking call to xQueueReceive on a queue in a Queue Set with a higher priority task pending. + * @coverage prvUnlockQueue + */ +void test_xQueueReceive_in_set_blocking_fail_locked_high_prio_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + xQueueSetHandleStatic = xQueueSet; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSet, TICKS_TO_WAIT ); + + TEST_ASSERT_EQUAL( NULL, xQueueFromSet ); + + TEST_ASSERT_EQUAL( TICKS_TO_WAIT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT + 1, td_task_getCount_YieldFromTaskResumeAll() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT - 1, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was called */ + TEST_ASSERT_EQUAL( 1, td_task_getCount_vTaskMissedYield() ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test a blocking call to xQueueReceive on a queue in a Queue Set with a lower priority task pending. + * @coverage prvUnlockQueue + */ +void test_xQueueReceive_in_set_blocking_success_locked_low_prio_pending( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + xQueueAddToSet( xQueue, xQueueSet ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + xQueueSetHandleStatic = xQueueSet; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); + + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + uint32_t checkVal = INVALID_UINT32; + + QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSet, NUM_CALLS_TO_INTERCEPT ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getYieldCount() ); + + TEST_ASSERT_EQUAL( NUM_CALLS_TO_INTERCEPT, td_task_getCount_vPortYieldWithinAPI() ); + + /* Check that vTaskMissedYield was not called */ + TEST_ASSERT_EQUAL( pdFALSE, td_task_getCount_vTaskMissedYield() ); + + TEST_ASSERT_NOT_NULL( xQueueFromSet ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueFromSet, &checkVal, TICKS_TO_WAIT ) ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_receive_blocking_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_receive_blocking_utest.c new file mode 120000 index 000000000..0e63f5ce8 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_receive_blocking_utest.c @@ -0,0 +1 @@ +../generic/queue_receive_blocking_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_receive_nonblocking_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_receive_nonblocking_utest.c new file mode 120000 index 000000000..7c311c248 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_receive_nonblocking_utest.c @@ -0,0 +1 @@ +../generic/queue_receive_nonblocking_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_send_blocking_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_send_blocking_utest.c new file mode 120000 index 000000000..9aae48328 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_send_blocking_utest.c @@ -0,0 +1 @@ +../generic/queue_send_blocking_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_send_nonblocking_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_send_nonblocking_utest.c new file mode 120000 index 000000000..82ade8293 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_send_nonblocking_utest.c @@ -0,0 +1 @@ +../generic/queue_send_nonblocking_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_set_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_set_utest.c new file mode 100644 index 000000000..c09b98718 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_set_utest.c @@ -0,0 +1,449 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_set_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ========================== Test Cases =========================== */ + +/** + * @brief Test xQueueCreateSet when calls to malloc fail. + * @coverage xQueueCreateSet + */ +void test_xQueueCreateSet_malloc_fail( void ) +{ + UnityMalloc_MakeMallocFailAfterCount( 0 ); + + QueueSetHandle_t xQueueSet = INVALID_PTR; + + xQueueSet = xQueueCreateSet( 1 ); + + TEST_ASSERT_EQUAL( NULL, xQueueSet ); +} + +/** + * @brief Test xQueueCreateSet with uxEventQueueLength=0 + * @coverage xQueueCreateSet + */ +void test_xQueueCreateSet_zeroLength( void ) +{ + /* Expect that xQueueCreateSet will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 0 ); + + /* validate returned QueueSet handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueueSet ); + + /* verify that configASSERT was called */ + TEST_ASSERT_EQUAL( true, fakeAssertGetFlagAndClear() ); + TEST_ASSERT_EQUAL( QUEUE_T_SIZE, getLastMallocSize() ); + + /* Veify that QueueSet is full */ + TEST_ASSERT_EQUAL( 0, uxQueueSpacesAvailable( xQueueSet ) ); + + /* Veify that QueueSet is also empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueueSet ) ); + + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueCreateSet with uxEventQueueLength=1 + * @coverage xQueueCreateSet + */ +void test_xQueueCreateSet_oneLength( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + /* validate returned QueueSet handle */ + TEST_ASSERT_NOT_EQUAL( NULL, xQueueSet ); + + TEST_ASSERT_EQUAL( QUEUE_T_SIZE + sizeof( void * ), getLastMallocSize() ); + + /* Veify that QueueSet is not full */ + TEST_ASSERT_EQUAL( 1, uxQueueSpacesAvailable( xQueueSet ) ); + + /* Veify that QueueSet is empty */ + TEST_ASSERT_EQUAL( 0, uxQueueMessagesWaiting( xQueueSet ) ); + + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xQueueAddToSet with a QueueSet of uxEventQueueLength=0 + * @details: Adds two queues of size 1,0 to a QueueSet of size 0. + * @coverage xQueueAddToSet + */ +void test_xQueueAddToSet_ZeroLength( void ) +{ + /* Expect that xQueueCreateSet will assert because a length of 0 is invalid */ + fakeAssertExpectFail(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 0 ); + + fakeAssertGetFlagAndClear(); + + QueueHandle_t xQueue1 = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue1, xQueueSet ) ); + + QueueHandle_t xQueue2 = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue2, xQueueSet ) ); + + ( void ) xQueueRemoveFromSet( xQueue1, xQueueSet ); + ( void ) xQueueRemoveFromSet( xQueue2, xQueueSet ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue1 ); + vQueueDelete( xQueue2 ); +} + +/** + * @brief Test xQueueAddToSet with the same queue twice + * @coverage xQueueAddToSet + */ +void test_xQueueAddToSet_AlreadyInSameSet( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 2 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet ) ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueAddToSet with a queue that is already a member of a different QueueSet. + * @coverage xQueueAddToSet + */ +void test_xQueueAddToSet_AlreadyInDifferentSet( void ) +{ + QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 ); + + QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet2 ) ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet1 ); + vQueueDelete( xQueueSet1 ); + vQueueDelete( xQueueSet2 ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueAddToSet with a queue that was previously a member of a different QueueSet, which was deleted. + * @coverage xQueueAddToSet + */ +void test_xQueueAddToSet_PreviouslyInDifferentSet( void ) +{ + QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 ); + QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet1 ); + vQueueDelete( xQueueSet1 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet2 ); + vQueueDelete( xQueue ); + vQueueDelete( xQueueSet2 ); +} + +/** + * @brief Test xQueueAddToSet with a queue that is not empty. + * @coverage xQueueAddToSet + */ +void test_xQueueAddToSet_QueueNotEmpty( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueAddToSet( xQueue, xQueueSet ) ); + + ( void ) xQueueRemoveFromSet( xQueue, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueSelectFromSet with multiple queues in a set. + * @coverage xQueueSelectFromSet + */ +void test_xQueueSelectFromSet( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 3 ); + + QueueHandle_t xQueue1 = xQueueCreate( 1, sizeof( uint32_t ) ); + QueueHandle_t xQueue2 = xQueueCreate( 1, sizeof( uint32_t ) ); + QueueHandle_t xQueue3 = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue1, xQueueSet ) ); + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue2, xQueueSet ) ); + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue3, xQueueSet ) ); + + uint32_t testVal1 = 1; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue1, &testVal1, 0 ) ); + + uint32_t testVal2 = 2; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue2, &testVal2, 0 ) ); + + uint32_t testVal3 = 3; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue3, &testVal3, 0 ) ); + + QueueHandle_t xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue1 ); + + uint32_t checkVal1 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + + xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue2 ); + + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal2, 0 ) ); + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + + xQueueTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue3 ); + + uint32_t checkVal3 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueTemp, &checkVal3, 0 ) ); + TEST_ASSERT_EQUAL( testVal3, checkVal3 ); + + ( void ) xQueueRemoveFromSet( xQueue1, xQueueSet ); + ( void ) xQueueRemoveFromSet( xQueue2, xQueueSet ); + ( void ) xQueueRemoveFromSet( xQueue3, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue1 ); + vQueueDelete( xQueue2 ); + vQueueDelete( xQueue3 ); +} + +/** + * @brief Test xQueueSelectFromSetFromISR with multiple queues in a set. + * @coverage xQueueSelectFromSetFromISR + */ +void test_xQueueSelectFromSetFromISR( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 3 ); + + QueueHandle_t xQueue1 = xQueueCreate( 1, sizeof( uint32_t ) ); + QueueHandle_t xQueue2 = xQueueCreate( 1, sizeof( uint32_t ) ); + QueueHandle_t xQueue3 = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue1, xQueueSet ) ); + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue2, xQueueSet ) ); + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue3, xQueueSet ) ); + + uint32_t testVal1 = 1; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue1, &testVal1, 0 ) ); + + uint32_t testVal2 = 2; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue2, &testVal2, 0 ) ); + + uint32_t testVal3 = 3; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue3, &testVal3, 0 ) ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + QueueHandle_t xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue1 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t checkVal1 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal1, 0 ) ); + TEST_ASSERT_EQUAL( testVal1, checkVal1 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue2 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t checkVal2 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal2, 0 ) ); + TEST_ASSERT_EQUAL( testVal2, checkVal2 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + xQueueTemp = xQueueSelectFromSetFromISR( xQueueSet ); + + TEST_ASSERT_EQUAL( xQueueTemp, xQueue3 ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + uint32_t checkVal3 = 0; + + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceiveFromISR( xQueueTemp, &checkVal3, 0 ) ); + TEST_ASSERT_EQUAL( testVal3, checkVal3 ); + + ( void ) xQueueRemoveFromSet( xQueue1, xQueueSet ); + ( void ) xQueueRemoveFromSet( xQueue2, xQueueSet ); + ( void ) xQueueRemoveFromSet( xQueue3, xQueueSet ); + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue1 ); + vQueueDelete( xQueue2 ); + vQueueDelete( xQueue3 ); +} + +/** + * @brief Test xQueueRemoveFromSet where the queue to be removed + * is not empty. + * @coverage xQueueRemoveFromSet + */ +void test_xQueueRemoveFromSet_QueueNotEmpty( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, NULL, 0 ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueRemoveFromSet( xQueue, xQueueSet ) ); + + vQueueDelete( xQueueSet ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueRemoveFromSet where the queue to be removed + * is already in a different set. + * @coverage xQueueRemoveFromSet + */ +void test_xQueueRemoveFromSet_QueueNotInSet( void ) +{ + QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 ); + QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xQueueRemoveFromSet( xQueue, xQueueSet2 ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueRemoveFromSet( xQueue, xQueueSet1 ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) ); + + vQueueDelete( xQueueSet1 ); + vQueueDelete( xQueueSet2 ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test xQueueRemoveFromSet where the queue to be removed + * is in the given set. + * @coverage xQueueRemoveFromSet + */ +void test_xQueueRemoveFromSet_QueueInSet( void ) +{ + QueueSetHandle_t xQueueSet1 = xQueueCreateSet( 1 ); + QueueSetHandle_t xQueueSet2 = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, 0 ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet1 ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueRemoveFromSet( xQueue, xQueueSet1 ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xQueueAddToSet( xQueue, xQueueSet2 ) ); + + vQueueDelete( xQueueSet1 ); + vQueueDelete( xQueueSet2 ); + vQueueDelete( xQueue ); +} diff --git a/FreeRTOS/Test/CMock/queue/sets/queue_unlock_cascaded_set_utest.c b/FreeRTOS/Test/CMock/queue/sets/queue_unlock_cascaded_set_utest.c new file mode 100644 index 000000000..c53284da9 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/queue_unlock_cascaded_set_utest.c @@ -0,0 +1,359 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_unlock_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +#define TICKS_TO_WAIT 10 +#define NUM_CALLS_TO_INTERCEPT_TX TICKS_TO_WAIT / 2 +#define NUM_CALLS_TO_INTERCEPT_RX TICKS_TO_WAIT / 2 + +/* Share QueueHandle_t / QueueSetHandle_t between a test case and it's callbacks */ +static QueueHandle_t xQueueHandleStatic; +static QueueSetHandle_t xQueueSetHandleStatic; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + vFakePortAssertIfInterruptPriorityInvalid_Ignore(); + xQueueHandleStatic = NULL; + xQueueSetHandleStatic = NULL; +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ========================== Test Cases =========================== */ + +/* / ** */ +/* * @brief Callback for test_macro_xQueueSend_blocking_success which empties it's test queue. */ +/* * / */ +/* static BaseType_t xQueueSend_locked_xTaskCheckForTimeOutCB( TimeOut_t* const pxTimeOut, */ +/* TickType_t* const pxTicksToWait, */ +/* int cmock_num_calls ) */ +/* { */ +/* BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); */ + +/* if(cmock_num_calls == NUM_CALLS_TO_INTERCEPT_TX) */ +/* { */ +/* uint32_t checkVal = INVALID_UINT32; */ +/* QueueHandle_t xQueue = xQueueSelectFromSetFromISR( xQueueSetHandleStatic ); */ +/* TEST_ASSERT_NOT_NULL( xQueue ); */ +/* xQueueReceiveFromISR( xQueue, &checkVal, NULL ); */ +/* TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); */ +/* } */ +/* return xReturnValue; */ +/* } */ + +/* void test_macro_xQueueSend_in_set_blocking_success_locked_no_pending( void ) */ +/* { */ +/* QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); */ + +/* QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); */ + +/* xQueueAddToSet( xQueue, xQueueSet ); */ + +/* / * Export for callbacks * / */ +/* xQueueSetHandleStatic = xQueueSet; */ + +/* uint32_t testVal = getNextMonotonicTestValue(); */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); */ + +/* xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); */ +/* xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); */ + +/* uint32_t testVal2 = getLastMonotonicTestValue() + 12345; */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); */ + +/* (void) xQueueRemoveFromSet( xQueue, xQueueSet ); */ +/* vQueueDelete( xQueueSet ); */ +/* vQueueDelete( xQueue ); */ +/* } */ + +/* static BaseType_t xQueueSend_xTaskResumeAllCallback( int cmock_num_calls ) */ +/* { */ +/* BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); */ +/* / * If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending */ +/* Send from an ISR to block * / */ +/* if( pdTRUE == xReturnValue ) */ +/* { */ +/* if(cmock_num_calls == NUM_CALLS_TO_INTERCEPT_TX) */ +/* { */ +/* uint32_t testVal = getNextMonotonicTestValue(); */ +/* (void) xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ); */ +/* } */ +/* } */ +/* return xReturnValue; */ +/* } */ + +/* / * @coverage prvUnlockQueue * / */ +/* void test_macro_xQueueSend_in_set_blocking_fail_locked_high_prio_pending( void ) */ +/* { */ +/* QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); */ + +/* QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); */ + +/* xQueueAddToSet( xQueue, xQueueSet ); */ + +/* / * Export for callbacks * / */ +/* xQueueHandleStatic = xQueue; */ +/* xQueueSetHandleStatic = xQueueSet; */ + +/* uint32_t testVal = getNextMonotonicTestValue(); */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); */ + +/* xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); */ +/* xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); */ + +/* / * this task is lower priority than the pending task * / */ +/* td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); */ + +/* td_task_addFakeTaskWaitingToSendToQueue( xQueue ); */ + +/* uint32_t testVal2 = getLastMonotonicTestValue() + 12345; */ + +/* TEST_ASSERT_EQUAL( pdFALSE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); */ + +/* (void) xQueueRemoveFromSet( xQueue, xQueueSet ); */ +/* vQueueDelete( xQueueSet ); */ +/* vQueueDelete( xQueue ); */ +/* } */ + + +/* void test_macro_xQueueSend_in_set_blocking_success_locked_low_prio_pending( void ) */ +/* { */ +/* QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); */ + +/* QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); */ + +/* xQueueAddToSet( xQueue, xQueueSet ); */ + +/* / * Export for callbacks * / */ +/* xQueueHandleStatic = xQueue; */ +/* xQueueSetHandleStatic = xQueueSet; */ + +/* uint32_t testVal = getNextMonotonicTestValue(); */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal, 0 ) ); */ + +/* xTaskCheckForTimeOut_Stub( &xQueueSend_locked_xTaskCheckForTimeOutCB ); */ +/* xTaskResumeAll_Stub( &xQueueSend_xTaskResumeAllCallback ); */ + +/* / * this task is higher priority than the pending task * / */ +/* td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); */ + +/* td_task_addFakeTaskWaitingToSendToQueue( xQueue ); */ + +/* uint32_t testVal2 = getLastMonotonicTestValue() + 12345; */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueSend( xQueue, &testVal2, TICKS_TO_WAIT ) ); */ + +/* (void) xQueueRemoveFromSet( xQueue, xQueueSet ); */ +/* vQueueDelete( xQueueSet ); */ +/* vQueueDelete( xQueue ); */ +/* } */ + +/** + * @brief Callback for test_macro_xQueueReceive_blocking_success_locked_no_pending which adds an item to it's test queue. + */ +static BaseType_t xQueueReceive_xTaskCheckForTimeOutCB( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = td_task_xTaskCheckForTimeOutStub( pxTimeOut, pxTicksToWait, cmock_num_calls ); + + printf( "In xQueueReceive_xTaskCheckForTimeOutCB %d\n", cmock_num_calls ); + + if( cmock_num_calls == NUM_CALLS_TO_INTERCEPT_TX ) + { + uint32_t testVal = getNextMonotonicTestValue(); + printf( "Calling xQueueSendFromISR\n" ); + TEST_ASSERT_TRUE( xQueueSendFromISR( xQueueHandleStatic, &testVal, NULL ) ); + } + + return xReturnValue; +} + +void test_macro_xQueueReceive_in_set_blocking_success_locked_no_pending( void ) +{ + QueueSetHandle_t xQueueSetOuter = xQueueCreateSet( 1 ); + QueueSetHandle_t xQueueSetInner = xQueueCreateSet( 1 ); + + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + printf( "xQueueSetOuter: %lu, xQueueSetInner: %lu, xQueue: %lu\n", ( unsigned long ) xQueueSetOuter, ( unsigned long ) xQueueSetInner, ( unsigned long ) xQueue ); + + + TEST_ASSERT_TRUE( xQueueAddToSet( xQueueSetInner, xQueueSetOuter ) ); + + TEST_ASSERT_TRUE( xQueueAddToSet( xQueue, xQueueSetInner ) ); + + /* Export for callbacks */ + xQueueHandleStatic = xQueue; + + xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + uint32_t checkVal = INVALID_UINT32; + + /* printf("Calling xQueueSelectFromSet from OuterSet\n"); */ + /* QueueSetHandle_t xQueueSetFromSet = xQueueSelectFromSet( xQueueSetOuter, TICKS_TO_WAIT ); */ + + /* TEST_ASSERT_EQUAL( xQueueSetInner, xQueueSetFromSet ); */ + + QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSetOuter, TICKS_TO_WAIT ); + + TEST_ASSERT_EQUAL( xQueue, xQueueFromSet ); /* TODO: assert equality */ + + printf( "Calling xQueueReceive\n" ); + TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueFromSet, &checkVal, 0 ) ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); + + ( void ) xQueueRemoveFromSet( xQueueSetInner, xQueueSetOuter ); + vQueueDelete( xQueueSetOuter ); + ( void ) xQueueRemoveFromSet( xQueue, xQueueSetInner ); + vQueueDelete( xQueueSetInner ); + vQueueDelete( xQueue ); +} + +/* static BaseType_t xQueueReceive_xTaskResumeAllCallback( int cmock_num_calls ) */ +/* { */ +/* BaseType_t xReturnValue = td_task_xTaskResumeAllStub( cmock_num_calls ); */ +/* / * If td_task_xTaskResumeAllStub returns pdTRUE, a higher priority task is pending */ +/* Receive from an ISR to block * / */ + +/* printf("In xQueueReceive_xTaskResumeAllCallback %d\n", cmock_num_calls); */ +/* if( pdTRUE == xReturnValue ) */ +/* { */ +/* if(cmock_num_calls == NUM_CALLS_TO_INTERCEPT_TX) */ +/* { */ +/* uint32_t checkValue = INVALID_UINT32; */ +/* QueueHandle_t xQueue = xQueueSelectFromSetFromISR( xQueueSetHandleStatic ); */ +/* TEST_ASSERT_TRUE( xQueueReceiveFromISR( xQueue, &checkValue, NULL ) ); */ +/* TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkValue ); */ +/* } */ +/* } */ +/* return xReturnValue; */ +/* } */ + + +/* void test_macro_xQueueReceive_in_set_blocking_success_locked_high_prio_pending( void ) */ +/* { */ +/* QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); */ + +/* QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); */ + +/* xQueueAddToSet( xQueue, xQueueSet ); */ + +/* / * Export for callbacks * / */ +/* xQueueHandleStatic = xQueue; */ +/* xQueueSetHandleStatic = xQueueSet; */ + +/* xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); */ +/* xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); */ + +/* td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); */ + +/* td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); */ + +/* QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSet, TICKS_TO_WAIT ); */ + +/* TEST_ASSERT_EQUAL( NULL, xQueueFromSet ); */ + +/* (void) xQueueRemoveFromSet( xQueue, xQueueSet ); */ +/* vQueueDelete( xQueueSet ); */ +/* vQueueDelete( xQueue ); */ +/* } */ + + +/* void test_macro_xQueueReceive_in_set_blocking_success_locked_low_prio_pending( void ) */ +/* { */ +/* QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); */ + +/* QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); */ + +/* xQueueAddToSet( xQueue, xQueueSet ); */ + +/* / * Export for callbacks * / */ +/* xQueueHandleStatic = xQueue; */ +/* xQueueSetHandleStatic = xQueueSet; */ + +/* xTaskCheckForTimeOut_Stub( &xQueueReceive_xTaskCheckForTimeOutCB ); */ +/* xTaskResumeAll_Stub( &xQueueReceive_xTaskResumeAllCallback ); */ + +/* td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); */ + +/* td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); */ + +/* uint32_t checkVal = INVALID_UINT32; */ + +/* QueueHandle_t xQueueFromSet = xQueueSelectFromSet( xQueueSet, TICKS_TO_WAIT ); */ + +/* TEST_ASSERT_NOT_NULL( xQueueFromSet ); */ + +/* TEST_ASSERT_EQUAL( pdTRUE, xQueueReceive( xQueueFromSet, &checkVal, TICKS_TO_WAIT ) ); */ + +/* TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), checkVal ); */ + +/* (void) xQueueRemoveFromSet( xQueue, xQueueSet ); */ +/* vQueueDelete( xQueueSet ); */ +/* vQueueDelete( xQueue ); */ +/* } */ diff --git a/FreeRTOS/Test/CMock/queue/sets/semaphore_in_set_utest.c b/FreeRTOS/Test/CMock/queue/sets/semaphore_in_set_utest.c new file mode 100644 index 000000000..bffb14da9 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/sets/semaphore_in_set_utest.c @@ -0,0 +1,206 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file semaphore_in_set_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "semphr.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/* ========================== Test Cases =========================== */ + +/** + * @brief Test xSemaphoreGiveFromISR with a higher priority task waiting and a null pointer for pxHigherPriorityTaskWoken + * @details Test xSemaphoreGiveFromISR on a queue that is in a Queue Set with a higher priority task waiting. + * Verify that a null pxHigherPriorityTaskWoken is handled correctly. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_in_set_high_priority_pending_null_ptr( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xSemaphore, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, NULL ) ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + SemaphoreHandle_t xSemaphoreTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphoreTemp ) ); + + vSemaphoreDelete( xSemaphore ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a higher priority task waiting on a queue in and Queue Set + * @details Test xSemaphoreGiveFromISR with a higher priority task waiting and + * verifies that xHigherPriorityTaskWoken is set accoridngly. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_in_set_high_priority_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xSemaphore, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY + 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdTRUE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdTRUE, td_task_getYieldPending() ); + + SemaphoreHandle_t xSemaphoreTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphoreTemp ) ); + + vSemaphoreDelete( xSemaphore ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xSemaphoreGiveFromISR with a lower priority task waiting on a queue in a Queue Set + * @details Test xSemaphoreGiveFromISR on a Queeu in a Queue Set with a lower priority task waiting and + * verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_in_set_low_priority_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xSemaphore, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + /* Insert an item into the event list */ + td_task_setFakeTaskPriority( DEFAULT_PRIORITY - 1 ); + td_task_addFakeTaskWaitingToReceiveFromQueue( xQueueSet ); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + TEST_ASSERT_EQUAL( pdFALSE, td_task_getYieldPending() ); + + SemaphoreHandle_t xSemaphoreTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphoreTemp ) ); + + vSemaphoreDelete( xSemaphore ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test xSemaphoreGiveFromISR on a queue in a Queue Set with no tasks waiting + * @details Test xSemaphoreGiveFromISR on a Queue in a Queue Set no tasks waiting and verify that xHigherPriorityTaskWoken is not modified. + * @coverage xQueueGiveFromISR + */ +void test_macro_xSemaphoreGiveFromISR_in_set_no_pending( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + xQueueAddToSet( xSemaphore, xQueueSet ); + + vFakePortAssertIfInterruptPriorityInvalid_Expect(); + + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + /* Give the semaphore */ + TEST_ASSERT_EQUAL( pdTRUE, xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken ) ); + + TEST_ASSERT_EQUAL( pdFALSE, xHigherPriorityTaskWoken ); + + SemaphoreHandle_t xSemaphoreTemp = xQueueSelectFromSet( xQueueSet, 0 ); + + TEST_ASSERT_EQUAL( B_SEMPHR_AVAILABLE, uxSemaphoreGetCount( xSemaphoreTemp ) ); + + vSemaphoreDelete( xSemaphore ); + vQueueDelete( xQueueSet ); +} diff --git a/FreeRTOS/Test/CMock/queue/static/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/static/FreeRTOSConfig.h new file mode 100644 index 000000000..613ce07ed --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/static/FreeRTOSConfig.h @@ -0,0 +1,141 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 0 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#define configCHECK_FOR_STACK_OVERFLOW 0 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configQUEUE_REGISTRY_SIZE 0 +#define configUSE_MALLOC_FAILED_HOOK 1 +#define configUSE_APPLICATION_TASK_TAG 1 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configUSE_ALTERNATIVE_API 0 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configSUPPORT_DYNAMIC_ALLOCATION 0 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/two_tests/Makefile b/FreeRTOS/Test/CMock/queue/static/Makefile similarity index 85% rename from FreeRTOS/Test/CMock/queue/two_tests/Makefile rename to FreeRTOS/Test/CMock/queue/static/Makefile index 1c79a491d..b6ad9c42f 100644 --- a/FreeRTOS/Test/CMock/queue/two_tests/Makefile +++ b/FreeRTOS/Test/CMock/queue/static/Makefile @@ -10,22 +10,23 @@ PROJECT_SRC += queue.c # PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files # Files in PROJECT_DEPS_SRC are excluded from coverage measurements -PROJECT_DEPS_SRC += +PROJECT_DEPS_SRC += list.c # PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. PROJECT_HEADER_DEPS += FreeRTOS.h # SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) -SUITE_UT_SRC += queue_2_utest.c -SUITE_UT_SRC += queue_1_utest.c +SUITE_UT_SRC += queue_create_static_utest.c +SUITE_UT_SRC += queue_delete_static_utest.c # SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. # Paths are relative to PROJECT_DIR -SUITE_SUPPORT_SRC += +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c # List the headers used by PROJECT_SRC that you would like to mock MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h -MOCK_FILES_FP += $(KERNEL_DIR)/include/list.h MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h diff --git a/FreeRTOS/Test/CMock/queue/static/queue_create_static_utest.c b/FreeRTOS/Test/CMock/queue/static/queue_create_static_utest.c new file mode 120000 index 000000000..0332b8d3f --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/static/queue_create_static_utest.c @@ -0,0 +1 @@ +../generic/queue_create_static_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/static/queue_delete_static_utest.c b/FreeRTOS/Test/CMock/queue/static/queue_delete_static_utest.c new file mode 120000 index 000000000..5ce261290 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/static/queue_delete_static_utest.c @@ -0,0 +1 @@ +../generic/queue_delete_static_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/td_port.c b/FreeRTOS/Test/CMock/queue/td_port.c new file mode 100644 index 000000000..a6a3360c8 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/td_port.c @@ -0,0 +1,122 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file td_port.c */ + +#include "queue_utest_common.h" + +/* C runtime includes. */ +#include +#include +#include + +/* Test includes. */ +#include "unity.h" +#include "unity_memory.h" + +/* Mock includes. */ +#include "mock_task.h" +#include "mock_fake_port.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +bool xInCriticalSection = false; +uint32_t ulNumEnterCriticalSection = 0; +uint32_t ulNumExitCriticalSection = 0; + +UBaseType_t uxSavedInterruptStatusGlobal = 0; +uint32_t ulNumCallsSetInterruptMaskFromISR = 0; +uint32_t ulNumCallsClearInterruptMaskFromISR = 0; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +static void enterCriticalSectionStub( int cmock_num_calls ) +{ + /* check that enterCriticalSectionStub was not called twice in a row */ + TEST_ASSERT_FALSE_MESSAGE( xInCriticalSection, "vFakePortEnterCriticalSection was called twice in a row." ); + xInCriticalSection = true; + ulNumEnterCriticalSection++; +} + +static void exitCriticalSectionStub( int cmock_num_calls ) +{ + /* check that exitCriticalSectionStub was not called twice in a row */ + TEST_ASSERT_TRUE_MESSAGE( xInCriticalSection, "vFakePortExitCriticalSection was called twice in a row." ); + xInCriticalSection = false; + ulNumExitCriticalSection++; +} + +static UBaseType_t portSetInterruptMaskFromISRStub( int cmock_num_calls ) +{ + ulNumCallsSetInterruptMaskFromISR++; + uxSavedInterruptStatusGlobal = getLastMonotonicTestValue() + 241235; + xInCriticalSection = true; + return uxSavedInterruptStatusGlobal; +} + +static void portClearInterruptMaskFromISRStub( UBaseType_t uxSavedInterruptStatus, + int cmock_num_calls ) +{ + ulNumCallsClearInterruptMaskFromISR++; + TEST_ASSERT_EQUAL_MESSAGE( uxSavedInterruptStatusGlobal, uxSavedInterruptStatus, + "Saved interrupt state from call to portClearInterruptMaskFromISR does not match last call to portSetInterruptMaskFromISR." ); + xInCriticalSection = false; + uxSavedInterruptStatusGlobal = 0; +} + +/* ============================= Unity Fixtures ============================= */ + +/* ========================== Helper functions =========================== */ + +void td_port_register_stubs( void ) +{ + /* Track critical section state */ + xInCriticalSection = false; + ulNumEnterCriticalSection = 0; + ulNumExitCriticalSection = 0; + + vFakePortEnterCriticalSection_Stub( &enterCriticalSectionStub ); + vFakePortExitCriticalSection_Stub( &exitCriticalSectionStub ); + + uxSavedInterruptStatusGlobal = 0; + vFakePortClearInterruptMaskFromISR_Stub( &portClearInterruptMaskFromISRStub ); + ulFakePortSetInterruptMaskFromISR_Stub( &portSetInterruptMaskFromISRStub ); +} + +BaseType_t td_port_isInCriticalSection( void ) +{ + return xInCriticalSection; +} + +void td_port_teardown_check( void ) +{ + TEST_ASSERT_EQUAL_MESSAGE( ulNumEnterCriticalSection, + ulNumExitCriticalSection, + "Number of calls to vFakePortEnterCriticalSection does not match the number of calls to vFakePortExitCriticalSection." ); + + TEST_ASSERT_EQUAL_MESSAGE( 0, + uxSavedInterruptStatusGlobal, + "uxSavedInterruptStatus was non-zero at the end of the preceeding test case." ); +} diff --git a/FreeRTOS/Test/CMock/queue/td_task.c b/FreeRTOS/Test/CMock/queue/td_task.c new file mode 100644 index 000000000..7fd4f27c3 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/td_task.c @@ -0,0 +1,352 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file td_task.c */ + +#include "queue_utest_common.h" + +/* Test includes. */ +#include "unity.h" + +/* Mock includes. */ +#include "mock_task.h" +#include "mock_fake_port.h" + + +/* ============================ GLOBAL VARIABLES =========================== */ +static BaseType_t xSchedulerState = taskSCHEDULER_RUNNING; +static ListItem_t taskListItem; +static ListItem_t fakeTaskListItem; +static TickType_t xTickCount = 0; +static BaseType_t xYieldPending = pdFALSE; +static BaseType_t xYieldCount = 0; +static BaseType_t xPortYieldCount = 0; +static BaseType_t xPortYieldFromISRCount = 0; +static BaseType_t xPortYieldWithinAPICount = 0; +static BaseType_t xTaskMissedYieldCount = 0; +static BaseType_t xYieldFromTaskResumeAllCount = 0; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +static BaseType_t xTaskGetSchedulerStateStub( int num_calls ) +{ + return xSchedulerState; +} + +static void vTaskSuspendAllStub( int cmock_num_calls ) +{ + TEST_ASSERT_EQUAL_MESSAGE( taskSCHEDULER_RUNNING, xSchedulerState, "vTaskSuspendAll called with scheduler suspended." ); + xSchedulerState = taskSCHEDULER_SUSPENDED; +} + +void td_task_vTaskSuspendAllStubNoCheck( int cmock_num_calls ) +{ + xSchedulerState = taskSCHEDULER_SUSPENDED; +} + +static void vTaskMissedYieldStub( int cmock_num_calls ) +{ + TEST_ASSERT_TRUE_MESSAGE( ( td_task_getFakeTaskPriority() >= DEFAULT_PRIORITY ), "A Missed Yield should only occur when a higher priority task is pending." ); + xTaskMissedYieldCount++; + xYieldPending = pdTRUE; +} + +BaseType_t td_task_xTaskResumeAllStub( int cmock_num_calls ) +{ + BaseType_t xDidYield = pdFALSE; + + TEST_ASSERT_EQUAL_MESSAGE( taskSCHEDULER_SUSPENDED, xSchedulerState, "xTaskResumeAll called with scheduler running." ); + + xSchedulerState = taskSCHEDULER_RUNNING; + + if( ( td_task_getFakeTaskPriority() >= DEFAULT_PRIORITY ) && + ( listLIST_ITEM_CONTAINER( &fakeTaskListItem ) != NULL ) ) + { + xYieldPending = pdTRUE; + } + + if( xYieldPending ) + { + #if ( configUSE_PREEMPTION == 1 ) + xDidYield = pdTRUE; + xYieldCount++; + xYieldFromTaskResumeAllCount++; + xYieldPending = pdFALSE; + #endif + } + + /* Remove task from blocked list */ + if( listLIST_ITEM_CONTAINER( &taskListItem ) ) + { + uxListRemove( &taskListItem ); + } + + return xDidYield; +} + +static void vPortYieldStub( int cmock_num_calls ) +{ + xYieldCount++; + xPortYieldCount++; + xYieldPending = pdFALSE; +} + +static void vPortYieldFromISRStub( int cmock_num_calls ) +{ + xYieldCount++; + xPortYieldFromISRCount++; + xYieldPending = pdFALSE; +} + +void td_task_vPortYieldWithinAPIStub( int cmock_num_calls ) +{ + xYieldCount++; + xPortYieldWithinAPICount++; + xYieldPending = pdFALSE; +} + +/* Timeout handling callbacks */ +static void vTaskInternalSetTimeOutStateStub( TimeOut_t * const pxTimeOut, + int cmock_num_calls ) +{ + pxTimeOut->xOverflowCount = 0; + pxTimeOut->xTimeOnEntering = xTickCount; +} + +BaseType_t td_task_xTaskCheckForTimeOutStub( TimeOut_t * const pxTimeOut, + TickType_t * const pxTicksToWait, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = pdFALSE; + + xTickCount++; + + if( ( xTickCount - pxTimeOut->xTimeOnEntering ) > *pxTicksToWait ) + { + xReturnValue = pdTRUE; + } + + return xReturnValue; +} + +/* Sorted Event list related */ +static BaseType_t xTaskRemoveFromEventListStub( const List_t * const pxEventList, + int cmock_num_calls ) +{ + BaseType_t xReturnValue = pdFALSE; + + /* check that xTaskRemoveFromEventList was called from within a critical section */ + TEST_ASSERT_TRUE_MESSAGE( td_port_isInCriticalSection(), "xTaskRemoveFromEventList was called outside of a critical section." ); + + ListItem_t * pxItem = listGET_HEAD_ENTRY( pxEventList ); + + TickType_t xItemPriority = ( configMAX_PRIORITIES - listGET_LIST_ITEM_VALUE( pxItem ) ); + + ( void ) uxListRemove( pxItem ); + + xReturnValue = ( xItemPriority > DEFAULT_PRIORITY ); + + xYieldPending |= xReturnValue; + + return( xReturnValue ); +} + + + +static void vTaskPlaceOnEventListStub( List_t * const pxEventList, + const TickType_t xTicksToWait, + int cmock_num_calls ) +{ + if( listLIST_ITEM_CONTAINER( &taskListItem ) ) + { + uxListRemove( &taskListItem ); + } + + listSET_LIST_ITEM_VALUE( &taskListItem, ( configMAX_PRIORITIES - DEFAULT_PRIORITY ) ); + + vListInsert( pxEventList, &taskListItem ); +} + +/* ============================= Unity Fixtures ============================= */ + + +/* ========================== Helper functions ============================= */ + + +void td_task_register_stubs( void ) +{ + /* Initialize local static variables */ + xSchedulerState = taskSCHEDULER_RUNNING; + xTickCount = 0; + vListInitialiseItem( &taskListItem ); + listSET_LIST_ITEM_VALUE( &taskListItem, configMAX_PRIORITIES - DEFAULT_PRIORITY ); + vListInitialiseItem( &fakeTaskListItem ); + listSET_LIST_ITEM_VALUE( &fakeTaskListItem, configMAX_PRIORITIES - DEFAULT_PRIORITY ); + xYieldPending = pdFALSE; + xYieldCount = 0; + xPortYieldCount = 0; + xPortYieldFromISRCount = 0; + xPortYieldWithinAPICount = 0; + xTaskMissedYieldCount = 0; + xYieldFromTaskResumeAllCount = 0; + + /* Setup stubs */ + vFakePortYield_Stub( &vPortYieldStub ); + vFakePortYieldFromISR_Stub( &vPortYieldFromISRStub ); + vFakePortYieldWithinAPI_Stub( &td_task_vPortYieldWithinAPIStub ); + + xTaskGetSchedulerState_Stub( &xTaskGetSchedulerStateStub ); + vTaskSuspendAll_Stub( &vTaskSuspendAllStub ); + vTaskMissedYield_Stub( &vTaskMissedYieldStub ); + xTaskResumeAll_Stub( &td_task_xTaskResumeAllStub ); + + vTaskInternalSetTimeOutState_Stub( &vTaskInternalSetTimeOutStateStub ); + xTaskCheckForTimeOut_Stub( &td_task_xTaskCheckForTimeOutStub ); + + xTaskRemoveFromEventList_Stub( &xTaskRemoveFromEventListStub ); + vTaskPlaceOnEventList_Stub( &vTaskPlaceOnEventListStub ); +} + +void td_task_setSchedulerState( BaseType_t state ) +{ + xSchedulerState = state; +} + +void td_task_teardown_check( void ) +{ + /* Assertions to run at the end of the test case */ + TEST_ASSERT_EQUAL_MESSAGE( taskSCHEDULER_RUNNING, xSchedulerState, "Test case ended with the scheduler suspended." ); + + TEST_ASSERT_EQUAL_MESSAGE( 0, xYieldCount, "Test case ended with xYieldCount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( 0, xPortYieldCount, "Test case ended with xPortYieldCount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( 0, xPortYieldFromISRCount, "Test case ended with xPortYieldFromISRCount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( 0, xPortYieldWithinAPICount, "Test case ended with xPortYieldWithinAPICount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( 0, xYieldFromTaskResumeAllCount, "Test case ended with xYieldFromTaskResumeAllCount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( 0, xTaskMissedYieldCount, "Test case ended with xTaskMissedYieldCount > 0" ); + TEST_ASSERT_EQUAL_MESSAGE( pdFALSE, xYieldPending, "Test case ended with xYieldPending != pdFALSE" ); +} + +void td_task_setFakeTaskPriority( TickType_t priority ) +{ + fakeTaskListItem.xItemValue = ( configMAX_PRIORITIES - priority ); + List_t * pxContainer = listLIST_ITEM_CONTAINER( &fakeTaskListItem ); + + if( pxContainer != NULL ) + { + uxListRemove( &fakeTaskListItem ); + vListInsert( pxContainer, &fakeTaskListItem ); + } +} + +void td_task_addFakeTaskWaitingToSendToQueue( QueueHandle_t xQueue ) +{ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + List_t * pxTasksWaitingToSend = ( List_t * ) &( pxQueue->xDummy3[ 0 ] ); + + if( listLIST_ITEM_CONTAINER( &fakeTaskListItem ) ) + { + uxListRemove( &fakeTaskListItem ); + } + + fakeTaskListItem.pvOwner = NULL; + + vListInsert( pxTasksWaitingToSend, &fakeTaskListItem ); +} + +void td_task_addFakeTaskWaitingToReceiveFromQueue( QueueHandle_t xQueue ) +{ + StaticQueue_t * pxQueue = ( StaticQueue_t * ) xQueue; + List_t * pxTasksWaitingToReceive = ( List_t * ) &( pxQueue->xDummy3[ 1 ] ); + + if( listLIST_ITEM_CONTAINER( &fakeTaskListItem ) ) + { + uxListRemove( &fakeTaskListItem ); + } + + fakeTaskListItem.pvOwner = NULL; + + vListInsert( pxTasksWaitingToReceive, &fakeTaskListItem ); +} + +TickType_t td_task_getFakeTaskPriority( void ) +{ + return( configMAX_PRIORITIES - fakeTaskListItem.xItemValue ); +} + +BaseType_t td_task_getYieldCount( void ) +{ + BaseType_t xReturnValue = xYieldCount; + + xYieldCount = 0; + return xReturnValue; +} + +BaseType_t td_task_getCount_vPortYield( void ) +{ + BaseType_t xReturnValue = xPortYieldCount; + + xPortYieldCount = 0; + return xReturnValue; +} + +BaseType_t td_task_getCount_vPortYieldFromISR( void ) +{ + BaseType_t xReturnValue = xPortYieldFromISRCount; + + xPortYieldFromISRCount = 0; + return xReturnValue; +} + +BaseType_t td_task_getCount_vPortYieldWithinAPI( void ) +{ + BaseType_t xReturnValue = xPortYieldWithinAPICount; + + xPortYieldWithinAPICount = 0; + return xReturnValue; +} + +BaseType_t td_task_getCount_vTaskMissedYield( void ) +{ + BaseType_t xReturnValue = xTaskMissedYieldCount; + + xTaskMissedYieldCount = 0; + return xReturnValue; +} + +BaseType_t td_task_getCount_YieldFromTaskResumeAll( void ) +{ + BaseType_t xReturnValue = xYieldFromTaskResumeAllCount; + + xYieldFromTaskResumeAllCount = 0; + return xReturnValue; +} + +BaseType_t td_task_getYieldPending( void ) +{ + BaseType_t xReturnValue = xYieldPending; + + xYieldPending = pdFALSE; + return xReturnValue; +} diff --git a/FreeRTOS/Test/CMock/queue/tracing/FreeRTOSConfig.h b/FreeRTOS/Test/CMock/queue/tracing/FreeRTOSConfig.h new file mode 100644 index 000000000..93855d01f --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/FreeRTOSConfig.h @@ -0,0 +1,139 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ + + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +#include "fake_assert.h" + +/*----------------------------------------------------------- +* Application specific definitions. +* +* These definitions should be adjusted for your particular hardware and +* application requirements. +* +* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE +* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. See +* http://www.freertos.org/a00110.html +*----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configUSE_IDLE_HOOK 1 +#define configUSE_TICK_HOOK 1 +#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 ) ( 52 * 1024 ) ) +#define configMAX_TASK_NAME_LEN ( 12 ) +#define configUSE_TRACE_FACILITY 1 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#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 +#define configUSE_QUEUE_SETS 1 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configTASK_NOTIFICATION_ARRAY_ENTRIES 5 +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configINITIAL_TICK_COUNT ( ( TickType_t ) 0 ) /* For test. */ +#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 1 /* As there are a lot of tasks running. */ + +/* Software timer related configuration options. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#define configTIMER_QUEUE_LENGTH 20 +#define configTIMER_TASK_STACK_DEPTH ( configMINIMAL_STACK_SIZE * 2 ) + +#define configMAX_PRIORITIES ( 7 ) + +/* Run time stats gathering configuration options. */ +unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */ +void vConfigureTimerForRunTimeStats( void ); /* Prototype of function that initialises the run time counter. */ +#define configGENERATE_RUN_TIME_STATS 1 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats() +#define portGET_RUN_TIME_COUNTER_VALUE() ulGetRunTimeCounterValue() + +/* Co-routine related configuration options. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES ( 2 ) + +/* This demo makes 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 + +/* 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 + * functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xSemaphoreGetMutexHolder 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 + +/* It is a good idea to define configASSERT() while developing. configASSERT() + * uses the same semantics as the standard C assert() macro. */ +#define configASSERT( x ) \ + do \ + { \ + if( x ) \ + { \ + vFakeAssert( true, __FILE__, __LINE__ ); \ + } \ + else \ + { \ + vFakeAssert( false, __FILE__, __LINE__ ); \ + } \ + } while ( 0 ) + +#define mtCOVERAGE_TEST_MARKER() __asm volatile ( "NOP" ) + +#define configINCLUDE_MESSAGE_BUFFER_AMP_DEMO 0 +#if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 ) + extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer ); + #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer ) +#endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */ + +#endif /* FREERTOS_CONFIG_H */ diff --git a/FreeRTOS/Test/CMock/queue/tracing/Makefile b/FreeRTOS/Test/CMock/queue/tracing/Makefile new file mode 100644 index 000000000..58932691d --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/Makefile @@ -0,0 +1,50 @@ +# Indent with spaces +.RECIPEPREFIX := $(.RECIPEPREFIX) $(.RECIPEPREFIX) + +# Do not move this line below the include +MAKEFILE_ABSPATH := $(abspath $(lastword $(MAKEFILE_LIST))) +include ../../makefile.in + +# PROJECT_SRC lists the .c files under test +PROJECT_SRC += queue.c + +# PROJECT_DEPS_SRC list the .c file that are dependencies of PROJECT_SRC files +# Files in PROJECT_DEPS_SRC are excluded from coverage measurements +PROJECT_DEPS_SRC += list.c + +# PROJECT_HEADER_DEPS: headers that should be excluded from coverage measurements. +PROJECT_HEADER_DEPS += FreeRTOS.h + +# SUITE_UT_SRC: .c files that contain test cases (must end in _utest.c) +SUITE_UT_SRC += queue_registry_utest.c +SUITE_UT_SRC += queue_trace_utest.c +SUITE_UT_SRC += queue_delete_dynamic_utest.c +SUITE_UT_SRC += queue_delete_static_utest.c + +# SUITE_SUPPORT_SRC: .c files used for testing that do not contain test cases. +# Paths are relative to PROJECT_DIR +SUITE_SUPPORT_SRC += queue_utest_common.c +SUITE_SUPPORT_SRC += td_task.c +SUITE_SUPPORT_SRC += td_port.c + +# List the headers used by PROJECT_SRC that you would like to mock +MOCK_FILES_FP += $(KERNEL_DIR)/include/task.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_assert.h +MOCK_FILES_FP += $(UT_ROOT_DIR)/config/fake_port.h + +# List any addiitonal flags needed by the preprocessor +CPPFLAGS += -DportUSING_MPU_WRAPPERS=0 + +# List any addiitonal flags needed by the compiler +CFLAGS += + +# Try not to edit beyond this line unless necessary. + +# Project / Suite are determined based on path: $(UT_ROOT_DIR)/$(PROJECT)/$(SUITE) +PROJECT := $(lastword $(subst /, ,$(dir $(abspath $(MAKEFILE_ABSPATH)/../)))) +SUITE := $(lastword $(subst /, ,$(dir $(MAKEFILE_ABSPATH)))) + +# Make variables available to included makefile +export + +include ../../testdir.mk diff --git a/FreeRTOS/Test/CMock/queue/tracing/queue_delete_dynamic_utest.c b/FreeRTOS/Test/CMock/queue/tracing/queue_delete_dynamic_utest.c new file mode 120000 index 000000000..45ed1e093 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/queue_delete_dynamic_utest.c @@ -0,0 +1 @@ +../generic/queue_delete_dynamic_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/tracing/queue_delete_static_utest.c b/FreeRTOS/Test/CMock/queue/tracing/queue_delete_static_utest.c new file mode 120000 index 000000000..5ce261290 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/queue_delete_static_utest.c @@ -0,0 +1 @@ +../generic/queue_delete_static_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/tracing/queue_registry_utest.c b/FreeRTOS/Test/CMock/queue/tracing/queue_registry_utest.c new file mode 100644 index 000000000..daed68ca8 --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/queue_registry_utest.c @@ -0,0 +1,395 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_registry_utest.c */ + +/* C runtime includes. */ +#include +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/** + * @brief Copy of QueueRegistryItem_t from queue.c to allow clearing items between test cases. + */ +typedef struct QUEUE_REGISTRY_ITEM +{ + const char * pcQueueName; + QueueHandle_t xHandle; +} xQueueRegistryItem; +typedef xQueueRegistryItem QueueRegistryItem_t; + +/* Access the xQueueRegistry to clear between test cases */ +extern PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[ configQUEUE_REGISTRY_SIZE ]; + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); + /* Clear the queue registry between test cases */ + memset( &xQueueRegistry, 0, ( configQUEUE_REGISTRY_SIZE * sizeof( QueueRegistryItem_t ) ) ); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* =========================== Helper functions ============================ */ + +static bool helper_find_in_queue_registry( QueueHandle_t xQueue, + const char * pcQueueName ) +{ + for( int i = 0; i < configQUEUE_REGISTRY_SIZE; i++ ) + { + if( ( xQueueRegistry[ i ].pcQueueName == pcQueueName ) && + ( xQueueRegistry[ i ].xHandle == xQueue ) ) + { + return true; + } + } + + return false; +} + +static bool helper_find_handle_in_queue_registry( QueueHandle_t xQueue ) +{ + for( int i = 0; i < configQUEUE_REGISTRY_SIZE; i++ ) + { + if( xQueueRegistry[ i ].xHandle == xQueue ) + { + return true; + } + } + + return false; +} + +/* ============================== Test Cases =============================== */ + +/** + * @brief Test vQueueAddToRegistry with a NULL QueueHandle_t + * @details Verify that a NULL QueueHandle_t results in the string being stored + * to the QueueRegistry and a configASSERT failure. + * @coverage vQueueAddToRegistry + **/ +void test_vQueueAddToRegistry_null_xQueue( void ) +{ + const char * pcFakeStringPtr = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Expect a failed configASSERT when adding a NULL xQueue to the QueueRegistry */ + fakeAssertExpectFail(); + + vQueueAddToRegistry( NULL, pcFakeStringPtr ); + TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() ); + + TEST_ASSERT_TRUE( helper_find_in_queue_registry( NULL, pcFakeStringPtr ) ); +} + +/** + * @brief Test vQueueAddToRegistry with a NULL pcQueueName + * @details Verify that a NULL pcQueueName results in the NULL string being stored + * in the QueueRegistry and a configASSERT failure. + * @coverage vQueueAddToRegistry + **/ +void test_vQueueAddToRegistry_null_pcQueueName( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + + vQueueAddToRegistry( xFakeHandle, NULL ); + + TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, NULL ) ); +} + +/** + * @brief Test vQueueAddToRegistry with a valid xQueue and pcQueueName + * @details Verify that calling vQueueAddToRegistry with a valid xQueue and + * pcQueueName stores the tuple. + * @coverage vQueueAddToRegistry + **/ +void test_vQueueAddToRegistry_success( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry */ + vQueueAddToRegistry( xFakeHandle, pcFakeString ); + + /* Verify that the value was added to the registry */ + TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString ) ); +} + +/** + * @brief Test vQueueAddToRegistry with the same QueueHandle_t twice + * @details Verify that a given QueueHandle_t can be added to the queue registry + * multiple times and that the l + * @coverage vQueueAddToRegistry + **/ +void test_vQueueAddToRegistry_twice( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString1 = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString2 = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry **/ + vQueueAddToRegistry( xFakeHandle, pcFakeString1 ); + + TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString1 ) ); + + vQueueAddToRegistry( xFakeHandle, pcFakeString2 ); + + /* Verify that pcFakeString2 is now in the queue registry */ + TEST_ASSERT_TRUE( helper_find_in_queue_registry( xFakeHandle, pcFakeString2 ) ); + + /* Verify that pcFakeString1 is no longer in the queue registry */ + TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, pcFakeString1 ) ); + + vQueueUnregisterQueue( xFakeHandle ); + + /* Verify that pcFakeString2 has been removed from the registry */ + TEST_ASSERT_FALSE( helper_find_in_queue_registry( xFakeHandle, pcFakeString2 ) ); +} + +/** + * @brief Test vQueueAddToRegistry with a queue registry that is already full. + * @details Verify that a call to vQueueAddToRegistry with a full queue registry + * fails silently. + * @coverage vQueueAddToRegistry + **/ +void test_vQueueAddToRegistry_full( void ) +{ + TEST_ASSERT_TRUE( configQUEUE_REGISTRY_SIZE < UINT32_MAX ); + + /* Fill the queue registry and verify that the max items were successfully stored. + * Start at i=1 since a NULL / 0 pcQueueName denotes an empty queue registry location */ + for( BaseType_t i = 1; i <= configQUEUE_REGISTRY_SIZE; i++ ) + { + QueueHandle_t fakeHandle = ( QueueHandle_t ) i; + const char * fakeString = ( char * ) i; + + /* Add our fake QueueHandle_t and const char* to the registry */ + vQueueAddToRegistry( fakeHandle, fakeString ); + + /* Verify that the fake queue handle was added to the registry */ + TEST_ASSERT_EQUAL( pcQueueGetName( fakeHandle ), fakeString ); + } + + /* Prepare one more fake item to add to the registry */ + QueueHandle_t fakeHandle = ( QueueHandle_t ) ( configQUEUE_REGISTRY_SIZE + 1 ); + const char * fakeString = ( char * ) ( configQUEUE_REGISTRY_SIZE + 1 ); + + /* Add one more item */ + vQueueAddToRegistry( fakeHandle, fakeString ); + + TEST_ASSERT_FALSE( helper_find_in_queue_registry( fakeHandle, fakeString ) ); +} + +/** + * @brief Test pcQueueGetName with a NULL QueueHandle_t + * @details Verify that a NULL QueueHandle_t can be used as a lookup value with + * pcQueueGetName, but causes a failed configASSERT. + * @coverage pcQueueGetName + **/ +void test_pcQueueGetName_null_xQueue( void ) +{ + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Expect a failed configASSERT when adding a NULL xQueue to the QueueRegistry */ + fakeAssertExpectFail(); + + vQueueAddToRegistry( NULL, pcFakeString ); + fakeAssertGetFlagAndClear(); + + TEST_ASSERT_TRUE( helper_find_in_queue_registry( NULL, pcFakeString ) ); + + /* Expect a failed configASSERT when pcQueueGetName with a NULL xQueue */ + fakeAssertExpectFail(); + + /* Validate the value returned by pcQueueGetName */ + TEST_ASSERT_EQUAL( pcQueueGetName( NULL ), pcFakeString ); + TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() ); +} + +/** + * @brief Test pcQueueGetName with an xQueue handle that was not registered. + * @details Verify that a call to pcQueueGetName with an unregisteredd xQueue + * returns a NULL pointer. + * @coverage pcQueueGetName + **/ +void test_pcQueueGetName_not_registered( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry */ + vQueueAddToRegistry( xFakeHandle, pcFakeString ); + + /* Verify the value returned by pcQueueGetName matches the value added to the registry */ + TEST_ASSERT_EQUAL( pcQueueGetName( xFakeHandle ), pcFakeString ); + + vQueueUnregisterQueue( xFakeHandle ); + + /* Verify the value returned by pcQueueGetName matches the value added to the registry */ + TEST_ASSERT_EQUAL( NULL, pcQueueGetName( xFakeHandle ) ); +} + +/** + * @brief Test pcQueueGetName with an xQueue handle that was previously registered. + * @details Verify that a call to pcQueueGetName with a registered xQueue handle + * returns the correct pointer + * @coverage pcQueueGetName + **/ +void test_pcQueueGetName_registered( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry */ + vQueueAddToRegistry( xFakeHandle, pcFakeString ); + + /* Verify the value returned by pcQueueGetName matches the value added to the registry */ + TEST_ASSERT_EQUAL( pcQueueGetName( xFakeHandle ), pcFakeString ); +} + +/** + * @brief Test vQueueUnregisterQueue with a NULL xQueue handle + * @details Verify that calling vQueueUnregisterQueue with a NULL xQueue results + * in a configASSERT failure. + * @coverage vQueueUnregisterQueue + **/ +void test_vQueueUnregisterQueue_null_handle( void ) +{ + fakeAssertExpectFail(); + + vQueueUnregisterQueue( NULL ); + + TEST_ASSERT_TRUE( fakeAssertGetFlagAndClear() ); +} + +/** + * @brief Test vQueueUnregisterQueue with an unregisterd xQueue handle + * @details Verify that calling vQueueUnregisterQueue does not result in an assertion. + * @coverage vQueueUnregisterQueue + **/ +void test_vQueueUnregisterQueue_queue_not_registered( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + + vQueueUnregisterQueue( xFakeHandle ); +} + +/** + * @brief Test vQueueUnregisterQueue on a registered xQueue + * @details Verify that calling vQueueUnregisterQueue with a registered xQueue + * removes the xQueue from the Queue Registry and does not result in a + * configASSERT failure. + * @coverage vQueueUnregisterQueue + **/ +void test_vQueueUnregisterQueue( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry */ + vQueueAddToRegistry( xFakeHandle, pcFakeString ); + + TEST_ASSERT_TRUE( helper_find_handle_in_queue_registry( xFakeHandle ) ); + TEST_ASSERT_EQUAL( pcFakeString, pcQueueGetName( xFakeHandle ) ); + + vQueueUnregisterQueue( xFakeHandle ); + + TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) ); +} + +/** + * @brief Test two subsequent calls to vQueueUnregisterQueue on a registered xQueue + * @details Verify that calling vQueueUnregisterQueue twice on a registered xQueue + * succeeds the first time and results in no change on the second call. + * @coverage vQueueUnregisterQueue + **/ +void test_vQueueUnregisterQueue_twice( void ) +{ + QueueHandle_t xFakeHandle = ( QueueHandle_t ) ( BaseType_t ) getNextMonotonicTestValue(); + const char * pcFakeString = ( char * ) ( BaseType_t ) getNextMonotonicTestValue(); + + /* Add an item to the registry */ + vQueueAddToRegistry( xFakeHandle, pcFakeString ); + + /* Verify that the value was added to the registry */ + TEST_ASSERT_TRUE( helper_find_handle_in_queue_registry( xFakeHandle ) ); + + vQueueUnregisterQueue( xFakeHandle ); + + TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) ); + + vQueueUnregisterQueue( xFakeHandle ); + + TEST_ASSERT_FALSE( helper_find_handle_in_queue_registry( xFakeHandle ) ); +} + +/** + * @brief Test that vQueueDelete removes the xQueue from the Queue Registry + * @details Verify that vQueueDelete removes a queue from the Queue Registry + * by calling vQueueUnregisterQueue. + * @coverage vQueueDelete vQueueUnregisterQueue + **/ +void test_vQueueDelete_vQueueUnregisterQueue( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + const char * xQueueName = "Testing 123"; + + /* Add the queue to the registry */ + vQueueAddToRegistry( xQueue, xQueueName ); + + /* Verify the value returned by pcQueueGetName matches the value added to the registry */ + TEST_ASSERT_EQUAL( xQueueName, pcQueueGetName( xQueue ) ); + + vQueueDelete( xQueue ); + + /* Verify the value returned by pcQueueGetName is now NULL */ + TEST_ASSERT_EQUAL( NULL, pcQueueGetName( xQueue ) ); +} diff --git a/FreeRTOS/Test/CMock/queue/tracing/queue_trace_utest.c b/FreeRTOS/Test/CMock/queue/tracing/queue_trace_utest.c new file mode 100644 index 000000000..873f947cb --- /dev/null +++ b/FreeRTOS/Test/CMock/queue/tracing/queue_trace_utest.c @@ -0,0 +1,195 @@ +/* + * FreeRTOS V202012.00 + * Copyright (C) 2020 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. + * + * https://www.FreeRTOS.org + * https://github.com/FreeRTOS + * + */ +/*! @file queue_trace_utest.c */ + +/* C runtime includes. */ +#include +#include +#include + +#include "../queue_utest_common.h" + +/* Queue includes */ +#include "FreeRTOS.h" +#include "FreeRTOSConfig.h" +#include "queue.h" +#include "semphr.h" + +/* ============================ GLOBAL VARIABLES =========================== */ + +/* ========================== CALLBACK FUNCTIONS =========================== */ + +/* ============================= Unity Fixtures ============================= */ + +void setUp( void ) +{ + commonSetUp(); +} + +void tearDown( void ) +{ + commonTearDown(); +} + +void suiteSetUp() +{ + commonSuiteSetUp(); +} + +int suiteTearDown( int numFailures ) +{ + return commonSuiteTearDown( numFailures ); +} + +/* ========================== Helper functions =========================== */ + +/** + * @brief Test vQueueSetQueueNumber and uxQueueGetQueueNumber + * @details Verify that the queue number set with vQueueSetQueueNumber is returned + * by a subsequent call to uxQueueGetQueueNumber. + * @coverage vQueueSetQueueNumber uxQueueGetQueueNumber + */ +void test_vQueueSetQueueNumber_uxQueueGetQueueNumber( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vQueueSetQueueNumber( xQueue, getNextMonotonicTestValue() ); + + TEST_ASSERT_EQUAL( getLastMonotonicTestValue(), uxQueueGetQueueNumber( xQueue ) ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test vQueueSetQueueNumber and uxQueueGetQueueNumber with UINT64_MAX + * @details Verify that the queue number of UINT64_MAX set with + * vQueueSetQueueNumber is returned by a subsequent call to uxQueueGetQueueNumber. + * @coverage vQueueSetQueueNumber uxQueueGetQueueNumber + */ +void test_vQueueSetQueueNumber_uxQueueGetQueueNumber_max( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vQueueSetQueueNumber( xQueue, UINT64_MAX ); + + TEST_ASSERT_EQUAL( UINT64_MAX, uxQueueGetQueueNumber( xQueue ) ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test vQueueSetQueueNumber and uxQueueGetQueueNumber with 0 + * @details Verify that the queue number of 0 set with vQueueSetQueueNumber + * is returned by a subsequent call to uxQueueGetQueueNumber. + * @coverage vQueueSetQueueNumber uxQueueGetQueueNumber + */ +void test_vQueueSetQueueNumber_uxQueueGetQueueNumber_zero( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + vQueueSetQueueNumber( xQueue, 0 ); + + TEST_ASSERT_EQUAL( 0, uxQueueGetQueueNumber( xQueue ) ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test ucQueueGetQueueType with a Queue + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_BASE for a normal queue. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_queue( void ) +{ + QueueHandle_t xQueue = xQueueCreate( 1, sizeof( uint32_t ) ); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_BASE, ucQueueGetQueueType( xQueue ) ); + vQueueDelete( xQueue ); +} + +/** + * @brief Test ucQueueGetQueueType with a QueueSet + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_SET for a QueueSet. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_queue_set( void ) +{ + QueueSetHandle_t xQueueSet = xQueueCreateSet( 1 ); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_SET, ucQueueGetQueueType( xQueueSet ) ); + vQueueDelete( xQueueSet ); +} + +/** + * @brief Test ucQueueGetQueueType with a Mutex + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_MUTEX for a Mutex. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_mutex( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex(); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_MUTEX, ucQueueGetQueueType( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test ucQueueGetQueueType with a Counting Semaphore + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_COUNTING_SEMAPHORE for a Counting Semaphore. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_counting_semaphore( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting( 1, 0 ); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_COUNTING_SEMAPHORE, ucQueueGetQueueType( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test ucQueueGetQueueType with a Binary Semaphore + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_BINARY_SEMAPHORE for a Binary Semaphore. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_binary_semaphore( void ) +{ + SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary(); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_BINARY_SEMAPHORE, ucQueueGetQueueType( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} + +/** + * @brief Test ucQueueGetQueueType with a Recursive Mutex + * @details Verify that ucQueueGetQueueType returns queueQUEUE_TYPE_RECURSIVE_MUTEX for a Recursive Mutex. + * @coverage ucQueueGetQueueType prvInitialiseNewQueue + */ +void test_ucQueueGetQueueType_recursive_mutex( void ) +{ + xTaskPriorityDisinherit_ExpectAndReturn( NULL, pdFALSE ); + SemaphoreHandle_t xSemaphore = xSemaphoreCreateRecursiveMutex(); + + TEST_ASSERT_EQUAL( queueQUEUE_TYPE_RECURSIVE_MUTEX, ucQueueGetQueueType( xSemaphore ) ); + vSemaphoreDelete( xSemaphore ); +} diff --git a/FreeRTOS/Test/CMock/queue/two_tests/queue_1_utest.c b/FreeRTOS/Test/CMock/queue/two_tests/queue_1_utest.c deleted file mode 120000 index 50aba69ca..000000000 --- a/FreeRTOS/Test/CMock/queue/two_tests/queue_1_utest.c +++ /dev/null @@ -1 +0,0 @@ -../queue_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/queue/two_tests/queue_2_utest.c b/FreeRTOS/Test/CMock/queue/two_tests/queue_2_utest.c deleted file mode 120000 index 50aba69ca..000000000 --- a/FreeRTOS/Test/CMock/queue/two_tests/queue_2_utest.c +++ /dev/null @@ -1 +0,0 @@ -../queue_utest.c \ No newline at end of file diff --git a/FreeRTOS/Test/CMock/tools/filtercov.py b/FreeRTOS/Test/CMock/tools/filtercov.py index 62ffed3a9..f8733b910 100755 --- a/FreeRTOS/Test/CMock/tools/filtercov.py +++ b/FreeRTOS/Test/CMock/tools/filtercov.py @@ -199,7 +199,7 @@ def filter_coverage_file(covfile_handle, cov_functions): cur_file["functions"] = cur_functions cur_lines = list() for line in targetfile["lines"]: - if line["function_name"] in cov_functions: + if "function_name" in line and line["function_name"] in cov_functions: cur_lines.append(line) cur_file["lines"] = cur_lines covdata_out["files"].append(cur_file)