diff options
Diffstat (limited to '')
321 files changed, 8971 insertions, 2503 deletions
diff --git a/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-halt.c b/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-halt.c new file mode 100644 index 0000000000..0b0b5cf5b7 --- /dev/null +++ b/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-halt.c @@ -0,0 +1,142 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalShutdownHalt + */ + +/* + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/sysinit.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValFatalShutdownHalt \ + * spec:/bsp/sparc/leon3/val/fatal-shutdown-halt + * + * @ingroup TestsuitesBspsFatalSparcLeon3Shutdown + * + * @brief Tests the leon3 BSP family shutdown procedure. + * + * This test case performs the following actions: + * + * - Check the effects of the leon3 BSP family shutdown procedure. + * + * - Check that no dynamic fatal error extension was invoked. This shows + * that the leon3 BSP family shutdown procedure called the wrapped + * _CPU_Fatal_halt() function of the test suite. + * + * @{ + */ + +static Atomic_Uint dynamic_fatal_extension_counter; + +static rtems_status_code status; + +static unsigned int Add( Atomic_Uint *a, unsigned int b ) +{ + return _Atomic_Fetch_add_uint( a, b, ATOMIC_ORDER_RELAXED ); +} + +static void DynamicFatalHandler( + rtems_fatal_source source, + bool always_set_to_false, + rtems_fatal_code code +) +{ + (void) source; + (void) code; + (void) always_set_to_false; + (void) Add( &dynamic_fatal_extension_counter, 1 ); +} + +static void InitBspSparcLeon3ValFatalShutdownHalt( void ) +{ + rtems_extensions_table table = { .fatal = DynamicFatalHandler }; + rtems_id id; + + status = rtems_extension_create( OBJECT_NAME, &table, &id ); +} + +RTEMS_SYSINIT_ITEM( + InitBspSparcLeon3ValFatalShutdownHalt, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_MIDDLE +); + +/** + * @brief Check the effects of the leon3 BSP family shutdown procedure. + */ +static void BspSparcLeon3ValFatalShutdownHalt_Action_0( void ) +{ + uint32_t counter; + + /* + * Check that no dynamic fatal error extension was invoked. This shows that + * the leon3 BSP family shutdown procedure called the wrapped + * _CPU_Fatal_halt() function of the test suite. + */ + T_step_rsc_success( 0, status ); + counter = Add( &dynamic_fatal_extension_counter, 0 ); + T_step_eq_u32( 1, counter, 0 ); +} + +/** + * @fn void T_case_body_BspSparcLeon3ValFatalShutdownHalt( void ) + */ +T_TEST_CASE( BspSparcLeon3ValFatalShutdownHalt ) +{ + T_plan( 2 ); + + BspSparcLeon3ValFatalShutdownHalt_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-request.c b/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-request.c new file mode 100644 index 0000000000..46bc44e7cb --- /dev/null +++ b/testsuites/validation/bsps/tc-fatal-sparc-leon3-shutdown-request.c @@ -0,0 +1,179 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalShutdownRequest + */ + +/* + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp/leon3.h> +#include <rtems/sysinit.h> +#include <rtems/score/smpimpl.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValFatalShutdownRequest \ + * spec:/bsp/sparc/leon3/val/fatal-shutdown-request + * + * @ingroup TestsuitesBspsFatalSparcLeon3Shutdown + * + * @brief Tests the leon3 BSP family SMP-specific shutdown procedure. + * + * This test case performs the following actions: + * + * - Check the effects of the leon3 BSP family shutdown procedure. + * + * - Check that the second processor was not powered down during system + * initialization. + * + * - Wait until the second processor is powered down. + * + * - Check that the RTEMS_FATAL_SOURCE_SMP with SMP_FATAL_SHUTDOWN_RESPONSE + * fatal error occurred exactly once. + * + * - Check that the RTEMS_FATAL_SOURCE_SMP with SMP_FATAL_SHUTDOWN_RESPONSE + * fatal error occurred on the second processor. + * + * @{ + */ + +static uint32_t mpstat_during_sysinit; + +static Atomic_Uint shutdown_response_counter; + +static uint32_t shutdown_response_cpu_index = UINT32_MAX; + +static unsigned int Add( Atomic_Uint *a, unsigned int b ) +{ + return _Atomic_Fetch_add_uint( a, b, ATOMIC_ORDER_RELAXED ); +} + +static void ShutdownFatalHandler( + rtems_fatal_source source, + rtems_fatal_code code, + void *arg +) +{ + T_null( arg ); + + if ( + source == RTEMS_FATAL_SOURCE_SMP && + code == SMP_FATAL_SHUTDOWN_RESPONSE + ) { + (void) Add( &shutdown_response_counter, 1 ); + shutdown_response_cpu_index = rtems_scheduler_get_processor(); + } +} + +static void InitBspSparcLeon3ValFatalShutdownRequest( void ) +{ + irqamp *regs; + + regs = LEON3_IrqCtrl_Regs; + mpstat_during_sysinit = grlib_load_32( ®s->mpstat ); + SetFatalHandler( ShutdownFatalHandler, NULL ); +} + +RTEMS_SYSINIT_ITEM( + InitBspSparcLeon3ValFatalShutdownRequest, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_MIDDLE +); + +/** + * @brief Check the effects of the leon3 BSP family shutdown procedure. + */ +static void BspSparcLeon3ValFatalShutdownRequest_Action_0( void ) +{ + irqamp *regs; + uint32_t counter; + + regs = LEON3_IrqCtrl_Regs; + + /* + * Check that the second processor was not powered down during system + * initialization. + */ + T_step_eq_u32( 0, mpstat_during_sysinit & 0x2, 0 ); + + /* + * Wait until the second processor is powered down. + */ + while ( ( grlib_load_32( ®s->mpstat ) & 0x2 ) != 0x2U ) { + /* Wait */ + } + + /* + * Check that the RTEMS_FATAL_SOURCE_SMP with SMP_FATAL_SHUTDOWN_RESPONSE + * fatal error occurred exactly once. + */ + counter = Add( &shutdown_response_counter, 0 ); + T_step_eq_uint( 1, counter, 1 ); + + /* + * Check that the RTEMS_FATAL_SOURCE_SMP with SMP_FATAL_SHUTDOWN_RESPONSE + * fatal error occurred on the second processor. + */ + T_step_eq_u32( 2, shutdown_response_cpu_index, 1 ); +} + +/** + * @fn void T_case_body_BspSparcLeon3ValFatalShutdownRequest( void ) + */ +T_TEST_CASE( BspSparcLeon3ValFatalShutdownRequest ) +{ + T_plan( 3 ); + + BspSparcLeon3ValFatalShutdownRequest_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tc-sparc-gr712rc.c b/testsuites/validation/bsps/tc-sparc-gr712rc.c new file mode 100644 index 0000000000..a16de3d6ed --- /dev/null +++ b/testsuites/validation/bsps/tc-sparc-gr712rc.c @@ -0,0 +1,124 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValGr712rc + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValGr712rc spec:/bsp/sparc/leon3/val/gr712rc + * + * @ingroup TestsuitesBspsValidationBsp0 + * + * @brief This test case collection provides validation test cases for the + * ``sparc/gr712rc`` BSP. + * + * This test case performs the following actions: + * + * - Validate the use of the ``-mfix-gr712rc`` compiler option. + * + * - Check that the compiler built-in define ``__FIX_LEON3FT_B2BST`` is + * defined. + * + * - Check that the compiler built-in define ``__FIX_LEON3FT_TN0018`` is + * defined. + * + * - Check that the ``SPARC_LEON3FT_B2BST_NOP`` define expands to a ``nop`` + * instruction. + * + * @{ + */ + +/** + * @brief Validate the use of the ``-mfix-gr712rc`` compiler option. + */ +static void BspSparcLeon3ValGr712rc_Action_0( void ) +{ + const char *s; + + /* + * Check that the compiler built-in define ``__FIX_LEON3FT_B2BST`` is + * defined. + */ + #if !defined(__FIX_LEON3FT_B2BST) + #error "__FIX_LEON3FT_B2BST is not defined" + #endif + + /* + * Check that the compiler built-in define ``__FIX_LEON3FT_TN0018`` is + * defined. + */ + #if !defined(__FIX_LEON3FT_TN0018) + #error "__FIX_LEON3FT_TN0018 is not defined" + #endif + + /* + * Check that the ``SPARC_LEON3FT_B2BST_NOP`` define expands to a ``nop`` + * instruction. + */ + s = RTEMS_XSTRING( SPARC_LEON3FT_B2BST_NOP ); + T_true( IsEqualIgnoreWhiteSpace( s, "nop" ) ); +} + +/** + * @fn void T_case_body_BspSparcLeon3ValGr712rc( void ) + */ +T_TEST_CASE( BspSparcLeon3ValGr712rc ) +{ + BspSparcLeon3ValGr712rc_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.c b/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.c new file mode 100644 index 0000000000..731b454ee4 --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.c @@ -0,0 +1,187 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevClockXilTtcValFatalIrqInstall + */ + +/* + * Copyright (C) 2024 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp.h> +#include <rtems.h> +#include <bsp/fatal.h> +#include <rtems/sysinit.h> + +#include "tr-fatal-clock-xil-ttc-irq-install.h" + +#include <rtems/test.h> + +/** + * @defgroup DevClockXilTtcValFatalIrqInstall \ + * spec:/dev/clock/xil-ttc/val/fatal-irq-install + * + * @ingroup TestsuitesBspsFatalClockXilTtcIrqInstall + * + * @brief Tests a fatal error. + * + * This test case performs the following actions: + * + * - The test action is carried out by the OccupyClockInterrupt() system + * initialization handler. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * @{ + */ + +/** + * @brief Test context for spec:/dev/clock/xil-ttc/val/fatal-irq-install test + * case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * DevClockXilTtcValFatalIrqInstall_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * DevClockXilTtcValFatalIrqInstall_Run() parameter. + */ + rtems_fatal_code code; +} DevClockXilTtcValFatalIrqInstall_Context; + +static DevClockXilTtcValFatalIrqInstall_Context + DevClockXilTtcValFatalIrqInstall_Instance; + +static void ClockInterrupt( void *arg ) +{ + (void) arg; +} + +static rtems_interrupt_entry interrupt_entry = RTEMS_INTERRUPT_ENTRY_INITIALIZER( + ClockInterrupt, + NULL, + "Clock" +); + +static void OccupyClockInterrupt( void ) +{ + (void) rtems_interrupt_entry_install( + XIL_CLOCK_TTC_IRQ, + RTEMS_INTERRUPT_UNIQUE, + &interrupt_entry + ); +} + +RTEMS_SYSINIT_ITEM( + OccupyClockInterrupt, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_FIRST +); + +static T_fixture DevClockXilTtcValFatalIrqInstall_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &DevClockXilTtcValFatalIrqInstall_Instance +}; + +/** + * @brief The test action is carried out by the OccupyClockInterrupt() system + * initialization handler. + */ +static void DevClockXilTtcValFatalIrqInstall_Action_0( + DevClockXilTtcValFatalIrqInstall_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, RTEMS_FATAL_SOURCE_BSP ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + XIL_FATAL_TTC_IRQ_INSTALL + ); +} + +void DevClockXilTtcValFatalIrqInstall_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + DevClockXilTtcValFatalIrqInstall_Context *ctx; + + ctx = &DevClockXilTtcValFatalIrqInstall_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "DevClockXilTtcValFatalIrqInstall", + &DevClockXilTtcValFatalIrqInstall_Fixture + ); + + T_plan( 2 ); + + DevClockXilTtcValFatalIrqInstall_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.h b/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.h new file mode 100644 index 0000000000..74021233a0 --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-clock-xil-ttc-irq-install.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevClockXilTtcValFatalIrqInstall + */ + +/* + * Copyright (C) 2024 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_CLOCK_XIL_TTC_IRQ_INSTALL_H +#define _TR_FATAL_CLOCK_XIL_TTC_IRQ_INSTALL_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup DevClockXilTtcValFatalIrqInstall + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is fatal source. + * + * @param code is fatal code. + */ +void DevClockXilTtcValFatalIrqInstall_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_CLOCK_XIL_TTC_IRQ_INSTALL_H */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.c b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.c new file mode 100644 index 0000000000..748fd88e70 --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.c @@ -0,0 +1,175 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalCacheSnoopingDisabledBoot + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp/fatal.h> +#include <bsp/leon3.h> +#include <rtems/sysinit.h> + +#include "tr-fatal-sparc-leon3-cache-snooping-disabled-boot.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValFatalCacheSnoopingDisabledBoot \ + * spec:/bsp/sparc/leon3/val/fatal-cache-snooping-disabled-boot + * + * @ingroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledBoot + * + * @brief Tests a fatal error. + * + * This test case performs the following actions: + * + * - The test action is carried out by the DisableCacheSnooping() system + * initialization handler. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * @{ + */ + +/** + * @brief Test context for + * spec:/bsp/sparc/leon3/val/fatal-cache-snooping-disabled-boot test case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Run() parameter. + */ + rtems_fatal_code code; +} BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Context; + +static BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Context + BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Instance; + +static void DisableCacheSnooping( void ) +{ + uint32_t control; + + control = leon3_get_cache_control_register(); + control &= ~LEON3_REG_CACHE_CTRL_DS; + leon3_set_cache_control_register( control ); +} + +RTEMS_SYSINIT_ITEM( + DisableCacheSnooping, + RTEMS_SYSINIT_BSP_EARLY, + RTEMS_SYSINIT_ORDER_FIRST +); + +static T_fixture BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Instance +}; + +/** + * @brief The test action is carried out by the DisableCacheSnooping() system + * initialization handler. + */ +static void BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Action_0( + BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, RTEMS_FATAL_SOURCE_BSP ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + LEON3_FATAL_INVALID_CACHE_CONFIG_BOOT_PROCESSOR + ); +} + +void BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Context *ctx; + + ctx = &BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "BspSparcLeon3ValFatalCacheSnoopingDisabledBoot", + &BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Fixture + ); + + T_plan( 2 ); + + BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.h b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.h new file mode 100644 index 0000000000..e375e6baac --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-boot.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalCacheSnoopingDisabledBoot + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_BOOT_H +#define _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_BOOT_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup BspSparcLeon3ValFatalCacheSnoopingDisabledBoot + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is fatal source. + * + * @param code is fatal code. + */ +void BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_BOOT_H */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.c b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.c new file mode 100644 index 0000000000..4d90abf42d --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.c @@ -0,0 +1,176 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp/bootcard.h> +#include <bsp/fatal.h> +#include <bsp/leon3.h> + +#include "tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary \ + * spec:/bsp/sparc/leon3/val/fatal-cache-snooping-disabled-secondary + * + * @ingroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledSecondary + * + * @brief Tests a fatal error. + * + * This test case performs the following actions: + * + * - The test action is carried out by the wrapped + * bsp_start_on_secondary_processor() function. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * @{ + */ + +/** + * @brief Test context for + * spec:/bsp/sparc/leon3/val/fatal-cache-snooping-disabled-secondary test + * case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Run() parameter. + */ + rtems_fatal_code code; +} BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Context; + +static BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Context + BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Instance; + +void __real_bsp_start_on_secondary_processor( struct Per_CPU_Control *cpu_self ); + +void __wrap_bsp_start_on_secondary_processor( struct Per_CPU_Control *cpu_self ); + +void __wrap_bsp_start_on_secondary_processor( struct Per_CPU_Control *cpu_self ) +{ + uint32_t control; + + control = leon3_get_cache_control_register(); + control &= ~LEON3_REG_CACHE_CTRL_DS; + leon3_set_cache_control_register( control ); + + __real_bsp_start_on_secondary_processor( cpu_self ); +} + +static T_fixture BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Instance +}; + +/** + * @brief The test action is carried out by the wrapped + * bsp_start_on_secondary_processor() function. + */ +static void BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Action_0( + BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, RTEMS_FATAL_SOURCE_BSP ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + LEON3_FATAL_INVALID_CACHE_CONFIG_SECONDARY_PROCESSOR + ); +} + +void BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Context *ctx; + + ctx = &BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary", + &BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Fixture + ); + + T_plan( 2 ); + + BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.h b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.h new file mode 100644 index 0000000000..0782942222 --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_SECONDARY_H +#define _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_SECONDARY_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is fatal source. + * + * @param code is fatal code. + */ +void BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_SPARC_LEON3_CACHE_SNOOPING_DISABLED_SECONDARY_H */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.c b/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.c new file mode 100644 index 0000000000..5cd81b736c --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.c @@ -0,0 +1,190 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalClockInitialization + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <bsp/fatal.h> +#include <bsp/leon3.h> +#include <rtems/irq-extension.h> +#include <rtems/sysinit.h> + +#include "tr-fatal-sparc-leon3-clock-initialization.h" + +#include <rtems/test.h> + +/** + * @defgroup BspSparcLeon3ValFatalClockInitialization \ + * spec:/bsp/sparc/leon3/val/fatal-clock-initialization + * + * @ingroup TestsuitesBspsFatalSparcLeon3ClockInitialization + * + * @brief Tests a fatal error. + * + * This test case performs the following actions: + * + * - The test action is carried out by the OccupyClockInterrupt() system + * initialization handler. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * @{ + */ + +/** + * @brief Test context for spec:/bsp/sparc/leon3/val/fatal-clock-initialization + * test case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalClockInitialization_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * BspSparcLeon3ValFatalClockInitialization_Run() parameter. + */ + rtems_fatal_code code; +} BspSparcLeon3ValFatalClockInitialization_Context; + +static BspSparcLeon3ValFatalClockInitialization_Context + BspSparcLeon3ValFatalClockInitialization_Instance; + +static void ClockInterrupt( void *arg ) +{ + (void) arg; +} + +static rtems_interrupt_entry interrupt_entry = RTEMS_INTERRUPT_ENTRY_INITIALIZER( + ClockInterrupt, + NULL, + "Clock" +); + +static void OccupyClockInterrupt( void ) +{ + rtems_vector_number vector; + + vector = GPTIMER_CONFIG_IRQ_GET( grlib_load_32( &LEON3_Timer_Regs->config ) ); + (void) rtems_interrupt_entry_install( + vector, + RTEMS_INTERRUPT_UNIQUE, + &interrupt_entry + ); +} + +RTEMS_SYSINIT_ITEM( + OccupyClockInterrupt, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_FIRST +); + +static T_fixture BspSparcLeon3ValFatalClockInitialization_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &BspSparcLeon3ValFatalClockInitialization_Instance +}; + +/** + * @brief The test action is carried out by the OccupyClockInterrupt() system + * initialization handler. + */ +static void BspSparcLeon3ValFatalClockInitialization_Action_0( + BspSparcLeon3ValFatalClockInitialization_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, RTEMS_FATAL_SOURCE_BSP ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + LEON3_FATAL_CLOCK_INITIALIZATION + ); +} + +void BspSparcLeon3ValFatalClockInitialization_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + BspSparcLeon3ValFatalClockInitialization_Context *ctx; + + ctx = &BspSparcLeon3ValFatalClockInitialization_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "BspSparcLeon3ValFatalClockInitialization", + &BspSparcLeon3ValFatalClockInitialization_Fixture + ); + + T_plan( 2 ); + + BspSparcLeon3ValFatalClockInitialization_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.h b/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.h new file mode 100644 index 0000000000..6997b3f22c --- /dev/null +++ b/testsuites/validation/bsps/tr-fatal-sparc-leon3-clock-initialization.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspSparcLeon3ValFatalClockInitialization + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_SPARC_LEON3_CLOCK_INITIALIZATION_H +#define _TR_FATAL_SPARC_LEON3_CLOCK_INITIALIZATION_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup BspSparcLeon3ValFatalClockInitialization + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is fatal source. + * + * @param code is fatal code. + */ +void BspSparcLeon3ValFatalClockInitialization_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_SPARC_LEON3_CLOCK_INITIALIZATION_H */ diff --git a/testsuites/validation/bsps/ts-fatal-clock-xil-ttc-irq-install.c b/testsuites/validation/bsps/ts-fatal-clock-xil-ttc-irq-install.c new file mode 100644 index 0000000000..e5c1062348 --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-clock-xil-ttc-irq-install.c @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsFatalClockXilTtcIrqInstall + */ + +/* + * Copyright (C) 2024 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-clock-xil-ttc-irq-install.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsFatalClockXilTtcIrqInstall \ + * spec:/testsuites/bsps/fatal-clock-xil-ttc-irq-install + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which triggers a + * fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsFatalClockXilTtcIrqInstall"; + +#define FATAL_SYSINIT_RUN DevClockXilTtcValFatalIrqInstall_Run + +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-boot.c b/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-boot.c new file mode 100644 index 0000000000..53e18b5b0b --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-boot.c @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledBoot + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-sparc-leon3-cache-snooping-disabled-boot.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledBoot \ + * spec:/testsuites/bsps/fatal-sparc-leon3-cache-snooping-disabled-boot + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which triggers a + * fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledBoot"; + +#define FATAL_SYSINIT_RUN BspSparcLeon3ValFatalCacheSnoopingDisabledBoot_Run + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-secondary.c b/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-secondary.c new file mode 100644 index 0000000000..3b8829dcf9 --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-sparc-leon3-cache-snooping-disabled-secondary.c @@ -0,0 +1,82 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledSecondary + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-sparc-leon3-cache-snooping-disabled-secondary.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledSecondary \ + * spec:/testsuites/bsps/fatal-sparc-leon3-cache-snooping-disabled-secondary + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which triggers a + * fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsFatalSparcLeon3CacheSnoopingDisabledSecondary"; + +#define FATAL_SYSINIT_RUN \ + BspSparcLeon3ValFatalCacheSnoopingDisabledSecondary_Run + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#define CONFIGURE_MAXIMUM_PROCESSORS 2 + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/bsps/ts-fatal-sparc-leon3-clock-initialization.c b/testsuites/validation/bsps/ts-fatal-sparc-leon3-clock-initialization.c new file mode 100644 index 0000000000..b75223537f --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-sparc-leon3-clock-initialization.c @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsFatalSparcLeon3ClockInitialization + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-sparc-leon3-clock-initialization.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsFatalSparcLeon3ClockInitialization \ + * spec:/testsuites/bsps/fatal-sparc-leon3-clock-initialization + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which triggers a + * fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsFatalSparcLeon3ClockInitialization"; + +#define FATAL_SYSINIT_RUN BspSparcLeon3ValFatalClockInitialization_Run + +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown-response.c b/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown-response.c new file mode 100644 index 0000000000..d730b6d027 --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown-response.c @@ -0,0 +1,94 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup RTEMSTestSuiteTestsuitesFatalBspSparcLeon3ShutdownResponse + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/score/smpimpl.h> + +#include "tr-fatal-sparc-leon3-shutdown-response.h" + +#include <rtems/test.h> + +/** + * @defgroup RTEMSTestSuiteTestsuitesFatalBspSparcLeon3ShutdownResponse \ + * spec:/testsuites/fatal-sparc-leon3-shutdown-response + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which performs a + * system shutdown. + * + * @{ + */ + +const char rtems_test_name[] = "FatalBspSparcLeon3ShutdownResponse"; + +#define FATAL_SYSINIT_RUN BspSparcLeon3ValFatalShutdownResponse_Run + +static void FatalSysinitExit( rtems_fatal_code exit_code ) +{ + if ( exit_code == 0 ) { + rtems_fatal( RTEMS_FATAL_SOURCE_SMP, SMP_FATAL_SHUTDOWN ); + } else { + rtems_fatal( RTEMS_FATAL_SOURCE_EXIT, exit_code ); + } +} + +#define FATAL_SYSINIT_EXIT( exit_code ) FatalSysinitExit( exit_code ) + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#define CONFIGURE_MAXIMUM_PROCESSORS 2 + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown.c b/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown.c new file mode 100644 index 0000000000..bc229e7824 --- /dev/null +++ b/testsuites/validation/bsps/ts-fatal-sparc-leon3-shutdown.c @@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsFatalSparcLeon3Shutdown + */ + +/* + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> +#include <rtems/bspIo.h> +#include <rtems/test-info.h> +#include <rtems/test.h> +#include <rtems/testopts.h> +#include <rtems/score/smpimpl.h> + +#include "ts-config.h" +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsFatalSparcLeon3Shutdown \ + * spec:/testsuites/bsps/fatal-sparc-leon3-shutdown + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite provides an application configuration to + * perform a shutdown. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsFatalSparcLeon3Shutdown"; + +static char buffer[ 512 ]; + +static const T_action actions[] = { + T_report_hash_sha256 +}; + +static const T_config test_config = { + .name = rtems_test_name, + .buf = buffer, + .buf_size = sizeof( buffer ), + .putchar = rtems_put_char, + .verbosity = RTEMS_TEST_VERBOSITY, + .now = T_now_tick, + .allocate = T_memory_allocate, + .deallocate = T_memory_deallocate, + .action_count = T_ARRAY_SIZE( actions ), + .actions = actions +}; + +void __real__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code ); + +void __wrap__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code ); + +void __wrap__CPU_Fatal_halt( uint32_t source, CPU_Uint32ptr code ) +{ + int exit_code; + + T_register(); + exit_code = T_main( &test_config ); + + if ( exit_code == 0 ) { + rtems_test_end( rtems_test_name ); + } + +#if defined(RTEMS_GCOV_COVERAGE) + rtems_test_gcov_dump_info(); +#endif + __real__CPU_Fatal_halt( source, code ); +} + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#if defined(RTEMS_SMP) +#define CONFIGURE_MAXIMUM_PROCESSORS 2 + +#include <rtems/score/scheduleredfsmp.h> + +#define CONFIGURE_SCHEDULER_EDF_SMP + +#include <rtems/scheduler.h> + +RTEMS_SCHEDULER_EDF_SMP( a ); + +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, TEST_SCHEDULER_A_NAME ) + +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) +#endif /* RTEMS_SMP */ + +#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 0 + +#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1 + +#define CONFIGURE_DISABLE_NEWLIB_REENTRANCY + +#define CONFIGURE_APPLICATION_DISABLE_FILESYSTEM + +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE + +#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION + +static void *ShutdownIdleBody( uintptr_t arg ) +{ +#if defined(RTEMS_SMP) + if ( rtems_scheduler_get_processor() == 0 ) { + rtems_test_begin( rtems_test_name, TEST_STATE ); + rtems_fatal( RTEMS_FATAL_SOURCE_SMP, SMP_FATAL_SHUTDOWN ); + } + + return _CPU_Thread_Idle_body( arg ); +#else + rtems_test_begin( rtems_test_name, TEST_STATE ); + rtems_fatal( RTEMS_FATAL_SOURCE_APPLICATION, 123 ); +#endif +} + +#define CONFIGURE_IDLE_TASK_BODY ShutdownIdleBody + +#define CONFIGURE_INITIAL_EXTENSIONS { .fatal = FatalInitialExtension } + +#define CONFIGURE_INIT + +#include <rtems/confdefs.h> + +/** @} */ diff --git a/testsuites/validation/bsps/ts-validation-bsp-0.c b/testsuites/validation/bsps/ts-validation-bsp-0.c new file mode 100644 index 0000000000..c072c8fdf1 --- /dev/null +++ b/testsuites/validation/bsps/ts-validation-bsp-0.c @@ -0,0 +1,73 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesBspsValidationBsp0 + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesBspsValidationBsp0 \ + * spec:/testsuites/bsps/validation-bsp-0 + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This general purpose validation test suite provides enough resources + * to run target-specific tests. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesBspsValidationBsp0"; + +#include "ts-default.h" + +/** @} */ diff --git a/testsuites/validation/tc-acfg-appl-does-not-need-clock-driver.c b/testsuites/validation/tc-acfg-appl-does-not-need-clock-driver.c index 3aef1497be..632ce8f164 100644 --- a/testsuites/validation/tc-acfg-appl-does-not-need-clock-driver.c +++ b/testsuites/validation/tc-acfg-appl-does-not-need-clock-driver.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValApplDoesNotNeedClockDriver + * @ingroup AcfgValApplDoesNotNeedClockDriver */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValApplDoesNotNeedClockDriver \ + * @defgroup AcfgValApplDoesNotNeedClockDriver \ * spec:/acfg/val/appl-does-not-need-clock-driver * - * @ingroup RTEMSTestSuiteTestsuitesValidationAcfg0 + * @ingroup TestsuitesValidationAcfg0 * * @brief Tests the effect of the * CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER application configuration diff --git a/testsuites/validation/tc-acfg-appl-needs-clock-driver.c b/testsuites/validation/tc-acfg-appl-needs-clock-driver.c index 5da259977f..fe62dd7de6 100644 --- a/testsuites/validation/tc-acfg-appl-needs-clock-driver.c +++ b/testsuites/validation/tc-acfg-appl-needs-clock-driver.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValApplNeedsClockDriver + * @ingroup AcfgValApplNeedsClockDriver */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValApplNeedsClockDriver \ - * spec:/acfg/val/appl-needs-clock-driver + * @defgroup AcfgValApplNeedsClockDriver spec:/acfg/val/appl-needs-clock-driver * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 * * @brief Tests the effect of the CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER * application configuration option. diff --git a/testsuites/validation/tc-acfg-default.c b/testsuites/validation/tc-acfg-default.c index 95fa497cf1..bc23363c49 100644 --- a/testsuites/validation/tc-acfg-default.c +++ b/testsuites/validation/tc-acfg-default.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValDefault + * @ingroup AcfgValDefault */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValDefault spec:/acfg/val/default + * @defgroup AcfgValDefault spec:/acfg/val/default * - * @ingroup RTEMSTestSuiteTestsuitesValidationAcfg0 + * @ingroup TestsuitesValidationAcfg0 * * @brief Tests the default values of application configuration options. * @@ -74,10 +74,10 @@ * * - Check the configured CONFIGURE_IDLE_TASK_BODY. * - * - Check the default value CONFIGURE_IDLE_TASK_STACK_SIZE where the + * - Check the default value of CONFIGURE_IDLE_TASK_STACK_SIZE where the * optional BSP-provided default value is enabled. * - * - Check the default value CONFIGURE_INTERRUPT_STACK_SIZE where the + * - Check the default value of CONFIGURE_INTERRUPT_STACK_SIZE where the * optional BSP-provided default value is enabled. * * - Check the BSP-provided initial extension is registered. @@ -160,8 +160,8 @@ static void AcfgValDefault_Action_0( void ) T_step_eq_ptr( 0, rtems_configuration_get_idle_task(), IdleBody ); /* - * Check the default value CONFIGURE_IDLE_TASK_STACK_SIZE where the optional - * BSP-provided default value is enabled. + * Check the default value of CONFIGURE_IDLE_TASK_STACK_SIZE where the + * optional BSP-provided default value is enabled. */ T_step_eq_sz( 1, @@ -174,8 +174,8 @@ static void AcfgValDefault_Action_0( void ) ); /* - * Check the default value CONFIGURE_INTERRUPT_STACK_SIZE where the optional - * BSP-provided default value is enabled. + * Check the default value of CONFIGURE_INTERRUPT_STACK_SIZE where the + * optional BSP-provided default value is enabled. */ T_step_eq_sz( 2, diff --git a/testsuites/validation/tc-acfg-disabled-bsp-settings.c b/testsuites/validation/tc-acfg-disabled-bsp-settings.c index 0dbae670f3..acd5d454e3 100644 --- a/testsuites/validation/tc-acfg-disabled-bsp-settings.c +++ b/testsuites/validation/tc-acfg-disabled-bsp-settings.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValDisabledBspSettings + * @ingroup AcfgValDisabledBspSettings */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValDisabledBspSettings \ - * spec:/acfg/val/disabled-bsp-settings + * @defgroup AcfgValDisabledBspSettings spec:/acfg/val/disabled-bsp-settings * - * @ingroup RTEMSTestSuiteTestsuitesValidationAcfg1 + * @ingroup TestsuitesValidationAcfg1 * * @brief Tests the default values of application configuration options where * all optional BSP provided settings are disabled. diff --git a/testsuites/validation/tc-acfg-one-cpu.c b/testsuites/validation/tc-acfg-one-cpu.c index 5175829d55..8806e11b4e 100644 --- a/testsuites/validation/tc-acfg-one-cpu.c +++ b/testsuites/validation/tc-acfg-one-cpu.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValOneCpu + * @ingroup AcfgValOneCpu */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValOneCpu spec:/acfg/val/one-cpu + * @defgroup AcfgValOneCpu spec:/acfg/val/one-cpu * - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationOneCpu0 * * @brief Tests the effect of application configuration options. * @@ -73,7 +73,7 @@ * * - Check that the CONFIGURE_MAXIMUM_PRIORITY application configuration * option resulted in the expected system setting using - * /rtems/task/if/maximum-priority. + * spec:/rtems/task/if/maximum-priority. * * - Check that the Deterministic Priority Scheduler which was configured by * the CONFIGURE_SCHEDULER_PRIORITY application configuration in the test @@ -122,7 +122,7 @@ static void AcfgValOneCpu_Action_0( void ) /* * Check that the CONFIGURE_MAXIMUM_PRIORITY application configuration option * resulted in the expected system setting using - * /rtems/task/if/maximum-priority. + * spec:/rtems/task/if/maximum-priority. */ T_eq_u32( RTEMS_MAXIMUM_PRIORITY, 127 ); diff --git a/testsuites/validation/tc-acfg-scheduler-edf-smp.c b/testsuites/validation/tc-acfg-scheduler-edf-smp.c index 75b24b97d3..bbd974a588 100644 --- a/testsuites/validation/tc-acfg-scheduler-edf-smp.c +++ b/testsuites/validation/tc-acfg-scheduler-edf-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValSchedulerEdfSmp + * @ingroup AcfgValSchedulerEdfSmp */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValSchedulerEdfSmp \ - * spec:/acfg/val/scheduler-edf-smp + * @defgroup AcfgValSchedulerEdfSmp spec:/acfg/val/scheduler-edf-smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests the effect of application configuration options. * diff --git a/testsuites/validation/tc-acfg-scheduler-table-entries-one-cpu.c b/testsuites/validation/tc-acfg-scheduler-table-entries-one-cpu.c new file mode 100644 index 0000000000..48db6c4244 --- /dev/null +++ b/testsuites/validation/tc-acfg-scheduler-table-entries-one-cpu.c @@ -0,0 +1,102 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup AcfgValSchedulerTableEntriesOneCpu + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> + +#include <rtems/test.h> + +/** + * @defgroup AcfgValSchedulerTableEntriesOneCpu \ + * spec:/acfg/val/scheduler-table-entries-one-cpu + * + * @ingroup TestsuitesValidationOneCpu1 + * + * @brief Tests the effect of CONFIGURE_SCHEDULER_TABLE_ENTRIES the application + * configuration options in a configuration with only one processor. + * + * This test case performs the following actions: + * + * - Check the effect of the application configuration option. + * + * - Check that the CONFIGURE_SCHEDULER_TABLE_ENTRIES application + * configuration option resulted in the expected system setting using + * RTEMS_MAXIMUM_PRIORITY. + * + * @{ + */ + +/** + * @brief Check the effect of the application configuration option. + */ +static void AcfgValSchedulerTableEntriesOneCpu_Action_0( void ) +{ + /* Nothing to do */ + + /* + * Check that the CONFIGURE_SCHEDULER_TABLE_ENTRIES application configuration + * option resulted in the expected system setting using + * RTEMS_MAXIMUM_PRIORITY. + */ + T_eq_u32( RTEMS_MAXIMUM_PRIORITY, 63 ); +} + +/** + * @fn void T_case_body_AcfgValSchedulerTableEntriesOneCpu( void ) + */ +T_TEST_CASE( AcfgValSchedulerTableEntriesOneCpu ) +{ + AcfgValSchedulerTableEntriesOneCpu_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/tc-acfg.c b/testsuites/validation/tc-acfg.c index fb16536737..60f32ad929 100644 --- a/testsuites/validation/tc-acfg.c +++ b/testsuites/validation/tc-acfg.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValAcfg + * @ingroup AcfgValAcfg */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValAcfg spec:/acfg/val/acfg + * @defgroup AcfgValAcfg spec:/acfg/val/acfg * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the effect of application configuration options. * @@ -132,11 +132,11 @@ * * - Check the configured CONFIGURE_TASK_STACK_ALLOCATOR hook. Using the * test stack allocator validates also - * /acfg/if/init-task-construct-storage-size, since the + * spec:/acfg/if/init-task-construct-storage-size, since the * test_task_stack_allocate() allocate handler only supports * CONFIGURE_MAXIMUM_TASKS minus one stacks and the validation test for - * /rtems/task/req/create-errors creates for some pre-condition variants - * all tasks until RTEMS_TOO_MANY is returned. In addition, + * spec:/rtems/task/req/create-errors creates for some pre-condition + * variants all tasks until RTEMS_TOO_MANY is returned. In addition, * test_task_stack_allocate() checks that the allocation size is greater * than or equal to TEST_MINIMUM_STACK_SIZE which validates * CONFIGURE_MINIMUM_TASK_STACK_SIZE. @@ -342,11 +342,12 @@ static void AcfgValAcfg_Action_0( void ) /* * Check the configured CONFIGURE_TASK_STACK_ALLOCATOR hook. Using the test - * stack allocator validates also /acfg/if/init-task-construct-storage-size, - * since the test_task_stack_allocate() allocate handler only supports + * stack allocator validates also + * spec:/acfg/if/init-task-construct-storage-size, since the + * test_task_stack_allocate() allocate handler only supports * CONFIGURE_MAXIMUM_TASKS minus one stacks and the validation test for - * /rtems/task/req/create-errors creates for some pre-condition variants all - * tasks until RTEMS_TOO_MANY is returned. In addition, + * spec:/rtems/task/req/create-errors creates for some pre-condition variants + * all tasks until RTEMS_TOO_MANY is returned. In addition, * test_task_stack_allocate() checks that the allocation size is greater than * or equal to TEST_MINIMUM_STACK_SIZE which validates * CONFIGURE_MINIMUM_TASK_STACK_SIZE. diff --git a/testsuites/validation/tc-attr.c b/testsuites/validation/tc-attr.c index 3d39dcd6d5..05128372bf 100644 --- a/testsuites/validation/tc-attr.c +++ b/testsuites/validation/tc-attr.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsAttrValAttr + * @ingroup RtemsAttrValAttr */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsAttrValAttr spec:/rtems/attr/val/attr + * @defgroup RtemsAttrValAttr spec:/rtems/attr/val/attr * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the attribute constants of the Classic API. * @@ -124,7 +124,7 @@ * * - Check the value of RTEMS_DEFAULT_ATTRIBUTES. * - * - Check RTEMS_DEFAULT_ATTRIBUTES equals ``RTEMS_FIFO | RTEMS_LOCAL``. + * - Check RTEMS_DEFAULT_ATTRIBUTES equals RTEMS_FIFO | RTEMS_LOCAL. * * @{ */ @@ -324,7 +324,7 @@ static void RtemsAttrValAttr_Action_4( void ) /* No action */ /* - * Check RTEMS_DEFAULT_ATTRIBUTES equals ``RTEMS_FIFO | RTEMS_LOCAL``. + * Check RTEMS_DEFAULT_ATTRIBUTES equals RTEMS_FIFO | RTEMS_LOCAL. */ T_step_eq_int( 22, diff --git a/testsuites/validation/tc-barrier-create.c b/testsuites/validation/tc-barrier-create.c index 64b2540c79..ba35d0ad97 100644 --- a/testsuites/validation/tc-barrier-create.c +++ b/testsuites/validation/tc-barrier-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierReqCreate + * @ingroup RtemsBarrierReqCreate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierReqCreate spec:/rtems/barrier/req/create + * @defgroup RtemsBarrierReqCreate spec:/rtems/barrier/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-barrier-delete.c b/testsuites/validation/tc-barrier-delete.c index 1915ffb7ad..456459c343 100644 --- a/testsuites/validation/tc-barrier-delete.c +++ b/testsuites/validation/tc-barrier-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierReqDelete + * @ingroup RtemsBarrierReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierReqDelete spec:/rtems/barrier/req/delete + * @defgroup RtemsBarrierReqDelete spec:/rtems/barrier/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-barrier-ident.c b/testsuites/validation/tc-barrier-ident.c index dcb4a1c273..0378301fb8 100644 --- a/testsuites/validation/tc-barrier-ident.c +++ b/testsuites/validation/tc-barrier-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierValIdent + * @ingroup RtemsBarrierValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierValIdent spec:/rtems/barrier/val/ident + * @defgroup RtemsBarrierValIdent spec:/rtems/barrier/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_barrier_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API partition - * class objects defined by /rtems/req/ident-local. + * class objects defined by spec:/rtems/req/ident-local. * * @{ */ @@ -83,7 +83,7 @@ static rtems_status_code ClassicBarrierIdentAction( /** * @brief Run the generic object identification tests for Classic API partition - * class objects defined by /rtems/req/ident-local. + * class objects defined by spec:/rtems/req/ident-local. */ static void RtemsBarrierValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-barrier-performance.c b/testsuites/validation/tc-barrier-performance.c index 91573e4c10..52ca8685b6 100644 --- a/testsuites/validation/tc-barrier-performance.c +++ b/testsuites/validation/tc-barrier-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierValPerf + * @ingroup RtemsBarrierValPerf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierValPerf spec:/rtems/barrier/val/perf + * @defgroup RtemsBarrierValPerf spec:/rtems/barrier/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicBarrier * performance tests. @@ -160,6 +160,13 @@ static T_fixture RtemsBarrierValPerf_Fixture = { }; /** + * @defgroup RtemsBarrierReqPerfReleaseAuto \ + * spec:/rtems/barrier/req/perf-release-auto + * + * @{ + */ + +/** * @brief Create an automatic release barrier. */ static void RtemsBarrierReqPerfReleaseAuto_Prepare( @@ -244,8 +251,17 @@ static void RtemsBarrierReqPerfReleaseAuto_Cleanup( T_rsc_success( sc ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsBarrierReqPerfReleaseAutoOtherCpu \ + * spec:/rtems/barrier/req/perf-release-auto-other-cpu + * + * @{ + */ + +/** * @brief Create an automatic release barrier. Create and start a worker task. */ static void RtemsBarrierReqPerfReleaseAutoOtherCpu_Prepare( @@ -341,9 +357,18 @@ static void RtemsBarrierReqPerfReleaseAutoOtherCpu_Cleanup( sc = rtems_barrier_delete( ctx->barrier_id ); T_rsc_success( sc ); } + +/** @} */ #endif /** + * @defgroup RtemsBarrierReqPerfReleaseManual \ + * spec:/rtems/barrier/req/perf-release-manual + * + * @{ + */ + +/** * @brief Create a manual release barrier. Create and start a worker task. */ static void RtemsBarrierReqPerfReleaseManual_Prepare( @@ -456,6 +481,15 @@ static void RtemsBarrierReqPerfReleaseManual_Cleanup( RestoreRunnerPriority(); } +/** @} */ + +/** + * @defgroup RtemsBarrierReqPerfReleaseManualPreempt \ + * spec:/rtems/barrier/req/perf-release-manual-preempt + * + * @{ + */ + /** * @brief Create a manual release barrier. Create and start a worker task. */ @@ -555,6 +589,8 @@ static void RtemsBarrierReqPerfReleaseManualPreempt_Cleanup( RestoreRunnerPriority(); } +/** @} */ + /** * @fn void T_case_body_RtemsBarrierValPerf( void ) */ diff --git a/testsuites/validation/tc-barrier-release.c b/testsuites/validation/tc-barrier-release.c index beb26f4660..b584943531 100644 --- a/testsuites/validation/tc-barrier-release.c +++ b/testsuites/validation/tc-barrier-release.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierReqRelease + * @ingroup RtemsBarrierReqRelease */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierReqRelease \ - * spec:/rtems/barrier/req/release + * @defgroup RtemsBarrierReqRelease spec:/rtems/barrier/req/release * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-barrier-wait.c b/testsuites/validation/tc-barrier-wait.c index 700b846cad..49d29a45c8 100644 --- a/testsuites/validation/tc-barrier-wait.c +++ b/testsuites/validation/tc-barrier-wait.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBarrierReqWait + * @ingroup RtemsBarrierReqWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBarrierReqWait spec:/rtems/barrier/req/wait + * @defgroup RtemsBarrierReqWait spec:/rtems/barrier/req/wait * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-basedefs-no-debug.c b/testsuites/validation/tc-basedefs-no-debug.c new file mode 100644 index 0000000000..b3cfa5dd40 --- /dev/null +++ b/testsuites/validation/tc-basedefs-no-debug.c @@ -0,0 +1,135 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup RtemsBasedefsValBasedefsNoDebug + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup RtemsBasedefsValBasedefsNoDebug \ + * spec:/rtems/basedefs/val/basedefs-no-debug + * + * @ingroup TestsuitesValidationNoClock0 + * + * @brief Tests the basedefs macros where RTEMS_DEBUG is disabled. + * + * This test case performs the following actions: + * + * - Expand and stringify RTEMS_UNREACHABLE(). + * + * - Check that the string is equal to the expected statement. + * + * - Expand RTEMS_FUNCTION_NAME. + * + * - Check that the string is equal to the expected function name. + * + * @{ + */ + +/** + * @brief Expand and stringify RTEMS_UNREACHABLE(). + */ +static void RtemsBasedefsValBasedefsNoDebug_Action_0( void ) +{ + const char *s; + + s = RTEMS_XSTRING( RTEMS_UNREACHABLE() ); + + /* + * Check that the string is equal to the expected statement. + */ + T_step_true( + 0, + IsEqualIgnoreWhiteSpace( + s, + "__builtin_unreachable()" + ) + ); +} + +/** + * @brief Expand RTEMS_FUNCTION_NAME. + */ +static void RtemsBasedefsValBasedefsNoDebug_Action_1( void ) +{ + const char *s; + + s = RTEMS_FUNCTION_NAME; + + /* + * Check that the string is equal to the expected function name. + */ + T_step_true( + 1, + IsEqualIgnoreWhiteSpace( + s, + "RtemsBasedefsValBasedefsNoDebug_Action_1" + ) + ); +} + +/** + * @fn void T_case_body_RtemsBasedefsValBasedefsNoDebug( void ) + */ +T_TEST_CASE( RtemsBasedefsValBasedefsNoDebug ) +{ + T_plan( 2 ); + + RtemsBasedefsValBasedefsNoDebug_Action_0(); + RtemsBasedefsValBasedefsNoDebug_Action_1(); +} + +/** @} */ diff --git a/testsuites/validation/tc-basedefs-pendant.c b/testsuites/validation/tc-basedefs-pendant.c index e9a7552d28..620e2d0efa 100644 --- a/testsuites/validation/tc-basedefs-pendant.c +++ b/testsuites/validation/tc-basedefs-pendant.c @@ -3,7 +3,7 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs + * @ingroup RtemsBasedefsValBasedefs * * @brief Helper file to verify the requirements towards the basedefs. * @@ -22,7 +22,7 @@ */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tc-basedefs-pendant.h b/testsuites/validation/tc-basedefs-pendant.h index 591e0e6441..7c1fbd8ae3 100644 --- a/testsuites/validation/tc-basedefs-pendant.h +++ b/testsuites/validation/tc-basedefs-pendant.h @@ -3,7 +3,7 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs + * @ingroup RtemsBasedefsValBasedefs * * @brief Helper file to verify the requirements towards the basedefs. * @@ -13,7 +13,7 @@ */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tc-basedefs.c b/testsuites/validation/tc-basedefs.c index bec43fa476..835f76ec64 100644 --- a/testsuites/validation/tc-basedefs.c +++ b/testsuites/validation/tc-basedefs.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs + * @ingroup RtemsBasedefsValBasedefs */ /* - * Copyright (C) 2020, 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020, 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsBasedefsValBasedefs \ - * spec:/rtems/basedefs/val/basedefs + * @defgroup RtemsBasedefsValBasedefs spec:/rtems/basedefs/val/basedefs * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the basedefs macros of the Classic API. * @@ -313,15 +312,9 @@ * effect. Yet, the check confirms that such a macro exists and can be * used. * - * - Use the RTEMS_STATIC_ANALYSIS macro. + * - Evaluate if RTEMS_STATIC_ANALYSIS is defined. * - * - It cannot be automatically check that the RTEMS_STATIC_ANALYSIS macro - * has the desired effect. - * - * - Use the RTEMS_STATIC_ANALYSIS macro. - * - * - It cannot be automatically check that the RTEMS_STATIC_ANALYSIS macro - * has the desired effect. + * - Check that RTEMS_STATIC_ANALYSIS was not defined. * * - Use the RTEMS_STATIC_ASSERT() macro. * @@ -439,6 +432,12 @@ * - Checked that the RTEMS_ZERO_LENGTH_ARRAY macro produces a structure * similar to a structure with one element. * + * - Use the RTEMS_DEFINE_GLOBAL_SYMBOL() macro at the beginning of this file + * and assign the address of the symbol to an object. + * + * - Check that the RTEMS_DEFINE_GLOBAL_SYMBOL() macro defines a global + * symbol with the correct value. + * * @{ */ @@ -534,8 +533,18 @@ RTEMS_COMPILER_PURE_ATTRIBUTE static int compiler_pure_attribute_func( void ) return 21; } +static int global_symbol_base; + RTEMS_DEFINE_GLOBAL_SYMBOL( - GLOBAL_SYMBOL, GLOBAL_SYMBOL_VALULE( abc ) ); + GLOBAL_SYMBOL, + RTEMS_SYMBOL_NAME( global_symbol_base ) + GLOBAL_SYMBOL_VALULE( abc ) +); + +RTEMS_DECLARE_GLOBAL_SYMBOL( global_symbol_2 ); + +RTEMS_DEFINE_GLOBAL_SYMBOL( global_symbol_2, 0x123 ); + +static const char * const volatile global_symbol_2_object = global_symbol_2; static int deprecated_func( int i ) RTEMS_DEPRECATED; static int deprecated_func( int i ) @@ -1062,7 +1071,11 @@ static void RtemsBasedefsValBasedefs_Action_18( void ) * which is defined in a file different from the file in which the gobal * symbol is defined. */ - T_step_eq_int( 45, basedefs_get_global_symbol(), 0xabc ); + T_step_eq_uptr( + 45, + basedefs_get_global_symbol() - (uintptr_t) &global_symbol_base, + 0xabc + ); } /** @@ -1096,7 +1109,11 @@ static void RtemsBasedefsValBasedefs_Action_20( void ) * Check that the RTEMS_DEFINE_GLOBAL_SYMBOL() macro defines a global symbol * with the correct value. */ - T_step_eq_int( 49, (uintptr_t) global_symbol, 0xabc ); + T_step_eq_uptr( + 49, + (uintptr_t) global_symbol - (uintptr_t) &global_symbol_base, + 0xabc + ); } /** @@ -1557,49 +1574,26 @@ static void RtemsBasedefsValBasedefs_Action_40( void ) } /** - * @brief Use the RTEMS_STATIC_ANALYSIS macro. + * @brief Evaluate if RTEMS_STATIC_ANALYSIS is defined. */ static void RtemsBasedefsValBasedefs_Action_41( void ) { - /* No action */ - - /* - * It cannot be automatically check that the RTEMS_STATIC_ANALYSIS macro has - * the desired effect. - */ - #if defined(__COVERITY__) - # if defined(RTEMS_STATIC_ANALYSIS) - T_quiet_true( true, "test passes, no output" ); - # else - T_quiet_true( false, "RTEMS_STATIC_ANALYSIS not defined" ); - # endif + #if defined(RTEMS_STATIC_ANALYSIS) + bool defined = true; + #else + bool defined = false; #endif -} - -/** - * @brief Use the RTEMS_STATIC_ANALYSIS macro. - */ -static void RtemsBasedefsValBasedefs_Action_42( void ) -{ - /* No action */ /* - * It cannot be automatically check that the RTEMS_STATIC_ANALYSIS macro has - * the desired effect. + * Check that RTEMS_STATIC_ANALYSIS was not defined. */ - #if !defined(__COVERITY__) - # if !defined(RTEMS_STATIC_ANALYSIS) - T_quiet_true( true, "test passes, no output" ); - # else - T_quiet_true( false, "RTEMS_STATIC_ANALYSIS defined" ); - # endif - #endif + T_step_false( 94, defined ); } /** * @brief Use the RTEMS_STATIC_ASSERT() macro. */ -static void RtemsBasedefsValBasedefs_Action_43( void ) +static void RtemsBasedefsValBasedefs_Action_42( void ) { RTEMS_STATIC_ASSERT( STATIC_ASSERT_COND 1, RTEMS_STATIC_ASSERT_test ); @@ -1614,7 +1608,7 @@ static void RtemsBasedefsValBasedefs_Action_43( void ) /** * @brief Use the RTEMS_STRING() macro. */ -static void RtemsBasedefsValBasedefs_Action_44( void ) +static void RtemsBasedefsValBasedefs_Action_43( void ) { const char *string_var; const char *string_empty_var; @@ -1628,16 +1622,16 @@ static void RtemsBasedefsValBasedefs_Action_44( void ) * Check that the RTEMS_STRING() macro converts its arguments into a single * string without applying pre-processor substitutions on its arguments. */ - T_step_eq_str( 94, string_var, "\\ STRING_PREFIX cat\"\"\n" ); - T_step_eq_str( 95, string_empty_var, "" ); - T_step_eq_str( 96, string_multi_args_var, + T_step_eq_str( 95, string_var, "\\ STRING_PREFIX cat\"\"\n" ); + T_step_eq_str( 96, string_empty_var, "" ); + T_step_eq_str( 97, string_multi_args_var, "STRING_PREFIX, \"abc\", DEF" ); } /** * @brief Use the RTEMS_SYMBOL_NAME() macro with an example object. */ -static void RtemsBasedefsValBasedefs_Action_45( void ) +static void RtemsBasedefsValBasedefs_Action_44( void ) { /* Nothing to do */ @@ -1645,13 +1639,13 @@ static void RtemsBasedefsValBasedefs_Action_45( void ) * Check that the RTEMS_SYMBOL_NAME() macro expands to the expected symbol * name. */ - T_step_eq_ptr( 97, &global_object, &address_of_global_object ); + T_step_eq_ptr( 98, &global_object, &address_of_global_object ); } /** * @brief Invoke the TRUE macro on an example. */ -static void RtemsBasedefsValBasedefs_Action_46( void ) +static void RtemsBasedefsValBasedefs_Action_45( void ) { char *true_result; true_result = _TO_STR( TRUE ); @@ -1659,7 +1653,7 @@ static void RtemsBasedefsValBasedefs_Action_46( void ) /* * Check that of TRUE is substituted by 0. */ - T_step_eq_str( 98, true_result, "1" ); + T_step_eq_str( 99, true_result, "1" ); } /** @@ -1667,7 +1661,7 @@ static void RtemsBasedefsValBasedefs_Action_46( void ) * is already the test as the statements will not compile without error if * the macro did not evaluate to the correct type. */ -static void RtemsBasedefsValBasedefs_Action_47( void ) +static void RtemsBasedefsValBasedefs_Action_46( void ) { int type_refx_val = 7; char type_refx_chr = 'c'; @@ -1689,24 +1683,24 @@ static void RtemsBasedefsValBasedefs_Action_47( void ) * The checks here are proforma. The macro is tested by the fact that the * action will not compile if the macro returns a wrong result. */ - T_step_eq_int( 99, type_refx_val, 7 ); - T_step_eq_int( 100, type_refx_x_int, 8 ); - T_step_eq_int( 101, type_refx_xx_int, 9 ); - T_step_eq_int( 102, type_refx_xxx_int, 10 ); - T_step_eq_int( 103, *type_refx_xxx_int_p, 7 ); - T_step_eq_char( 104, type_refx_chr, 'c' ); - T_step_eq_char( 105, type_refx_ax_char, 'd' ); - T_step_eq_char( 106, type_refx_x_char, 'e' ); - T_step_eq_char( 107, type_refx_char, 'f' ); - T_step_eq_char( 108, type_refx_xx_char, 'g' ); - T_step_eq_short( 109, *type_refx_xx_const_short_p, 333 ); + T_step_eq_int( 100, type_refx_val, 7 ); + T_step_eq_int( 101, type_refx_x_int, 8 ); + T_step_eq_int( 102, type_refx_xx_int, 9 ); + T_step_eq_int( 103, type_refx_xxx_int, 10 ); + T_step_eq_int( 104, *type_refx_xxx_int_p, 7 ); + T_step_eq_char( 105, type_refx_chr, 'c' ); + T_step_eq_char( 106, type_refx_ax_char, 'd' ); + T_step_eq_char( 107, type_refx_x_char, 'e' ); + T_step_eq_char( 108, type_refx_char, 'f' ); + T_step_eq_char( 109, type_refx_xx_char, 'g' ); + T_step_eq_short( 110, *type_refx_xx_const_short_p, 333 ); } /** * @brief Use the RTEMS_UNUSED macro. See also unused_func() at the beginning * of this file. */ -static void RtemsBasedefsValBasedefs_Action_48( void ) +static void RtemsBasedefsValBasedefs_Action_47( void ) { int unused_var RTEMS_UNUSED; typedef struct RTEMS_UNUSED { @@ -1753,7 +1747,7 @@ static void RtemsBasedefsValBasedefs_Action_48( void ) * @brief Use of the RTEMS_UNREACHABLE() macro in function definition of * unreachable_func() at the beginning of this file. */ -static void RtemsBasedefsValBasedefs_Action_49( void ) +static void RtemsBasedefsValBasedefs_Action_48( void ) { int unreachable_result; unreachable_result = unreachable_func(2101); @@ -1763,14 +1757,14 @@ static void RtemsBasedefsValBasedefs_Action_49( void ) * effect. It is checked that such a macro exists and the compiler warning * about the missing return statement is suppressed. */ - T_step_eq_int( 110, unreachable_result, 2101 ); + T_step_eq_int( 111, unreachable_result, 2101 ); } /** * @brief Use of the RTEMS_USED macro in function definition of used_func() at * the beginning of this file and with used_var above. */ -static void RtemsBasedefsValBasedefs_Action_50( void ) +static void RtemsBasedefsValBasedefs_Action_49( void ) { /* No action */ @@ -1785,7 +1779,7 @@ static void RtemsBasedefsValBasedefs_Action_50( void ) * @brief Use of the RTEMS_WARN_UNUSED_RESULT macro in function definition of * warn_unused_func() at the beginning of this file. */ -static void RtemsBasedefsValBasedefs_Action_51( void ) +static void RtemsBasedefsValBasedefs_Action_50( void ) { int warn_unused_result; warn_unused_result = warn_unused_func( 33 ); @@ -1809,14 +1803,14 @@ static void RtemsBasedefsValBasedefs_Action_51( void ) * disregarded result returned by the call to the ``warn_unused_func()`` * function. */ - T_step_eq_int( 111, warn_unused_result, 11 ); + T_step_eq_int( 112, warn_unused_result, 11 ); } /** * @brief Use of ``basedefs_weak_alias_0/1_func()`` which are defined with the * RTEMS_WEAK_ALIAS() macro at the beginning of this file. */ -static void RtemsBasedefsValBasedefs_Action_52( void ) +static void RtemsBasedefsValBasedefs_Action_51( void ) { int weak_alias_0_result; int weak_alias_1_result; @@ -1827,21 +1821,21 @@ static void RtemsBasedefsValBasedefs_Action_52( void ) * There exists no strong alias for basedefs_weak_alias_0_func(). Check that * ori_func() and basedefs_weak_alias_0_func() are the same function. */ - T_step_eq_int( 112, weak_alias_0_result, 16 ); + T_step_eq_int( 113, weak_alias_0_result, 16 ); /* * File ``tc_basedefs_pndant.c`` defines a strong function for * basedefs_weak_alias_1_func(). Check that ori_func() and * basedefs_weak_alias_1_func() are not the same function. */ - T_step_eq_int( 113, weak_alias_1_result, 56 ); + T_step_eq_int( 114, weak_alias_1_result, 56 ); } /** * @brief Use of ``basedefs_weak_0/1_var`` and ``basedefs_weak_0/1_func()`` * which are defined with the RTEMS_WEAK macro at the beginning of this file. */ -static void RtemsBasedefsValBasedefs_Action_53( void ) +static void RtemsBasedefsValBasedefs_Action_52( void ) { int weak_0_result; int weak_1_result; @@ -1853,22 +1847,22 @@ static void RtemsBasedefsValBasedefs_Action_53( void ) * other symbols with the same name. Hence, the checks test that the weak * symbols are used. */ - T_step_eq_int( 114, basedefs_weak_0_var, 60 ); - T_step_eq_int( 115, weak_0_result, 63 ); + T_step_eq_int( 115, basedefs_weak_0_var, 60 ); + T_step_eq_int( 116, weak_0_result, 63 ); /* * ``basedefs_weak_1_var`` and ``basedefs_weak_1_func()`` are overwritten by * strong symbols defined in file ``tc_basedefs_pendant.c``. Hence, the * checks test that the strong variants are used. */ - T_step_eq_int( 116, basedefs_weak_1_var, 62 ); - T_step_eq_int( 117, weak_1_result, 65 ); + T_step_eq_int( 117, basedefs_weak_1_var, 62 ); + T_step_eq_int( 118, weak_1_result, 65 ); } /** * @brief Invoke the RTEMS_XCONCAT() macro on examples. */ -static void RtemsBasedefsValBasedefs_Action_54( void ) +static void RtemsBasedefsValBasedefs_Action_53( void ) { int xconcat0_result; int xconcat1_result; @@ -1884,31 +1878,31 @@ static void RtemsBasedefsValBasedefs_Action_54( void ) * Check that the two arguments of RTEMS_XCONCAT() are concatenated without * inserting new characters. */ - T_step_eq_int( 118, xconcat0_result, 91 ); + T_step_eq_int( 119, xconcat0_result, 91 ); /* * Check that the two arguments of RTEMS_XCONCAT() are substituted before * they are concatenated. */ - T_step_eq_int( 119, xconcat1_result, 91 ); + T_step_eq_int( 120, xconcat1_result, 91 ); /* * Check that the two arguments of RTEMS_XCONCAT() are can be the macro * itself. */ - T_step_eq_int( 120, xconcat2_result, 91 ); + T_step_eq_int( 121, xconcat2_result, 91 ); /* * Check that the result of the RTEMS_XCONCAT() expansion is subject to a * further pre-processor substitution. */ - T_step_eq_int( 121, xconcat3_result, 91 ); + T_step_eq_int( 122, xconcat3_result, 91 ); } /** * @brief Use the RTEMS_XSTRING() macro. */ -static void RtemsBasedefsValBasedefs_Action_55( void ) +static void RtemsBasedefsValBasedefs_Action_54( void ) { const char *xstring_var; const char *xstring_empty_var; @@ -1922,9 +1916,9 @@ static void RtemsBasedefsValBasedefs_Action_55( void ) * Check that the RTEMS_XSTRING() macro applies pre-processor substitutions * on its arguments and converts its arguments into a single string. */ - T_step_eq_str( 122, xstring_var, "\\ str cat\"\"\n" ); - T_step_eq_str( 123, xstring_empty_var, "" ); - T_step_eq_str( 124, string_multi_args_var, + T_step_eq_str( 123, xstring_var, "\\ str cat\"\"\n" ); + T_step_eq_str( 124, xstring_empty_var, "" ); + T_step_eq_str( 125, string_multi_args_var, "str, ABC, \"abc\", DEF" ); } @@ -1932,7 +1926,7 @@ static void RtemsBasedefsValBasedefs_Action_55( void ) * @brief Use of the RTEMS_ZERO_LENGTH_ARRAY macro in a declaration of a * structure. */ -static void RtemsBasedefsValBasedefs_Action_56( void ) +static void RtemsBasedefsValBasedefs_Action_55( void ) { typedef struct { char chr; @@ -1947,20 +1941,35 @@ static void RtemsBasedefsValBasedefs_Action_56( void ) * Checked that the RTEMS_ZERO_LENGTH_ARRAY macro produces a structure * similar to a structure with one element. */ - T_step_eq_sz( 125, sizeof( zero_length_struct_0 ), + T_step_eq_sz( 126, sizeof( zero_length_struct_0 ), sizeof( zero_length_struct_1 ) - sizeof( int ) ); - T_step_eq_sz( 126, offsetof( zero_length_struct_0, chr ), + T_step_eq_sz( 127, offsetof( zero_length_struct_0, chr ), offsetof( zero_length_struct_1, chr ) ); - T_step_eq_sz( 127, offsetof( zero_length_struct_0, array ), + T_step_eq_sz( 128, offsetof( zero_length_struct_0, array ), offsetof( zero_length_struct_1, array ) ); } /** + * @brief Use the RTEMS_DEFINE_GLOBAL_SYMBOL() macro at the beginning of this + * file and assign the address of the symbol to an object. + */ +static void RtemsBasedefsValBasedefs_Action_56( void ) +{ + /* No action */ + + /* + * Check that the RTEMS_DEFINE_GLOBAL_SYMBOL() macro defines a global symbol + * with the correct value. + */ + T_step_eq_uptr( 129, (uintptr_t) global_symbol_2_object, 0x123 ); +} + +/** * @fn void T_case_body_RtemsBasedefsValBasedefs( void ) */ T_TEST_CASE( RtemsBasedefsValBasedefs ) { - T_plan( 128 ); + T_plan( 130 ); RtemsBasedefsValBasedefs_Action_0(); RtemsBasedefsValBasedefs_Action_1(); diff --git a/testsuites/validation/tc-bsp-interrupt-handler-dispatch-unchecked.c b/testsuites/validation/tc-bsp-interrupt-handler-dispatch-unchecked.c new file mode 100644 index 0000000000..cef52bd991 --- /dev/null +++ b/testsuites/validation/tc-bsp-interrupt-handler-dispatch-unchecked.c @@ -0,0 +1,649 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup BspReqInterruptHandlerDispatchUnchecked + */ + +/* + * Copyright (C) 2021, 2023 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <setjmp.h> +#include <bsp/irq-generic.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup BspReqInterruptHandlerDispatchUnchecked \ + * spec:/bsp/req/interrupt-handler-dispatch-unchecked + * + * @ingroup TestsuitesValidationIntr + * + * @{ + */ + +typedef enum { + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Null, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Entry, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_NA +} BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst; + +typedef enum { + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Null, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Entry, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_NA +} BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain; + +typedef enum { + BspReqInterruptHandlerDispatchUnchecked_Post_Result_FatalError, + BspReqInterruptHandlerDispatchUnchecked_Post_Result_Dispatch, + BspReqInterruptHandlerDispatchUnchecked_Post_Result_NA +} BspReqInterruptHandlerDispatchUnchecked_Post_Result; + +typedef enum { + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_NA +} BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource; + +typedef enum { + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Vector, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_NA +} BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode; + +typedef struct { + uint8_t Skip : 1; + uint8_t Pre_LoadFirst_NA : 1; + uint8_t Pre_LoadFirstAgain_NA : 1; + uint8_t Post_Result : 2; + uint8_t Post_FatalSource : 1; + uint8_t Post_FatalCode : 1; +} BspReqInterruptHandlerDispatchUnchecked_Entry; + +/** + * @brief Test context for spec:/bsp/req/interrupt-handler-dispatch-unchecked + * test case. + */ +typedef struct { + /** + * @brief This member references the interrupt entry to restore during test + * case teardown. + */ + rtems_interrupt_entry *entry_to_restore; + + /** + * @brief This member provides a jump buffer to return from the fatal error. + */ + jmp_buf before_call; + + /** + * @brief This member provides an interrupt entry to be dispatched. + */ + rtems_interrupt_entry entry; + + /** + * @brief This member is true, then an interrupt occurred. + */ + volatile bool interrupt_occurred; + + /** + * @brief This member provides an entry dispatch counter. + */ + uint32_t entry_counter; + + /** + * @brief This member provides a fatal error counter. + */ + uint32_t fatal_counter; + + /** + * @brief This member contains the fatal source. + */ + rtems_fatal_source fatal_source; + + /** + * @brief This member contains a fatal code. + */ + rtems_fatal_code fatal_code; + + /** + * @brief This member contains the vector number of a testable interrupt. + */ + rtems_vector_number test_vector; + + /** + * @brief This member references the pointer to the first entry of the + * interrupt vector. + */ + rtems_interrupt_entry **first; + + /** + * @brief This member references an interrupt entry for the first entry of + * the interrupt vector or is NULL. + */ + rtems_interrupt_entry *first_again; + + struct { + /** + * @brief This member defines the pre-condition indices for the next + * action. + */ + size_t pci[ 2 ]; + + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 2 ]; + + /** + * @brief If this member is true, then the test action loop is executed. + */ + bool in_action_loop; + + /** + * @brief This member contains the next transition map index. + */ + size_t index; + + /** + * @brief This member contains the current transition map entry. + */ + BspReqInterruptHandlerDispatchUnchecked_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} BspReqInterruptHandlerDispatchUnchecked_Context; + +static BspReqInterruptHandlerDispatchUnchecked_Context + BspReqInterruptHandlerDispatchUnchecked_Instance; + +static const char * const BspReqInterruptHandlerDispatchUnchecked_PreDesc_LoadFirst[] = { + "Null", + "Entry", + "NA" +}; + +static const char * const BspReqInterruptHandlerDispatchUnchecked_PreDesc_LoadFirstAgain[] = { + "Null", + "Entry", + "NA" +}; + +static const char * const * const BspReqInterruptHandlerDispatchUnchecked_PreDesc[] = { + BspReqInterruptHandlerDispatchUnchecked_PreDesc_LoadFirst, + BspReqInterruptHandlerDispatchUnchecked_PreDesc_LoadFirstAgain, + NULL +}; + +typedef BspReqInterruptHandlerDispatchUnchecked_Context Context; + +static bool test_case_active; + +static void Disable( const Context *ctx ) +{ + (void) rtems_interrupt_vector_disable( ctx->test_vector ); +} + +static void ProcessInterrupt( Context *ctx ) +{ + ctx->interrupt_occurred = true; + CallWithinISRClear(); + Disable( ctx ); +} + +static void EntryRoutine( void *arg ) +{ + Context *ctx; + + ctx = arg; + ++ctx->entry_counter; + ProcessInterrupt( ctx ); +} + +static void Fatal( + rtems_fatal_source source, + rtems_fatal_code code, + void *arg +) +{ + Context *ctx; + + ctx = arg; + ctx->fatal_source = source; + ctx->fatal_code = code; + ++ctx->fatal_counter; + longjmp( ctx->before_call, 1 ); +} + +void __real_bsp_interrupt_handler_default( rtems_vector_number vector ); + +void __wrap_bsp_interrupt_handler_default( rtems_vector_number vector ); + +void __wrap_bsp_interrupt_handler_default( rtems_vector_number vector ) +{ + if ( test_case_active ) { + Context *ctx; + + ctx = T_fixture_context(); + ProcessInterrupt( ctx ); + + if ( setjmp( ctx->before_call ) == 0 ) { + __real_bsp_interrupt_handler_default( vector ); + } + } else { + __real_bsp_interrupt_handler_default( vector ); + } +} + +#if defined(RTEMS_SMP) +void __real_bsp_interrupt_spurious( rtems_vector_number vector ); + +void __wrap_bsp_interrupt_spurious( rtems_vector_number vector ); + +void __wrap_bsp_interrupt_spurious( rtems_vector_number vector ) +{ + if ( test_case_active ) { + Context *ctx; + + ctx = T_fixture_context(); + *ctx->first = ctx->first_again; + } + + __real_bsp_interrupt_spurious( vector ); +} +#endif + +static void BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Prepare( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst state +) +{ + switch ( state ) { + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Null: { + /* + * While the first loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter is + * equal to NULL. + */ + *ctx->first = NULL; + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Entry: { + /* + * While the first loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter + * references an object of type rtems_interrupt_entry. + */ + *ctx->first = &ctx->entry; + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_NA: + break; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Prepare( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx, + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain state +) +{ + switch ( state ) { + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Null: { + /* + * While the second loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter is + * equal to NULL. + */ + ctx->first_again = NULL; + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Entry: { + /* + * While the second loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter + * references an object of type rtems_interrupt_entry. + */ + ctx->first_again = &ctx->entry; + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_NA: + break; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Post_Result_Check( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx, + BspReqInterruptHandlerDispatchUnchecked_Post_Result state +) +{ + switch ( state ) { + case BspReqInterruptHandlerDispatchUnchecked_Post_Result_FatalError: { + /* + * A fatal error shall occur. + */ + T_eq_u32( ctx->entry_counter, 0 ); + T_eq_u32( ctx->fatal_counter, 1 ); + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Post_Result_Dispatch: { + /* + * The interrupt entries installed at the interrupt vector specified by + * the ``vector`` parameter shall be dispatched. + */ + T_eq_u32( ctx->entry_counter, 1 ); + T_eq_u32( ctx->fatal_counter, 0 ); + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Post_Result_NA: + break; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_Check( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource state +) +{ + switch ( state ) { + case BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_SpuriousInterrupt: { + /* + * The fatal source shall be equal to + * RTEMS_FATAL_SOURCE_SPURIOUS_INTERRUPT. + */ + T_eq_int( ctx->fatal_source, RTEMS_FATAL_SOURCE_SPURIOUS_INTERRUPT ); + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_NA: + break; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Check( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode state +) +{ + switch ( state ) { + case BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Vector: { + /* + * The fatal code shall be equal to the ``vector`` parameter. + */ + T_eq_ulong( ctx->fatal_code, ctx->test_vector ); + break; + } + + case BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_NA: + break; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Setup( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + ctx->first = NULL; + ctx->test_vector = CallWithinISRGetVector(); + T_assert_lt_u32( ctx->test_vector, BSP_INTERRUPT_VECTOR_COUNT ); + ctx->first = &bsp_interrupt_dispatch_table[ + bsp_interrupt_dispatch_index( ctx->test_vector ) + ]; + ctx->entry_to_restore = *ctx->first; + + rtems_interrupt_entry_initialize( &ctx->entry, EntryRoutine, ctx, "Info" ); + test_case_active = true; + SetFatalHandler( Fatal, ctx ); +} + +static void BspReqInterruptHandlerDispatchUnchecked_Setup_Wrap( void *arg ) +{ + BspReqInterruptHandlerDispatchUnchecked_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + BspReqInterruptHandlerDispatchUnchecked_Setup( ctx ); +} + +static void BspReqInterruptHandlerDispatchUnchecked_Teardown( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + SetFatalHandler( NULL, NULL ); + test_case_active = false; + + if ( ctx->first != NULL ) { + *ctx->first = ctx->entry_to_restore; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_Teardown_Wrap( void *arg ) +{ + BspReqInterruptHandlerDispatchUnchecked_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + BspReqInterruptHandlerDispatchUnchecked_Teardown( ctx ); +} + +static void BspReqInterruptHandlerDispatchUnchecked_Action( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + ctx->interrupt_occurred = false; + ctx->entry_counter = 0; + ctx->fatal_counter = 0; + ctx->fatal_source = RTEMS_FATAL_SOURCE_LAST; + ctx->fatal_code = UINT32_MAX; + + (void) rtems_interrupt_vector_enable( ctx->test_vector ); + + CallWithinISRRaise(); + + while ( !ctx->interrupt_occurred ) { + /* Wait */ + } + + Disable( ctx ); +} + +static const BspReqInterruptHandlerDispatchUnchecked_Entry +BspReqInterruptHandlerDispatchUnchecked_Entries[] = { + { 0, 0, 1, BspReqInterruptHandlerDispatchUnchecked_Post_Result_Dispatch, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_NA, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_NA }, +#if defined(RTEMS_SMP) + { 0, 0, 0, BspReqInterruptHandlerDispatchUnchecked_Post_Result_FatalError, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Vector }, +#else + { 0, 0, 1, BspReqInterruptHandlerDispatchUnchecked_Post_Result_FatalError, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Vector }, +#endif +#if defined(RTEMS_SMP) + { 0, 0, 0, BspReqInterruptHandlerDispatchUnchecked_Post_Result_Dispatch, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_NA, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_NA } +#else + { 0, 0, 1, BspReqInterruptHandlerDispatchUnchecked_Post_Result_FatalError, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Vector } +#endif +}; + +static const uint8_t +BspReqInterruptHandlerDispatchUnchecked_Map[] = { + 1, 2, 0, 0 +}; + +static size_t BspReqInterruptHandlerDispatchUnchecked_Scope( + void *arg, + char *buf, + size_t n +) +{ + BspReqInterruptHandlerDispatchUnchecked_Context *ctx; + + ctx = arg; + + if ( ctx->Map.in_action_loop ) { + return T_get_scope( + BspReqInterruptHandlerDispatchUnchecked_PreDesc, + buf, + n, + ctx->Map.pcs + ); + } + + return 0; +} + +static T_fixture BspReqInterruptHandlerDispatchUnchecked_Fixture = { + .setup = BspReqInterruptHandlerDispatchUnchecked_Setup_Wrap, + .stop = NULL, + .teardown = BspReqInterruptHandlerDispatchUnchecked_Teardown_Wrap, + .scope = BspReqInterruptHandlerDispatchUnchecked_Scope, + .initial_context = &BspReqInterruptHandlerDispatchUnchecked_Instance +}; + +static inline BspReqInterruptHandlerDispatchUnchecked_Entry +BspReqInterruptHandlerDispatchUnchecked_PopEntry( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return BspReqInterruptHandlerDispatchUnchecked_Entries[ + BspReqInterruptHandlerDispatchUnchecked_Map[ index ] + ]; +} + +static void BspReqInterruptHandlerDispatchUnchecked_SetPreConditionStates( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; + + if ( ctx->Map.entry.Pre_LoadFirstAgain_NA ) { + ctx->Map.pcs[ 1 ] = BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_NA; + } else { + ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; + } +} + +static void BspReqInterruptHandlerDispatchUnchecked_TestVariant( + BspReqInterruptHandlerDispatchUnchecked_Context *ctx +) +{ + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Prepare( + ctx, + ctx->Map.pcs[ 0 ] + ); + BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Prepare( + ctx, + ctx->Map.pcs[ 1 ] + ); + BspReqInterruptHandlerDispatchUnchecked_Action( ctx ); + BspReqInterruptHandlerDispatchUnchecked_Post_Result_Check( + ctx, + ctx->Map.entry.Post_Result + ); + BspReqInterruptHandlerDispatchUnchecked_Post_FatalSource_Check( + ctx, + ctx->Map.entry.Post_FatalSource + ); + BspReqInterruptHandlerDispatchUnchecked_Post_FatalCode_Check( + ctx, + ctx->Map.entry.Post_FatalCode + ); +} + +/** + * @fn void T_case_body_BspReqInterruptHandlerDispatchUnchecked( void ) + */ +T_TEST_CASE_FIXTURE( + BspReqInterruptHandlerDispatchUnchecked, + &BspReqInterruptHandlerDispatchUnchecked_Fixture +) +{ + BspReqInterruptHandlerDispatchUnchecked_Context *ctx; + + ctx = T_fixture_context(); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pci[ 0 ] = BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_Null; + ctx->Map.pci[ 0 ] < BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirst_NA; + ++ctx->Map.pci[ 0 ] + ) { + for ( + ctx->Map.pci[ 1 ] = BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_Null; + ctx->Map.pci[ 1 ] < BspReqInterruptHandlerDispatchUnchecked_Pre_LoadFirstAgain_NA; + ++ctx->Map.pci[ 1 ] + ) { + ctx->Map.entry = BspReqInterruptHandlerDispatchUnchecked_PopEntry( ctx ); + BspReqInterruptHandlerDispatchUnchecked_SetPreConditionStates( ctx ); + BspReqInterruptHandlerDispatchUnchecked_TestVariant( ctx ); + } + } +} + +/** @} */ diff --git a/testsuites/validation/tc-bsp-interrupt-spurious.c b/testsuites/validation/tc-bsp-interrupt-spurious.c deleted file mode 100644 index f5e992a51d..0000000000 --- a/testsuites/validation/tc-bsp-interrupt-spurious.c +++ /dev/null @@ -1,636 +0,0 @@ -/* SPDX-License-Identifier: BSD-2-Clause */ - -/** - * @file - * - * @ingroup RTEMSTestCaseBspReqInterruptSpurious - */ - -/* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/* - * This file is part of the RTEMS quality process and was automatically - * generated. If you find something that needs to be fixed or - * worded better please post a report or patch to an RTEMS mailing list - * or raise a bug report: - * - * https://www.rtems.org/bugs.html - * - * For information on updating and regenerating please refer to the How-To - * section in the Software Requirements Engineering chapter of the - * RTEMS Software Engineering manual. The manual is provided as a part of - * a release. For development sources please refer to the online - * documentation at: - * - * https://docs.rtems.org - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include <setjmp.h> -#include <bsp/irq-generic.h> - -#include "tx-support.h" - -#include <rtems/test.h> - -/** - * @defgroup RTEMSTestCaseBspReqInterruptSpurious \ - * spec:/bsp/req/interrupt-spurious - * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr - * - * @{ - */ - -typedef enum { - BspReqInterruptSpurious_Pre_First_Null, - BspReqInterruptSpurious_Pre_First_Entry, - BspReqInterruptSpurious_Pre_First_NA -} BspReqInterruptSpurious_Pre_First; - -typedef enum { - BspReqInterruptSpurious_Pre_FirstAgain_Null, - BspReqInterruptSpurious_Pre_FirstAgain_Entry, - BspReqInterruptSpurious_Pre_FirstAgain_NA -} BspReqInterruptSpurious_Pre_FirstAgain; - -typedef enum { - BspReqInterruptSpurious_Post_Result_FatalError, - BspReqInterruptSpurious_Post_Result_Dispatch, - BspReqInterruptSpurious_Post_Result_NA -} BspReqInterruptSpurious_Post_Result; - -typedef enum { - BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, - BspReqInterruptSpurious_Post_FatalSource_NA -} BspReqInterruptSpurious_Post_FatalSource; - -typedef enum { - BspReqInterruptSpurious_Post_FatalCode_Vector, - BspReqInterruptSpurious_Post_FatalCode_NA -} BspReqInterruptSpurious_Post_FatalCode; - -typedef struct { - uint8_t Skip : 1; - uint8_t Pre_First_NA : 1; - uint8_t Pre_FirstAgain_NA : 1; - uint8_t Post_Result : 2; - uint8_t Post_FatalSource : 1; - uint8_t Post_FatalCode : 1; -} BspReqInterruptSpurious_Entry; - -/** - * @brief Test context for spec:/bsp/req/interrupt-spurious test case. - */ -typedef struct { - /** - * @brief This member provides a jump buffer to return from the fatal error. - */ - jmp_buf before_call; - - /** - * @brief This member provides an interrupt entry to be dispatched. - */ - rtems_interrupt_entry entry; - - /** - * @brief If this member is true, then the interrupt shall be cleared. - */ - bool do_clear; - - /** - * @brief This member is true, then an interrupt occurred. - */ - volatile bool interrupt_occurred; - - /** - * @brief This member provides an entry dispatch counter. - */ - uint32_t entry_counter; - - /** - * @brief This member provides a fatal error counter. - */ - uint32_t fatal_counter; - - /** - * @brief This member contains the fatal source. - */ - rtems_fatal_source fatal_source; - - /** - * @brief This member contains a fatal code. - */ - rtems_fatal_code fatal_code; - - /** - * @brief This member contains the vector number of a testable interrupt. - */ - rtems_vector_number test_vector; - - /** - * @brief This member references the pointer to the first entry of the - * interrupt vector. - */ - rtems_interrupt_entry **first; - - /** - * @brief This member references an interrupt entry for the first entry of - * the interrupt vector or is NULL. - */ - rtems_interrupt_entry *first_again; - - struct { - /** - * @brief This member defines the pre-condition indices for the next - * action. - */ - size_t pci[ 2 ]; - - /** - * @brief This member defines the pre-condition states for the next action. - */ - size_t pcs[ 2 ]; - - /** - * @brief If this member is true, then the test action loop is executed. - */ - bool in_action_loop; - - /** - * @brief This member contains the next transition map index. - */ - size_t index; - - /** - * @brief This member contains the current transition map entry. - */ - BspReqInterruptSpurious_Entry entry; - - /** - * @brief If this member is true, then the current transition variant - * should be skipped. - */ - bool skip; - } Map; -} BspReqInterruptSpurious_Context; - -static BspReqInterruptSpurious_Context - BspReqInterruptSpurious_Instance; - -static const char * const BspReqInterruptSpurious_PreDesc_First[] = { - "Null", - "Entry", - "NA" -}; - -static const char * const BspReqInterruptSpurious_PreDesc_FirstAgain[] = { - "Null", - "Entry", - "NA" -}; - -static const char * const * const BspReqInterruptSpurious_PreDesc[] = { - BspReqInterruptSpurious_PreDesc_First, - BspReqInterruptSpurious_PreDesc_FirstAgain, - NULL -}; - -typedef BspReqInterruptSpurious_Context Context; - -static bool test_case_active; - -static void Disable( const Context *ctx ) -{ - (void) rtems_interrupt_vector_disable( ctx->test_vector ); -} - -static void ProcessInterrupt( Context *ctx ) -{ - ctx->interrupt_occurred = true; - - if ( ctx->do_clear ) { - rtems_status_code sc; - - sc = rtems_interrupt_clear( ctx->test_vector ); - T_rsc_success( sc ); - } - - Disable( ctx ); -} - -static void EntryRoutine( void *arg ) -{ - Context *ctx; - - ctx = arg; - ++ctx->entry_counter; - ProcessInterrupt( ctx ); -} - -static void Fatal( - rtems_fatal_source source, - rtems_fatal_code code, - void *arg -) -{ - Context *ctx; - - ctx = arg; - ctx->fatal_source = source; - ctx->fatal_code = code; - ++ctx->fatal_counter; - longjmp( ctx->before_call, 1 ); -} - -void __real_bsp_interrupt_handler_default( rtems_vector_number vector ); - -void __wrap_bsp_interrupt_handler_default( rtems_vector_number vector ); - -void __wrap_bsp_interrupt_handler_default( rtems_vector_number vector ) -{ - if ( test_case_active ) { - Context *ctx; - - ctx = T_fixture_context(); - ProcessInterrupt( ctx ); - - if ( setjmp( ctx->before_call ) == 0 ) { - __real_bsp_interrupt_handler_default( vector ); - } - } else { - __real_bsp_interrupt_handler_default( vector ); - } -} - -static void BspReqInterruptSpurious_Pre_First_Prepare( - BspReqInterruptSpurious_Context *ctx, - BspReqInterruptSpurious_Pre_First state -) -{ - switch ( state ) { - case BspReqInterruptSpurious_Pre_First_Null: { - /* - * While the first loaded value of the pointer to the first interrupt - * entry of the interrupt vector specified by the ``vector`` parameter is - * equal to NULL. - */ - *ctx->first = NULL; - break; - } - - case BspReqInterruptSpurious_Pre_First_Entry: { - /* - * While the first loaded value of the pointer to the first interrupt - * entry of the interrupt vector specified by the ``vector`` parameter - * references an object of type rtems_interrupt_entry. - */ - *ctx->first = &ctx->entry; - break; - } - - case BspReqInterruptSpurious_Pre_First_NA: - break; - } -} - -static void BspReqInterruptSpurious_Pre_FirstAgain_Prepare( - BspReqInterruptSpurious_Context *ctx, - BspReqInterruptSpurious_Pre_FirstAgain state -) -{ - switch ( state ) { - case BspReqInterruptSpurious_Pre_FirstAgain_Null: { - /* - * While the second loaded value of the pointer to the first interrupt - * entry of the interrupt vector specified by the ``vector`` parameter is - * equal to NULL. - */ - ctx->first_again = NULL; - break; - } - - case BspReqInterruptSpurious_Pre_FirstAgain_Entry: { - /* - * While the second loaded value of the pointer to the first interrupt - * entry of the interrupt vector specified by the ``vector`` parameter - * references an object of type rtems_interrupt_entry. - */ - ctx->first_again = &ctx->entry; - break; - } - - case BspReqInterruptSpurious_Pre_FirstAgain_NA: - break; - } -} - -static void BspReqInterruptSpurious_Post_Result_Check( - BspReqInterruptSpurious_Context *ctx, - BspReqInterruptSpurious_Post_Result state -) -{ - switch ( state ) { - case BspReqInterruptSpurious_Post_Result_FatalError: { - /* - * A fatal error shall occur. - */ - T_eq_u32( ctx->entry_counter, 0 ); - T_eq_u32( ctx->fatal_counter, 1 ); - break; - } - - case BspReqInterruptSpurious_Post_Result_Dispatch: { - /* - * The interrupt entries installed at the interrupt vector specified by - * the ``vector`` parameter shall be dispatched. - */ - T_eq_u32( ctx->entry_counter, 1 ); - T_eq_u32( ctx->fatal_counter, 0 ); - break; - } - - case BspReqInterruptSpurious_Post_Result_NA: - break; - } -} - -static void BspReqInterruptSpurious_Post_FatalSource_Check( - BspReqInterruptSpurious_Context *ctx, - BspReqInterruptSpurious_Post_FatalSource state -) -{ - switch ( state ) { - case BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt: { - /* - * The fatal source shall be equal to - * RTEMS_FATAL_SOURCE_SPURIOUS_INTERRUPT. - */ - T_eq_int( ctx->fatal_source, RTEMS_FATAL_SOURCE_SPURIOUS_INTERRUPT ); - break; - } - - case BspReqInterruptSpurious_Post_FatalSource_NA: - break; - } -} - -static void BspReqInterruptSpurious_Post_FatalCode_Check( - BspReqInterruptSpurious_Context *ctx, - BspReqInterruptSpurious_Post_FatalCode state -) -{ - switch ( state ) { - case BspReqInterruptSpurious_Post_FatalCode_Vector: { - /* - * The fatal code shall be equal to the ``vector`` parameter. - */ - T_eq_ulong( ctx->fatal_code, ctx->test_vector ); - break; - } - - case BspReqInterruptSpurious_Post_FatalCode_NA: - break; - } -} - -static void BspReqInterruptSpurious_Setup( - BspReqInterruptSpurious_Context *ctx -) -{ - rtems_interrupt_attributes attr = { - .can_raise = true - }; - rtems_status_code sc; - - ctx->test_vector = GetTestableInterruptVector( &attr ); - T_assert_lt_u32( ctx->test_vector, BSP_INTERRUPT_VECTOR_COUNT ); - ctx->first = &bsp_interrupt_handler_table[ - bsp_interrupt_handler_index( ctx->test_vector ) - ]; - - sc = rtems_interrupt_get_attributes( ctx->test_vector, &attr ); - T_rsc_success( sc ); - ctx->do_clear = attr.can_clear && !attr.cleared_by_acknowledge; - - rtems_interrupt_entry_initialize( &ctx->entry, EntryRoutine, ctx, "Info" ); - test_case_active = true; - SetFatalHandler( Fatal, ctx ); -} - -static void BspReqInterruptSpurious_Setup_Wrap( void *arg ) -{ - BspReqInterruptSpurious_Context *ctx; - - ctx = arg; - ctx->Map.in_action_loop = false; - BspReqInterruptSpurious_Setup( ctx ); -} - -static void BspReqInterruptSpurious_Teardown( - BspReqInterruptSpurious_Context *ctx -) -{ - SetFatalHandler( NULL, NULL ); - test_case_active = false; -} - -static void BspReqInterruptSpurious_Teardown_Wrap( void *arg ) -{ - BspReqInterruptSpurious_Context *ctx; - - ctx = arg; - ctx->Map.in_action_loop = false; - BspReqInterruptSpurious_Teardown( ctx ); -} - -static void BspReqInterruptSpurious_Action( - BspReqInterruptSpurious_Context *ctx -) -{ - ctx->interrupt_occurred = false; - ctx->entry_counter = 0; - ctx->fatal_counter = 0; - ctx->fatal_source = RTEMS_FATAL_SOURCE_LAST; - ctx->fatal_code = UINT32_MAX; - - #if defined(RTEMS_SMP) - if ( *ctx->first == NULL && ctx->first_again != NULL ) { - *ctx->first = ctx->first_again; - bsp_interrupt_spurious( ctx->test_vector ); - } else - #endif - { - rtems_status_code sc; - - (void) rtems_interrupt_vector_enable( ctx->test_vector ); - - sc = rtems_interrupt_raise( ctx->test_vector ); - T_rsc_success( sc ); - - while ( !ctx->interrupt_occurred ) { - /* Wait */ - } - - Disable( ctx ); - } -} - -static const BspReqInterruptSpurious_Entry -BspReqInterruptSpurious_Entries[] = { - { 0, 0, 1, BspReqInterruptSpurious_Post_Result_Dispatch, - BspReqInterruptSpurious_Post_FatalSource_NA, - BspReqInterruptSpurious_Post_FatalCode_NA }, -#if defined(RTEMS_SMP) - { 0, 0, 0, BspReqInterruptSpurious_Post_Result_FatalError, - BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, - BspReqInterruptSpurious_Post_FatalCode_Vector }, -#else - { 0, 0, 1, BspReqInterruptSpurious_Post_Result_FatalError, - BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, - BspReqInterruptSpurious_Post_FatalCode_Vector }, -#endif -#if defined(RTEMS_SMP) - { 0, 0, 0, BspReqInterruptSpurious_Post_Result_Dispatch, - BspReqInterruptSpurious_Post_FatalSource_NA, - BspReqInterruptSpurious_Post_FatalCode_NA } -#else - { 0, 0, 1, BspReqInterruptSpurious_Post_Result_FatalError, - BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, - BspReqInterruptSpurious_Post_FatalCode_Vector } -#endif -}; - -static const uint8_t -BspReqInterruptSpurious_Map[] = { - 1, 2, 0, 0 -}; - -static size_t BspReqInterruptSpurious_Scope( void *arg, char *buf, size_t n ) -{ - BspReqInterruptSpurious_Context *ctx; - - ctx = arg; - - if ( ctx->Map.in_action_loop ) { - return T_get_scope( - BspReqInterruptSpurious_PreDesc, - buf, - n, - ctx->Map.pcs - ); - } - - return 0; -} - -static T_fixture BspReqInterruptSpurious_Fixture = { - .setup = BspReqInterruptSpurious_Setup_Wrap, - .stop = NULL, - .teardown = BspReqInterruptSpurious_Teardown_Wrap, - .scope = BspReqInterruptSpurious_Scope, - .initial_context = &BspReqInterruptSpurious_Instance -}; - -static inline BspReqInterruptSpurious_Entry BspReqInterruptSpurious_PopEntry( - BspReqInterruptSpurious_Context *ctx -) -{ - size_t index; - - index = ctx->Map.index; - ctx->Map.index = index + 1; - return BspReqInterruptSpurious_Entries[ - BspReqInterruptSpurious_Map[ index ] - ]; -} - -static void BspReqInterruptSpurious_SetPreConditionStates( - BspReqInterruptSpurious_Context *ctx -) -{ - ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; - - if ( ctx->Map.entry.Pre_FirstAgain_NA ) { - ctx->Map.pcs[ 1 ] = BspReqInterruptSpurious_Pre_FirstAgain_NA; - } else { - ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; - } -} - -static void BspReqInterruptSpurious_TestVariant( - BspReqInterruptSpurious_Context *ctx -) -{ - BspReqInterruptSpurious_Pre_First_Prepare( ctx, ctx->Map.pcs[ 0 ] ); - BspReqInterruptSpurious_Pre_FirstAgain_Prepare( ctx, ctx->Map.pcs[ 1 ] ); - BspReqInterruptSpurious_Action( ctx ); - BspReqInterruptSpurious_Post_Result_Check( ctx, ctx->Map.entry.Post_Result ); - BspReqInterruptSpurious_Post_FatalSource_Check( - ctx, - ctx->Map.entry.Post_FatalSource - ); - BspReqInterruptSpurious_Post_FatalCode_Check( - ctx, - ctx->Map.entry.Post_FatalCode - ); -} - -/** - * @fn void T_case_body_BspReqInterruptSpurious( void ) - */ -T_TEST_CASE_FIXTURE( - BspReqInterruptSpurious, - &BspReqInterruptSpurious_Fixture -) -{ - BspReqInterruptSpurious_Context *ctx; - - ctx = T_fixture_context(); - ctx->Map.in_action_loop = true; - ctx->Map.index = 0; - - for ( - ctx->Map.pci[ 0 ] = BspReqInterruptSpurious_Pre_First_Null; - ctx->Map.pci[ 0 ] < BspReqInterruptSpurious_Pre_First_NA; - ++ctx->Map.pci[ 0 ] - ) { - for ( - ctx->Map.pci[ 1 ] = BspReqInterruptSpurious_Pre_FirstAgain_Null; - ctx->Map.pci[ 1 ] < BspReqInterruptSpurious_Pre_FirstAgain_NA; - ++ctx->Map.pci[ 1 ] - ) { - ctx->Map.entry = BspReqInterruptSpurious_PopEntry( ctx ); - BspReqInterruptSpurious_SetPreConditionStates( ctx ); - BspReqInterruptSpurious_TestVariant( ctx ); - } - } -} - -/** @} */ diff --git a/testsuites/validation/tc-c.c b/testsuites/validation/tc-c.c index 32b55fd845..646a838609 100644 --- a/testsuites/validation/tc-c.c +++ b/testsuites/validation/tc-c.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseCValC + * @ingroup CValC */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseCValC spec:/c/val/c + * @defgroup CValC spec:/c/val/c * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests C library functions. * diff --git a/testsuites/validation/tc-cache.c b/testsuites/validation/tc-cache.c index 3e0cdf7deb..e85b9033e7 100644 --- a/testsuites/validation/tc-cache.c +++ b/testsuites/validation/tc-cache.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsCacheValCache + * @ingroup RtemsCacheValCache */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsCacheValCache spec:/rtems/cache/val/cache + * @defgroup RtemsCacheValCache spec:/rtems/cache/val/cache * - * @ingroup RTEMSTestSuiteTestsuitesValidationCache + * @ingroup TestsuitesValidationCache * * @brief Tests some @ref RTEMSAPIClassicCache directives. * diff --git a/testsuites/validation/tc-clock-get-tod.c b/testsuites/validation/tc-clock-get-tod.c index f3ff4a3830..8bf5717171 100644 --- a/testsuites/validation/tc-clock-get-tod.c +++ b/testsuites/validation/tc-clock-get-tod.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsClockReqGetTod + * @ingroup RtemsClockReqGetTod */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsClockReqGetTod spec:/rtems/clock/req/get-tod + * @defgroup RtemsClockReqGetTod spec:/rtems/clock/req/get-tod * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-clock-get-uptime.c b/testsuites/validation/tc-clock-get-uptime.c index ebc8b2de74..19608c33e6 100644 --- a/testsuites/validation/tc-clock-get-uptime.c +++ b/testsuites/validation/tc-clock-get-uptime.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsClockReqGetUptime + * @ingroup RtemsClockReqGetUptime */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsClockReqGetUptime \ - * spec:/rtems/clock/req/get-uptime + * @defgroup RtemsClockReqGetUptime spec:/rtems/clock/req/get-uptime * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-clock-nanosleep.c b/testsuites/validation/tc-clock-nanosleep.c index 45a3355384..514f5376ba 100644 --- a/testsuites/validation/tc-clock-nanosleep.c +++ b/testsuites/validation/tc-clock-nanosleep.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseCReqClockNanosleep + * @ingroup CReqClockNanosleep */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -64,9 +64,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseCReqClockNanosleep spec:/c/req/clock-nanosleep + * @defgroup CReqClockNanosleep spec:/c/req/clock-nanosleep * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -166,29 +166,29 @@ typedef struct { /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_4 scheduler_log;; + T_scheduler_log_4 scheduler_log; /** * @brief This member contains the CLOCK_REALTIME value before the * clock_nanosleep() call. */ - struct timespec now_realtime;; + struct timespec now_realtime; /** * @brief This member contains the CLOCK_MONOTONIC value before the * clock_nanosleep() call. */ - struct timespec now_monotonic;; + struct timespec now_monotonic; /** * @brief This member contains the worker task identifier. */ - rtems_id worker_id;; + rtems_id worker_id; /** * @brief This member contains the timer information of the worker task. */ - TaskTimerInfo timer_info;; + TaskTimerInfo timer_info; /** * @brief This member provides the object referenced by the ``rqtp`` @@ -430,7 +430,7 @@ static void CReqClockNanosleep_Pre_RQTp_Prepare( case CReqClockNanosleep_Pre_RQTp_Null: { /* - * While the ``rqtp parameter is equal to NULL. + * While the ``rqtp`` parameter is equal to NULL. */ ctx->rqtp = NULL; break; @@ -543,7 +543,7 @@ static void CReqClockNanosleep_Pre_RMTp_Prepare( case CReqClockNanosleep_Pre_RMTp_Null: { /* - * While the ``rmtp parameter is equal to NULL. + * While the ``rmtp`` parameter is equal to NULL. */ ctx->rmtp = NULL; break; diff --git a/testsuites/validation/tc-clock-set.c b/testsuites/validation/tc-clock-set.c index 55012dffd3..0ed631004b 100644 --- a/testsuites/validation/tc-clock-set.c +++ b/testsuites/validation/tc-clock-set.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsClockReqSet + * @ingroup RtemsClockReqSet */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsClockReqSet spec:/rtems/clock/req/set + * @defgroup RtemsClockReqSet spec:/rtems/clock/req/set * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-clock.c b/testsuites/validation/tc-clock.c index b0592c2b26..7e21e6d77c 100644 --- a/testsuites/validation/tc-clock.c +++ b/testsuites/validation/tc-clock.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsClockValClock + * @ingroup RtemsClockValClock */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,19 +60,30 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsClockValClock spec:/rtems/clock/val/clock + * @defgroup RtemsClockValClock spec:/rtems/clock/val/clock * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicClock directives. * * This test case performs the following actions: * - * - Use the rtems_clock_get_ticks_since_boot() function. + * - Use the rtems_clock_get_ticks_since_boot() directive before and after + * exactly one clock tick. * * - Check that clock tick gets incremented. * - * - Use the rtems_clock_get_ticks_per_second() function. + * - Use the rtems_clock_get_ticks_since_boot() directive before and after + * exactly one clock tick. + * + * - Check that clock tick gets incremented. + * + * - Use the rtems_clock_get_ticks_per_second() directive. + * + * - Check that rtems_clock_get_ticks_per_second() actually returns 1us / + * CONFIGURE_MICROSECONDS_PER_TICK. + * + * - Use the rtems_clock_get_ticks_per_second() directive. * * - Check that rtems_clock_get_ticks_per_second() actually returns 1us / * CONFIGURE_MICROSECONDS_PER_TICK. @@ -81,43 +92,77 @@ */ /** - * @brief Use the rtems_clock_get_ticks_since_boot() function. + * @brief Use the rtems_clock_get_ticks_since_boot() directive before and after + * exactly one clock tick. */ static void RtemsClockValClock_Action_0( void ) { rtems_interval result_0; rtems_interval result_1; - int32_t difference; /* Note: rtems_interval = uint32_t (unsigned!) */ result_0 = rtems_clock_get_ticks_since_boot(); ClockTick(); result_1 = rtems_clock_get_ticks_since_boot(); + /* - * Because of the ones-complement, the overflow - * is handled correctly. result_0 = 0xFFFFFFFF will become -1 - * and result_1 = 0x0 will become 0. + * Check that clock tick gets incremented. */ - difference = (int32_t) result_1 - (int32_t) result_0; + T_step_eq_u32( 0, result_1 - result_0, 1 ); +} + +/** + * @brief Use the rtems_clock_get_ticks_since_boot() directive before and after + * exactly one clock tick. + */ +static void RtemsClockValClock_Action_1( void ) +{ + rtems_interval result_0; + rtems_interval result_1; + + #undef rtems_clock_get_ticks_since_boot + + result_0 = rtems_clock_get_ticks_since_boot(); + ClockTick(); + result_1 = rtems_clock_get_ticks_since_boot(); /* * Check that clock tick gets incremented. */ - T_step_eq_i32( 0, difference, 1 ); + T_step_eq_u32( 1, result_1 - result_0, 1 ); } /** - * @brief Use the rtems_clock_get_ticks_per_second() function. + * @brief Use the rtems_clock_get_ticks_per_second() directive. */ -static void RtemsClockValClock_Action_1( void ) +static void RtemsClockValClock_Action_2( void ) { rtems_interval result; + + result = rtems_clock_get_ticks_per_second(); + + /* + * Check that rtems_clock_get_ticks_per_second() actually returns 1us / + * CONFIGURE_MICROSECONDS_PER_TICK. + */ + T_step_eq_u32( 2, result, 1000000UL / TEST_MICROSECONDS_PER_TICK ); +} + +/** + * @brief Use the rtems_clock_get_ticks_per_second() directive. + */ +static void RtemsClockValClock_Action_3( void ) +{ + rtems_interval result; + + #undef rtems_clock_get_ticks_per_second + result = rtems_clock_get_ticks_per_second(); /* * Check that rtems_clock_get_ticks_per_second() actually returns 1us / * CONFIGURE_MICROSECONDS_PER_TICK. */ - T_step_eq_u32( 1, result, 1000000UL / TEST_MICROSECONDS_PER_TICK ); + T_step_eq_u32( 3, result, 1000000UL / TEST_MICROSECONDS_PER_TICK ); } /** @@ -125,10 +170,12 @@ static void RtemsClockValClock_Action_1( void ) */ T_TEST_CASE( RtemsClockValClock ) { - T_plan( 2 ); + T_plan( 4 ); RtemsClockValClock_Action_0(); RtemsClockValClock_Action_1(); + RtemsClockValClock_Action_2(); + RtemsClockValClock_Action_3(); } /** @} */ diff --git a/testsuites/validation/tc-cpu-performance.c b/testsuites/validation/tc-cpu-performance.c new file mode 100644 index 0000000000..4f090e704f --- /dev/null +++ b/testsuites/validation/tc-cpu-performance.c @@ -0,0 +1,270 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreCpuValPerf + */ + +/* + * Copyright (C) 2023 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/score/cpuimpl.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreCpuValPerf spec:/score/cpu/val/perf + * + * @ingroup TestsuitesPerformanceNoClock0 + * + * @brief This test case provides a context to run CPU port performance tests. + * + * @{ + */ + +/** + * @brief Test context for spec:/score/cpu/val/perf test case. + */ +typedef struct { + /** + * @brief This member references the measure runtime context. + */ + T_measure_runtime_context *context; + + /** + * @brief This member provides the measure runtime request. + */ + T_measure_runtime_request request; + + /** + * @brief This member provides an optional measurement begin time point. + */ + T_ticks begin; + + /** + * @brief This member provides an optional measurement end time point. + */ + T_ticks end; +} ScoreCpuValPerf_Context; + +static ScoreCpuValPerf_Context + ScoreCpuValPerf_Instance; + +static void ScoreCpuValPerf_Setup_Context( ScoreCpuValPerf_Context *ctx ) +{ + T_measure_runtime_config config; + + memset( &config, 0, sizeof( config ) ); + config.sample_count = 100; + ctx->request.arg = ctx; + ctx->request.flags = T_MEASURE_RUNTIME_REPORT_SAMPLES; + ctx->context = T_measure_runtime_create( &config ); + T_assert_not_null( ctx->context ); +} + +static void ScoreCpuValPerf_Setup_Wrap( void *arg ) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = arg; + ScoreCpuValPerf_Setup_Context( ctx ); +} + +static T_fixture ScoreCpuValPerf_Fixture = { + .setup = ScoreCpuValPerf_Setup_Wrap, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &ScoreCpuValPerf_Instance +}; + +/** + * @defgroup ScoreCpuReqPerfEmpty spec:/score/cpu/req/perf-empty + * + * @{ + */ + +/** + * @brief Do nothing and just return. + */ +static void ScoreCpuReqPerfEmpty_Body( ScoreCpuValPerf_Context *ctx ) +{ + /* No code */ +} + +static void ScoreCpuReqPerfEmpty_Body_Wrap( void *arg ) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = arg; + ScoreCpuReqPerfEmpty_Body( ctx ); +} + +/** + * @brief Discard samples interrupted by a clock tick. + */ +static bool ScoreCpuReqPerfEmpty_Teardown( + ScoreCpuValPerf_Context *ctx, + T_ticks *delta, + uint32_t tic, + uint32_t toc, + unsigned int retry +) +{ + return tic == toc; +} + +static bool ScoreCpuReqPerfEmpty_Teardown_Wrap( + void *arg, + T_ticks *delta, + uint32_t tic, + uint32_t toc, + unsigned int retry +) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = arg; + return ScoreCpuReqPerfEmpty_Teardown( ctx, delta, tic, toc, retry ); +} + +/** @} */ + +/** + * @defgroup ScoreCpuReqPerfNops spec:/score/cpu/req/perf-nops + * + * @{ + */ + +/** + * @brief Execute exactly 1000 no-operation instructions. + */ +static void ScoreCpuReqPerfNops_Body( ScoreCpuValPerf_Context *ctx ) +{ + #define NOPS_10 \ + _CPU_Instruction_no_operation(); _CPU_Instruction_no_operation(); \ + _CPU_Instruction_no_operation(); _CPU_Instruction_no_operation(); \ + _CPU_Instruction_no_operation(); _CPU_Instruction_no_operation(); \ + _CPU_Instruction_no_operation(); _CPU_Instruction_no_operation(); \ + _CPU_Instruction_no_operation(); _CPU_Instruction_no_operation(); + #define NOPS_100 NOPS_10 NOPS_10 NOPS_10 NOPS_10 NOPS_10 NOPS_10 NOPS_10 \ + NOPS_10 NOPS_10 NOPS_10 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 + NOPS_100 +} + +static void ScoreCpuReqPerfNops_Body_Wrap( void *arg ) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = arg; + ScoreCpuReqPerfNops_Body( ctx ); +} + +/** + * @brief Discard samples interrupted by a clock tick. + */ +static bool ScoreCpuReqPerfNops_Teardown( + ScoreCpuValPerf_Context *ctx, + T_ticks *delta, + uint32_t tic, + uint32_t toc, + unsigned int retry +) +{ + return tic == toc; +} + +static bool ScoreCpuReqPerfNops_Teardown_Wrap( + void *arg, + T_ticks *delta, + uint32_t tic, + uint32_t toc, + unsigned int retry +) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = arg; + return ScoreCpuReqPerfNops_Teardown( ctx, delta, tic, toc, retry ); +} + +/** @} */ + +/** + * @fn void T_case_body_ScoreCpuValPerf( void ) + */ +T_TEST_CASE_FIXTURE( ScoreCpuValPerf, &ScoreCpuValPerf_Fixture ) +{ + ScoreCpuValPerf_Context *ctx; + + ctx = T_fixture_context(); + + ctx->request.name = "ScoreCpuReqPerfEmpty"; + ctx->request.setup = NULL; + ctx->request.body = ScoreCpuReqPerfEmpty_Body_Wrap; + ctx->request.teardown = ScoreCpuReqPerfEmpty_Teardown_Wrap; + T_measure_runtime( ctx->context, &ctx->request ); + + ctx->request.name = "ScoreCpuReqPerfNops"; + ctx->request.setup = NULL; + ctx->request.body = ScoreCpuReqPerfNops_Body_Wrap; + ctx->request.teardown = ScoreCpuReqPerfNops_Teardown_Wrap; + T_measure_runtime( ctx->context, &ctx->request ); +} + +/** @} */ diff --git a/testsuites/validation/tc-cpuuse.c b/testsuites/validation/tc-cpuuse.c index 0e06471ff0..f554a0b4e1 100644 --- a/testsuites/validation/tc-cpuuse.c +++ b/testsuites/validation/tc-cpuuse.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsCpuuseValCpuuse + * @ingroup RtemsCpuuseValCpuuse */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsCpuuseValCpuuse spec:/rtems/cpuuse/val/cpuuse + * @defgroup RtemsCpuuseValCpuuse spec:/rtems/cpuuse/val/cpuuse * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the CPU usage reporting and reset. * @@ -97,6 +97,21 @@ static void RtemsCpuuseValCpuuse_Action_0( void ) Thread_Control *other; Timestamp_Control cpu_usage_self; Timestamp_Control cpu_usage_other; + uint32_t idle_tasks; + uint32_t cpu_index; + + idle_tasks = 0; + + for ( cpu_index = 0; cpu_index < rtems_scheduler_get_processor_maximum(); ++cpu_index ) { + rtems_status_code sc; + rtems_id unused; + + sc = rtems_scheduler_ident_by_processor( cpu_index, &unused ); + + if ( sc == RTEMS_SUCCESSFUL ) { + ++idle_tasks; + } + } id = CreateTask( "WORK", GetSelfPriority() ); StartTask( id, Worker, NULL ); @@ -128,7 +143,7 @@ static void RtemsCpuuseValCpuuse_Action_0( void ) T_eq_i64( _Thread_Get_CPU_time_used_after_last_reset( self ), 4295 ); T_eq_i64( _Thread_Get_CPU_time_used( self ), - cpu_usage_self + 12885 + rtems_scheduler_get_processor_maximum() * 4295 + cpu_usage_self + 12885 + 4295 * idle_tasks ); T_eq_i64( _Thread_Get_CPU_time_used_after_last_reset( other ), 0 ); diff --git a/testsuites/validation/tc-dev-clock-xil-ttc.c b/testsuites/validation/tc-dev-clock-xil-ttc.c new file mode 100644 index 0000000000..70f49a4cc6 --- /dev/null +++ b/testsuites/validation/tc-dev-clock-xil-ttc.c @@ -0,0 +1,136 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevClockXilTtcValTickCatchUp + */ + +/* + * Copyright (C) 2024 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> +#include <sys/time.h> + +#include <rtems/test.h> + +/** + * @defgroup DevClockXilTtcValTickCatchUp \ + * spec:/dev/clock/xil-ttc/val/tick-catch-up + * + * @ingroup TestsuitesBspsValidationBsp0 + * + * @brief Tests some Xilinx TTC clock driver functions. + * + * This test case performs the following actions: + * + * - Synchronize with the clock tick. Disable interrupts. Busy wait three + * clock tick intervals. Enable interrupts. + * + * - Check that exactly three clock ticks happened once interrupts are + * enabled again. + * + * @{ + */ + +/** + * @brief Synchronize with the clock tick. Disable interrupts. Busy wait + * three clock tick intervals. Enable interrupts. + */ +static void DevClockXilTtcValTickCatchUp_Action_0( void ) +{ + uint32_t ns_per_tick; + uint64_t three_ticks_interval; + rtems_interrupt_level level; + rtems_interval t_0; + rtems_interval t_1; + rtems_interval t_2; + uint64_t m_0; + uint64_t m_1; + + ns_per_tick = rtems_configuration_get_nanoseconds_per_tick(); + three_ticks_interval = ( 7 * (uint64_t) nstosbt( ns_per_tick ) ) / 2; + t_0 = rtems_clock_get_ticks_since_boot(); + + /* Synchronize with clock tick */ + do { + t_1 = rtems_clock_get_ticks_since_boot(); + m_0 = (uint64_t) rtems_clock_get_monotonic_sbintime(); + } while ( t_0 == t_1 ); + + rtems_interrupt_local_disable( level ); + + do { + m_1 = (uint64_t) rtems_clock_get_monotonic_sbintime(); + } while ( m_1 - m_0 <= three_ticks_interval ); + + rtems_interrupt_local_enable( level ); + + /* + * Make sure the clock interrupt was serviced after the interrupt enable. + */ + do { + t_2 = rtems_clock_get_ticks_since_boot(); + } while ( t_1 == t_2 ); + + /* + * Check that exactly three clock ticks happened once interrupts are enabled + * again. + */ + T_step_eq_u32( 0, t_2 - t_1, 3 ); +} + +/** + * @fn void T_case_body_DevClockXilTtcValTickCatchUp( void ) + */ +T_TEST_CASE( DevClockXilTtcValTickCatchUp ) +{ + T_plan( 1 ); + + DevClockXilTtcValTickCatchUp_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/tc-dev-grlib-apbuart-inbyte-nonblocking.c b/testsuites/validation/tc-dev-grlib-apbuart-inbyte-nonblocking.c new file mode 100644 index 0000000000..b33b6f1a25 --- /dev/null +++ b/testsuites/validation/tc-dev-grlib-apbuart-inbyte-nonblocking.c @@ -0,0 +1,348 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevGrlibReqApbuartInbyteNonblocking + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> +#include <grlib/apbuart.h> + +#include <rtems/test.h> + +/** + * @defgroup DevGrlibReqApbuartInbyteNonblocking \ + * spec:/dev/grlib/req/apbuart-inbyte-nonblocking + * + * @ingroup TestsuitesBspsValidationBsp0 + * + * @{ + */ + +typedef enum { + DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_Yes, + DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_No, + DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_NA +} DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady; + +typedef enum { + DevGrlibReqApbuartInbyteNonblocking_Post_Result_Data, + DevGrlibReqApbuartInbyteNonblocking_Post_Result_MinusOne, + DevGrlibReqApbuartInbyteNonblocking_Post_Result_NA +} DevGrlibReqApbuartInbyteNonblocking_Post_Result; + +typedef enum { + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Cleared, + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_NA +} DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags; + +typedef struct { + uint8_t Skip : 1; + uint8_t Pre_DataReady_NA : 1; + uint8_t Post_Result : 2; + uint8_t Post_ErrorFlags : 1; +} DevGrlibReqApbuartInbyteNonblocking_Entry; + +/** + * @brief Test context for spec:/dev/grlib/req/apbuart-inbyte-nonblocking test + * case. + */ +typedef struct { + /** + * @brief This member provides the APBUART register block. + */ + apbuart regs; + + /** + * @brief This member contains the return value of the + * apbuart_inbyte_nonblocking() call. + */ + int result; + + struct { + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 1 ]; + + /** + * @brief If this member is true, then the test action loop is executed. + */ + bool in_action_loop; + + /** + * @brief This member contains the next transition map index. + */ + size_t index; + + /** + * @brief This member contains the current transition map entry. + */ + DevGrlibReqApbuartInbyteNonblocking_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} DevGrlibReqApbuartInbyteNonblocking_Context; + +static DevGrlibReqApbuartInbyteNonblocking_Context + DevGrlibReqApbuartInbyteNonblocking_Instance; + +static const char * const DevGrlibReqApbuartInbyteNonblocking_PreDesc_DataReady[] = { + "Yes", + "No", + "NA" +}; + +static const char * const * const DevGrlibReqApbuartInbyteNonblocking_PreDesc[] = { + DevGrlibReqApbuartInbyteNonblocking_PreDesc_DataReady, + NULL +}; + +static void DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_Prepare( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx, + DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady state +) +{ + switch ( state ) { + case DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_Yes: { + /* + * While the data ready flag is set in the status register of the + * register block specified by ``regs`` parameter. + */ + ctx->regs.status |= APBUART_STATUS_DR; + break; + } + + case DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_No: { + /* + * While the data ready flag is cleared in the status register of the + * register block specified by ``regs`` parameter. + */ + ctx->regs.status &= ~APBUART_STATUS_DR; + break; + } + + case DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_NA: + break; + } +} + +static void DevGrlibReqApbuartInbyteNonblocking_Post_Result_Check( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx, + DevGrlibReqApbuartInbyteNonblocking_Post_Result state +) +{ + switch ( state ) { + case DevGrlibReqApbuartInbyteNonblocking_Post_Result_Data: { + /* + * The return value of apbuart_inbyte_nonblocking() shall be the data + * read from the data register of the register block specified by + * ``regs``. + */ + T_eq_int( ctx->result, 0xff ); + break; + } + + case DevGrlibReqApbuartInbyteNonblocking_Post_Result_MinusOne: { + /* + * The return value of apbuart_inbyte_nonblocking() shall be minus one. + */ + T_eq_int( ctx->result, -1 ); + break; + } + + case DevGrlibReqApbuartInbyteNonblocking_Post_Result_NA: + break; + } +} + +static void DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Check( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx, + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags state +) +{ + switch ( state ) { + case DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Cleared: { + /* + * The framing error, parity error, overrun, and break received flags in + * the status register of the register block specified by ``regs`` shall + * be cleared. + */ + T_eq_u32( ctx->regs.status & 0x78, 0 ); + break; + } + + case DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_NA: + break; + } +} + +static void DevGrlibReqApbuartInbyteNonblocking_Prepare( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx +) +{ + memset( &ctx->regs, 0, sizeof( ctx->regs ) ); + ctx->regs.status = 0x78; + ctx->regs.data = 0xff; +} + +static void DevGrlibReqApbuartInbyteNonblocking_Action( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx +) +{ + ctx->result = apbuart_inbyte_nonblocking( &ctx->regs ); +} + +static const DevGrlibReqApbuartInbyteNonblocking_Entry +DevGrlibReqApbuartInbyteNonblocking_Entries[] = { + { 0, 0, DevGrlibReqApbuartInbyteNonblocking_Post_Result_Data, + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Cleared }, + { 0, 0, DevGrlibReqApbuartInbyteNonblocking_Post_Result_MinusOne, + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Cleared } +}; + +static const uint8_t +DevGrlibReqApbuartInbyteNonblocking_Map[] = { + 0, 1 +}; + +static size_t DevGrlibReqApbuartInbyteNonblocking_Scope( + void *arg, + char *buf, + size_t n +) +{ + DevGrlibReqApbuartInbyteNonblocking_Context *ctx; + + ctx = arg; + + if ( ctx->Map.in_action_loop ) { + return T_get_scope( + DevGrlibReqApbuartInbyteNonblocking_PreDesc, + buf, + n, + ctx->Map.pcs + ); + } + + return 0; +} + +static T_fixture DevGrlibReqApbuartInbyteNonblocking_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = DevGrlibReqApbuartInbyteNonblocking_Scope, + .initial_context = &DevGrlibReqApbuartInbyteNonblocking_Instance +}; + +static inline DevGrlibReqApbuartInbyteNonblocking_Entry +DevGrlibReqApbuartInbyteNonblocking_PopEntry( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return DevGrlibReqApbuartInbyteNonblocking_Entries[ + DevGrlibReqApbuartInbyteNonblocking_Map[ index ] + ]; +} + +static void DevGrlibReqApbuartInbyteNonblocking_TestVariant( + DevGrlibReqApbuartInbyteNonblocking_Context *ctx +) +{ + DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_Prepare( + ctx, + ctx->Map.pcs[ 0 ] + ); + DevGrlibReqApbuartInbyteNonblocking_Action( ctx ); + DevGrlibReqApbuartInbyteNonblocking_Post_Result_Check( + ctx, + ctx->Map.entry.Post_Result + ); + DevGrlibReqApbuartInbyteNonblocking_Post_ErrorFlags_Check( + ctx, + ctx->Map.entry.Post_ErrorFlags + ); +} + +/** + * @fn void T_case_body_DevGrlibReqApbuartInbyteNonblocking( void ) + */ +T_TEST_CASE_FIXTURE( + DevGrlibReqApbuartInbyteNonblocking, + &DevGrlibReqApbuartInbyteNonblocking_Fixture +) +{ + DevGrlibReqApbuartInbyteNonblocking_Context *ctx; + + ctx = T_fixture_context(); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pcs[ 0 ] = DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_Yes; + ctx->Map.pcs[ 0 ] < DevGrlibReqApbuartInbyteNonblocking_Pre_DataReady_NA; + ++ctx->Map.pcs[ 0 ] + ) { + ctx->Map.entry = DevGrlibReqApbuartInbyteNonblocking_PopEntry( ctx ); + DevGrlibReqApbuartInbyteNonblocking_Prepare( ctx ); + DevGrlibReqApbuartInbyteNonblocking_TestVariant( ctx ); + } +} + +/** @} */ diff --git a/testsuites/validation/tc-dev-grlib-io.c b/testsuites/validation/tc-dev-grlib-io.c new file mode 100644 index 0000000000..5bfc3fcfab --- /dev/null +++ b/testsuites/validation/tc-dev-grlib-io.c @@ -0,0 +1,295 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevGrlibValIo + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> +#include <grlib/apbuart.h> +#include <grlib/io.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup DevGrlibValIo spec:/dev/grlib/val/io + * + * @ingroup TestsuitesBspsValidationBsp0 + * + * @brief Tests some @ref RTEMSDeviceGRLIB directives. + * + * This test case performs the following actions: + * + * - Call grlib_load_8() to load a prepared value. + * + * - Check that the returned value is equal to the prepared value. + * + * - Call grlib_load_16() to load a prepared value. + * + * - Check that the returned value is equal to the prepared value. + * + * - Call grlib_load_32() to load a prepared value. + * + * - Check that the returned value is equal to the prepared value. + * + * - Call grlib_load_64() to load a prepared value. + * + * - Check that the returned value is equal to the prepared value. + * + * - Call grlib_store_8() to store a value to an object. + * + * - Check that the value of the object is equal to the stored value. + * + * - Call grlib_store_16() to store a value to an object. + * + * - Check that the value of the object is equal to the stored value. + * + * - Call grlib_store_32() to store a value to an object. + * + * - Check that the value of the object is equal to the stored value. + * + * - Call grlib_store_64() to store a value to an object. + * + * - Check that the value of the object is equal to the stored value. + * + * - Call apbuart_outbyte_polled() to store a character to the data register. + * The transmitter FIFO shall be initially non-empty. The status is checked + * by apbuart_outbyte_wait(). + * + * - Check that the transmitter FIFO empty flag was set by ApbuartIORelax(). + * + * - Check that the data register was written by apbuart_outbyte_polled(). + * + * @{ + */ + +static void ApbuartIORelax( void *arg ) +{ + apbuart *regs; + + regs = arg; + regs->status = 0x4; + T_quiet_eq_u32( regs->data, 0 ); +} + +/** + * @brief Call grlib_load_8() to load a prepared value. + */ +static void DevGrlibValIo_Action_0( void ) +{ + uint8_t reg_8; + uint8_t val_8; + + reg_8 = 0x81; + val_8 = grlib_load_8( ®_8 ); + + /* + * Check that the returned value is equal to the prepared value. + */ + T_step_eq_u8( 0, val_8, 0x81 ); +} + +/** + * @brief Call grlib_load_16() to load a prepared value. + */ +static void DevGrlibValIo_Action_1( void ) +{ + uint16_t reg_16; + uint16_t val_16; + + reg_16 = 0x8001; + val_16 = grlib_load_16( ®_16 ); + + /* + * Check that the returned value is equal to the prepared value. + */ + T_step_eq_u16( 1, val_16, 0x8001 ); +} + +/** + * @brief Call grlib_load_32() to load a prepared value. + */ +static void DevGrlibValIo_Action_2( void ) +{ + uint32_t reg_32; + uint32_t val_32; + + reg_32 = 0x80000001; + val_32 = grlib_load_32( ®_32 ); + + /* + * Check that the returned value is equal to the prepared value. + */ + T_step_eq_u32( 2, val_32, 0x80000001 ); +} + +/** + * @brief Call grlib_load_64() to load a prepared value. + */ +static void DevGrlibValIo_Action_3( void ) +{ + uint64_t reg_64; + uint64_t val_64; + + reg_64 = 0x8000000000000001; + val_64 = grlib_load_64( ®_64 ); + + /* + * Check that the returned value is equal to the prepared value. + */ + T_step_eq_u64( 3, val_64, 0x8000000000000001 ); +} + +/** + * @brief Call grlib_store_8() to store a value to an object. + */ +static void DevGrlibValIo_Action_4( void ) +{ + uint8_t reg_8; + + grlib_store_8( ®_8, 0x81 ); + + /* + * Check that the value of the object is equal to the stored value. + */ + T_step_eq_u8( 4, reg_8, 0x81 ); +} + +/** + * @brief Call grlib_store_16() to store a value to an object. + */ +static void DevGrlibValIo_Action_5( void ) +{ + uint16_t reg_16; + + grlib_store_16( ®_16, 0x8001 ); + + /* + * Check that the value of the object is equal to the stored value. + */ + T_step_eq_u16( 5, reg_16, 0x8001 ); +} + +/** + * @brief Call grlib_store_32() to store a value to an object. + */ +static void DevGrlibValIo_Action_6( void ) +{ + uint32_t reg_32; + + grlib_store_32( ®_32, 0x80000001 ); + + /* + * Check that the value of the object is equal to the stored value. + */ + T_step_eq_u32( 6, reg_32, 0x80000001 ); +} + +/** + * @brief Call grlib_store_64() to store a value to an object. + */ +static void DevGrlibValIo_Action_7( void ) +{ + uint64_t reg_64; + + grlib_store_64( ®_64, 0x8000000000000001 ); + + /* + * Check that the value of the object is equal to the stored value. + */ + T_step_eq_u64( 7, reg_64, 0x8000000000000001 ); +} + +/** + * @brief Call apbuart_outbyte_polled() to store a character to the data + * register. The transmitter FIFO shall be initially non-empty. The status + * is checked by apbuart_outbyte_wait(). + */ +static void DevGrlibValIo_Action_8( void ) +{ + apbuart regs; + + memset( ®s, 0, sizeof( regs ) ); + SetIORelaxHandler( ApbuartIORelax, ®s ); + apbuart_outbyte_polled( ®s, (char) 0xff ); + SetIORelaxHandler( NULL, NULL ); + + /* + * Check that the transmitter FIFO empty flag was set by ApbuartIORelax(). + */ + T_step_eq_u32( 8, regs.status, APBUART_STATUS_TE ); + + /* + * Check that the data register was written by apbuart_outbyte_polled(). + */ + T_step_eq_u32( 9, regs.data, 0xff ); +} + +/** + * @fn void T_case_body_DevGrlibValIo( void ) + */ +T_TEST_CASE( DevGrlibValIo ) +{ + T_plan( 10 ); + + DevGrlibValIo_Action_0(); + DevGrlibValIo_Action_1(); + DevGrlibValIo_Action_2(); + DevGrlibValIo_Action_3(); + DevGrlibValIo_Action_4(); + DevGrlibValIo_Action_5(); + DevGrlibValIo_Action_6(); + DevGrlibValIo_Action_7(); + DevGrlibValIo_Action_8(); +} + +/** @} */ diff --git a/testsuites/validation/tc-dev-grlib-irqamp-get-timestamp.c b/testsuites/validation/tc-dev-grlib-irqamp-get-timestamp.c new file mode 100644 index 0000000000..a064c479b9 --- /dev/null +++ b/testsuites/validation/tc-dev-grlib-irqamp-get-timestamp.c @@ -0,0 +1,304 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup DevGrlibReqIrqampGetTimestamp + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <grlib/irqamp.h> + +#include <rtems/test.h> + +/** + * @defgroup DevGrlibReqIrqampGetTimestamp \ + * spec:/dev/grlib/req/irqamp-get-timestamp + * + * @ingroup TestsuitesBspsValidationBsp0 + * + * @{ + */ + +typedef enum { + DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Zero, + DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Positive, + DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_NA +} DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets; + +typedef enum { + DevGrlibReqIrqampGetTimestamp_Post_Result_Registers, + DevGrlibReqIrqampGetTimestamp_Post_Result_Null, + DevGrlibReqIrqampGetTimestamp_Post_Result_NA +} DevGrlibReqIrqampGetTimestamp_Post_Result; + +typedef struct { + uint8_t Skip : 1; + uint8_t Pre_NumberOfTimestampRegisterSets_NA : 1; + uint8_t Post_Result : 2; +} DevGrlibReqIrqampGetTimestamp_Entry; + +/** + * @brief Test context for spec:/dev/grlib/req/irqamp-get-timestamp test case. + */ +typedef struct { + /** + * @brief This member contains the return value of the + * irqamp_get_timestamp_registers() call. + */ + irqamp_timestamp *result; + + /** + * @brief This member contains the IRQ(A)MP register block. + */ + irqamp irqamp_regs; + + struct { + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 1 ]; + + /** + * @brief If this member is true, then the test action loop is executed. + */ + bool in_action_loop; + + /** + * @brief This member contains the next transition map index. + */ + size_t index; + + /** + * @brief This member contains the current transition map entry. + */ + DevGrlibReqIrqampGetTimestamp_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} DevGrlibReqIrqampGetTimestamp_Context; + +static DevGrlibReqIrqampGetTimestamp_Context + DevGrlibReqIrqampGetTimestamp_Instance; + +static const char * const DevGrlibReqIrqampGetTimestamp_PreDesc_NumberOfTimestampRegisterSets[] = { + "Zero", + "Positive", + "NA" +}; + +static const char * const * const DevGrlibReqIrqampGetTimestamp_PreDesc[] = { + DevGrlibReqIrqampGetTimestamp_PreDesc_NumberOfTimestampRegisterSets, + NULL +}; + +static void +DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Prepare( + DevGrlibReqIrqampGetTimestamp_Context *ctx, + DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets state +) +{ + switch ( state ) { + case DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Zero: { + /* + * While the number of timestamp register sets indicated by the IRQ(A)MP + * register block specified by the ``irqamp_regs`` parameter is zero. + */ + ctx->irqamp_regs.itstmp[ 0 ].itstmpc = 0; + break; + } + + case DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Positive: { + /* + * While the number of timestamp register sets indicated by the IRQ(A)MP + * register block specified by the ``irqamp_regs`` parameter is positive. + */ + ctx->irqamp_regs.itstmp[ 0 ].itstmpc = IRQAMP_ITSTMPC_TSTAMP( 1 ); + break; + } + + case DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_NA: + break; + } +} + +static void DevGrlibReqIrqampGetTimestamp_Post_Result_Check( + DevGrlibReqIrqampGetTimestamp_Context *ctx, + DevGrlibReqIrqampGetTimestamp_Post_Result state +) +{ + switch ( state ) { + case DevGrlibReqIrqampGetTimestamp_Post_Result_Registers: { + /* + * The return value of irqamp_get_timestamp_registers() shall be address + * of the timestamping register block contained in the IRQ(A)MP register + * block specified by the ``irqamp_regs`` parameter. + */ + T_not_null( ctx->result ); + break; + } + + case DevGrlibReqIrqampGetTimestamp_Post_Result_Null: { + /* + * The return value of irqamp_get_timestamp_registers() shall be false. + */ + T_null( ctx->result ); + break; + } + + case DevGrlibReqIrqampGetTimestamp_Post_Result_NA: + break; + } +} + +static void DevGrlibReqIrqampGetTimestamp_Action( + DevGrlibReqIrqampGetTimestamp_Context *ctx +) +{ + ctx->result = irqamp_get_timestamp_registers( &ctx->irqamp_regs ); +} + +static const DevGrlibReqIrqampGetTimestamp_Entry +DevGrlibReqIrqampGetTimestamp_Entries[] = { + { 0, 0, DevGrlibReqIrqampGetTimestamp_Post_Result_Null }, + { 0, 0, DevGrlibReqIrqampGetTimestamp_Post_Result_Registers } +}; + +static const uint8_t +DevGrlibReqIrqampGetTimestamp_Map[] = { + 0, 1 +}; + +static size_t DevGrlibReqIrqampGetTimestamp_Scope( + void *arg, + char *buf, + size_t n +) +{ + DevGrlibReqIrqampGetTimestamp_Context *ctx; + + ctx = arg; + + if ( ctx->Map.in_action_loop ) { + return T_get_scope( + DevGrlibReqIrqampGetTimestamp_PreDesc, + buf, + n, + ctx->Map.pcs + ); + } + + return 0; +} + +static T_fixture DevGrlibReqIrqampGetTimestamp_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = DevGrlibReqIrqampGetTimestamp_Scope, + .initial_context = &DevGrlibReqIrqampGetTimestamp_Instance +}; + +static inline DevGrlibReqIrqampGetTimestamp_Entry +DevGrlibReqIrqampGetTimestamp_PopEntry( + DevGrlibReqIrqampGetTimestamp_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return DevGrlibReqIrqampGetTimestamp_Entries[ + DevGrlibReqIrqampGetTimestamp_Map[ index ] + ]; +} + +static void DevGrlibReqIrqampGetTimestamp_TestVariant( + DevGrlibReqIrqampGetTimestamp_Context *ctx +) +{ + DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Prepare( + ctx, + ctx->Map.pcs[ 0 ] + ); + DevGrlibReqIrqampGetTimestamp_Action( ctx ); + DevGrlibReqIrqampGetTimestamp_Post_Result_Check( + ctx, + ctx->Map.entry.Post_Result + ); +} + +/** + * @fn void T_case_body_DevGrlibReqIrqampGetTimestamp( void ) + */ +T_TEST_CASE_FIXTURE( + DevGrlibReqIrqampGetTimestamp, + &DevGrlibReqIrqampGetTimestamp_Fixture +) +{ + DevGrlibReqIrqampGetTimestamp_Context *ctx; + + ctx = T_fixture_context(); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pcs[ 0 ] = DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_Zero; + ctx->Map.pcs[ 0 ] < DevGrlibReqIrqampGetTimestamp_Pre_NumberOfTimestampRegisterSets_NA; + ++ctx->Map.pcs[ 0 ] + ) { + ctx->Map.entry = DevGrlibReqIrqampGetTimestamp_PopEntry( ctx ); + DevGrlibReqIrqampGetTimestamp_TestVariant( ctx ); + } +} + +/** @} */ diff --git a/testsuites/validation/tc-event-performance.c b/testsuites/validation/tc-event-performance.c index 1baefecea5..9cf71e92f5 100644 --- a/testsuites/validation/tc-event-performance.c +++ b/testsuites/validation/tc-event-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventValPerf + * @ingroup RtemsEventValPerf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsEventValPerf spec:/rtems/event/val/perf + * @defgroup RtemsEventValPerf spec:/rtems/event/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicEvent * performance tests. @@ -107,12 +107,11 @@ typedef struct { static RtemsEventValPerf_Context RtemsEventValPerf_Instance; -typedef RtemsEventValPerf_Context Context; +#define EVENT_END RTEMS_EVENT_0 + +#define EVENT_OTHER RTEMS_EVENT_1 -typedef enum { - EVENT_END = RTEMS_EVENT_0, - EVENT_OTHER = RTEMS_EVENT_1 -} Event; +typedef RtemsEventValPerf_Context Context; static void Send( const Context *ctx, rtems_event_set events ) { @@ -211,6 +210,12 @@ static T_fixture RtemsEventValPerf_Fixture = { }; /** + * @defgroup RtemsEventReqPerfIsrPreempt spec:/rtems/event/req/perf-isr-preempt + * + * @{ + */ + +/** * @brief Send two events from with interrupt context. Satisfy the event * condition. */ @@ -260,6 +265,14 @@ static bool RtemsEventReqPerfIsrPreempt_Teardown_Wrap( return RtemsEventReqPerfIsrPreempt_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsEventReqPerfOther spec:/rtems/event/req/perf-other + * + * @{ + */ + /** * @brief Lower the worker priority. */ @@ -325,8 +338,16 @@ static bool RtemsEventReqPerfOther_Teardown_Wrap( return RtemsEventReqPerfOther_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsEventReqPerfOtherCpu spec:/rtems/event/req/perf-other-cpu + * + * @{ + */ + +/** * @brief Move worker to scheduler B. */ static void RtemsEventReqPerfOtherCpu_Prepare( RtemsEventValPerf_Context *ctx ) @@ -392,9 +413,18 @@ static void RtemsEventReqPerfOtherCpu_Cleanup( RtemsEventValPerf_Context *ctx ) { SetScheduler( ctx->worker_id, SCHEDULER_A_ID, PRIO_HIGH ); } + +/** @} */ #endif /** + * @defgroup RtemsEventReqPerfOtherNotSatisfied \ + * spec:/rtems/event/req/perf-other-not-satisfied + * + * @{ + */ + +/** * @brief Send an event. Do not satisfy the event condition. */ static void RtemsEventReqPerfOtherNotSatisfied_Body( @@ -451,6 +481,15 @@ static bool RtemsEventReqPerfOtherNotSatisfied_Teardown_Wrap( ); } +/** @} */ + +/** + * @defgroup RtemsEventReqPerfOtherPreempt \ + * spec:/rtems/event/req/perf-other-preempt + * + * @{ + */ + /** * @brief Send two events. Satisfy the event condition. */ @@ -503,6 +542,8 @@ static bool RtemsEventReqPerfOtherPreempt_Teardown_Wrap( return RtemsEventReqPerfOtherPreempt_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + /** * @fn void T_case_body_RtemsEventValPerf( void ) */ diff --git a/testsuites/validation/tc-event-send-receive.c b/testsuites/validation/tc-event-send-receive.c index 7db58bedcd..54a527cbaa 100644 --- a/testsuites/validation/tc-event-send-receive.c +++ b/testsuites/validation/tc-event-send-receive.c @@ -3,12 +3,12 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventValSendReceive - * @ingroup RTEMSTestCaseRtemsEventValSystemSendReceive + * @ingroup RtemsEventValSendReceive + * @ingroup RtemsEventValSystemSendReceive */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,17 +63,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsEventValSendReceive \ - * spec:/rtems/event/val/send-receive + * @defgroup RtemsEventValSendReceive spec:/rtems/event/val/send-receive * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 * * @brief Tests the rtems_event_send() and rtems_event_receive() directives. * * This test case performs the following actions: * * - Run the event send and receive tests for the application event set defined - * by /rtems/event/req/send-receive. + * by spec:/rtems/event/req/send-receive. * * @{ */ @@ -106,7 +105,7 @@ static rtems_event_set GetPendingEvents( Thread_Control *thread ) /** * @brief Run the event send and receive tests for the application event set - * defined by /rtems/event/req/send-receive. + * defined by spec:/rtems/event/req/send-receive. */ static void RtemsEventValSendReceive_Action_0( void ) { @@ -130,10 +129,10 @@ T_TEST_CASE( RtemsEventValSendReceive ) /** @} */ /** - * @defgroup RTEMSTestCaseRtemsEventValSystemSendReceive \ + * @defgroup RtemsEventValSystemSendReceive \ * spec:/rtems/event/val/system-send-receive * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 * * @brief Tests the rtems_event_system_send() and rtems_event_system_receive() * directives. @@ -141,7 +140,7 @@ T_TEST_CASE( RtemsEventValSendReceive ) * This test case performs the following actions: * * - Run the event send and receive tests for the system event set defined by - * /rtems/event/req/send-receive. + * spec:/rtems/event/req/send-receive. * * @{ */ @@ -179,7 +178,7 @@ static rtems_event_set GetPendingSystemEvents( Thread_Control *thread ) /** * @brief Run the event send and receive tests for the system event set defined - * by /rtems/event/req/send-receive. + * by spec:/rtems/event/req/send-receive. */ static void RtemsEventValSystemSendReceive_Action_0( void ) { diff --git a/testsuites/validation/tc-events.c b/testsuites/validation/tc-events.c index 54df2f7ceb..e7d009fe8a 100644 --- a/testsuites/validation/tc-events.c +++ b/testsuites/validation/tc-events.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventValEvents + * @ingroup RtemsEventValEvents */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsEventValEvents spec:/rtems/event/val/events + * @defgroup RtemsEventValEvents spec:/rtems/event/val/events * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the Event Manager API. * diff --git a/testsuites/validation/tc-flsl.c b/testsuites/validation/tc-flsl.c index fef1f2bae1..95f0ed9ccf 100644 --- a/testsuites/validation/tc-flsl.c +++ b/testsuites/validation/tc-flsl.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseCReqFlsl + * @ingroup CReqFlsl */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseCReqFlsl spec:/c/req/flsl + * @defgroup CReqFlsl spec:/c/req/flsl * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-futex-wait.c b/testsuites/validation/tc-futex-wait.c index 396b26525f..3730df2a40 100644 --- a/testsuites/validation/tc-futex-wait.c +++ b/testsuites/validation/tc-futex-wait.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseNewlibReqFutexWait + * @ingroup NewlibReqFutexWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseNewlibReqFutexWait spec:/newlib/req/futex-wait + * @defgroup NewlibReqFutexWait spec:/newlib/req/futex-wait * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -101,7 +101,7 @@ typedef struct { /** * @brief This member contains the thread queue test context. */ - TQContext tq_ctx;; + TQContext tq_ctx; /** * @brief This member specifies the expected futex state value. diff --git a/testsuites/validation/tc-futex-wake.c b/testsuites/validation/tc-futex-wake.c index 1d996d1d2b..baaa0daa6b 100644 --- a/testsuites/validation/tc-futex-wake.c +++ b/testsuites/validation/tc-futex-wake.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseNewlibReqFutexWake + * @ingroup NewlibReqFutexWake */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,17 +62,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseNewlibReqFutexWake spec:/newlib/req/futex-wake + * @defgroup NewlibReqFutexWake spec:/newlib/req/futex-wake * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ typedef enum { - NewlibReqFutexWake_Pre_Count_Negative, - NewlibReqFutexWake_Pre_Count_Partial, - NewlibReqFutexWake_Pre_Count_All, + NewlibReqFutexWake_Pre_Count_NegativeOrZero, + NewlibReqFutexWake_Pre_Count_Positive, NewlibReqFutexWake_Pre_Count_NA } NewlibReqFutexWake_Pre_Count; @@ -83,8 +82,7 @@ typedef enum { typedef enum { NewlibReqFutexWake_Post_Flush_No, - NewlibReqFutexWake_Post_Flush_Partial, - NewlibReqFutexWake_Post_Flush_All, + NewlibReqFutexWake_Post_Flush_Yes, NewlibReqFutexWake_Post_Flush_NA } NewlibReqFutexWake_Post_Flush; @@ -102,7 +100,7 @@ typedef struct { /** * @brief This member contains the thread queue test context. */ - TQContext tq_ctx;; + TQContext tq_ctx; /** * @brief This member provides the futex object. @@ -147,9 +145,8 @@ static NewlibReqFutexWake_Context NewlibReqFutexWake_Instance; static const char * const NewlibReqFutexWake_PreDesc_Count[] = { - "Negative", - "Partial", - "All", + "NegativeOrZero", + "Positive", "NA" }; @@ -185,20 +182,22 @@ static Status_Control Enqueue( TQContext *tq_ctx, TQWait wait ) return STATUS_BUILD( 0, eno ); } -static void Flush( TQContext *tq_ctx ) +static uint32_t Flush( TQContext *tq_ctx, uint32_t thread_count, bool all ) { Context *ctx; int count; - int how_many; + + (void) thread_count; ctx = ToContext( tq_ctx ); - how_many = (int) ctx->tq_ctx.how_many; - count = _Futex_Wake( &ctx->futex, 1 ); - T_eq_int( count, how_many > 0 ? 1 : 0 ); + if ( all ) { + count = _Futex_Wake( &ctx->futex, INT_MAX ); + } else { + count = _Futex_Wake( &ctx->futex, 1 ); + } - count = _Futex_Wake( &ctx->futex, INT_MAX ); - T_eq_int( count, how_many > 1 ? how_many - 1 : 0 ); + return (uint32_t) count; } static void NewlibReqFutexWake_Pre_Count_Prepare( @@ -207,29 +206,17 @@ static void NewlibReqFutexWake_Pre_Count_Prepare( ) { switch ( state ) { - case NewlibReqFutexWake_Pre_Count_Negative: { + case NewlibReqFutexWake_Pre_Count_NegativeOrZero: { /* - * While the ``count`` parameter is less than zero. + * While the ``count`` parameter is less or equal to than zero. */ /* This state is prepared by Enqueue() */ break; } - case NewlibReqFutexWake_Pre_Count_Partial: { - /* - * While the ``count`` parameter is greater than or equal to zero, while - * the ``count`` parameter is less than the count of threads enqueued on - * the thread queue of the futex object. - */ - /* This state is prepared by Flush() */ - break; - } - - case NewlibReqFutexWake_Pre_Count_All: { + case NewlibReqFutexWake_Pre_Count_Positive: { /* - * While the ``count`` parameter is greater than or equal to zero, while - * the ``count`` parameter is greater than or equal to the count of - * threads enqueued on the thread queue of the futex object. + * While the ``count`` parameter is greater than zero. */ /* This state is prepared by Flush() */ break; @@ -275,21 +262,12 @@ static void NewlibReqFutexWake_Post_Flush_Check( break; } - case NewlibReqFutexWake_Post_Flush_Partial: { + case NewlibReqFutexWake_Post_Flush_Yes: { /* * The first count threads specified by the ``count`` parameter shall be * extracted from the thread queue of the futex object in FIFO order. */ - /* This state is checked by Flush() */ - break; - } - - case NewlibReqFutexWake_Post_Flush_All: { - /* - * All threads shall be extracted from the thread queue of the futex - * object in FIFO order. - */ - ScoreTqReqFlushFifo_Run( &ctx->tq_ctx ); + ScoreTqReqFlushFifo_Run( &ctx->tq_ctx, true ); break; } @@ -355,14 +333,12 @@ NewlibReqFutexWake_Entries[] = { { 0, 0, NewlibReqFutexWake_Post_Result_Count, NewlibReqFutexWake_Post_Flush_No }, { 0, 0, NewlibReqFutexWake_Post_Result_Count, - NewlibReqFutexWake_Post_Flush_Partial }, - { 0, 0, NewlibReqFutexWake_Post_Result_Count, - NewlibReqFutexWake_Post_Flush_All } + NewlibReqFutexWake_Post_Flush_Yes } }; static const uint8_t NewlibReqFutexWake_Map[] = { - 0, 1, 2 + 0, 1 }; static size_t NewlibReqFutexWake_Scope( void *arg, char *buf, size_t n ) @@ -419,7 +395,7 @@ T_TEST_CASE_FIXTURE( NewlibReqFutexWake, &NewlibReqFutexWake_Fixture ) ctx->Map.index = 0; for ( - ctx->Map.pcs[ 0 ] = NewlibReqFutexWake_Pre_Count_Negative; + ctx->Map.pcs[ 0 ] = NewlibReqFutexWake_Pre_Count_NegativeOrZero; ctx->Map.pcs[ 0 ] < NewlibReqFutexWake_Pre_Count_NA; ++ctx->Map.pcs[ 0 ] ) { diff --git a/testsuites/validation/tc-intr-clear.c b/testsuites/validation/tc-intr-clear.c index 1c6c451a39..b131b738fd 100644 --- a/testsuites/validation/tc-intr-clear.c +++ b/testsuites/validation/tc-intr-clear.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqClear + * @ingroup RtemsIntrReqClear */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqClear spec:/rtems/intr/req/clear + * @defgroup RtemsIntrReqClear spec:/rtems/intr/req/clear * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ diff --git a/testsuites/validation/tc-intr-entry-install.c b/testsuites/validation/tc-intr-entry-install.c index 714486772a..58c7989dbe 100644 --- a/testsuites/validation/tc-intr-entry-install.c +++ b/testsuites/validation/tc-intr-entry-install.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqEntryInstall + * @ingroup RtemsIntrReqEntryInstall */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqEntryInstall \ - * spec:/rtems/intr/req/entry-install + * @defgroup RtemsIntrReqEntryInstall spec:/rtems/intr/req/entry-install * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -181,7 +180,7 @@ typedef struct { /** * @brief This member provides a counter snapshot for each entry. */ - uint32_t counter_by_entry[ 3 ];; + uint32_t counter_by_entry[ 3 ]; /** * @brief This member provides the vector number of a testable interrupt @@ -190,6 +189,12 @@ typedef struct { rtems_vector_number test_vector; /** + * @brief If this member is true, then the testable interrupt vector was + * enabled at the test case begin. + */ + bool test_vector_was_enabled; + + /** * @brief This member provides the attributes of the testable interrupt * vector. */ @@ -267,7 +272,7 @@ typedef struct { /** * @brief This member specifies if the ``entry`` parameter value. */ - rtems_interrupt_entry *entry;; + rtems_interrupt_entry *entry; /** * @brief This member contains the return value of the @@ -426,11 +431,8 @@ static void Routine( Context *ctx, uint32_t counter ) ctx->handler_counter = counter; - if ( - ctx->attributes.can_clear && - !ctx->attributes.cleared_by_acknowledge - ) { - sc = rtems_interrupt_clear( ctx->test_vector ); + if ( !ctx->attributes.cleared_by_acknowledge ) { + sc = ClearSoftwareInterrupt( ctx->test_vector ); T_rsc_success( sc ); } @@ -517,7 +519,7 @@ static void Action( void *arg ) T_rsc_success( sc ); bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized ); @@ -528,7 +530,7 @@ static void Action( void *arg ) ); bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized_during_setup ); @@ -539,7 +541,7 @@ static void Action( void *arg ) T_rsc_success( sc ); if ( ctx->status == RTEMS_SUCCESSFUL ) { - sc = rtems_interrupt_raise( ctx->test_vector ); + sc = RaiseSoftwareInterrupt( ctx->test_vector ); T_rsc_success( sc ); } } @@ -1120,6 +1122,11 @@ static void RtemsIntrReqEntryInstall_Setup( ctx->initialized_during_setup = bsp_interrupt_is_initialized(); ctx->test_vector = GetTestableInterruptVector( &required ); + ctx->test_vector_was_enabled = false; + (void) rtems_interrupt_vector_is_enabled( + ctx->test_vector, + &ctx->test_vector_was_enabled + ); sc = rtems_interrupt_get_attributes( ctx->test_vector, &ctx->attributes ); T_rsc_success( sc ); } @@ -1133,6 +1140,24 @@ static void RtemsIntrReqEntryInstall_Setup_Wrap( void *arg ) RtemsIntrReqEntryInstall_Setup( ctx ); } +static void RtemsIntrReqEntryInstall_Teardown( + RtemsIntrReqEntryInstall_Context *ctx +) +{ + if ( ctx->test_vector_was_enabled ) { + (void) rtems_interrupt_vector_enable( ctx->test_vector ); + } +} + +static void RtemsIntrReqEntryInstall_Teardown_Wrap( void *arg ) +{ + RtemsIntrReqEntryInstall_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + RtemsIntrReqEntryInstall_Teardown( ctx ); +} + static void RtemsIntrReqEntryInstall_Prepare( RtemsIntrReqEntryInstall_Context *ctx ) @@ -1320,7 +1345,7 @@ static size_t RtemsIntrReqEntryInstall_Scope( void *arg, char *buf, size_t n ) static T_fixture RtemsIntrReqEntryInstall_Fixture = { .setup = RtemsIntrReqEntryInstall_Setup_Wrap, .stop = NULL, - .teardown = NULL, + .teardown = RtemsIntrReqEntryInstall_Teardown_Wrap, .scope = RtemsIntrReqEntryInstall_Scope, .initial_context = &RtemsIntrReqEntryInstall_Instance }; diff --git a/testsuites/validation/tc-intr-entry-remove.c b/testsuites/validation/tc-intr-entry-remove.c index c73bcbb3fc..01a72410e1 100644 --- a/testsuites/validation/tc-intr-entry-remove.c +++ b/testsuites/validation/tc-intr-entry-remove.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqEntryRemove + * @ingroup RtemsIntrReqEntryRemove */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqEntryRemove \ - * spec:/rtems/intr/req/entry-remove + * @defgroup RtemsIntrReqEntryRemove spec:/rtems/intr/req/entry-remove * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -182,7 +181,7 @@ typedef struct { /** * @brief This member provides a counter incremented by EntryRoutine(). */ - uint32_t entry_counter;; + uint32_t entry_counter; /** * @brief This member provides another rtems_interrupt_entry object. @@ -234,6 +233,12 @@ typedef struct { rtems_vector_number test_vector; /** + * @brief If this member is true, then the testable interrupt vector was + * enabled at the test case begin. + */ + bool test_vector_was_enabled; + + /** * @brief This member provides the attributes of the testable interrupt * vector. */ @@ -280,7 +285,7 @@ typedef struct { /** * @brief This member specifies if the ``entry`` parameter value. */ - rtems_interrupt_entry *entry;; + rtems_interrupt_entry *entry; /** * @brief This member contains the return value of the @@ -473,14 +478,14 @@ static void Action( void *arg ) T_rsc_success( sc ); bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized ); ctx->status = rtems_interrupt_entry_remove( ctx->vector, ctx->entry ); bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized_during_setup ); @@ -1034,8 +1039,8 @@ static void RtemsIntrReqEntryRemove_Post_Installed_Check( } else { rtems_interrupt_entry *first; - first = bsp_interrupt_handler_table[ - bsp_interrupt_handler_index( ctx->test_vector ) + first = bsp_interrupt_dispatch_table[ + bsp_interrupt_dispatch_index( ctx->test_vector ) ]; T_null( first ); } @@ -1088,6 +1093,11 @@ static void RtemsIntrReqEntryRemove_Setup( ctx->initialized_during_setup = bsp_interrupt_is_initialized(); ctx->test_vector = GetTestableInterruptVector( NULL ); + ctx->test_vector_was_enabled = false; + (void) rtems_interrupt_vector_is_enabled( + ctx->test_vector, + &ctx->test_vector_was_enabled + ); sc = rtems_interrupt_get_attributes( ctx->test_vector, &ctx->attributes ); T_rsc_success( sc ); } @@ -1101,6 +1111,24 @@ static void RtemsIntrReqEntryRemove_Setup_Wrap( void *arg ) RtemsIntrReqEntryRemove_Setup( ctx ); } +static void RtemsIntrReqEntryRemove_Teardown( + RtemsIntrReqEntryRemove_Context *ctx +) +{ + if ( ctx->test_vector_was_enabled ) { + (void) rtems_interrupt_vector_enable( ctx->test_vector ); + } +} + +static void RtemsIntrReqEntryRemove_Teardown_Wrap( void *arg ) +{ + RtemsIntrReqEntryRemove_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + RtemsIntrReqEntryRemove_Teardown( ctx ); +} + static void RtemsIntrReqEntryRemove_Prepare( RtemsIntrReqEntryRemove_Context *ctx ) @@ -1292,7 +1320,7 @@ static size_t RtemsIntrReqEntryRemove_Scope( void *arg, char *buf, size_t n ) static T_fixture RtemsIntrReqEntryRemove_Fixture = { .setup = RtemsIntrReqEntryRemove_Setup_Wrap, .stop = NULL, - .teardown = NULL, + .teardown = RtemsIntrReqEntryRemove_Teardown_Wrap, .scope = RtemsIntrReqEntryRemove_Scope, .initial_context = &RtemsIntrReqEntryRemove_Instance }; diff --git a/testsuites/validation/tc-intr-get-affinity.c b/testsuites/validation/tc-intr-get-affinity.c index 277cb790a3..60509203b4 100644 --- a/testsuites/validation/tc-intr-get-affinity.c +++ b/testsuites/validation/tc-intr-get-affinity.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqGetAffinity + * @ingroup RtemsIntrReqGetAffinity */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqGetAffinity \ - * spec:/rtems/intr/req/get-affinity + * @defgroup RtemsIntrReqGetAffinity spec:/rtems/intr/req/get-affinity * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -139,7 +138,7 @@ typedef struct { * @brief This member provides the object referenced by the ``affinity`` * parameter. */ - cpu_set_t cpuset_obj[ 2 ];; + cpu_set_t cpuset_obj[ 2 ]; /** * @brief This member contains the return value of the @@ -244,6 +243,9 @@ static void CheckGetAffinity( rtems_status_code sc; cpu_set_t set[ 2 ]; + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Warray-bounds" + if ( attr->can_get_affinity ) { CPU_ZERO_S( sizeof( ctx->cpuset_obj ), ctx->cpuset_obj ); } else { @@ -265,6 +267,8 @@ static void CheckGetAffinity( T_rsc( sc, RTEMS_UNSATISFIED ); T_true( CPU_EQUAL_S( sizeof( set ), ctx->cpuset_obj, set ) ); } + + #pragma GCC diagnostic pop } static void RtemsIntrReqGetAffinity_Pre_Vector_Prepare( @@ -565,6 +569,9 @@ static void RtemsIntrReqGetAffinity_Action( ctx->vector = BSP_INTERRUPT_VECTOR_COUNT; } + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Warray-bounds" + CPU_FILL_S( sizeof( ctx->cpuset_obj ), ctx->cpuset_obj ); ctx->status = rtems_interrupt_get_affinity( @@ -583,6 +590,8 @@ static void RtemsIntrReqGetAffinity_Action( } T_true( CPU_EQUAL_S( sizeof( set ), ctx->cpuset_obj, set ) ); + + #pragma GCC diagnostic pop } } diff --git a/testsuites/validation/tc-intr-get-attributes.c b/testsuites/validation/tc-intr-get-attributes.c index 713defaa1a..4594c78a2e 100644 --- a/testsuites/validation/tc-intr-get-attributes.c +++ b/testsuites/validation/tc-intr-get-attributes.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqGetAttributes + * @ingroup RtemsIntrReqGetAttributes */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqGetAttributes \ - * spec:/rtems/intr/req/get-attributes + * @defgroup RtemsIntrReqGetAttributes spec:/rtems/intr/req/get-attributes * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -119,7 +118,7 @@ typedef struct { /** * @brief This member specifies if the ``attributes`` parameter value. */ - rtems_interrupt_attributes *attributes;; + rtems_interrupt_attributes *attributes; /** * @brief This member contains the return value of the diff --git a/testsuites/validation/tc-intr-handler-iterate.c b/testsuites/validation/tc-intr-handler-iterate.c index 77b9b2b7d7..fc3f498838 100644 --- a/testsuites/validation/tc-intr-handler-iterate.c +++ b/testsuites/validation/tc-intr-handler-iterate.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqHandlerIterate + * @ingroup RtemsIntrReqHandlerIterate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqHandlerIterate \ - * spec:/rtems/intr/req/handler-iterate + * @defgroup RtemsIntrReqHandlerIterate spec:/rtems/intr/req/handler-iterate * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -134,6 +133,12 @@ typedef struct { rtems_vector_number test_vector; /** + * @brief If this member is true, then the testable interrupt vector was + * enabled at the test case begin. + */ + bool test_vector_was_enabled; + + /** * @brief If this member is true, then the service shall be initialized. */ bool initialized; @@ -282,7 +287,7 @@ static void Action( void *arg ) ctx->visited_entries = 0; bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized ); @@ -293,7 +298,7 @@ static void Action( void *arg ) ); bsp_interrupt_set_handler_unique( - BSP_INTERRUPT_HANDLER_TABLE_SIZE, + BSP_INTERRUPT_DISPATCH_TABLE_SIZE, ctx->initialized_during_setup ); } @@ -506,6 +511,11 @@ static void RtemsIntrReqHandlerIterate_Setup( ctx->initialized_during_setup = bsp_interrupt_is_initialized(); ctx->test_vector = GetTestableInterruptVector( NULL ); + ctx->test_vector_was_enabled = false; + (void) rtems_interrupt_vector_is_enabled( + ctx->test_vector, + &ctx->test_vector_was_enabled + ); rtems_interrupt_entry_initialize( &ctx->entry, EntryRoutine, @@ -529,6 +539,32 @@ static void RtemsIntrReqHandlerIterate_Setup_Wrap( void *arg ) RtemsIntrReqHandlerIterate_Setup( ctx ); } +static void RtemsIntrReqHandlerIterate_Teardown( + RtemsIntrReqHandlerIterate_Context *ctx +) +{ + rtems_status_code sc; + + sc = rtems_interrupt_entry_remove( + ctx->test_vector, + &ctx->entry + ); + T_rsc_success( sc ); + + if ( ctx->test_vector_was_enabled ) { + (void) rtems_interrupt_vector_enable( ctx->test_vector ); + } +} + +static void RtemsIntrReqHandlerIterate_Teardown_Wrap( void *arg ) +{ + RtemsIntrReqHandlerIterate_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + RtemsIntrReqHandlerIterate_Teardown( ctx ); +} + static void RtemsIntrReqHandlerIterate_Action( RtemsIntrReqHandlerIterate_Context *ctx ) @@ -586,7 +622,7 @@ static size_t RtemsIntrReqHandlerIterate_Scope( static T_fixture RtemsIntrReqHandlerIterate_Fixture = { .setup = RtemsIntrReqHandlerIterate_Setup_Wrap, .stop = NULL, - .teardown = NULL, + .teardown = RtemsIntrReqHandlerIterate_Teardown_Wrap, .scope = RtemsIntrReqHandlerIterate_Scope, .initial_context = &RtemsIntrReqHandlerIterate_Instance }; diff --git a/testsuites/validation/tc-intr-is-pending.c b/testsuites/validation/tc-intr-is-pending.c index 93be686038..097e3d7a17 100644 --- a/testsuites/validation/tc-intr-is-pending.c +++ b/testsuites/validation/tc-intr-is-pending.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqIsPending + * @ingroup RtemsIntrReqIsPending */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqIsPending spec:/rtems/intr/req/is-pending + * @defgroup RtemsIntrReqIsPending spec:/rtems/intr/req/is-pending * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -142,7 +142,7 @@ typedef struct { /** * @brief This member specifies if the ``pending`` parameter value. */ - bool *pending;; + bool *pending; /** * @brief This member contains the return value of the diff --git a/testsuites/validation/tc-intr-non-smp.c b/testsuites/validation/tc-intr-non-smp.c index bb75ccc1b6..ce34571298 100644 --- a/testsuites/validation/tc-intr-non-smp.c +++ b/testsuites/validation/tc-intr-non-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrValIntrNonSmp + * @ingroup RtemsIntrValIntrNonSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrValIntrNonSmp \ - * spec:/rtems/intr/val/intr-non-smp + * @defgroup RtemsIntrValIntrNonSmp spec:/rtems/intr/val/intr-non-smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationNonSmp + * @ingroup TestsuitesValidationNonSmp * * @brief Tests some @ref RTEMSAPIClassicIntr interfaces. * diff --git a/testsuites/validation/tc-intr-raise-on.c b/testsuites/validation/tc-intr-raise-on.c index 4d305258b3..d4298463b6 100644 --- a/testsuites/validation/tc-intr-raise-on.c +++ b/testsuites/validation/tc-intr-raise-on.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqRaiseOn + * @ingroup RtemsIntrReqRaiseOn */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqRaiseOn spec:/rtems/intr/req/raise-on + * @defgroup RtemsIntrReqRaiseOn spec:/rtems/intr/req/raise-on * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ diff --git a/testsuites/validation/tc-intr-raise.c b/testsuites/validation/tc-intr-raise.c index dde5f2c0e0..1faa48fc79 100644 --- a/testsuites/validation/tc-intr-raise.c +++ b/testsuites/validation/tc-intr-raise.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqRaise + * @ingroup RtemsIntrReqRaise */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqRaise spec:/rtems/intr/req/raise + * @defgroup RtemsIntrReqRaise spec:/rtems/intr/req/raise * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ diff --git a/testsuites/validation/tc-intr-set-affinity.c b/testsuites/validation/tc-intr-set-affinity.c index e49d83e8e1..3354681b47 100644 --- a/testsuites/validation/tc-intr-set-affinity.c +++ b/testsuites/validation/tc-intr-set-affinity.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqSetAffinity + * @ingroup RtemsIntrReqSetAffinity */ /* - * Copyright (C) 2021, 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqSetAffinity \ - * spec:/rtems/intr/req/set-affinity + * @defgroup RtemsIntrReqSetAffinity spec:/rtems/intr/req/set-affinity * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ diff --git a/testsuites/validation/tc-intr-smp-only.c b/testsuites/validation/tc-intr-smp-only.c index 4bf596141c..4d1f64b699 100644 --- a/testsuites/validation/tc-intr-smp-only.c +++ b/testsuites/validation/tc-intr-smp-only.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrValIntrSmpOnly + * @ingroup RtemsIntrValIntrSmpOnly */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrValIntrSmpOnly \ - * spec:/rtems/intr/val/intr-smp-only + * @defgroup RtemsIntrValIntrSmpOnly spec:/rtems/intr/val/intr-smp-only * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests some @ref RTEMSAPIClassicIntr directives. * diff --git a/testsuites/validation/tc-intr-vector-disable.c b/testsuites/validation/tc-intr-vector-disable.c index 3c7eb11838..013befeff8 100644 --- a/testsuites/validation/tc-intr-vector-disable.c +++ b/testsuites/validation/tc-intr-vector-disable.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqVectorDisable + * @ingroup RtemsIntrReqVectorDisable */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqVectorDisable \ - * spec:/rtems/intr/req/vector-disable + * @defgroup RtemsIntrReqVectorDisable spec:/rtems/intr/req/vector-disable * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ diff --git a/testsuites/validation/tc-intr-vector-enable.c b/testsuites/validation/tc-intr-vector-enable.c index 024953ab48..91993fb8d4 100644 --- a/testsuites/validation/tc-intr-vector-enable.c +++ b/testsuites/validation/tc-intr-vector-enable.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqVectorEnable + * @ingroup RtemsIntrReqVectorEnable */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqVectorEnable \ - * spec:/rtems/intr/req/vector-enable + * @defgroup RtemsIntrReqVectorEnable spec:/rtems/intr/req/vector-enable * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -368,7 +367,7 @@ static void RtemsIntrReqVectorEnable_Pre_IsEnabled_Prepare( case RtemsIntrReqVectorEnable_Pre_IsEnabled_No: { /* * While the interrupt vector associated with the ``vector`` parameter is - * enabled. + * disabled. */ /* * This pre-condition depends on the attributes of an interrupt vector, diff --git a/testsuites/validation/tc-intr-vector-is-enabled.c b/testsuites/validation/tc-intr-vector-is-enabled.c index ea26b80aee..d24ad3f602 100644 --- a/testsuites/validation/tc-intr-vector-is-enabled.c +++ b/testsuites/validation/tc-intr-vector-is-enabled.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrReqVectorIsEnabled + * @ingroup RtemsIntrReqVectorIsEnabled */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrReqVectorIsEnabled \ - * spec:/rtems/intr/req/vector-is-enabled + * @defgroup RtemsIntrReqVectorIsEnabled spec:/rtems/intr/req/vector-is-enabled * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr * * @{ */ @@ -144,7 +143,7 @@ typedef struct { /** * @brief This member specifies if the ``enabled`` parameter value. */ - bool *enabled;; + bool *enabled; /** * @brief This member contains the return value of the diff --git a/testsuites/validation/tc-intr.c b/testsuites/validation/tc-intr.c index 7b2e6b0d48..72ac626c97 100644 --- a/testsuites/validation/tc-intr.c +++ b/testsuites/validation/tc-intr.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIntrValIntr + * @ingroup RtemsIntrValIntr */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIntrValIntr spec:/rtems/intr/val/intr + * @defgroup RtemsIntrValIntr spec:/rtems/intr/val/intr * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicIntr directives. * diff --git a/testsuites/validation/tc-io-getchark.c b/testsuites/validation/tc-io-getchark.c index 54a24d5694..20aede7fd9 100644 --- a/testsuites/validation/tc-io-getchark.c +++ b/testsuites/validation/tc-io-getchark.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIoReqGetchark + * @ingroup RtemsIoReqGetchark */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIoReqGetchark spec:/rtems/io/req/getchark + * @defgroup RtemsIoReqGetchark spec:/rtems/io/req/getchark * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-io-put-char.c b/testsuites/validation/tc-io-put-char.c index ab4c82ffda..671eed9835 100644 --- a/testsuites/validation/tc-io-put-char.c +++ b/testsuites/validation/tc-io-put-char.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIoReqPutChar + * @ingroup RtemsIoReqPutChar */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIoReqPutChar spec:/rtems/io/req/put-char + * @defgroup RtemsIoReqPutChar spec:/rtems/io/req/put-char * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-io-putc.c b/testsuites/validation/tc-io-putc.c index d55ed5dae7..7b0efe2b17 100644 --- a/testsuites/validation/tc-io-putc.c +++ b/testsuites/validation/tc-io-putc.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIoReqPutc + * @ingroup RtemsIoReqPutc */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIoReqPutc spec:/rtems/io/req/putc + * @defgroup RtemsIoReqPutc spec:/rtems/io/req/putc * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-message-broadcast.c b/testsuites/validation/tc-message-broadcast.c index 62e5aa5c7e..01de6a99b3 100644 --- a/testsuites/validation/tc-message-broadcast.c +++ b/testsuites/validation/tc-message-broadcast.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqBroadcast + * @ingroup RtemsMessageReqBroadcast */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqBroadcast \ - * spec:/rtems/message/req/broadcast + * @defgroup RtemsMessageReqBroadcast spec:/rtems/message/req/broadcast * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-message-construct.c b/testsuites/validation/tc-message-construct.c index a7093b28e1..316849ba68 100644 --- a/testsuites/validation/tc-message-construct.c +++ b/testsuites/validation/tc-message-construct.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqConstruct + * @ingroup RtemsMessageReqConstruct */ /* - * Copyright (C) 2020, 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020, 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqConstruct \ - * spec:/rtems/message/req/construct + * @defgroup RtemsMessageReqConstruct spec:/rtems/message/req/construct * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-message-delete.c b/testsuites/validation/tc-message-delete.c index 0835a5c5e9..b0fa53be66 100644 --- a/testsuites/validation/tc-message-delete.c +++ b/testsuites/validation/tc-message-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqDelete + * @ingroup RtemsMessageReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqDelete spec:/rtems/message/req/delete + * @defgroup RtemsMessageReqDelete spec:/rtems/message/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-message-flush-pending.c b/testsuites/validation/tc-message-flush-pending.c index 67d2ede6bd..48ade108d0 100644 --- a/testsuites/validation/tc-message-flush-pending.c +++ b/testsuites/validation/tc-message-flush-pending.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqFlushPending + * @ingroup RtemsMessageReqFlushPending */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqFlushPending \ - * spec:/rtems/message/req/flush-pending + * @defgroup RtemsMessageReqFlushPending spec:/rtems/message/req/flush-pending * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-message-ident.c b/testsuites/validation/tc-message-ident.c index 70e7d53350..dc3ed119a6 100644 --- a/testsuites/validation/tc-message-ident.c +++ b/testsuites/validation/tc-message-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageValIdent + * @ingroup RtemsMessageValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageValIdent spec:/rtems/message/val/ident + * @defgroup RtemsMessageValIdent spec:/rtems/message/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_message_queue_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API message queue - * class objects defined by /rtems/req/ident. + * class objects defined by spec:/rtems/req/ident. * * @{ */ @@ -95,7 +95,7 @@ static rtems_status_code ClassicMessageIdentAction( /** * @brief Run the generic object identification tests for Classic API message - * queue class objects defined by /rtems/req/ident. + * queue class objects defined by spec:/rtems/req/ident. */ static void RtemsMessageValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-message-macros.c b/testsuites/validation/tc-message-macros.c index f8e6a46252..b3c37b1963 100644 --- a/testsuites/validation/tc-message-macros.c +++ b/testsuites/validation/tc-message-macros.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageValMessageMacros + * @ingroup RtemsMessageValMessageMacros */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageValMessageMacros \ + * @defgroup RtemsMessageValMessageMacros \ * spec:/rtems/message/val/message-macros * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the macros of the @ref RTEMSAPIClassicMessage. * diff --git a/testsuites/validation/tc-message-performance.c b/testsuites/validation/tc-message-performance.c index 162c094078..c01570b772 100644 --- a/testsuites/validation/tc-message-performance.c +++ b/testsuites/validation/tc-message-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageValPerf + * @ingroup RtemsMessageValPerf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageValPerf spec:/rtems/message/val/perf + * @defgroup RtemsMessageValPerf spec:/rtems/message/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicMessage * performance tests. @@ -79,6 +79,11 @@ typedef struct { rtems_id queue_id; /** + * @brief This member provides a message to send. + */ + long message; + + /** * @brief This member provides a worker identifier. */ rtems_id worker_id; @@ -116,15 +121,17 @@ static RtemsMessageValPerf_Context #define MAXIMUM_MESSAGE_SIZE 8 -typedef RtemsMessageValPerf_Context Context; +#define EVENT_END RTEMS_EVENT_0 + +#define EVENT_SEND RTEMS_EVENT_1 -typedef enum { - EVENT_END = RTEMS_EVENT_0, - EVENT_SEND = RTEMS_EVENT_1, - EVENT_SEND_END = RTEMS_EVENT_2, - EVENT_RECEIVE = RTEMS_EVENT_3, - EVENT_RECEIVE_END = RTEMS_EVENT_4 -} Event; +#define EVENT_SEND_END RTEMS_EVENT_2 + +#define EVENT_RECEIVE RTEMS_EVENT_3 + +#define EVENT_RECEIVE_END RTEMS_EVENT_4 + +typedef RtemsMessageValPerf_Context Context; static RTEMS_MESSAGE_QUEUE_BUFFER( MAXIMUM_MESSAGE_SIZE ) storage_area[ MAXIMUM_PENDING_MESSAGES ]; @@ -152,7 +159,6 @@ static void Worker( rtems_task_argument arg ) rtems_event_set events; rtems_status_code sc; T_ticks ticks; - uint64_t message; sc = rtems_event_receive( RTEMS_ALL_EVENTS, @@ -168,11 +174,10 @@ static void Worker( rtems_task_argument arg ) } if ( ( events & EVENT_SEND ) != 0 ) { - message = 0; sc = rtems_message_queue_send( ctx->queue_id, - &message, - sizeof( message ) + &ctx->message, + sizeof( ctx->message ) ); ticks = T_tick(); T_quiet_rsc_success( sc ); @@ -183,6 +188,7 @@ static void Worker( rtems_task_argument arg ) } if ( ( events & EVENT_RECEIVE ) != 0 ) { + long message; size_t size; sc = rtems_message_queue_receive( @@ -273,6 +279,13 @@ static T_fixture RtemsMessageValPerf_Fixture = { }; /** + * @defgroup RtemsMessageReqPerfReceiveTry \ + * spec:/rtems/message/req/perf-receive-try + * + * @{ + */ + +/** * @brief Try to receive a message. */ static void RtemsMessageReqPerfReceiveTry_Body( @@ -329,6 +342,15 @@ static bool RtemsMessageReqPerfReceiveTry_Teardown_Wrap( return RtemsMessageReqPerfReceiveTry_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsMessageReqPerfReceiveWaitForever \ + * spec:/rtems/message/req/perf-receive-wait-forever + * + * @{ + */ + /** * @brief Schedule a message send. */ @@ -416,6 +438,15 @@ static bool RtemsMessageReqPerfReceiveWaitForever_Teardown_Wrap( ); } +/** @} */ + +/** + * @defgroup RtemsMessageReqPerfReceiveWaitTimed \ + * spec:/rtems/message/req/perf-receive-wait-timed + * + * @{ + */ + /** * @brief Schedule a message send. */ @@ -503,17 +534,23 @@ static bool RtemsMessageReqPerfReceiveWaitTimed_Teardown_Wrap( ); } +/** @} */ + +/** + * @defgroup RtemsMessageReqPerfSend spec:/rtems/message/req/perf-send + * + * @{ + */ + /** * @brief Send a message. */ static void RtemsMessageReqPerfSend_Body( RtemsMessageValPerf_Context *ctx ) { - uint64_t message; - ctx->status = rtems_message_queue_send( ctx->queue_id, - &message, - sizeof( message ) + &ctx->message, + sizeof( ctx->message ) ); } @@ -563,6 +600,15 @@ static bool RtemsMessageReqPerfSend_Teardown_Wrap( return RtemsMessageReqPerfSend_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsMessageReqPerfSendOther \ + * spec:/rtems/message/req/perf-send-other + * + * @{ + */ + /** * @brief Let the worker wait on the message queue. */ @@ -589,12 +635,10 @@ static void RtemsMessageReqPerfSendOther_Body( RtemsMessageValPerf_Context *ctx ) { - uint64_t message; - ctx->status = rtems_message_queue_send( ctx->queue_id, - &message, - sizeof( message ) + &ctx->message, + sizeof( ctx->message ) ); } @@ -639,8 +683,17 @@ static bool RtemsMessageReqPerfSendOther_Teardown_Wrap( return RtemsMessageReqPerfSendOther_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsMessageReqPerfSendOtherCpu \ + * spec:/rtems/message/req/perf-send-other-cpu + * + * @{ + */ + +/** * @brief Move worker to scheduler B. */ static void RtemsMessageReqPerfSendOtherCpu_Prepare( @@ -676,13 +729,11 @@ static void RtemsMessageReqPerfSendOtherCpu_Body( RtemsMessageValPerf_Context *ctx ) { - uint64_t message; - ctx->begin = T_tick(); ctx->status = rtems_message_queue_send( ctx->queue_id, - &message, - sizeof( message ) + &ctx->message, + sizeof( ctx->message ) ); } @@ -743,9 +794,18 @@ static void RtemsMessageReqPerfSendOtherCpu_Cleanup( { SetScheduler( ctx->worker_id, SCHEDULER_A_ID, PRIO_HIGH ); } + +/** @} */ #endif /** + * @defgroup RtemsMessageReqPerfSendPreempt \ + * spec:/rtems/message/req/perf-send-preempt + * + * @{ + */ + +/** * @brief Let the worker wait on the message queue. */ static void RtemsMessageReqPerfSendPreempt_Setup( @@ -770,13 +830,11 @@ static void RtemsMessageReqPerfSendPreempt_Body( RtemsMessageValPerf_Context *ctx ) { - uint64_t message; - ctx->begin = T_tick(); ctx->status = rtems_message_queue_send( ctx->queue_id, - &message, - sizeof( message ) + &ctx->message, + sizeof( ctx->message ) ); } @@ -827,6 +885,8 @@ static bool RtemsMessageReqPerfSendPreempt_Teardown_Wrap( ); } +/** @} */ + /** * @fn void T_case_body_RtemsMessageValPerf( void ) */ diff --git a/testsuites/validation/tc-message-receive.c b/testsuites/validation/tc-message-receive.c index 02a8ba9062..944512eaa8 100644 --- a/testsuites/validation/tc-message-receive.c +++ b/testsuites/validation/tc-message-receive.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqReceive + * @ingroup RtemsMessageReqReceive */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,10 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqReceive \ - * spec:/rtems/message/req/receive + * @defgroup RtemsMessageReqReceive spec:/rtems/message/req/receive * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -208,7 +207,7 @@ typedef struct { * * It is used for run-time type checking. */ - uint32_t magic;; + uint32_t magic; /** * @brief This member contains a number which is sent as next message. @@ -392,7 +391,7 @@ static void DoAction( void *ctx_in ) ); } -static void WorkerTask( unsigned int argument ) +static void WorkerTask( rtems_task_argument argument ) { Context *ctx = (Context *) argument; if ( ctx != NULL ) { diff --git a/testsuites/validation/tc-message-urgent-send.c b/testsuites/validation/tc-message-urgent-send.c index fb42f94b84..e7364f108d 100644 --- a/testsuites/validation/tc-message-urgent-send.c +++ b/testsuites/validation/tc-message-urgent-send.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsMessageReqUrgentSend + * @ingroup RtemsMessageReqUrgentSend */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsMessageReqUrgentSend \ - * spec:/rtems/message/req/urgent-send + * @defgroup RtemsMessageReqUrgentSend spec:/rtems/message/req/urgent-send * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -173,7 +172,7 @@ typedef struct { * * It is used for run-time type checking. */ - uint32_t magic;; + uint32_t magic; /** * @brief This member contains a number which is sent as next message. diff --git a/testsuites/validation/tc-modes.c b/testsuites/validation/tc-modes.c index c9f8fe65ca..91d26e835c 100644 --- a/testsuites/validation/tc-modes.c +++ b/testsuites/validation/tc-modes.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsModeValModes + * @ingroup RtemsModeValModes */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsModeValModes spec:/rtems/mode/val/modes + * @defgroup RtemsModeValModes spec:/rtems/mode/val/modes * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the task mode constants and function-like macros of the Classic * API. diff --git a/testsuites/validation/tc-object.c b/testsuites/validation/tc-object.c index 9e63d2a44e..6ee87dbf4e 100644 --- a/testsuites/validation/tc-object.c +++ b/testsuites/validation/tc-object.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsObjectValObject + * @ingroup RtemsObjectValObject */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsObjectValObject spec:/rtems/object/val/object + * @defgroup RtemsObjectValObject spec:/rtems/object/val/object * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicObject directives. * diff --git a/testsuites/validation/tc-options.c b/testsuites/validation/tc-options.c index 9db52bdaaf..166b3b8b31 100644 --- a/testsuites/validation/tc-options.c +++ b/testsuites/validation/tc-options.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsOptionValOptions + * @ingroup RtemsOptionValOptions */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsOptionValOptions spec:/rtems/option/val/options + * @defgroup RtemsOptionValOptions spec:/rtems/option/val/options * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the option constants of the Classic API. * @@ -88,7 +88,7 @@ * * - Check the value of RTEMS_DEFAULT_OPTIONS. * - * - Check RTEMS_DEFAULT_OPTIONS equals ``RTEMS_WAIT``. + * - Check RTEMS_DEFAULT_OPTIONS equals RTEMS_WAIT. * * @{ */ @@ -181,7 +181,7 @@ static void RtemsOptionValOptions_Action_3( void ) /* No action */ /* - * Check RTEMS_DEFAULT_OPTIONS equals ``RTEMS_WAIT``. + * Check RTEMS_DEFAULT_OPTIONS equals RTEMS_WAIT. */ T_step_eq_int( 6, RTEMS_DEFAULT_OPTIONS, RTEMS_WAIT ); } diff --git a/testsuites/validation/tc-part-create.c b/testsuites/validation/tc-part-create.c index 7121b07d4e..3e7389d98a 100644 --- a/testsuites/validation/tc-part-create.c +++ b/testsuites/validation/tc-part-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartReqCreate + * @ingroup RtemsPartReqCreate */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartReqCreate spec:/rtems/part/req/create + * @defgroup RtemsPartReqCreate spec:/rtems/part/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-part-delete.c b/testsuites/validation/tc-part-delete.c index 0ec1dd0bde..227382961f 100644 --- a/testsuites/validation/tc-part-delete.c +++ b/testsuites/validation/tc-part-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartReqDelete + * @ingroup RtemsPartReqDelete */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartReqDelete spec:/rtems/part/req/delete + * @defgroup RtemsPartReqDelete spec:/rtems/part/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-part-get.c b/testsuites/validation/tc-part-get.c index 9308c1350a..3b8d2cc59b 100644 --- a/testsuites/validation/tc-part-get.c +++ b/testsuites/validation/tc-part-get.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartReqGetBuffer + * @ingroup RtemsPartReqGetBuffer */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartReqGetBuffer spec:/rtems/part/req/get-buffer + * @defgroup RtemsPartReqGetBuffer spec:/rtems/part/req/get-buffer * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-part-ident.c b/testsuites/validation/tc-part-ident.c index fccdf9671c..40f66d436e 100644 --- a/testsuites/validation/tc-part-ident.c +++ b/testsuites/validation/tc-part-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartValIdent + * @ingroup RtemsPartValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartValIdent spec:/rtems/part/val/ident + * @defgroup RtemsPartValIdent spec:/rtems/part/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_partition_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API partition - * class objects defined by /rtems/req/ident. + * class objects defined by spec:/rtems/req/ident. * * @{ */ @@ -84,7 +84,7 @@ static rtems_status_code ClassicPartIdentAction( /** * @brief Run the generic object identification tests for Classic API partition - * class objects defined by /rtems/req/ident. + * class objects defined by spec:/rtems/req/ident. */ static void RtemsPartValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-part-performance.c b/testsuites/validation/tc-part-performance.c index 4c223910d0..858dbc0b4b 100644 --- a/testsuites/validation/tc-part-performance.c +++ b/testsuites/validation/tc-part-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartValPerf + * @ingroup RtemsPartValPerf */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -53,14 +53,13 @@ #endif #include <rtems.h> -#include <rtems/chain.h> #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartValPerf spec:/rtems/part/val/perf + * @defgroup RtemsPartValPerf spec:/rtems/part/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicPart * performance tests. @@ -143,7 +142,7 @@ static void RtemsPartValPerf_Setup( RtemsPartValPerf_Context *ctx ) void *area; uintptr_t length; - size = sizeof( rtems_chain_node ); + size = 2 * sizeof( uintptr_t ); area = T_malloc( size ); sc = rtems_partition_create( @@ -213,6 +212,12 @@ static T_fixture RtemsPartValPerf_Fixture = { }; /** + * @defgroup RtemsPartReqPerfGetBuffer spec:/rtems/part/req/perf-get-buffer + * + * @{ + */ + +/** * @brief Get a buffer. */ static void RtemsPartReqPerfGetBuffer_Body( RtemsPartValPerf_Context *ctx ) @@ -263,6 +268,15 @@ static bool RtemsPartReqPerfGetBuffer_Teardown_Wrap( return RtemsPartReqPerfGetBuffer_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsPartReqPerfGetNoBuffer \ + * spec:/rtems/part/req/perf-get-no-buffer + * + * @{ + */ + /** * @brief Get the buffer. */ @@ -335,6 +349,15 @@ static void RtemsPartReqPerfGetNoBuffer_Cleanup( T_rsc_success( sc ); } +/** @} */ + +/** + * @defgroup RtemsPartReqPerfReturnBuffer \ + * spec:/rtems/part/req/perf-return-buffer + * + * @{ + */ + /** * @brief Get the buffer. */ @@ -400,6 +423,8 @@ static bool RtemsPartReqPerfReturnBuffer_Teardown_Wrap( return RtemsPartReqPerfReturnBuffer_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + /** * @fn void T_case_body_RtemsPartValPerf( void ) */ diff --git a/testsuites/validation/tc-part-return.c b/testsuites/validation/tc-part-return.c index 71c6a31e66..864d916f61 100644 --- a/testsuites/validation/tc-part-return.c +++ b/testsuites/validation/tc-part-return.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartReqReturnBuffer + * @ingroup RtemsPartReqReturnBuffer */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartReqReturnBuffer \ - * spec:/rtems/part/req/return-buffer + * @defgroup RtemsPartReqReturnBuffer spec:/rtems/part/req/return-buffer * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-part.c b/testsuites/validation/tc-part.c index 220c8a6b63..ad241e975c 100644 --- a/testsuites/validation/tc-part.c +++ b/testsuites/validation/tc-part.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsPartValPart + * @ingroup RtemsPartValPart */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsPartValPart spec:/rtems/part/val/part + * @defgroup RtemsPartValPart spec:/rtems/part/val/part * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief This test case collection provides validation test cases for * requirements of the @ref RTEMSAPIClassicPart. diff --git a/testsuites/validation/tc-preinit-array.c b/testsuites/validation/tc-preinit-array.c new file mode 100644 index 0000000000..244b30b40e --- /dev/null +++ b/testsuites/validation/tc-preinit-array.c @@ -0,0 +1,150 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreThreadValPreinitArray + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> + +#include <rtems/test.h> + +/** + * @defgroup ScoreThreadValPreinitArray spec:/score/thread/val/preinit-array + * + * @ingroup TestsuitesValidationNoClock0 + * + * @brief Tests the ``.preinit_array`` constructor handling of the C runtime + * support. + * + * This test case performs the following actions: + * + * - Validate the ``.preinit_array`` constructor invocation. Mark that the + * test case executed. + * + * - Check that the ``.preinit_array`` constructor was called exactly once. + * + * - Check that the ``.preeinit_array`` construction was done by the Classic + * API user initialization task. + * + * - Check that the ``.preinit_array`` constructor was called before the + * global constructor invocations. + * + * @{ + */ + +static bool test_case_executed; + +static bool constructor_test_case_executed; + +static uint32_t counter; + +static uint32_t normal_constructor_counter; + +static uint32_t constructor_counter; + +static uint32_t constructor_calls; + +static rtems_id constructor_id; + +static __attribute__(( __constructor__ )) void NormalConstructor( void ) +{ + ++counter; + normal_constructor_counter = counter; +} + +static void Constructor( void ) +{ + constructor_test_case_executed = test_case_executed; + ++counter; + constructor_counter = counter; + ++constructor_calls; + constructor_id = rtems_task_self(); +} + +static RTEMS_USED RTEMS_SECTION( ".preinit_array" ) void + ( * const constructor_registration )( void ) = Constructor; + +/** + * @brief Validate the ``.preinit_array`` constructor invocation. Mark that + * the test case executed. + */ +static void ScoreThreadValPreinitArray_Action_0( void ) +{ + test_case_executed = true; + + /* + * Check that the ``.preinit_array`` constructor was called exactly once. + */ + T_eq_u32( constructor_calls, 1 ); + + /* + * Check that the ``.preeinit_array`` construction was done by the Classic + * API user initialization task. + */ + T_eq_u32( constructor_id, rtems_task_self() ); + + /* + * Check that the ``.preinit_array`` constructor was called before the global + * constructor invocations. + */ + T_eq_u32( constructor_counter, 1 ); + T_eq_u32( normal_constructor_counter, 2 ); +} + +/** + * @fn void T_case_body_ScoreThreadValPreinitArray( void ) + */ +T_TEST_CASE( ScoreThreadValPreinitArray ) +{ + ScoreThreadValPreinitArray_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/tc-ratemon-cancel.c b/testsuites/validation/tc-ratemon-cancel.c index 7cbbbcda7d..b3683ac338 100644 --- a/testsuites/validation/tc-ratemon-cancel.c +++ b/testsuites/validation/tc-ratemon-cancel.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqCancel + * @ingroup RtemsRatemonReqCancel */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqCancel spec:/rtems/ratemon/req/cancel + * @defgroup RtemsRatemonReqCancel spec:/rtems/ratemon/req/cancel * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-ratemon-create.c b/testsuites/validation/tc-ratemon-create.c index d86cd977c9..ff7672beeb 100644 --- a/testsuites/validation/tc-ratemon-create.c +++ b/testsuites/validation/tc-ratemon-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqCreate + * @ingroup RtemsRatemonReqCreate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqCreate spec:/rtems/ratemon/req/create + * @defgroup RtemsRatemonReqCreate spec:/rtems/ratemon/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-ratemon-delete.c b/testsuites/validation/tc-ratemon-delete.c index 3b30188fe1..93e863f023 100644 --- a/testsuites/validation/tc-ratemon-delete.c +++ b/testsuites/validation/tc-ratemon-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqDelete + * @ingroup RtemsRatemonReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqDelete spec:/rtems/ratemon/req/delete + * @defgroup RtemsRatemonReqDelete spec:/rtems/ratemon/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-ratemon-get-status.c b/testsuites/validation/tc-ratemon-get-status.c index fe3fb300e3..750654e2c9 100644 --- a/testsuites/validation/tc-ratemon-get-status.c +++ b/testsuites/validation/tc-ratemon-get-status.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqGetStatus + * @ingroup RtemsRatemonReqGetStatus */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,11 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqGetStatus \ - * spec:/rtems/ratemon/req/get-status + * @defgroup RtemsRatemonReqGetStatus spec:/rtems/ratemon/req/get-status * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-ratemon-ident.c b/testsuites/validation/tc-ratemon-ident.c index beeb0bfd14..27a414a980 100644 --- a/testsuites/validation/tc-ratemon-ident.c +++ b/testsuites/validation/tc-ratemon-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonValIdent + * @ingroup RtemsRatemonValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonValIdent spec:/rtems/ratemon/val/ident + * @defgroup RtemsRatemonValIdent spec:/rtems/ratemon/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_rate_monotonic_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API rate monotonic - * class objects defined by /rtems/req/ident-local. + * class objects defined by spec:/rtems/req/ident-local. * * @{ */ @@ -83,7 +83,7 @@ static rtems_status_code ClassicRatemonIdentAction( /** * @brief Run the generic object identification tests for Classic API rate - * monotonic class objects defined by /rtems/req/ident-local. + * monotonic class objects defined by spec:/rtems/req/ident-local. */ static void RtemsRatemonValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-ratemon-period.c b/testsuites/validation/tc-ratemon-period.c index 9e2d294581..c8a73905c1 100644 --- a/testsuites/validation/tc-ratemon-period.c +++ b/testsuites/validation/tc-ratemon-period.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqPeriod + * @ingroup RtemsRatemonReqPeriod */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqPeriod spec:/rtems/ratemon/req/period + * @defgroup RtemsRatemonReqPeriod spec:/rtems/ratemon/req/period * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-ratemon-timeout.c b/testsuites/validation/tc-ratemon-timeout.c index b70a5cc85c..dc2c745e61 100644 --- a/testsuites/validation/tc-ratemon-timeout.c +++ b/testsuites/validation/tc-ratemon-timeout.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsRatemonReqTimeout + * @ingroup RtemsRatemonReqTimeout */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,11 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsRatemonReqTimeout \ - * spec:/rtems/ratemon/req/timeout + * @defgroup RtemsRatemonReqTimeout spec:/rtems/ratemon/req/timeout * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ @@ -281,13 +280,13 @@ static const char * const * const RtemsRatemonReqTimeout_PreDesc[] = { NULL }; -typedef RtemsRatemonReqTimeout_Context Context; +#define EVENT_RESET RTEMS_EVENT_0 -typedef enum { - EVENT_RESET = RTEMS_EVENT_0, - EVENT_PERIOD_WAIT = RTEMS_EVENT_1, - EVENT_PERIOD_OTHER = RTEMS_EVENT_2 -} Event; +#define EVENT_PERIOD_WAIT RTEMS_EVENT_1 + +#define EVENT_PERIOD_OTHER RTEMS_EVENT_2 + +typedef RtemsRatemonReqTimeout_Context Context; static void Tick( void *arg ) { diff --git a/testsuites/validation/tc-sched-smp-edf-set-affinity.c b/testsuites/validation/tc-sched-smp-edf-set-affinity.c index 4e5fab70dc..9e13c19ff7 100644 --- a/testsuites/validation/tc-sched-smp-edf-set-affinity.c +++ b/testsuites/validation/tc-sched-smp-edf-set-affinity.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSchedSmpEdfReqSetAffinity + * @ingroup ScoreSchedSmpEdfReqSetAffinity */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,10 +63,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSchedSmpEdfReqSetAffinity \ + * @defgroup ScoreSchedSmpEdfReqSetAffinity \ * spec:/score/sched/smp/edf/req/set-affinity * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @{ */ diff --git a/testsuites/validation/tc-sched-smp-edf.c b/testsuites/validation/tc-sched-smp-edf.c index 94d685bd08..7b07813ee1 100644 --- a/testsuites/validation/tc-sched-smp-edf.c +++ b/testsuites/validation/tc-sched-smp-edf.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSchedSmpEdfValEdf + * @ingroup ScoreSchedSmpEdfValEdf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSchedSmpEdfValEdf \ - * spec:/score/sched/smp/edf/val/edf + * @defgroup ScoreSchedSmpEdfValEdf spec:/score/sched/smp/edf/val/edf * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests for operations of the EDF SMP scheduler. * diff --git a/testsuites/validation/tc-sched-smp.c b/testsuites/validation/tc-sched-smp.c index 6eb98b5360..3e8e3fe1a2 100644 --- a/testsuites/validation/tc-sched-smp.c +++ b/testsuites/validation/tc-sched-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSchedSmpValSmp + * @ingroup ScoreSchedSmpValSmp */ /* - * Copyright (C) 2021, 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSchedSmpValSmp spec:/score/sched/smp/val/smp + * @defgroup ScoreSchedSmpValSmp spec:/score/sched/smp/val/smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests SMP-specific scheduler behaviour. * @@ -284,7 +284,7 @@ typedef struct { /** * @brief If this member is true, then the worker shall be in the busy loop. */ - volatile bool is_busy[ WORKER_COUNT ];; + volatile bool is_busy[ WORKER_COUNT ]; /** * @brief This member contains the per-CPU jobs. @@ -299,24 +299,31 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; } ScoreSchedSmpValSmp_Context; static ScoreSchedSmpValSmp_Context ScoreSchedSmpValSmp_Instance; +#define EVENT_OBTAIN RTEMS_EVENT_0 + +#define EVENT_RELEASE RTEMS_EVENT_1 + +#define EVENT_STICKY_OBTAIN RTEMS_EVENT_2 + +#define EVENT_STICKY_RELEASE RTEMS_EVENT_3 + +#define EVENT_SYNC_RUNNER RTEMS_EVENT_4 + +#define EVENT_BUSY RTEMS_EVENT_5 + typedef ScoreSchedSmpValSmp_Context Context; -typedef enum { - EVENT_OBTAIN = RTEMS_EVENT_0, - EVENT_RELEASE = RTEMS_EVENT_1, - EVENT_STICKY_OBTAIN = RTEMS_EVENT_2, - EVENT_STICKY_RELEASE = RTEMS_EVENT_3, - EVENT_SYNC_RUNNER = RTEMS_EVENT_4, - EVENT_BUSY = RTEMS_EVENT_5 -} Event; - -static void SendAndSync( Context *ctx, WorkerIndex worker, Event event ) +static void SendAndSync( + Context *ctx, + WorkerIndex worker, + rtems_event_set event +) { SendEvents( ctx->worker_id[ worker ], EVENT_SYNC_RUNNER | event ); ReceiveAllEvents( EVENT_SYNC_RUNNER ); @@ -678,6 +685,7 @@ static void PrepareOwnerScheduled( Context *ctx ) SetScheduler( ctx->worker_id[ WORKER_C ], SCHEDULER_B_ID, PRIO_HIGH ); SetPriority( ctx->worker_id[ WORKER_A ], PRIO_NORMAL ); MakeBusy( ctx, WORKER_C ); + WaitForBusy( ctx, WORKER_C ); MakeBusy( ctx, WORKER_A ); } diff --git a/testsuites/validation/tc-sched-yield.c b/testsuites/validation/tc-sched-yield.c index 8aa953fd46..057579fd1c 100644 --- a/testsuites/validation/tc-sched-yield.c +++ b/testsuites/validation/tc-sched-yield.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSchedReqYield + * @ingroup ScoreSchedReqYield */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSchedReqYield spec:/score/sched/req/yield + * @defgroup ScoreSchedReqYield spec:/score/sched/req/yield * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-scheduler-add-processor.c b/testsuites/validation/tc-scheduler-add-processor.c index dbeaaa7b16..a26132aea0 100644 --- a/testsuites/validation/tc-scheduler-add-processor.c +++ b/testsuites/validation/tc-scheduler-add-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqAddProcessor + * @ingroup RtemsSchedulerReqAddProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqAddProcessor \ + * @defgroup RtemsSchedulerReqAddProcessor \ * spec:/rtems/scheduler/req/add-processor * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -155,18 +155,18 @@ typedef struct { * @brief This member contains the online status of the processor to add * before the rtems_scheduler_add_processor() call is prepared. */ - bool online;; + bool online; /** * @brief If this member is true, then the processor should be added to the * scheduler B during cleanup. */ - bool add_cpu_to_scheduler_b;; + bool add_cpu_to_scheduler_b; /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_2 scheduler_log;; + T_scheduler_log_2 scheduler_log; /** * @brief This member contains the return value of the diff --git a/testsuites/validation/tc-scheduler-get-maximum-priority.c b/testsuites/validation/tc-scheduler-get-maximum-priority.c index 45ef88c5a6..82aef23b67 100644 --- a/testsuites/validation/tc-scheduler-get-maximum-priority.c +++ b/testsuites/validation/tc-scheduler-get-maximum-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqGetMaximumPriority + * @ingroup RtemsSchedulerReqGetMaximumPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqGetMaximumPriority \ + * @defgroup RtemsSchedulerReqGetMaximumPriority \ * spec:/rtems/scheduler/req/get-maximum-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-scheduler-get-processor-set.c b/testsuites/validation/tc-scheduler-get-processor-set.c index 3b48df44f9..ecc0254106 100644 --- a/testsuites/validation/tc-scheduler-get-processor-set.c +++ b/testsuites/validation/tc-scheduler-get-processor-set.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqGetProcessorSet + * @ingroup RtemsSchedulerReqGetProcessorSet */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqGetProcessorSet \ + * @defgroup RtemsSchedulerReqGetProcessorSet \ * spec:/rtems/scheduler/req/get-processor-set * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-scheduler-ident-by-processor-set.c b/testsuites/validation/tc-scheduler-ident-by-processor-set.c index 57b660c835..43c3b660a7 100644 --- a/testsuites/validation/tc-scheduler-ident-by-processor-set.c +++ b/testsuites/validation/tc-scheduler-ident-by-processor-set.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqIdentByProcessorSet + * @ingroup RtemsSchedulerReqIdentByProcessorSet */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqIdentByProcessorSet \ + * @defgroup RtemsSchedulerReqIdentByProcessorSet \ * spec:/rtems/scheduler/req/ident-by-processor-set * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-scheduler-ident-by-processor.c b/testsuites/validation/tc-scheduler-ident-by-processor.c index 43021fdc23..8cfe25a70e 100644 --- a/testsuites/validation/tc-scheduler-ident-by-processor.c +++ b/testsuites/validation/tc-scheduler-ident-by-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqIdentByProcessor + * @ingroup RtemsSchedulerReqIdentByProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqIdentByProcessor \ + * @defgroup RtemsSchedulerReqIdentByProcessor \ * spec:/rtems/scheduler/req/ident-by-processor * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -246,7 +246,7 @@ static void RtemsSchedulerReqIdentByProcessor_Pre_CPUIndex_Prepare( switch ( state ) { case RtemsSchedulerReqIdentByProcessor_Pre_CPUIndex_Invalid: { /* - * While the ``cpu_index`` parameter greater than or equal to the + * While the ``cpu_index`` parameter is greater than or equal to the * processor maximum. */ ctx->cpu_index = rtems_scheduler_get_processor_maximum(); @@ -255,7 +255,7 @@ static void RtemsSchedulerReqIdentByProcessor_Pre_CPUIndex_Prepare( case RtemsSchedulerReqIdentByProcessor_Pre_CPUIndex_Valid: { /* - * While the ``cpu_index`` parameter less than the processor maximum. + * While the ``cpu_index`` parameter is less than the processor maximum. */ if ( ctx->cpu_has_scheduler ) { ctx->cpu_index = 0; diff --git a/testsuites/validation/tc-scheduler-ident.c b/testsuites/validation/tc-scheduler-ident.c index 2517e1b50f..7b19f4a08e 100644 --- a/testsuites/validation/tc-scheduler-ident.c +++ b/testsuites/validation/tc-scheduler-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqIdent + * @ingroup RtemsSchedulerReqIdent */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqIdent \ - * spec:/rtems/scheduler/req/ident + * @defgroup RtemsSchedulerReqIdent spec:/rtems/scheduler/req/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-scheduler-non-smp.c b/testsuites/validation/tc-scheduler-non-smp.c index a3eec8fd2d..4e805769a0 100644 --- a/testsuites/validation/tc-scheduler-non-smp.c +++ b/testsuites/validation/tc-scheduler-non-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerValNonSmp + * @ingroup RtemsSchedulerValNonSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2023 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,28 +57,31 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerValNonSmp \ - * spec:/rtems/scheduler/val/non-smp + * @defgroup RtemsSchedulerValNonSmp spec:/rtems/scheduler/val/non-smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationNonSmp + * @ingroup TestsuitesValidationNonSmp * * @brief This test case collection provides validation test cases for non-SMP * requirements of the @ref RTEMSAPIClassicScheduler. * * This test case performs the following actions: * - * - Check that calling rtems_scheduler_get_processor() is a constant - * expression which evaluates to zero. + * - Assert that rtems_scheduler_get_processor() is a constant expression which + * evaluates to zero. + * + * - Check that calling rtems_scheduler_get_processor() returns zero. * - * - Check that calling rtems_scheduler_get_processor_maximum() is a constant + * - Assert that rtems_scheduler_get_processor_maximum() is a constant * expression which evaluates to zero. * + * - Check that calling rtems_scheduler_get_processor_maximum() returns one. + * * @{ */ /** - * @brief Check that calling rtems_scheduler_get_processor() is a constant - * expression which evaluates to zero. + * @brief Assert that rtems_scheduler_get_processor() is a constant expression + * which evaluates to zero. */ static void RtemsSchedulerValNonSmp_Action_0( void ) { @@ -86,11 +89,19 @@ static void RtemsSchedulerValNonSmp_Action_0( void ) } /** - * @brief Check that calling rtems_scheduler_get_processor_maximum() is a - * constant expression which evaluates to zero. + * @brief Check that calling rtems_scheduler_get_processor() returns zero. */ static void RtemsSchedulerValNonSmp_Action_1( void ) { + T_eq_u32( rtems_scheduler_get_processor(), 0 ); +} + +/** + * @brief Assert that rtems_scheduler_get_processor_maximum() is a constant + * expression which evaluates to zero. + */ +static void RtemsSchedulerValNonSmp_Action_2( void ) +{ RTEMS_STATIC_ASSERT( rtems_scheduler_get_processor_maximum() == 1, GET_PROCESSOR_MAXIMUM @@ -98,12 +109,23 @@ static void RtemsSchedulerValNonSmp_Action_1( void ) } /** + * @brief Check that calling rtems_scheduler_get_processor_maximum() returns + * one. + */ +static void RtemsSchedulerValNonSmp_Action_3( void ) +{ + T_eq_u32( rtems_scheduler_get_processor_maximum(), 1 ); +} + +/** * @fn void T_case_body_RtemsSchedulerValNonSmp( void ) */ T_TEST_CASE( RtemsSchedulerValNonSmp ) { RtemsSchedulerValNonSmp_Action_0(); RtemsSchedulerValNonSmp_Action_1(); + RtemsSchedulerValNonSmp_Action_2(); + RtemsSchedulerValNonSmp_Action_3(); } /** @} */ diff --git a/testsuites/validation/tc-scheduler-remove-processor.c b/testsuites/validation/tc-scheduler-remove-processor.c index 6be66fa961..f199389a33 100644 --- a/testsuites/validation/tc-scheduler-remove-processor.c +++ b/testsuites/validation/tc-scheduler-remove-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerReqRemoveProcessor + * @ingroup RtemsSchedulerReqRemoveProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,10 +63,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerReqRemoveProcessor \ + * @defgroup RtemsSchedulerReqRemoveProcessor \ * spec:/rtems/scheduler/req/remove-processor * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -177,12 +177,12 @@ typedef struct { /** * @brief This member contains the worker busy status. */ - volatile bool busy[ WORKER_COUNT ];; + volatile bool busy[ WORKER_COUNT ]; /** * @brief This member contains the worker busy status. */ - volatile uint32_t busy_counter[ WORKER_COUNT ];; + volatile uint32_t busy_counter[ WORKER_COUNT ]; /** * @brief This member contains the barrier to synchronize the runner and the @@ -193,7 +193,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member provides the context to wrap thread queue operations. @@ -246,7 +246,7 @@ typedef struct { /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_4 scheduler_log;; + T_scheduler_log_4 scheduler_log; /** * @brief This member contains the return value of the @@ -377,16 +377,22 @@ static void DoRemoveProcessor( Context *ctx ) } #if defined(RTEMS_SMP) -typedef enum { - EVENT_SYNC_RUNNER = RTEMS_EVENT_0, - EVENT_OBTAIN = RTEMS_EVENT_1, - EVENT_RELEASE = RTEMS_EVENT_2, - EVENT_STICKY_OBTAIN = RTEMS_EVENT_3, - EVENT_STICKY_RELEASE = RTEMS_EVENT_4, - EVENT_RESTART = RTEMS_EVENT_5, - EVENT_BUSY = RTEMS_EVENT_6, - EVENT_SYNC_RUNNER_LATE = RTEMS_EVENT_7 -} Event; + +#define EVENT_SYNC_RUNNER RTEMS_EVENT_0 + +#define EVENT_OBTAIN RTEMS_EVENT_1 + +#define EVENT_RELEASE RTEMS_EVENT_2 + +#define EVENT_STICKY_OBTAIN RTEMS_EVENT_3 + +#define EVENT_STICKY_RELEASE RTEMS_EVENT_4 + +#define EVENT_RESTART RTEMS_EVENT_5 + +#define EVENT_BUSY RTEMS_EVENT_6 + +#define EVENT_SYNC_RUNNER_LATE RTEMS_EVENT_7 static void Barriers( void *arg ) { @@ -413,7 +419,11 @@ static void RequestISR( void *arg ) CallWithinISRSubmit( &ctx->request ); } -static void SendAndSync( Context *ctx, WorkerIndex worker, Event event ) +static void SendAndSync( + Context *ctx, + WorkerIndex worker, + rtems_event_set event +) { SendEvents( ctx->worker_id[ worker ], EVENT_SYNC_RUNNER | event ); ReceiveAllEvents( EVENT_SYNC_RUNNER ); diff --git a/testsuites/validation/tc-scheduler-smp-only.c b/testsuites/validation/tc-scheduler-smp-only.c index 2a6f0b53c6..0455567aee 100644 --- a/testsuites/validation/tc-scheduler-smp-only.c +++ b/testsuites/validation/tc-scheduler-smp-only.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerValSmpOnly + * @ingroup RtemsSchedulerValSmpOnly */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -52,6 +52,7 @@ #include "config.h" #endif +#include <limits.h> #include <rtems.h> #include "ts-config.h" @@ -60,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerValSmpOnly \ - * spec:/rtems/scheduler/val/smp-only + * @defgroup RtemsSchedulerValSmpOnly spec:/rtems/scheduler/val/smp-only * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief This test case collection provides validation test cases for SMP-only * requirements of the @ref RTEMSAPIClassicScheduler. @@ -94,6 +94,9 @@ * * - Check that processor 1 has scheduler B assigned. * + * - Check that scheduler B has the maximum priority of the EDF SMP + * scheduler. + * * - Check that processor 2 has scheduler C assigned if it is present. * * - Check that processor 3 has scheduler C assigned if it is present. @@ -166,9 +169,10 @@ static void RtemsSchedulerValSmpOnly_Action_1( void ) */ static void RtemsSchedulerValSmpOnly_Action_2( void ) { - rtems_status_code sc; - rtems_id id[ 4 ]; - rtems_id id_by_cpu; + rtems_status_code sc; + rtems_id id[ 4 ]; + rtems_id id_by_cpu; + rtems_task_priority priority; sc = rtems_scheduler_ident( TEST_SCHEDULER_A_NAME, &id[ 0 ]); T_step_rsc_success( 3, sc ); @@ -217,16 +221,23 @@ static void RtemsSchedulerValSmpOnly_Action_2( void ) T_step_eq_u32( 14, id[ 1 ], id_by_cpu ); /* + * Check that scheduler B has the maximum priority of the EDF SMP scheduler. + */ + sc = rtems_scheduler_get_maximum_priority( id_by_cpu, &priority ); + T_step_rsc_success( 15, sc ); + T_step_eq_u32( 16, priority, (uint32_t) INT_MAX ); + + /* * Check that processor 2 has scheduler C assigned if it is present. */ sc = rtems_scheduler_ident_by_processor( 2, &id_by_cpu ); - T_step_true( 15, sc == RTEMS_INVALID_NAME || id[ 2 ] == id_by_cpu ); + T_step_true( 17, sc == RTEMS_INVALID_NAME || id[ 2 ] == id_by_cpu ); /* * Check that processor 3 has scheduler C assigned if it is present. */ sc = rtems_scheduler_ident_by_processor( 3, &id_by_cpu ); - T_step_true( 16, sc == RTEMS_INVALID_NAME || id[ 2 ] == id_by_cpu ); + T_step_true( 18, sc == RTEMS_INVALID_NAME || id[ 2 ] == id_by_cpu ); } /** @@ -234,7 +245,7 @@ static void RtemsSchedulerValSmpOnly_Action_2( void ) */ T_TEST_CASE( RtemsSchedulerValSmpOnly ) { - T_plan( 17 ); + T_plan( 19 ); RtemsSchedulerValSmpOnly_Action_0(); RtemsSchedulerValSmpOnly_Action_1(); diff --git a/testsuites/validation/tc-scheduler.c b/testsuites/validation/tc-scheduler.c index e930d3ee51..2f5b70fc1a 100644 --- a/testsuites/validation/tc-scheduler.c +++ b/testsuites/validation/tc-scheduler.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSchedulerValScheduler + * @ingroup RtemsSchedulerValScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSchedulerValScheduler \ - * spec:/rtems/scheduler/val/scheduler + * @defgroup RtemsSchedulerValScheduler spec:/rtems/scheduler/val/scheduler * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief This test case collection provides validation test cases for general * requirements of the @ref RTEMSAPIClassicScheduler. diff --git a/testsuites/validation/tc-score-fatal.c b/testsuites/validation/tc-score-fatal.c index 02131ee68e..b0a55f4664 100644 --- a/testsuites/validation/tc-score-fatal.c +++ b/testsuites/validation/tc-score-fatal.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreValFatal + * @ingroup ScoreValFatal */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2024 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -64,24 +64,31 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreValFatal spec:/score/val/fatal + * @defgroup ScoreValFatal spec:/score/val/fatal * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @brief Tests some fatal errors. * * This test case performs the following actions: * * - Construct a task with a task body which returns. Check that the right - * fatal error occurs. + * fatal error occurred. * - * - Construct a task which performs a thread dispatch with maskable interrupts - * disabled. Check that the right fatal error occurs or no fatal error - * occurs. + * - Construct a task which performs a direct thread dispatch with maskable + * interrupts disabled. Where robust thread dispatching is required, check + * that the right fatal error occurred, otherwise check that no fatal error + * occurred. + * + * - Construct a task which performs an on demand thread dispatch with maskable + * interrupts disabled. Where robust thread dispatching is required, check + * that the right fatal error occurred, otherwise check that no fatal error + * occurred. * * - Construct a task which performs a direct thread dispatch with a thread - * dispatch level not equal to one. Check that the right fatal error occurs. + * dispatch level not equal to one. Check that the right fatal error + * occurred. * * - Create a mutex and construct a task which produces a deadlock which * involves the allocator mutex. @@ -164,10 +171,11 @@ static void FatalBadThreadDispatchEnvironment( { Fatal( source, code, arg ); _ISR_Set_level( 0 ); - _Thread_Dispatch_direct_no_return( _Per_CPU_Get() ); + _Thread_Dispatch_unnest( _Per_CPU_Get() ); + rtems_task_exit(); } -static void ISRDisabledThreadDispatchTask( rtems_task_argument arg ) +static void ISRDisabledDirectThreadDispatchTask( rtems_task_argument arg ) { rtems_interrupt_level level; @@ -177,6 +185,16 @@ static void ISRDisabledThreadDispatchTask( rtems_task_argument arg ) rtems_task_exit(); } +static void ISRDisabledOnDemandThreadDispatchTask( rtems_task_argument arg ) +{ + rtems_interrupt_level level; + + (void) arg; + rtems_interrupt_local_disable( level ); + (void) level; + SetSelfPriority( PRIO_VERY_HIGH ); +} + static void FatalBadThreadDispatchDisableLevel( rtems_fatal_source source, rtems_fatal_code code, @@ -245,7 +263,7 @@ static T_fixture ScoreValFatal_Fixture = { /** * @brief Construct a task with a task body which returns. Check that the - * right fatal error occurs. + * right fatal error occurred. */ static void ScoreValFatal_Action_0( ScoreValFatal_Context *ctx ) { @@ -265,9 +283,10 @@ static void ScoreValFatal_Action_0( ScoreValFatal_Context *ctx ) } /** - * @brief Construct a task which performs a thread dispatch with maskable - * interrupts disabled. Check that the right fatal error occurs or no fatal - * error occurs. + * @brief Construct a task which performs a direct thread dispatch with + * maskable interrupts disabled. Where robust thread dispatching is + * required, check that the right fatal error occurred, otherwise check that + * no fatal error occurred. */ static void ScoreValFatal_Action_1( ScoreValFatal_Context *ctx ) { @@ -278,7 +297,40 @@ static void ScoreValFatal_Action_1( ScoreValFatal_Context *ctx ) SetSelfPriority( PRIO_NORMAL ); counter = ResetFatalInfo( ctx ); id = CreateTask( "BENV", PRIO_HIGH ); - StartTask( id, ISRDisabledThreadDispatchTask, NULL ); + StartTask( id, ISRDisabledDirectThreadDispatchTask, NULL ); + + #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE + if ( rtems_configuration_get_maximum_processors() > 1 ) { + #endif + T_eq_uint( GetFatalCounter( ctx ), counter + 1 ); + T_eq_int( ctx->source, INTERNAL_ERROR_CORE ); + T_eq_ulong( ctx->code, INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); + #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE + } else { + T_eq_uint( GetFatalCounter( ctx ), counter ); + } + #endif + + RestoreRunnerPriority(); + SetFatalHandler( NULL, NULL ); +} + +/** + * @brief Construct a task which performs an on demand thread dispatch with + * maskable interrupts disabled. Where robust thread dispatching is + * required, check that the right fatal error occurred, otherwise check that + * no fatal error occurred. + */ +static void ScoreValFatal_Action_2( ScoreValFatal_Context *ctx ) +{ + rtems_id id; + unsigned int counter; + + SetFatalHandler( FatalBadThreadDispatchEnvironment, ctx ); + SetSelfPriority( PRIO_NORMAL ); + counter = ResetFatalInfo( ctx ); + id = CreateTask( "BENV", PRIO_HIGH ); + StartTask( id, ISRDisabledOnDemandThreadDispatchTask, NULL ); #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE if ( rtems_configuration_get_maximum_processors() > 1 ) { @@ -299,9 +351,9 @@ static void ScoreValFatal_Action_1( ScoreValFatal_Context *ctx ) /** * @brief Construct a task which performs a direct thread dispatch with a * thread dispatch level not equal to one. Check that the right fatal error - * occurs. + * occurred. */ -static void ScoreValFatal_Action_2( ScoreValFatal_Context *ctx ) +static void ScoreValFatal_Action_3( ScoreValFatal_Context *ctx ) { rtems_id id; unsigned int counter; @@ -322,7 +374,7 @@ static void ScoreValFatal_Action_2( ScoreValFatal_Context *ctx ) * @brief Create a mutex and construct a task which produces a deadlock which * involves the allocator mutex. */ -static void ScoreValFatal_Action_3( ScoreValFatal_Context *ctx ) +static void ScoreValFatal_Action_4( ScoreValFatal_Context *ctx ) { rtems_extensions_table extensions; rtems_status_code sc; @@ -374,7 +426,7 @@ static void ScoreValFatal_Action_3( ScoreValFatal_Context *ctx ) * SetFatalHandler() requires an initial extension this validates * CONFIGURE_INITIAL_EXTENSIONS. */ -static void ScoreValFatal_Action_4( ScoreValFatal_Context *ctx ) +static void ScoreValFatal_Action_5( ScoreValFatal_Context *ctx ) { unsigned int counter; @@ -404,6 +456,7 @@ T_TEST_CASE_FIXTURE( ScoreValFatal, &ScoreValFatal_Fixture ) ScoreValFatal_Action_2( ctx ); ScoreValFatal_Action_3( ctx ); ScoreValFatal_Action_4( ctx ); + ScoreValFatal_Action_5( ctx ); } /** @} */ diff --git a/testsuites/validation/tc-score-isr.c b/testsuites/validation/tc-score-isr.c new file mode 100644 index 0000000000..b178541e72 --- /dev/null +++ b/testsuites/validation/tc-score-isr.c @@ -0,0 +1,285 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreIsrValIsr + */ + +/* + * Copyright (C) 2023 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> +#include <rtems/sysinit.h> +#include <rtems/score/percpu.h> +#include <rtems/score/thread.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreIsrValIsr spec:/score/isr/val/isr + * + * @ingroup TestsuitesValidationIntr + * + * @brief Tests general interrupt support behaviour. + * + * This test case performs the following actions: + * + * - Submit an ISR request during system initialization. Check the stack of + * the interrupted context while the ISR request is serviced. Store the + * result of the check in interrupted_stack_at_multitasking_start_is_valid. + * + * - Check that stack of the interrupted context was valid when an interrupt + * was serviced during the multitasking start. + * + * @{ + */ + +static uintptr_t interrupted_stack_at_multitasking_start; + +static bool interrupted_stack_at_multitasking_start_is_valid; + +#if defined(__aarch64__) +void __real_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ) +{ + if ( interrupted_stack_at_multitasking_start == 0 ) { + uintptr_t sp; + rtems_interrupt_level level; + + rtems_interrupt_local_disable( level ); + __asm__ volatile ( + "msr spsel, #1\n" + "mov %0, sp\n" + "msr spsel, #0" + : "=r" ( sp ) + ); + rtems_interrupt_local_enable( level ); + + interrupted_stack_at_multitasking_start = sp; + } + + __real_bsp_interrupt_dispatch(); +} +#endif + +#if defined(ARM_MULTILIB_ARCH_V4) +void __real_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ) +{ + register uintptr_t sp __asm__( "9" ); + + if ( interrupted_stack_at_multitasking_start == 0 ) { + interrupted_stack_at_multitasking_start = sp; + } + + __real_bsp_interrupt_dispatch(); +} +#endif + +#if defined(__microblaze__) +void __real_bsp_interrupt_dispatch( uint32_t source ); + +void __wrap_bsp_interrupt_dispatch( uint32_t source ); + +void __wrap_bsp_interrupt_dispatch( uint32_t source ) +{ + register uintptr_t sp __asm__( "1" ); + + if ( interrupted_stack_at_multitasking_start == 0 ) { + interrupted_stack_at_multitasking_start = sp; + } + + __real_bsp_interrupt_dispatch( source ); +} +#endif + +#if defined(__PPC__) || defined(__powerpc64__) +void __real_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ); + +void __wrap_bsp_interrupt_dispatch( void ) +{ + register uintptr_t sp __asm__( "14" ); + + if ( interrupted_stack_at_multitasking_start == 0 ) { + interrupted_stack_at_multitasking_start = sp; + } + + __real_bsp_interrupt_dispatch(); +} +#endif + +#if defined(__riscv) +void __real__RISCV_Interrupt_dispatch( + uintptr_t mcause, + Per_CPU_Control *cpu_self +); + +void __wrap__RISCV_Interrupt_dispatch( + uintptr_t mcause, + Per_CPU_Control *cpu_self +); + +void __wrap__RISCV_Interrupt_dispatch( + uintptr_t mcause, + Per_CPU_Control *cpu_self +) +{ + register uintptr_t sp __asm__( "s1" ); + + if ( interrupted_stack_at_multitasking_start == 0 ) { + interrupted_stack_at_multitasking_start = sp; + } + + __real__RISCV_Interrupt_dispatch( mcause, cpu_self ); +} +#endif + +#if defined(__sparc__) +void __real__SPARC_Interrupt_dispatch( uint32_t irq ); + +static RTEMS_USED void InterruptDispatch( uint32_t irq, uintptr_t sp ) +{ + if ( interrupted_stack_at_multitasking_start == 0 ) { + interrupted_stack_at_multitasking_start = sp; + } + + __real__SPARC_Interrupt_dispatch( irq ); +} + +__asm__ ( + "\t.section\t\".text\"\n" + "\t.align\t4\n" + "\t.globl\t__wrap__SPARC_Interrupt_dispatch\n" + "\t.type\t__wrap__SPARC_Interrupt_dispatch, #function\n" + "__wrap__SPARC_Interrupt_dispatch:\n" + "\tmov\t%fp, %o1\n" + "\tor\t%o7, %g0, %g1\n" + "\tcall\tInterruptDispatch, 0\n" + "\t or\t%g1, %g0, %o7\n" + "\t.previous\n" +); +#endif + +static void ISRHandler( void *arg ) +{ + uintptr_t begin; + uintptr_t end; + + (void) arg; + +#if defined(RTEMS_SMP) && !(defined(__PPC__) || (__powerpc64__)) + Per_CPU_Control *cpu_self; + + cpu_self = _Per_CPU_Get(); + begin = (uintptr_t) &cpu_self->Interrupt_frame; + end = begin + sizeof( cpu_self->Interrupt_frame ); +#else + Thread_Control *executing; + + executing = GetExecuting(); + begin = (uintptr_t) executing->Start.Initial_stack.area; + end = begin + executing->Start.Initial_stack.size; +#endif + + interrupted_stack_at_multitasking_start_is_valid = + ( begin <= interrupted_stack_at_multitasking_start && + interrupted_stack_at_multitasking_start < end ); +} + +static CallWithinISRRequest isr_request = { + .handler = ISRHandler +}; + +static void SubmitISRRequest( void ) +{ + CallWithinISRSubmit( &isr_request ); +} + +RTEMS_SYSINIT_ITEM( + SubmitISRRequest, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_LAST +); + +/** + * @brief Submit an ISR request during system initialization. Check the stack + * of the interrupted context while the ISR request is serviced. Store the + * result of the check in interrupted_stack_at_multitasking_start_is_valid. + */ +static void ScoreIsrValIsr_Action_0( void ) +{ + /* + * The actions are performed during system initialization and the + * multitasking start. + */ + + /* + * Check that stack of the interrupted context was valid when an interrupt + * was serviced during the multitasking start. + */ + T_true( interrupted_stack_at_multitasking_start_is_valid ); +} + +/** + * @fn void T_case_body_ScoreIsrValIsr( void ) + */ +T_TEST_CASE( ScoreIsrValIsr ) +{ + ScoreIsrValIsr_Action_0(); +} + +/** @} */ diff --git a/testsuites/validation/tc-score-smp-per-cpu-jobs.c b/testsuites/validation/tc-score-smp-per-cpu-jobs.c index dad4a6a90f..62812279cb 100644 --- a/testsuites/validation/tc-score-smp-per-cpu-jobs.c +++ b/testsuites/validation/tc-score-smp-per-cpu-jobs.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValPerCpuJobs + * @ingroup ScoreSmpValPerCpuJobs */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValPerCpuJobs \ - * spec:/score/smp/val/per-cpu-jobs + * @defgroup ScoreSmpValPerCpuJobs spec:/score/smp/val/per-cpu-jobs * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests the processing order of per-processor jobs. * diff --git a/testsuites/validation/tc-score-smp-thread.c b/testsuites/validation/tc-score-smp-thread.c index fc1dd394c2..38d2b26e29 100644 --- a/testsuites/validation/tc-score-smp-thread.c +++ b/testsuites/validation/tc-score-smp-thread.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValSmp + * @ingroup ScoreThreadValSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValSmp spec:/score/thread/val/smp + * @defgroup ScoreThreadValSmp spec:/score/thread/val/smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests SMP-specific thread behaviour. * @@ -159,17 +159,21 @@ typedef struct { static ScoreThreadValSmp_Context ScoreThreadValSmp_Instance; -typedef ScoreThreadValSmp_Context Context; +#define EVENT_OBTAIN RTEMS_EVENT_0 + +#define EVENT_RELEASE RTEMS_EVENT_1 + +#define EVENT_COUNT_EARLY RTEMS_EVENT_2 + +#define EVENT_BUSY RTEMS_EVENT_3 -typedef enum { - EVENT_OBTAIN = RTEMS_EVENT_0, - EVENT_RELEASE = RTEMS_EVENT_1, - EVENT_COUNT_EARLY = RTEMS_EVENT_2, - EVENT_BUSY = RTEMS_EVENT_3, - EVENT_COUNT = RTEMS_EVENT_4, - EVENT_LET_WORKER_C_COUNT = RTEMS_EVENT_5, - EVENT_SET_TASK_SWITCH_EXTENSION = RTEMS_EVENT_6 -} Event; +#define EVENT_COUNT RTEMS_EVENT_4 + +#define EVENT_LET_WORKER_C_COUNT RTEMS_EVENT_5 + +#define EVENT_SET_TASK_SWITCH_EXTENSION RTEMS_EVENT_6 + +typedef ScoreThreadValSmp_Context Context; static void TaskSwitchExtension( rtems_tcb *executing, rtems_tcb *heir ) { diff --git a/testsuites/validation/tc-score-thread-smp-one-cpu.c b/testsuites/validation/tc-score-thread-smp-one-cpu.c index 3375f27e1d..b3564d574e 100644 --- a/testsuites/validation/tc-score-thread-smp-one-cpu.c +++ b/testsuites/validation/tc-score-thread-smp-one-cpu.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValSmpOneCpu + * @ingroup ScoreThreadValSmpOneCpu */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValSmpOneCpu \ - * spec:/score/thread/val/smp-one-cpu + * @defgroup ScoreThreadValSmpOneCpu spec:/score/thread/val/smp-one-cpu * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOneCpu0 + * @ingroup TestsuitesValidationSmpOneCpu0 * * @brief Tests SMP-specific thread behaviour using only one processor and a * uniprocessor scheduler. @@ -98,11 +97,9 @@ typedef struct { static ScoreThreadValSmpOneCpu_Context ScoreThreadValSmpOneCpu_Instance; -typedef ScoreThreadValSmpOneCpu_Context Context; +#define EVENT_COUNT RTEMS_EVENT_0 -typedef enum { - EVENT_COUNT = RTEMS_EVENT_0 -} Event; +typedef ScoreThreadValSmpOneCpu_Context Context; static void WorkerTask( rtems_task_argument arg ) { diff --git a/testsuites/validation/tc-score-thread-tls-max-zero.c b/testsuites/validation/tc-score-thread-tls-max-zero.c index d0d367437e..6205147865 100644 --- a/testsuites/validation/tc-score-thread-tls-max-zero.c +++ b/testsuites/validation/tc-score-thread-tls-max-zero.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValTlsMaxZero + * @ingroup ScoreThreadValTlsMaxZero */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValTlsMaxZero \ - * spec:/score/thread/val/tls-max-zero + * @defgroup ScoreThreadValTlsMaxZero spec:/score/thread/val/tls-max-zero * - * @ingroup RTEMSTestSuiteTestsuitesValidationTls1 + * @ingroup TestsuitesValidationTls1 * * @brief Tests properties of thread-local objects. * diff --git a/testsuites/validation/tc-score-thread-tls.c b/testsuites/validation/tc-score-thread-tls.c index 0676d4249a..54d930d111 100644 --- a/testsuites/validation/tc-score-thread-tls.c +++ b/testsuites/validation/tc-score-thread-tls.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValTls + * @ingroup ScoreThreadValTls */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValTls spec:/score/thread/val/tls + * @defgroup ScoreThreadValTls spec:/score/thread/val/tls * - * @ingroup RTEMSTestSuiteTestsuitesValidationTls0 - * @ingroup RTEMSTestSuiteTestsuitesValidationTls1 + * @ingroup TestsuitesValidationTls0 + * @ingroup TestsuitesValidationTls1 * * @brief Tests properties of thread-local objects. * diff --git a/testsuites/validation/tc-score-thread.c b/testsuites/validation/tc-score-thread.c index 694fcaefab..e065905641 100644 --- a/testsuites/validation/tc-score-thread.c +++ b/testsuites/validation/tc-score-thread.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValThread + * @ingroup ScoreThreadValThread */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2023 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValThread spec:/score/thread/val/thread + * @defgroup ScoreThreadValThread spec:/score/thread/val/thread * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests general thread behaviour. * @@ -95,6 +95,22 @@ * * - Clean up all used resources. * + * - Validate the global construction. Mark that the test case executed. + * + * - Check that the global constructor was called exactly once. + * + * - Check that the global construction was done by the Classic API user + * initialization task. + * + * - Check that the global constructor was called before the task entry. + * + * - Validate that thread dispatching does not recurse. Issue a couple of + * thread context switches during a thread dispatch. Record the stack + * pointers of the heir threads. + * + * - Check that the thread dispatching did not recurse through the recorded + * stack pointers. + * * @{ */ @@ -116,6 +132,21 @@ typedef struct { * @brief This member contains a floating-point object. */ volatile double fp_obj; + + /** + * @brief This member indicates the thread switch state. + */ + int thread_switch_state; + + /** + * @brief This member contain the runner stack pointer at the context switch. + */ + uintptr_t runner_stack[ 2 ]; + + /** + * @brief This member contain the worker stack pointer at the context switch. + */ + uintptr_t worker_stack[ 2 ]; } ScoreThreadValThread_Context; static ScoreThreadValThread_Context @@ -123,6 +154,21 @@ static ScoreThreadValThread_Context typedef ScoreThreadValThread_Context Context; +static bool test_case_executed; + +static bool constructor_test_case_executed; + +static uint32_t constructor_calls; + +static rtems_id constructor_id; + +static __attribute__(( __constructor__ )) void Constructor( void ) +{ + constructor_test_case_executed = test_case_executed; + ++constructor_calls; + constructor_id = rtems_task_self(); +} + static void TaskTerminate( rtems_tcb *executing ) { Context *ctx; @@ -171,6 +217,44 @@ static void KillerTask( rtems_task_argument arg ) DeleteTask( ctx->worker_id ); } +static void TaskSwitch( rtems_tcb *executing, rtems_tcb *heir ) +{ + Context *ctx; + rtems_id worker_id; + int state; + uintptr_t heir_stack; + + ctx = T_fixture_context(); + worker_id = ctx->worker_id; + state = ctx->thread_switch_state; + ctx->thread_switch_state = state + 1; + heir_stack = _CPU_Context_Get_SP( &heir->Registers ); + + switch ( state ) { + case 0: + T_eq_u32( heir->Object.id, worker_id ); + SuspendTask( worker_id ); + ctx->worker_stack[ 0 ] = heir_stack; + break; + case 1: + T_eq_u32( executing->Object.id, worker_id ); + ResumeTask( worker_id ); + ctx->runner_stack[ 0 ] = heir_stack; + break; + case 2: + T_eq_u32( heir->Object.id, worker_id ); + SuspendTask( worker_id ); + ctx->worker_stack[ 1 ] = heir_stack; + break; + case 3: + T_eq_u32( executing->Object.id, worker_id ); + ctx->runner_stack[ 1 ] = heir_stack; + break; + default: + T_unreachable(); + } +} + static T_fixture ScoreThreadValThread_Fixture = { .setup = NULL, .stop = NULL, @@ -290,6 +374,61 @@ static void ScoreThreadValThread_Action_1( ScoreThreadValThread_Context *ctx ) } /** + * @brief Validate the global construction. Mark that the test case executed. + */ +static void ScoreThreadValThread_Action_2( ScoreThreadValThread_Context *ctx ) +{ + test_case_executed = true; + + /* + * Check that the global constructor was called exactly once. + */ + T_eq_u32( constructor_calls, 1 ); + + /* + * Check that the global construction was done by the Classic API user + * initialization task. + */ + T_eq_u32( constructor_id, rtems_task_self() ); + + /* + * Check that the global constructor was called before the task entry. + */ + T_false( constructor_test_case_executed ); +} + +/** + * @brief Validate that thread dispatching does not recurse. Issue a couple of + * thread context switches during a thread dispatch. Record the stack + * pointers of the heir threads. + */ +static void ScoreThreadValThread_Action_3( ScoreThreadValThread_Context *ctx ) +{ + SetSelfPriority( PRIO_NORMAL ); + ctx->worker_id = CreateTask( "WORK", PRIO_HIGH ); + StartTask( ctx->worker_id, WorkerTask, NULL ); + + ctx->thread_switch_state = 0; + ctx->runner_stack[ 0 ] = 0; + ctx->runner_stack[ 1 ] = 1; + ctx->worker_stack[ 0 ] = 0; + ctx->worker_stack[ 1 ] = 1; + SetTaskSwitchExtension( TaskSwitch ); + ResumeTask( ctx->worker_id ); + + SetTaskSwitchExtension( NULL ); + DeleteTask( ctx->worker_id ); + RestoreRunnerPriority(); + + /* + * Check that the thread dispatching did not recurse through the recorded + * stack pointers. + */ + T_eq_uptr( ctx->runner_stack[ 0 ], ctx->runner_stack[ 1 ] ); + T_eq_uptr( ctx->worker_stack[ 0 ], ctx->worker_stack[ 1 ] ); +} + +/** * @fn void T_case_body_ScoreThreadValThread( void ) */ T_TEST_CASE_FIXTURE( ScoreThreadValThread, &ScoreThreadValThread_Fixture ) @@ -300,6 +439,8 @@ T_TEST_CASE_FIXTURE( ScoreThreadValThread, &ScoreThreadValThread_Fixture ) ScoreThreadValThread_Action_0( ctx ); ScoreThreadValThread_Action_1( ctx ); + ScoreThreadValThread_Action_2( ctx ); + ScoreThreadValThread_Action_3( ctx ); } /** @} */ diff --git a/testsuites/validation/tc-score-tq-smp.c b/testsuites/validation/tc-score-tq-smp.c index 4eff2de3c6..624ad0e7b6 100644 --- a/testsuites/validation/tc-score-tq-smp.c +++ b/testsuites/validation/tc-score-tq-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqValSmp + * @ingroup ScoreTqValSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqValSmp spec:/score/tq/val/smp + * @defgroup ScoreTqValSmp spec:/score/tq/val/smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests SMP-specific thread queue behaviour. * diff --git a/testsuites/validation/tc-score-tq.c b/testsuites/validation/tc-score-tq.c new file mode 100644 index 0000000000..5439d910f5 --- /dev/null +++ b/testsuites/validation/tc-score-tq.c @@ -0,0 +1,190 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreTqValTq + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tx-support.h" +#include "tx-thread-queue.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreTqValTq spec:/score/tq/val/tq + * + * @ingroup TestsuitesValidationNoClock0 + * + * @brief Tests special thread queue behaviour. + * + * This test case performs the following actions: + * + * - Use two worker threads to provoke a deadlock detection involving a thread + * queue with no owner. + * + * - Let blocker A obtain mutex A. + * + * - Let blocker A block on a counting semaphore. + * + * - Let blocker B block on mutex A. The deadlock detection will stop since + * blocker A blocks on the counting semaphore which has no owner. + * + * - Clean up all used resources. + * + * @{ + */ + +/** + * @brief Test context for spec:/score/tq/val/tq test case. + */ +typedef struct { + /** + * @brief This member contains the thread queue test context. + */ + TQContext tq_ctx; +} ScoreTqValTq_Context; + +static ScoreTqValTq_Context + ScoreTqValTq_Instance; + +static void ScoreTqValTq_Setup( ScoreTqValTq_Context *ctx ) +{ + rtems_status_code sc; + + SetSelfPriority( PRIO_NORMAL ); + TQInitialize( &ctx->tq_ctx ); + + /* Replace mutex D with a counting semaphore */ + DeleteMutex( ctx->tq_ctx.mutex_id[ TQ_MUTEX_D ] ); + sc = rtems_semaphore_create( + rtems_build_name( 'C', 'S', 'E', 'M' ), + 0, + RTEMS_COUNTING_SEMAPHORE | RTEMS_PRIORITY, + 0, + &ctx->tq_ctx.mutex_id[ TQ_MUTEX_D ] + ); + T_rsc_success( sc ); +} + +static void ScoreTqValTq_Setup_Wrap( void *arg ) +{ + ScoreTqValTq_Context *ctx; + + ctx = arg; + ScoreTqValTq_Setup( ctx ); +} + +static void ScoreTqValTq_Teardown( ScoreTqValTq_Context *ctx ) +{ + TQDestroy( &ctx->tq_ctx ); + RestoreRunnerPriority(); +} + +static void ScoreTqValTq_Teardown_Wrap( void *arg ) +{ + ScoreTqValTq_Context *ctx; + + ctx = arg; + ScoreTqValTq_Teardown( ctx ); +} + +static T_fixture ScoreTqValTq_Fixture = { + .setup = ScoreTqValTq_Setup_Wrap, + .stop = NULL, + .teardown = ScoreTqValTq_Teardown_Wrap, + .scope = NULL, + .initial_context = &ScoreTqValTq_Instance +}; + +/** + * @brief Use two worker threads to provoke a deadlock detection involving a + * thread queue with no owner. + */ +static void ScoreTqValTq_Action_0( ScoreTqValTq_Context *ctx ) +{ + TQReset( &ctx->tq_ctx ); + + /* + * Let blocker A obtain mutex A. + */ + TQSend( &ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_MUTEX_A_OBTAIN ); + + /* + * Let blocker A block on a counting semaphore. + */ + TQSend( &ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_MUTEX_D_OBTAIN ); + + /* + * Let blocker B block on mutex A. The deadlock detection will stop since + * blocker A blocks on the counting semaphore which has no owner. + */ + TQSend( &ctx->tq_ctx, TQ_BLOCKER_B, TQ_EVENT_MUTEX_A_OBTAIN ); + + /* + * Clean up all used resources. + */ + TQMutexRelease( &ctx->tq_ctx, TQ_MUTEX_D ); + TQSend( &ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_MUTEX_A_RELEASE ); + TQSend( &ctx->tq_ctx, TQ_BLOCKER_B, TQ_EVENT_MUTEX_A_RELEASE ); +} + +/** + * @fn void T_case_body_ScoreTqValTq( void ) + */ +T_TEST_CASE_FIXTURE( ScoreTqValTq, &ScoreTqValTq_Fixture ) +{ + ScoreTqValTq_Context *ctx; + + ctx = T_fixture_context(); + + ScoreTqValTq_Action_0( ctx ); +} + +/** @} */ diff --git a/testsuites/validation/tc-sem-create.c b/testsuites/validation/tc-sem-create.c index 7012c28275..9975cb0778 100644 --- a/testsuites/validation/tc-sem-create.c +++ b/testsuites/validation/tc-sem-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqCreate + * @ingroup RtemsSemReqCreate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqCreate spec:/rtems/sem/req/create + * @defgroup RtemsSemReqCreate spec:/rtems/sem/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -224,15 +224,15 @@ typedef struct { rtems_status_code status; - Semaphore_Variant variant;; + Semaphore_Variant variant; - Semaphore_Discipline discipline;; + Semaphore_Discipline discipline; - uint32_t sem_count;; + uint32_t sem_count; - Thread_Control *executing;; + Thread_Control *executing; - Thread_Control *owner;; + Thread_Control *owner; rtems_name name; diff --git a/testsuites/validation/tc-sem-delete.c b/testsuites/validation/tc-sem-delete.c index 7c31547eba..188b532870 100644 --- a/testsuites/validation/tc-sem-delete.c +++ b/testsuites/validation/tc-sem-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqDelete + * @ingroup RtemsSemReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqDelete spec:/rtems/sem/req/delete + * @defgroup RtemsSemReqDelete spec:/rtems/sem/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-sem-flush.c b/testsuites/validation/tc-sem-flush.c index af8f5407cd..4fb2027354 100644 --- a/testsuites/validation/tc-sem-flush.c +++ b/testsuites/validation/tc-sem-flush.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqFlush + * @ingroup RtemsSemReqFlush */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -64,9 +64,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqFlush spec:/rtems/sem/req/flush + * @defgroup RtemsSemReqFlush spec:/rtems/sem/req/flush * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -118,7 +118,7 @@ typedef struct { /** * @brief This member contains the thread queue test context. */ - TQContext tq_ctx;; + TQContext tq_ctx; /** * @brief This member specifies if the attribute set of the semaphore. @@ -228,12 +228,16 @@ static Status_Control Enqueue( TQContext *tq_ctx, TQWait wait ) return STATUS_BUILD( STATUS_SUCCESSFUL, 0 ); } -static void Flush( TQContext *tq_ctx ) +static uint32_t Flush( TQContext *tq_ctx, uint32_t thread_count, bool all ) { rtems_status_code sc; + (void) all; + sc = rtems_semaphore_flush( tq_ctx->thread_queue_id ); T_rsc_success( sc ); + + return thread_count; } static void RtemsSemReqFlush_Pre_Class_Prepare( @@ -401,16 +405,16 @@ static void RtemsSemReqFlush_Post_Action_Check( case RtemsSemReqFlush_Post_Action_FlushFIFO: { /* * The calling task shall flush the semaphore as specified by - * /score/tq/req/flush-fifo. + * spec:/score/tq/req/flush-fifo. */ - ScoreTqReqFlushFifo_Run( &ctx->tq_ctx ); + ScoreTqReqFlushFifo_Run( &ctx->tq_ctx, false ); break; } case RtemsSemReqFlush_Post_Action_FlushPriority: { /* * The calling task shall flush the semaphore as specified by - * /score/tq/req/flush-priority. + * spec:/score/tq/req/flush-priority. */ ScoreTqReqFlushPriority_Run( &ctx->tq_ctx, true ); break; @@ -419,7 +423,7 @@ static void RtemsSemReqFlush_Post_Action_Check( case RtemsSemReqFlush_Post_Action_FlushPriorityCeiling: { /* * The calling task shall flush the semaphore as specified by - * /score/tq/req/flush-priority. + * spec:/score/tq/req/flush-priority. */ ScoreTqReqFlushPriority_Run( &ctx->tq_ctx, false ); break; @@ -428,7 +432,7 @@ static void RtemsSemReqFlush_Post_Action_Check( case RtemsSemReqFlush_Post_Action_FlushPriorityInherit: { /* * The calling task shall flush the semaphore as specified by - * /score/tq/req/flush-priority-inherit. + * spec:/score/tq/req/flush-priority-inherit. */ ScoreTqReqFlushPriorityInherit_Run( &ctx->tq_ctx ); break; @@ -494,7 +498,9 @@ static void RtemsSemReqFlush_Action( RtemsSemReqFlush_Context *ctx ) static void RtemsSemReqFlush_Cleanup( RtemsSemReqFlush_Context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_delete( ctx->tq_ctx.thread_queue_id ); T_rsc_success( sc ); + + sc = rtems_semaphore_delete( ctx->tq_ctx.thread_queue_id ); + T_rsc_success( sc ); } static const RtemsSemReqFlush_Entry diff --git a/testsuites/validation/tc-sem-ident.c b/testsuites/validation/tc-sem-ident.c index 3014113189..abeddfa5e2 100644 --- a/testsuites/validation/tc-sem-ident.c +++ b/testsuites/validation/tc-sem-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemValIdent + * @ingroup RtemsSemValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemValIdent spec:/rtems/sem/val/ident + * @defgroup RtemsSemValIdent spec:/rtems/sem/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_semaphore_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API semaphore - * class objects defined by /rtems/req/ident. + * class objects defined by spec:/rtems/req/ident. * * @{ */ @@ -84,7 +84,7 @@ static rtems_status_code ClassicSemIdentAction( /** * @brief Run the generic object identification tests for Classic API semaphore - * class objects defined by /rtems/req/ident. + * class objects defined by spec:/rtems/req/ident. */ static void RtemsSemValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-sem-mrsp-obtain.c b/testsuites/validation/tc-sem-mrsp-obtain.c index dcbf7655ab..e7d50c34da 100644 --- a/testsuites/validation/tc-sem-mrsp-obtain.c +++ b/testsuites/validation/tc-sem-mrsp-obtain.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqMrspObtain + * @ingroup RtemsSemReqMrspObtain */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqMrspObtain spec:/rtems/sem/req/mrsp-obtain + * @defgroup RtemsSemReqMrspObtain spec:/rtems/sem/req/mrsp-obtain * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @{ */ diff --git a/testsuites/validation/tc-sem-obtain.c b/testsuites/validation/tc-sem-obtain.c index b07421f186..10c4475d8c 100644 --- a/testsuites/validation/tc-sem-obtain.c +++ b/testsuites/validation/tc-sem-obtain.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqObtain + * @ingroup RtemsSemReqObtain */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -65,9 +65,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqObtain spec:/rtems/sem/req/obtain + * @defgroup RtemsSemReqObtain spec:/rtems/sem/req/obtain * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -390,7 +390,7 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_SemSeizeTry: { /* * The calling task shall try to seize the semaphore as specified by - * /score/sem/req/seize-try. + * spec:/score/sem/req/seize-try. */ ctx->tq_sem_ctx.get_count = TQSemGetCountClassic; ctx->tq_sem_ctx.set_count = TQSemSetCountClassic; @@ -401,7 +401,7 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_SemSeizeWait: { /* * The calling task shall wait to seize the semaphore as specified by - * /score/sem/req/seize-wait. + * spec:/score/sem/req/seize-wait. */ ctx->tq_sem_ctx.get_count = TQSemGetCountClassic; ctx->tq_sem_ctx.set_count = TQSemSetCountClassic; @@ -412,8 +412,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_MtxSeizeTry: { /* * The calling task shall try to seize the mutex as specified by - * /score/mtx/req/seize-try where an enqueue blocks, a recursive seize is - * allowed, and no locking protocol is used. + * spec:/score/mtx/req/seize-try where an enqueue blocks, a recursive + * seize is allowed, and no locking protocol is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_NO_PROTOCOL; @@ -426,8 +426,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_MtxSeizeWait: { /* * The calling task shall wait to seize the mutex as specified by - * /score/mtx/req/seize-wait where an enqueue blocks, a recursive seize - * is allowed, and no locking protocol is used. + * spec:/score/mtx/req/seize-wait where an enqueue blocks, a recursive + * seize is allowed, and no locking protocol is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_NO_PROTOCOL; @@ -440,8 +440,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_InheritMtxSeizeTry: { /* * The calling task shall try to seize the mutex as specified by - * /score/mtx/req/seize-try where an enqueue blocks, a recursive seize is - * allowed, and a priority inheritance protocol is used. + * spec:/score/mtx/req/seize-try where an enqueue blocks, a recursive + * seize is allowed, and a priority inheritance protocol is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_NO_PROTOCOL; @@ -454,8 +454,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_InheritMtxSeizeWait: { /* * The calling task shall wait to seize the mutex as specified by - * /score/mtx/req/seize-wait where an enqueue blocks, a recursive seize - * is allowed, and a priority inheritance protocol is used. + * spec:/score/mtx/req/seize-wait where an enqueue blocks, a recursive + * seize is allowed, and a priority inheritance protocol is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_NO_PROTOCOL; @@ -468,8 +468,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_CeilingMtxSeizeTry: { /* * The calling task shall try to seize the mutex as specified by - * /score/mtx/req/seize-try where an enqueue blocks, a recursive seize is - * allowed, and a priority ceiling is used. + * spec:/score/mtx/req/seize-try where an enqueue blocks, a recursive + * seize is allowed, and a priority ceiling is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_PRIORITY_CEILING; @@ -482,8 +482,8 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_CeilingMtxSeizeWait: { /* * The calling task shall wait to seize the mutex as specified by - * /score/mtx/req/seize-wait where an enqueue blocks, a recursive seize - * is allowed, and a priority ceiling is used. + * spec:/score/mtx/req/seize-wait where an enqueue blocks, a recursive + * seize is allowed, and a priority ceiling is used. */ ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_mtx_ctx.protocol = TQ_MTX_PRIORITY_CEILING; @@ -496,28 +496,36 @@ static void RtemsSemReqObtain_Post_Action_Check( case RtemsSemReqObtain_Post_Action_MrsPMtxSeizeTry: { /* * The calling task shall try to seize the mutex as specified by - * /score/mtx/req/seize-try where an enqueue is sticky, a recursive seize - * returns an error status, and a priority ceiling is used. + * spec:/score/mtx/req/seize-try where an enqueue is sticky, a recursive + * seize returns an error status, and a priority ceiling is used. */ + #if defined(RTEMS_SMP) ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_STICKY; ctx->tq_mtx_ctx.protocol = TQ_MTX_MRSP; ctx->tq_mtx_ctx.recursive = TQ_MTX_RECURSIVE_DEADLOCK; ctx->tq_mtx_ctx.priority_ceiling = PRIO_VERY_HIGH; ScoreMtxReqSeizeTry_Run( &ctx->tq_mtx_ctx ); + #else + T_unreachable(); + #endif break; } case RtemsSemReqObtain_Post_Action_MrsPMtxSeizeWait: { /* * The calling task shall wait to seize the mutex as specified by - * /score/mtx/req/seize-wait where an enqueue is sticky, a recursive + * spec:/score/mtx/req/seize-wait where an enqueue is sticky, a recursive * seize returns an error status, and a priority ceiling is used. */ + #if defined(RTEMS_SMP) ctx->tq_mtx_ctx.base.enqueue_variant = TQ_ENQUEUE_STICKY; ctx->tq_mtx_ctx.protocol = TQ_MTX_MRSP; ctx->tq_mtx_ctx.recursive = TQ_MTX_RECURSIVE_DEADLOCK; ctx->tq_mtx_ctx.priority_ceiling = PRIO_VERY_HIGH; ScoreMtxReqSeizeWait_Run( &ctx->tq_mtx_ctx ); + #else + T_unreachable(); + #endif break; } @@ -580,6 +588,7 @@ static void RtemsSemReqObtain_Action( RtemsSemReqObtain_Context *ctx ) ); T_rsc_success( sc ); + #if defined(RTEMS_SMP) if ( ( ctx->attribute_set & RTEMS_MULTIPROCESSOR_RESOURCE_SHARING ) != 0 ) { rtems_task_priority prio; @@ -591,6 +600,7 @@ static void RtemsSemReqObtain_Action( RtemsSemReqObtain_Context *ctx ) ); T_rsc_success( sc ); } + #endif } static void RtemsSemReqObtain_Cleanup( RtemsSemReqObtain_Context *ctx ) @@ -606,33 +616,28 @@ RtemsSemReqObtain_Entries[] = { { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_SemSeizeWait }, { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_SemSeizeTry }, { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_MtxSeizeWait }, -#if defined(RTEMS_SMP) - { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_InvId }, -#else - { 1, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_NA }, -#endif { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_MtxSeizeTry }, { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_CeilingMtxSeizeWait }, { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_InheritMtxSeizeWait }, #if defined(RTEMS_SMP) { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_MrsPMtxSeizeWait }, #else - { 1, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_NA }, + { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_CeilingMtxSeizeWait }, #endif { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_CeilingMtxSeizeTry }, { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_InheritMtxSeizeTry }, #if defined(RTEMS_SMP) { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_MrsPMtxSeizeTry } #else - { 1, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_NA } + { 0, 0, 0, 0, 0, RtemsSemReqObtain_Post_Action_CeilingMtxSeizeTry } #endif }; static const uint8_t RtemsSemReqObtain_Map[] = { - 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 6, 4, - 4, 0, 0, 0, 6, 4, 4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 10, 7, 7, 0, 0, 0, 1, 1, 1, - 1, 1, 1, 11, 8, 8, 0, 0, 0, 1, 1, 1, 1, 1, 1, 12, 9, 9, 5, 5, 5 + 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 3, 2, 2, 0, 0, 0, 5, 4, + 4, 0, 0, 0, 5, 4, 4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 9, 6, 6, 0, 0, 0, 1, 1, 1, 1, + 1, 1, 10, 7, 7, 0, 0, 0, 1, 1, 1, 1, 1, 1, 11, 8, 8, 0, 0, 0 }; static size_t RtemsSemReqObtain_Scope( void *arg, char *buf, size_t n ) diff --git a/testsuites/validation/tc-sem-performance.c b/testsuites/validation/tc-sem-performance.c index 5bbff6a587..5861e3ee8e 100644 --- a/testsuites/validation/tc-sem-performance.c +++ b/testsuites/validation/tc-sem-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemValPerf + * @ingroup RtemsSemValPerf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemValPerf spec:/rtems/sem/val/perf + * @defgroup RtemsSemValPerf spec:/rtems/sem/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicSem * performance tests. @@ -112,15 +112,17 @@ typedef struct { static RtemsSemValPerf_Context RtemsSemValPerf_Instance; -typedef RtemsSemValPerf_Context Context; +#define EVENT_END RTEMS_EVENT_0 + +#define EVENT_OBTAIN RTEMS_EVENT_1 + +#define EVENT_OBTAIN_END RTEMS_EVENT_2 -typedef enum { - EVENT_END = RTEMS_EVENT_0, - EVENT_OBTAIN = RTEMS_EVENT_1, - EVENT_OBTAIN_END = RTEMS_EVENT_2, - EVENT_RELEASE = RTEMS_EVENT_3, - EVENT_RELEASE_END = RTEMS_EVENT_4 -} Event; +#define EVENT_RELEASE RTEMS_EVENT_3 + +#define EVENT_RELEASE_END RTEMS_EVENT_4 + +typedef RtemsSemValPerf_Context Context; static void Send( const Context *ctx, rtems_event_set events ) { @@ -236,6 +238,12 @@ static T_fixture RtemsSemValPerf_Fixture = { }; /** + * @defgroup RtemsSemReqPerfMtxPiObtain spec:/rtems/sem/req/perf-mtx-pi-obtain + * + * @{ + */ + +/** * @brief Obtain the available mutex. */ static void RtemsSemReqPerfMtxPiObtain_Body( RtemsSemValPerf_Context *ctx ) @@ -287,6 +295,15 @@ static bool RtemsSemReqPerfMtxPiObtain_Teardown_Wrap( return RtemsSemReqPerfMtxPiObtain_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsSemReqPerfMtxPiRelease \ + * spec:/rtems/sem/req/perf-mtx-pi-release + * + * @{ + */ + /** * @brief Obtain the mutex. */ @@ -349,6 +366,15 @@ static bool RtemsSemReqPerfMtxPiRelease_Teardown_Wrap( return RtemsSemReqPerfMtxPiRelease_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsSemReqPerfMtxPiReleaseOne \ + * spec:/rtems/sem/req/perf-mtx-pi-release-one + * + * @{ + */ + /** * @brief Let one task wait on the mutex. */ @@ -356,9 +382,10 @@ static void RtemsSemReqPerfMtxPiReleaseOne_Setup( RtemsSemValPerf_Context *ctx ) { + SetSelfPriority( PRIO_HIGH ); ObtainMutex( ctx->mutex_id ); Send( ctx, EVENT_OBTAIN ); - SetPriority( ctx->worker_id, PRIO_LOW ); + Yield(); Send( ctx, EVENT_RELEASE ); } @@ -375,6 +402,11 @@ static void RtemsSemReqPerfMtxPiReleaseOne_Setup_Wrap( void *arg ) */ static void RtemsSemReqPerfMtxPiReleaseOne_Body( RtemsSemValPerf_Context *ctx ) { + /* + * The release will unblock the worker task which has our priority. The + * scheduler ensures FIFO ordering for ready threads of the same priority, so + * the release will not preempt us. + */ ctx->status = rtems_semaphore_release( ctx->mutex_id ); } @@ -400,7 +432,7 @@ static bool RtemsSemReqPerfMtxPiReleaseOne_Teardown( { T_quiet_rsc( ctx->status, RTEMS_SUCCESSFUL ); - SetPriority( ctx->worker_id, PRIO_HIGH ); + SetSelfPriority( PRIO_NORMAL ); return tic == toc; } @@ -425,8 +457,17 @@ static bool RtemsSemReqPerfMtxPiReleaseOne_Teardown_Wrap( ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsSemReqPerfMtxPiReleaseOtherCpu \ + * spec:/rtems/sem/req/perf-mtx-pi-release-other-cpu + * + * @{ + */ + +/** * @brief Move worker to scheduler B. */ static void RtemsSemReqPerfMtxPiReleaseOtherCpu_Prepare( @@ -524,9 +565,18 @@ static void RtemsSemReqPerfMtxPiReleaseOtherCpu_Cleanup( { SetScheduler( ctx->worker_id, SCHEDULER_A_ID, PRIO_HIGH ); } + +/** @} */ #endif /** + * @defgroup RtemsSemReqPerfMtxPiReleasePreempt \ + * spec:/rtems/sem/req/perf-mtx-pi-release-preempt + * + * @{ + */ + +/** * @brief Let one task wait on the mutex. */ static void RtemsSemReqPerfMtxPiReleasePreempt_Setup( @@ -603,6 +653,14 @@ static bool RtemsSemReqPerfMtxPiReleasePreempt_Teardown_Wrap( ); } +/** @} */ + +/** + * @defgroup RtemsSemReqPerfMtxPiTry spec:/rtems/sem/req/perf-mtx-pi-try + * + * @{ + */ + /** * @brief Make the mutex unavailable. */ @@ -665,6 +723,15 @@ static void RtemsSemReqPerfMtxPiTry_Cleanup( RtemsSemValPerf_Context *ctx ) Send( ctx, EVENT_RELEASE ); } +/** @} */ + +/** + * @defgroup RtemsSemReqPerfMtxPiWaitForever \ + * spec:/rtems/sem/req/perf-mtx-pi-wait-forever + * + * @{ + */ + /** * @brief Make the mutex unavailable. */ @@ -673,7 +740,7 @@ static void RtemsSemReqPerfMtxPiWaitForever_Setup( ) { Send( ctx, EVENT_OBTAIN ); - SetPriority( ctx->worker_id, PRIO_LOW ); + SetSelfPriority( PRIO_VERY_HIGH ); Send( ctx, EVENT_END | EVENT_RELEASE ); } @@ -723,8 +790,8 @@ static bool RtemsSemReqPerfMtxPiWaitForever_Teardown( T_quiet_rsc( ctx->status, RTEMS_SUCCESSFUL ); *delta = ctx->end - ctx->begin; - SetPriority( ctx->worker_id, PRIO_HIGH ); ReleaseMutex( ctx->mutex_id ); + SetSelfPriority( PRIO_NORMAL ); return tic == toc; } @@ -749,13 +816,22 @@ static bool RtemsSemReqPerfMtxPiWaitForever_Teardown_Wrap( ); } +/** @} */ + +/** + * @defgroup RtemsSemReqPerfMtxPiWaitTimed \ + * spec:/rtems/sem/req/perf-mtx-pi-wait-timed + * + * @{ + */ + /** * @brief Make the mutex unavailable. */ static void RtemsSemReqPerfMtxPiWaitTimed_Setup( RtemsSemValPerf_Context *ctx ) { Send( ctx, EVENT_OBTAIN ); - SetPriority( ctx->worker_id, PRIO_LOW ); + SetSelfPriority( PRIO_VERY_HIGH ); Send( ctx, EVENT_END | EVENT_RELEASE ); } @@ -803,8 +879,8 @@ static bool RtemsSemReqPerfMtxPiWaitTimed_Teardown( T_quiet_rsc( ctx->status, RTEMS_SUCCESSFUL ); *delta = ctx->end - ctx->begin; - SetPriority( ctx->worker_id, PRIO_HIGH ); ReleaseMutex( ctx->mutex_id ); + SetSelfPriority( PRIO_NORMAL ); return tic == toc; } @@ -823,6 +899,8 @@ static bool RtemsSemReqPerfMtxPiWaitTimed_Teardown_Wrap( return RtemsSemReqPerfMtxPiWaitTimed_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + /** * @fn void T_case_body_RtemsSemValPerf( void ) */ diff --git a/testsuites/validation/tc-sem-release.c b/testsuites/validation/tc-sem-release.c index cfb5315a2a..1e9c2091c0 100644 --- a/testsuites/validation/tc-sem-release.c +++ b/testsuites/validation/tc-sem-release.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqRelease + * @ingroup RtemsSemReqRelease */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqRelease spec:/rtems/sem/req/release + * @defgroup RtemsSemReqRelease spec:/rtems/sem/req/release * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -331,7 +331,7 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_BinarySurrender: { /* * The calling task shall surrender the binary semaphore as specified by - * /score/sem/req/surrender. + * spec:/score/sem/req/surrender. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_ctx.get_owner = NULL; @@ -345,7 +345,7 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_CountingSurrender: { /* * The calling task shall surrender the counting semaphore as specified - * by /score/sem/req/surrender. + * by spec:/score/sem/req/surrender. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_ctx.get_owner = NULL; @@ -359,8 +359,9 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_MtxSurrender: { /* * The calling task shall surrender the mutex as specified by - * /score/mtx/req/surrender where an enqueue blocks, a recursive seize is - * allowed, the owner is checked, and no locking protocol is used. + * spec:/score/mtx/req/surrender where an enqueue blocks, a recursive + * seize is allowed, the owner is checked, and no locking protocol is + * used. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_ctx.get_owner = TQGetOwnerClassicSem; @@ -375,9 +376,9 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_InheritMtxSurrender: { /* * The calling task shall surrender the mutex as specified by - * /score/mtx/req/surrender where an enqueue blocks, a recursive seize is - * allowed, the owner is checked, and a priority inheritance protocol is - * used. + * spec:/score/mtx/req/surrender where an enqueue blocks, a recursive + * seize is allowed, the owner is checked, and a priority inheritance + * protocol is used. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_ctx.get_owner = TQGetOwnerClassicSem; @@ -392,8 +393,9 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_CeilingMtxSurrender: { /* * The calling task shall surrender the mutex as specified by - * /score/mtx/req/surrender where an enqueue blocks, a recursive seize is - * allowed, the owner is checked, and a priority ceiling is used. + * spec:/score/mtx/req/surrender where an enqueue blocks, a recursive + * seize is allowed, the owner is checked, and a priority ceiling is + * used. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; ctx->tq_ctx.get_owner = TQGetOwnerClassicSem; @@ -408,9 +410,9 @@ static void RtemsSemReqRelease_Post_Action_Check( case RtemsSemReqRelease_Post_Action_MrsPMtxSurrender: { /* * The calling task shall surrender the mutex as specified by - * /score/mtx/req/surrender where an enqueue is sticky, a recursive seize - * returns an error status, the owner is checked, and a priority ceiling - * is used. + * spec:/score/mtx/req/surrender where an enqueue is sticky, a recursive + * seize returns an error status, the owner is checked, and a priority + * ceiling is used. */ ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_STICKY; ctx->tq_ctx.get_owner = TQGetOwnerClassicSem; diff --git a/testsuites/validation/tc-sem-set-priority.c b/testsuites/validation/tc-sem-set-priority.c index d4418ad4de..fc4501b6fa 100644 --- a/testsuites/validation/tc-sem-set-priority.c +++ b/testsuites/validation/tc-sem-set-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqSetPriority + * @ingroup RtemsSemReqSetPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqSetPriority \ - * spec:/rtems/sem/req/set-priority + * @defgroup RtemsSemReqSetPriority spec:/rtems/sem/req/set-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-sem-smp.c b/testsuites/validation/tc-sem-smp.c index cfe82b3982..5dc3f437a1 100644 --- a/testsuites/validation/tc-sem-smp.c +++ b/testsuites/validation/tc-sem-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemValSmp + * @ingroup RtemsSemValSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemValSmp spec:/rtems/sem/val/smp + * @defgroup RtemsSemValSmp spec:/rtems/sem/val/smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief Tests SMP-specific semaphore behaviour. * @@ -123,12 +123,12 @@ typedef struct { /** * @brief This member contains the mutex identifier. */ - rtems_id mutex_id;; + rtems_id mutex_id; /** * @brief This member contains the second mutex identifier. */ - rtems_id mutex_2_id;; + rtems_id mutex_2_id; /** * @brief If this member is true, then the worker is done. diff --git a/testsuites/validation/tc-sem-timeout.c b/testsuites/validation/tc-sem-timeout.c index 254a6be5db..a150d067d2 100644 --- a/testsuites/validation/tc-sem-timeout.c +++ b/testsuites/validation/tc-sem-timeout.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemReqTimeout + * @ingroup RtemsSemReqTimeout */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,7 +55,6 @@ #include <rtems.h> #include <string.h> -#include "tr-tq-timeout-mrsp.h" #include "tr-tq-timeout-priority-inherit.h" #include "tr-tq-timeout.h" #include "tx-support.h" @@ -64,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemReqTimeout spec:/rtems/sem/req/timeout + * @defgroup RtemsSemReqTimeout spec:/rtems/sem/req/timeout * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -108,7 +107,7 @@ typedef struct { /** * @brief This member contains the thread queue test context. */ - TQContext tq_ctx;; + TQContext tq_ctx; /** * @brief This member specifies if the attribute set of the semaphore. @@ -169,6 +168,10 @@ static const char * const * const RtemsSemReqTimeout_PreDesc[] = { NULL }; +#if defined(RTEMS_SMP) +#include "tr-tq-timeout-mrsp.h" +#endif + static void RtemsSemReqTimeout_Pre_Class_Prepare( RtemsSemReqTimeout_Context *ctx, RtemsSemReqTimeout_Pre_Class state @@ -226,7 +229,11 @@ static void RtemsSemReqTimeout_Pre_Class_Prepare( */ ctx->attribute_set |= RTEMS_BINARY_SEMAPHORE | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING; + #if defined(RTEMS_SMP) ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_STICKY; + #else + ctx->tq_ctx.enqueue_variant = TQ_ENQUEUE_BLOCKS; + #endif break; } @@ -273,7 +280,7 @@ static void RtemsSemReqTimeout_Post_Action_Check( case RtemsSemReqTimeout_Post_Action_Timeout: { /* * The semaphore obtain timeout actions shall be done as specified by - * /score/tq/req/timeout. + * spec:/score/tq/req/timeout. */ ctx->tq_ctx.wait = TQ_WAIT_TIMED; ScoreTqReqTimeout_Run( &ctx->tq_ctx ); @@ -283,17 +290,21 @@ static void RtemsSemReqTimeout_Post_Action_Check( case RtemsSemReqTimeout_Post_Action_TimeoutMrsP: { /* * The semaphore obtain timeout actions shall be done as specified by - * /score/tq/req/timeout-mrsp. + * spec:/score/tq/req/timeout-mrsp. */ + #if defined(RTEMS_SMP) ctx->tq_ctx.wait = TQ_WAIT_TIMED; ScoreTqReqTimeoutMrsp_Run( &ctx->tq_ctx ); + #else + T_unreachable(); + #endif break; } case RtemsSemReqTimeout_Post_Action_TimeoutPriorityInherit: { /* * The semaphore obtain timeout actions shall be done as specified by - * /score/tq/req/timeout-priority-inherit. + * spec:/score/tq/req/timeout-priority-inherit. */ ctx->tq_ctx.wait = TQ_WAIT_FOREVER; ScoreTqReqTimeoutPriorityInherit_Run( &ctx->tq_ctx ); @@ -361,8 +372,12 @@ static void RtemsSemReqTimeout_Action( RtemsSemReqTimeout_Context *ctx ) static void RtemsSemReqTimeout_Cleanup( RtemsSemReqTimeout_Context *ctx ) { - if ( ctx->tq_ctx.thread_queue_id != 0 ) { rtems_status_code sc; - sc = rtems_semaphore_delete( ctx->tq_ctx.thread_queue_id ); T_rsc_success( sc ); } + if ( ctx->tq_ctx.thread_queue_id != 0 ) { + rtems_status_code sc; + + sc = rtems_semaphore_delete( ctx->tq_ctx.thread_queue_id ); + T_rsc_success( sc ); + } } static const RtemsSemReqTimeout_Entry @@ -370,10 +385,10 @@ RtemsSemReqTimeout_Entries[] = { { 0, 0, 0, RtemsSemReqTimeout_Post_Action_Timeout }, { 1, 0, 0, RtemsSemReqTimeout_Post_Action_NA }, { 0, 0, 0, RtemsSemReqTimeout_Post_Action_TimeoutPriorityInherit }, -#if !defined(RTEMS_SMP) - { 1, 0, 0, RtemsSemReqTimeout_Post_Action_NA } -#else +#if defined(RTEMS_SMP) { 0, 0, 0, RtemsSemReqTimeout_Post_Action_TimeoutMrsP } +#else + { 0, 0, 0, RtemsSemReqTimeout_Post_Action_Timeout } #endif }; diff --git a/testsuites/validation/tc-sem-uni.c b/testsuites/validation/tc-sem-uni.c index 08c38adb6c..04fec2009c 100644 --- a/testsuites/validation/tc-sem-uni.c +++ b/testsuites/validation/tc-sem-uni.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSemValUni + * @ingroup RtemsSemValUni */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSemValUni spec:/rtems/sem/val/uni + * @defgroup RtemsSemValUni spec:/rtems/sem/val/uni * - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationOneCpu0 * * @brief Tests uniprocessor-specific semaphore behaviour. * diff --git a/testsuites/validation/tc-signal-catch.c b/testsuites/validation/tc-signal-catch.c index 3618290443..7a6439a60f 100644 --- a/testsuites/validation/tc-signal-catch.c +++ b/testsuites/validation/tc-signal-catch.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSignalReqCatch + * @ingroup RtemsSignalReqCatch */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSignalReqCatch spec:/rtems/signal/req/catch + * @defgroup RtemsSignalReqCatch spec:/rtems/signal/req/catch * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-signal-send.c b/testsuites/validation/tc-signal-send.c index e6efbfd7cf..aedcec5e47 100644 --- a/testsuites/validation/tc-signal-send.c +++ b/testsuites/validation/tc-signal-send.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSignalReqSend + * @ingroup RtemsSignalReqSend */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSignalReqSend spec:/rtems/signal/req/send + * @defgroup RtemsSignalReqSend spec:/rtems/signal/req/send * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ @@ -154,9 +154,9 @@ typedef struct { rtems_signal_set processed_signal_sets[ 2 ]; - uintptr_t stack_pointers[ 2 ];; + uintptr_t stack_pointers[ 2 ]; - rtems_mode mode;; + rtems_mode mode; rtems_status_code status; diff --git a/testsuites/validation/tc-signals.c b/testsuites/validation/tc-signals.c index 86ae17e018..dc452ecbc0 100644 --- a/testsuites/validation/tc-signals.c +++ b/testsuites/validation/tc-signals.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSignalValSignals + * @ingroup RtemsSignalValSignals */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSignalValSignals spec:/rtems/signal/val/signals + * @defgroup RtemsSignalValSignals spec:/rtems/signal/val/signals * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief This test case collection provides validation test cases for the @ref * RTEMSAPIClassicSignal. diff --git a/testsuites/validation/tc-start-of-optional-processor-failed.c b/testsuites/validation/tc-start-of-optional-processor-failed.c index b033a18bae..826ff3848d 100644 --- a/testsuites/validation/tc-start-of-optional-processor-failed.c +++ b/testsuites/validation/tc-start-of-optional-processor-failed.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValStartOfOptionalProcessorFailed + * @ingroup ScoreSmpValStartOfOptionalProcessorFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValStartOfOptionalProcessorFailed \ + * @defgroup ScoreSmpValStartOfOptionalProcessorFailed \ * spec:/score/smp/val/start-of-optional-processor-failed * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly2 + * @ingroup TestsuitesValidationSmpOnly2 * * @brief Tests the state of an optional processor which failed to start. * diff --git a/testsuites/validation/tc-status-is-equal.c b/testsuites/validation/tc-status-is-equal.c index 6960270420..6981ef84d1 100644 --- a/testsuites/validation/tc-status-is-equal.c +++ b/testsuites/validation/tc-status-is-equal.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsStatusReqIsEqual + * @ingroup RtemsStatusReqIsEqual */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsStatusReqIsEqual spec:/rtems/status/req/is-equal + * @defgroup RtemsStatusReqIsEqual spec:/rtems/status/req/is-equal * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-status-is-successful.c b/testsuites/validation/tc-status-is-successful.c index 9ffe7a7df8..a04a9b4a7f 100644 --- a/testsuites/validation/tc-status-is-successful.c +++ b/testsuites/validation/tc-status-is-successful.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsStatusReqIsSuccessful + * @ingroup RtemsStatusReqIsSuccessful */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsStatusReqIsSuccessful \ - * spec:/rtems/status/req/is-successful + * @defgroup RtemsStatusReqIsSuccessful spec:/rtems/status/req/is-successful * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-status-text.c b/testsuites/validation/tc-status-text.c index dfed1501ed..a877519dd2 100644 --- a/testsuites/validation/tc-status-text.c +++ b/testsuites/validation/tc-status-text.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsStatusReqText + * @ingroup RtemsStatusReqText */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsStatusReqText spec:/rtems/status/req/text + * @defgroup RtemsStatusReqText spec:/rtems/status/req/text * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-status.c b/testsuites/validation/tc-status.c index 6b8c599516..41752a7f7d 100644 --- a/testsuites/validation/tc-status.c +++ b/testsuites/validation/tc-status.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsStatusValStatus + * @ingroup RtemsStatusValStatus */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2023 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsStatusValStatus spec:/rtems/status/val/status + * @defgroup RtemsStatusValStatus spec:/rtems/status/val/status * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicStatus interfaces. * @@ -67,12 +67,16 @@ * * - Validate the status code constants. * - * - Check that RTEMS_STATUS_CODES_FIRST has the expected value and is a + * - Assert that RTEMS_STATUS_CODES_FIRST has the expected value and is a * constant expression. * - * - Check that RTEMS_STATUS_CODES_LAST has the expected value and is a + * - Check that RTEMS_STATUS_CODES_FIRST has the expected value. + * + * - Assert that RTEMS_STATUS_CODES_LAST has the expected value and is a * constant expression. * + * - Check that RTEMS_STATUS_CODES_LAST has the expected value. + * * @{ */ @@ -84,16 +88,26 @@ static void RtemsStatusValStatus_Action_0( void ) /* Nothing to do */ /* - * Check that RTEMS_STATUS_CODES_FIRST has the expected value and is a + * Assert that RTEMS_STATUS_CODES_FIRST has the expected value and is a * constant expression. */ RTEMS_STATIC_ASSERT( RTEMS_STATUS_CODES_FIRST == 0, FIRST ); /* - * Check that RTEMS_STATUS_CODES_LAST has the expected value and is a + * Check that RTEMS_STATUS_CODES_FIRST has the expected value. + */ + T_eq_int( RTEMS_STATUS_CODES_FIRST, 0 ); + + /* + * Assert that RTEMS_STATUS_CODES_LAST has the expected value and is a * constant expression. */ RTEMS_STATIC_ASSERT( RTEMS_STATUS_CODES_LAST == 29, LAST ); + + /* + * Check that RTEMS_STATUS_CODES_LAST has the expected value. + */ + T_eq_int( RTEMS_STATUS_CODES_LAST, 29 ); } /** diff --git a/testsuites/validation/tc-support-is-name-valid.c b/testsuites/validation/tc-support-is-name-valid.c index 589cc4f7f4..2a47d27cd5 100644 --- a/testsuites/validation/tc-support-is-name-valid.c +++ b/testsuites/validation/tc-support-is-name-valid.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSupportReqIsNameValid + * @ingroup RtemsSupportReqIsNameValid */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSupportReqIsNameValid \ - * spec:/rtems/support/req/is-name-valid + * @defgroup RtemsSupportReqIsNameValid spec:/rtems/support/req/is-name-valid * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-support.c b/testsuites/validation/tc-support.c index fc13488d79..3e886c6027 100644 --- a/testsuites/validation/tc-support.c +++ b/testsuites/validation/tc-support.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSupportValSupport + * @ingroup RtemsSupportValSupport */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSupportValSupport \ - * spec:/rtems/support/val/support + * @defgroup RtemsSupportValSupport spec:/rtems/support/val/support * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicSupport directives. * diff --git a/testsuites/validation/tc-sys-lock.c b/testsuites/validation/tc-sys-lock.c index 85b290ab9b..56939a3dba 100644 --- a/testsuites/validation/tc-sys-lock.c +++ b/testsuites/validation/tc-sys-lock.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseNewlibValSysLock + * @ingroup NewlibValSysLock */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -65,9 +65,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseNewlibValSysLock spec:/newlib/val/sys-lock + * @defgroup NewlibValSysLock spec:/newlib/val/sys-lock * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests the <sys/lock.h> mutex directives. * diff --git a/testsuites/validation/tc-task-construct.c b/testsuites/validation/tc-task-construct.c index 2b0c75daa1..5a7ca4f497 100644 --- a/testsuites/validation/tc-task-construct.c +++ b/testsuites/validation/tc-task-construct.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqConstruct + * @ingroup RtemsTaskReqConstruct */ /* - * Copyright (C) 2020, 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020, 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -64,10 +64,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqConstruct spec:/rtems/task/req/construct + * @defgroup RtemsTaskReqConstruct spec:/rtems/task/req/construct * - * @ingroup RTEMSTestSuiteTestsuitesValidation1 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu1 + * @ingroup TestsuitesValidation1 + * @ingroup TestsuitesValidationOneCpu1 * * @{ */ @@ -291,7 +291,7 @@ typedef struct { * @brief If this member is true, then the zombie thread is ready to get * killed. */ - volatile bool zombie_ready;; + volatile bool zombie_ready; /** * @brief This member contains the actual modes of the constructed task. diff --git a/testsuites/validation/tc-task-create-errors.c b/testsuites/validation/tc-task-create-errors.c index 590fe47cb7..2378e55020 100644 --- a/testsuites/validation/tc-task-create-errors.c +++ b/testsuites/validation/tc-task-create-errors.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqCreateErrors + * @ingroup RtemsTaskReqCreateErrors */ /* - * Copyright (C) 2020, 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020, 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,11 +62,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqCreateErrors \ - * spec:/rtems/task/req/create-errors + * @defgroup RtemsTaskReqCreateErrors spec:/rtems/task/req/create-errors * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-task-delete.c b/testsuites/validation/tc-task-delete.c index a9340b4f20..d917062d0d 100644 --- a/testsuites/validation/tc-task-delete.c +++ b/testsuites/validation/tc-task-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqDelete + * @ingroup RtemsTaskReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,7 +57,6 @@ #include <setjmp.h> #include <rtems/bspIo.h> #include <rtems/test-scheduler.h> -#include <rtems/score/io.h> #include <rtems/score/statesimpl.h> #include <rtems/score/threaddispatch.h> #include <rtems/score/threadimpl.h> @@ -67,9 +66,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqDelete spec:/rtems/task/req/delete + * @defgroup RtemsTaskReqDelete spec:/rtems/task/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -262,7 +261,7 @@ typedef struct { /** * @brief This member provides a jump context to resume a thread dispatch. */ - jmp_buf thread_dispatch_context;; + jmp_buf thread_dispatch_context; /** * @brief This member contains the identifier of the runner scheduler. @@ -310,13 +309,13 @@ typedef struct { * @brief This member contains the worker timer info at the end of the * rtems_task_delete() call. */ - TaskTimerInfo worker_timer_info;; + TaskTimerInfo worker_timer_info; /** * @brief This member contains the worker thread queue at the end of the * rtems_task_delete() call. */ - const Thread_queue_Queue *worker_wait_queue;; + const Thread_queue_Queue *worker_wait_queue; /** * @brief This member contains the worker thread life state at the end of the @@ -358,13 +357,13 @@ typedef struct { /** * @brief This member contains extension calls. */ - ExtensionCalls calls;; + ExtensionCalls calls; /** * @brief This member contains extension calls after the rtems_task_delete() * call. */ - ExtensionCalls calls_after_restart;; + ExtensionCalls calls_after_restart; /** * @brief This member contains the delete counter. diff --git a/testsuites/validation/tc-task-exit.c b/testsuites/validation/tc-task-exit.c index 2f2733fe90..24373f6c47 100644 --- a/testsuites/validation/tc-task-exit.c +++ b/testsuites/validation/tc-task-exit.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqExit + * @ingroup RtemsTaskReqExit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,9 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqExit spec:/rtems/task/req/exit + * @defgroup RtemsTaskReqExit spec:/rtems/task/req/exit * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-get-affinity.c b/testsuites/validation/tc-task-get-affinity.c index 8200f9f840..54244560df 100644 --- a/testsuites/validation/tc-task-get-affinity.c +++ b/testsuites/validation/tc-task-get-affinity.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqGetAffinity + * @ingroup RtemsTaskReqGetAffinity */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqGetAffinity \ - * spec:/rtems/task/req/get-affinity + * @defgroup RtemsTaskReqGetAffinity spec:/rtems/task/req/get-affinity * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-get-priority.c b/testsuites/validation/tc-task-get-priority.c index 83843f4175..83170e8353 100644 --- a/testsuites/validation/tc-task-get-priority.c +++ b/testsuites/validation/tc-task-get-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqGetPriority + * @ingroup RtemsTaskReqGetPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqGetPriority \ - * spec:/rtems/task/req/get-priority + * @defgroup RtemsTaskReqGetPriority spec:/rtems/task/req/get-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-get-scheduler.c b/testsuites/validation/tc-task-get-scheduler.c index 1cd907cd09..41e0063b53 100644 --- a/testsuites/validation/tc-task-get-scheduler.c +++ b/testsuites/validation/tc-task-get-scheduler.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqGetScheduler + * @ingroup RtemsTaskReqGetScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqGetScheduler \ - * spec:/rtems/task/req/get-scheduler + * @defgroup RtemsTaskReqGetScheduler spec:/rtems/task/req/get-scheduler * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-ident.c b/testsuites/validation/tc-task-ident.c index c4247f22cf..214e6e99c5 100644 --- a/testsuites/validation/tc-task-ident.c +++ b/testsuites/validation/tc-task-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqIdent + * @ingroup RtemsTaskReqIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqIdent spec:/rtems/task/req/ident + * @defgroup RtemsTaskReqIdent spec:/rtems/task/req/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -167,7 +167,7 @@ static void RtemsTaskReqIdent_Pre_Name_Prepare( /* * While the ``name`` is not equal to RTEMS_WHO_AM_I or ``id`` parameter * is equal to NULL, the behaviour of rtems_task_ident() shall be - * specified by /rtems/req/ident. + * specified by spec:/rtems/req/ident. */ ctx->id = NULL; /* Preparation performed by RtemsReqIdent_Run() */ diff --git a/testsuites/validation/tc-task-is-suspended.c b/testsuites/validation/tc-task-is-suspended.c index 0897d28f56..d61c14f560 100644 --- a/testsuites/validation/tc-task-is-suspended.c +++ b/testsuites/validation/tc-task-is-suspended.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqIsSuspended + * @ingroup RtemsTaskReqIsSuspended */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqIsSuspended \ - * spec:/rtems/task/req/is-suspended + * @defgroup RtemsTaskReqIsSuspended spec:/rtems/task/req/is-suspended * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-mode.c b/testsuites/validation/tc-task-mode.c index f5e225a206..ac045e4176 100644 --- a/testsuites/validation/tc-task-mode.c +++ b/testsuites/validation/tc-task-mode.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqMode + * @ingroup RtemsTaskReqMode */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqMode spec:/rtems/task/req/mode + * @defgroup RtemsTaskReqMode spec:/rtems/task/req/mode * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-task-performance.c b/testsuites/validation/tc-task-performance.c index 2900ac6ca0..3fac8f4f4e 100644 --- a/testsuites/validation/tc-task-performance.c +++ b/testsuites/validation/tc-task-performance.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskValPerf + * @ingroup RtemsTaskValPerf */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskValPerf spec:/rtems/task/val/perf + * @defgroup RtemsTaskValPerf spec:/rtems/task/val/perf * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 * * @brief This test case provides a context to run @ref RTEMSAPIClassicTasks * performance tests. @@ -113,13 +113,13 @@ typedef struct { static RtemsTaskValPerf_Context RtemsTaskValPerf_Instance; -typedef RtemsTaskValPerf_Context Context; +#define EVENT_RESTART RTEMS_EVENT_0 + +#define EVENT_SET_END RTEMS_EVENT_1 -enum { - EVENT_RESTART = RTEMS_EVENT_0, - EVENT_SET_END = RTEMS_EVENT_1, - EVENT_BUSY = RTEMS_EVENT_2 -} Event; +#define EVENT_BUSY RTEMS_EVENT_2 + +typedef RtemsTaskValPerf_Context Context; RTEMS_ALIGNED( RTEMS_TASK_STORAGE_ALIGNMENT ) static char task_storage[ RTEMS_TASK_STORAGE_SIZE( @@ -226,6 +226,12 @@ static T_fixture RtemsTaskValPerf_Fixture = { }; /** + * @defgroup RtemsTaskReqPerfConstruct spec:/rtems/task/req/perf-construct + * + * @{ + */ + +/** * @brief Construct a worker task. */ static void RtemsTaskReqPerfConstruct_Body( RtemsTaskValPerf_Context *ctx ) @@ -274,6 +280,14 @@ static bool RtemsTaskReqPerfConstruct_Teardown_Wrap( return RtemsTaskReqPerfConstruct_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsTaskReqPerfRestart spec:/rtems/task/req/perf-restart + * + * @{ + */ + /** * @brief Create and start a worker task. */ @@ -340,6 +354,15 @@ static void RtemsTaskReqPerfRestart_Cleanup( RtemsTaskValPerf_Context *ctx ) DeleteTask( ctx->worker_id ); } +/** @} */ + +/** + * @defgroup RtemsTaskReqPerfRestartPreempt \ + * spec:/rtems/task/req/perf-restart-preempt + * + * @{ + */ + /** * @brief Create and start a worker task. */ @@ -422,6 +445,14 @@ static void RtemsTaskReqPerfRestartPreempt_Cleanup( DeleteTask( ctx->worker_id ); } +/** @} */ + +/** + * @defgroup RtemsTaskReqPerfRestartSelf spec:/rtems/task/req/perf-restart-self + * + * @{ + */ + /** * @brief Create and start a worker task. */ @@ -492,8 +523,17 @@ static void RtemsTaskReqPerfRestartSelf_Cleanup( DeleteTask( ctx->worker_id ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsTaskReqPerfSetSchedulerMove \ + * spec:/rtems/task/req/perf-set-scheduler-move + * + * @{ + */ + +/** * @brief Set the runner affinity. */ static void RtemsTaskReqPerfSetSchedulerMove_Prepare( @@ -572,9 +612,18 @@ static void RtemsTaskReqPerfSetSchedulerMove_Cleanup( { SetSelfAffinityOne( 0 ); } + +/** @} */ #endif /** + * @defgroup RtemsTaskReqPerfSetSchedulerNop \ + * spec:/rtems/task/req/perf-set-scheduler-nop + * + * @{ + */ + +/** * @brief Set the scheduler of the runner. */ static void RtemsTaskReqPerfSetSchedulerNop_Body( @@ -632,8 +681,17 @@ static bool RtemsTaskReqPerfSetSchedulerNop_Teardown_Wrap( ); } +/** @} */ + #if defined(RTEMS_SMP) /** + * @defgroup RtemsTaskReqPerfSetSchedulerOther \ + * spec:/rtems/task/req/perf-set-scheduler-other + * + * @{ + */ + +/** * @brief Create and start a worker task for scheduler B. */ static void RtemsTaskReqPerfSetSchedulerOther_Prepare( @@ -715,10 +773,19 @@ static void RtemsTaskReqPerfSetSchedulerOther_Cleanup( { DeleteTask( ctx->worker_id ); } + +/** @} */ #endif #if defined(RTEMS_SMP) /** + * @defgroup RtemsTaskReqPerfSetSchedulerPreempt \ + * spec:/rtems/task/req/perf-set-scheduler-preempt + * + * @{ + */ + +/** * @brief Create and start two worker tasks for scheduler B. Make the second * worker busy. */ @@ -834,9 +901,17 @@ static void RtemsTaskReqPerfSetSchedulerPreempt_Cleanup( DeleteTask( ctx->worker_2_id ); DeleteTask( ctx->worker_id ); } + +/** @} */ #endif /** + * @defgroup RtemsTaskReqPerfStart spec:/rtems/task/req/perf-start + * + * @{ + */ + +/** * @brief Create a worker task. */ static void RtemsTaskReqPerfStart_Setup( RtemsTaskValPerf_Context *ctx ) @@ -904,6 +979,15 @@ static bool RtemsTaskReqPerfStart_Teardown_Wrap( return RtemsTaskReqPerfStart_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + +/** + * @defgroup RtemsTaskReqPerfStartPreempt \ + * spec:/rtems/task/req/perf-start-preempt + * + * @{ + */ + /** * @brief Create a worker task. */ @@ -975,6 +1059,8 @@ static bool RtemsTaskReqPerfStartPreempt_Teardown_Wrap( return RtemsTaskReqPerfStartPreempt_Teardown( ctx, delta, tic, toc, retry ); } +/** @} */ + /** * @fn void T_case_body_RtemsTaskValPerf( void ) */ diff --git a/testsuites/validation/tc-task-restart.c b/testsuites/validation/tc-task-restart.c index f6c3aabd33..c915f01a49 100644 --- a/testsuites/validation/tc-task-restart.c +++ b/testsuites/validation/tc-task-restart.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqRestart + * @ingroup RtemsTaskReqRestart */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -65,9 +65,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqRestart spec:/rtems/task/req/restart + * @defgroup RtemsTaskReqRestart spec:/rtems/task/req/restart * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -251,7 +251,7 @@ typedef struct { /** * @brief This member provides a jump context to resume a thread dispatch. */ - jmp_buf thread_dispatch_context;; + jmp_buf thread_dispatch_context; /** * @brief This member provides the context to wrap thread queue operations. @@ -319,13 +319,13 @@ typedef struct { /** * @brief This member contains extension calls. */ - ExtensionCalls calls;; + ExtensionCalls calls; /** * @brief This member contains extension calls after the rtems_task_restart() * call. */ - ExtensionCalls calls_after_restart;; + ExtensionCalls calls_after_restart; /** * @brief This member contains the actual argument passed to the entry point. diff --git a/testsuites/validation/tc-task-resume.c b/testsuites/validation/tc-task-resume.c index f7c63234d6..d440b52bd5 100644 --- a/testsuites/validation/tc-task-resume.c +++ b/testsuites/validation/tc-task-resume.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqResume + * @ingroup RtemsTaskReqResume */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqResume spec:/rtems/task/req/resume + * @defgroup RtemsTaskReqResume spec:/rtems/task/req/resume * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-set-affinity.c b/testsuites/validation/tc-task-set-affinity.c index ffa40fcf58..9502d009e1 100644 --- a/testsuites/validation/tc-task-set-affinity.c +++ b/testsuites/validation/tc-task-set-affinity.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqSetAffinity + * @ingroup RtemsTaskReqSetAffinity */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,11 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqSetAffinity \ - * spec:/rtems/task/req/set-affinity + * @defgroup RtemsTaskReqSetAffinity spec:/rtems/task/req/set-affinity * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ @@ -132,7 +131,7 @@ typedef struct { /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_2 scheduler_log;; + T_scheduler_log_2 scheduler_log; /** * @brief This member provides the object referenced by the ``cpuset`` diff --git a/testsuites/validation/tc-task-set-priority.c b/testsuites/validation/tc-task-set-priority.c index cbe4bfda2b..4094aaedfb 100644 --- a/testsuites/validation/tc-task-set-priority.c +++ b/testsuites/validation/tc-task-set-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqSetPriority + * @ingroup RtemsTaskReqSetPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,11 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqSetPriority \ - * spec:/rtems/task/req/set-priority + * @defgroup RtemsTaskReqSetPriority spec:/rtems/task/req/set-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ diff --git a/testsuites/validation/tc-task-set-scheduler.c b/testsuites/validation/tc-task-set-scheduler.c index 018aa2c338..174aa55736 100644 --- a/testsuites/validation/tc-task-set-scheduler.c +++ b/testsuites/validation/tc-task-set-scheduler.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqSetScheduler + * @ingroup RtemsTaskReqSetScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqSetScheduler \ - * spec:/rtems/task/req/set-scheduler + * @defgroup RtemsTaskReqSetScheduler spec:/rtems/task/req/set-scheduler * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -267,7 +266,7 @@ typedef struct { /** * @brief This member contains the identifier of the new scheduler. */ - rtems_id new_scheduler;; + rtems_id new_scheduler; /** * @brief This member contains the new priorities of the task. diff --git a/testsuites/validation/tc-task-smp.c b/testsuites/validation/tc-task-smp.c index 51165153f5..9bfdc4fd73 100644 --- a/testsuites/validation/tc-task-smp.c +++ b/testsuites/validation/tc-task-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskValSmp + * @ingroup RtemsTaskValSmp */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskValSmp spec:/rtems/task/val/smp + * @defgroup RtemsTaskValSmp spec:/rtems/task/val/smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 * * @brief This test case collection provides SMP-specific validation test cases * for requirements of the @ref RTEMSAPIClassicTasks. diff --git a/testsuites/validation/tc-task-start.c b/testsuites/validation/tc-task-start.c index ffb0012439..235d9f0827 100644 --- a/testsuites/validation/tc-task-start.c +++ b/testsuites/validation/tc-task-start.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqStart + * @ingroup RtemsTaskReqStart */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqStart spec:/rtems/task/req/start + * @defgroup RtemsTaskReqStart spec:/rtems/task/req/start * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-storage-size.c b/testsuites/validation/tc-task-storage-size.c index 6ad8b72cbe..29ac53c237 100644 --- a/testsuites/validation/tc-task-storage-size.c +++ b/testsuites/validation/tc-task-storage-size.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqStorageSize + * @ingroup RtemsTaskReqStorageSize */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqStorageSize \ - * spec:/rtems/task/req/storage-size + * @defgroup RtemsTaskReqStorageSize spec:/rtems/task/req/storage-size * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-suspend.c b/testsuites/validation/tc-task-suspend.c index b56b420120..123e223fb9 100644 --- a/testsuites/validation/tc-task-suspend.c +++ b/testsuites/validation/tc-task-suspend.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqSuspend + * @ingroup RtemsTaskReqSuspend */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqSuspend spec:/rtems/task/req/suspend + * @defgroup RtemsTaskReqSuspend spec:/rtems/task/req/suspend * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-task-wake-after.c b/testsuites/validation/tc-task-wake-after.c index 8966a14648..ba12d21c85 100644 --- a/testsuites/validation/tc-task-wake-after.c +++ b/testsuites/validation/tc-task-wake-after.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqWakeAfter + * @ingroup RtemsTaskReqWakeAfter */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqWakeAfter spec:/rtems/task/req/wake-after + * @defgroup RtemsTaskReqWakeAfter spec:/rtems/task/req/wake-after * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationOneCpu0 * * @{ */ @@ -122,29 +122,29 @@ typedef struct { /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_4 scheduler_log;; + T_scheduler_log_4 scheduler_log; /** * @brief This member contains the clock tick value before the * rtems_task_wake_after() call. */ - uint64_t now;; + uint64_t now; /** * @brief This member contains the worker task identifier. */ - rtems_id worker_id;; + rtems_id worker_id; /** * @brief If this member is true, then the worker shall be suspended during * the rtems_task_wake_after() call. */ - bool suspended;; + bool suspended; /** * @brief This member contains the timer information of the worker task. */ - TaskTimerInfo timer_info;; + TaskTimerInfo timer_info; /** * @brief This member contains the return value of the diff --git a/testsuites/validation/tc-task-wake-when.c b/testsuites/validation/tc-task-wake-when.c index 223fbfd55f..bb31fded26 100644 --- a/testsuites/validation/tc-task-wake-when.c +++ b/testsuites/validation/tc-task-wake-when.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskReqWakeWhen + * @ingroup RtemsTaskReqWakeWhen */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskReqWakeWhen spec:/rtems/task/req/wake-when + * @defgroup RtemsTaskReqWakeWhen spec:/rtems/task/req/wake-when * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -131,23 +131,23 @@ typedef struct { /** * @brief This member provides the scheduler operation records. */ - T_scheduler_log_4 scheduler_log;; + T_scheduler_log_4 scheduler_log; /** * @brief This member contains the CLOCK_REALTIME value before the * rtems_task_wake_when() call. */ - struct timespec now;; + struct timespec now; /** * @brief This member contains the worker task identifier. */ - rtems_id worker_id;; + rtems_id worker_id; /** * @brief This member contains the timer information of the worker task. */ - TaskTimerInfo timer_info;; + TaskTimerInfo timer_info; /** * @brief This member provides the object referenced by the ``time_buffer`` diff --git a/testsuites/validation/tc-task.c b/testsuites/validation/tc-task.c index 11d37e7017..5ab96445ed 100644 --- a/testsuites/validation/tc-task.c +++ b/testsuites/validation/tc-task.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTaskValTask + * @ingroup RtemsTaskValTask */ /* - * Copyright (C) 2021, 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,9 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTaskValTask spec:/rtems/task/val/task + * @defgroup RtemsTaskValTask spec:/rtems/task/val/task * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief This test case collection provides validation test cases for * requirements of the @ref RTEMSAPIClassicTasks. @@ -303,7 +303,7 @@ static void RtemsTaskValTask_Action_8( void ) static void RtemsTaskValTask_Action_9( void ) { rtems_status_code sc; - rtems_status_code id; + rtems_id id; /* * Create a task. Check that the home scheduler of the created task is diff --git a/testsuites/validation/tc-terminate.c b/testsuites/validation/tc-terminate.c index 7eeaa9e3ea..b533092c19 100644 --- a/testsuites/validation/tc-terminate.c +++ b/testsuites/validation/tc-terminate.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreInterrValTerminate + * @ingroup ScoreInterrValTerminate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,6 @@ #include <rtems/bspIo.h> #include <rtems/test-info.h> #include <rtems/score/atomic.h> -#include <rtems/score/io.h> #include <rtems/score/percpu.h> #include <rtems/score/sysstate.h> @@ -67,10 +66,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreInterrValTerminate \ - * spec:/score/interr/val/terminate + * @defgroup ScoreInterrValTerminate spec:/score/interr/val/terminate * - * @ingroup RTEMSTestSuiteTestsuitesTerminate + * @ingroup TestsuitesTerminate * * @brief Tests system termination procedure. * diff --git a/testsuites/validation/tc-thread-idle-body-no-return.c b/testsuites/validation/tc-thread-idle-body-no-return.c index 5234a460f9..19c86dad99 100644 --- a/testsuites/validation/tc-thread-idle-body-no-return.c +++ b/testsuites/validation/tc-thread-idle-body-no-return.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreThreadValIdleBodyNoReturn + * @ingroup ScoreThreadValIdleBodyNoReturn */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreThreadValIdleBodyNoReturn \ + * @defgroup ScoreThreadValIdleBodyNoReturn \ * spec:/score/thread/val/idle-body-no-return * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 * * @brief Tests thread idle body behaviour. * @@ -90,7 +90,7 @@ typedef struct { /** * @brief This member contains a counter. */ - uint32_t counter;; + uint32_t counter; } ScoreThreadValIdleBodyNoReturn_Context; static ScoreThreadValIdleBodyNoReturn_Context @@ -100,19 +100,30 @@ typedef ScoreThreadValIdleBodyNoReturn_Context Context; static void CheckIdleBody( Context *ctx, rtems_task_entry entry ) { - rtems_id id; + rtems_id id; + rtems_interval interval; + rtems_status_code sc; ctx->counter = 0; id = CreateTask( "WORK", PRIO_LOW ); StartTask( id, entry, ctx ); - while ( ctx->counter == 0 ) { - rtems_status_code sc; + /* + * With optimization disabled, coverage enabled, SMP enabled and a slow + * target, things may take some time. + */ + interval = 1; + while ( ctx->counter == 0 && interval <= 1024 ) { - sc = rtems_task_wake_after( 1 ); + sc = rtems_task_wake_after( interval ); T_rsc_success( sc ); + + interval *= 2; } + sc = rtems_task_wake_after( interval ); + T_rsc_success( sc ); + T_eq_u32( ctx->counter, 1 ); DeleteTask( id ); } diff --git a/testsuites/validation/tc-timecounter-get-smp.c b/testsuites/validation/tc-timecounter-get-smp.c index 520d532c7b..d8c9f598dd 100644 --- a/testsuites/validation/tc-timecounter-get-smp.c +++ b/testsuites/validation/tc-timecounter-get-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTimecounterValGetSmp + * @ingroup ScoreTimecounterValGetSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -63,10 +63,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTimecounterValGetSmp \ - * spec:/score/timecounter/val/get-smp + * @defgroup ScoreTimecounterValGetSmp spec:/score/timecounter/val/get-smp * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounterSmp0 + * @ingroup TestsuitesValidationTimecounterSmp0 * * @brief Tests directives to get a time value. * diff --git a/testsuites/validation/tc-timecounter-get.c b/testsuites/validation/tc-timecounter-get.c index 7ab746ab86..cd2464399e 100644 --- a/testsuites/validation/tc-timecounter-get.c +++ b/testsuites/validation/tc-timecounter-get.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTimecounterValGet + * @ingroup ScoreTimecounterValGet */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTimecounterValGet \ - * spec:/score/timecounter/val/get + * @defgroup ScoreTimecounterValGet spec:/score/timecounter/val/get * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounter1 + * @ingroup TestsuitesValidationTimecounter1 * * @brief Tests directives to get a time value. * diff --git a/testsuites/validation/tc-timecounter-install.c b/testsuites/validation/tc-timecounter-install.c index 3189f37a23..14babc5b94 100644 --- a/testsuites/validation/tc-timecounter-install.c +++ b/testsuites/validation/tc-timecounter-install.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTimecounterValInstall + * @ingroup ScoreTimecounterValInstall */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTimecounterValInstall \ - * spec:/score/timecounter/val/install + * @defgroup ScoreTimecounterValInstall spec:/score/timecounter/val/install * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounter0 + * @ingroup TestsuitesValidationTimecounter0 * * @brief Tests timecounter installation related functions and directives of * the Clock Manager. diff --git a/testsuites/validation/tc-timer-cancel.c b/testsuites/validation/tc-timer-cancel.c index 223848fdee..3030045e9c 100644 --- a/testsuites/validation/tc-timer-cancel.c +++ b/testsuites/validation/tc-timer-cancel.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqCancel + * @ingroup RtemsTimerReqCancel */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqCancel spec:/rtems/timer/req/cancel + * @defgroup RtemsTimerReqCancel spec:/rtems/timer/req/cancel * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-create.c b/testsuites/validation/tc-timer-create.c index dea3a40175..416f5401d0 100644 --- a/testsuites/validation/tc-timer-create.c +++ b/testsuites/validation/tc-timer-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqCreate + * @ingroup RtemsTimerReqCreate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqCreate spec:/rtems/timer/req/create + * @defgroup RtemsTimerReqCreate spec:/rtems/timer/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-delete.c b/testsuites/validation/tc-timer-delete.c index 92032c80cf..84999c5ae7 100644 --- a/testsuites/validation/tc-timer-delete.c +++ b/testsuites/validation/tc-timer-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqDelete + * @ingroup RtemsTimerReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqDelete spec:/rtems/timer/req/delete + * @defgroup RtemsTimerReqDelete spec:/rtems/timer/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-fire-after.c b/testsuites/validation/tc-timer-fire-after.c index 980ecdde2d..27c27523cb 100644 --- a/testsuites/validation/tc-timer-fire-after.c +++ b/testsuites/validation/tc-timer-fire-after.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqFireAfter + * @ingroup RtemsTimerReqFireAfter */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqFireAfter \ - * spec:/rtems/timer/req/fire-after + * @defgroup RtemsTimerReqFireAfter spec:/rtems/timer/req/fire-after * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-fire-when.c b/testsuites/validation/tc-timer-fire-when.c index 8d5584ebf0..92bd505a41 100644 --- a/testsuites/validation/tc-timer-fire-when.c +++ b/testsuites/validation/tc-timer-fire-when.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqFireWhen + * @ingroup RtemsTimerReqFireWhen */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqFireWhen spec:/rtems/timer/req/fire-when + * @defgroup RtemsTimerReqFireWhen spec:/rtems/timer/req/fire-when * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-ident.c b/testsuites/validation/tc-timer-ident.c index bdee3d89d2..e39ec73b9a 100644 --- a/testsuites/validation/tc-timer-ident.c +++ b/testsuites/validation/tc-timer-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerValIdent + * @ingroup RtemsTimerValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerValIdent spec:/rtems/timer/val/ident + * @defgroup RtemsTimerValIdent spec:/rtems/timer/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_timer_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API timer class - * objects defined by /rtems/req/ident-local. + * objects defined by spec:/rtems/req/ident-local. * * @{ */ @@ -83,7 +83,7 @@ static rtems_status_code ClassicTimerIdentAction( /** * @brief Run the generic object identification tests for Classic API timer - * class objects defined by /rtems/req/ident-local. + * class objects defined by spec:/rtems/req/ident-local. */ static void RtemsTimerValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-timer-initiate-server.c b/testsuites/validation/tc-timer-initiate-server.c index 89bb445a6f..7a21a3a10b 100644 --- a/testsuites/validation/tc-timer-initiate-server.c +++ b/testsuites/validation/tc-timer-initiate-server.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqInitiateServer + * @ingroup RtemsTimerReqInitiateServer */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqInitiateServer \ - * spec:/rtems/timer/req/initiate-server + * @defgroup RtemsTimerReqInitiateServer spec:/rtems/timer/req/initiate-server * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-reset.c b/testsuites/validation/tc-timer-reset.c index 2b87717b43..709b9fe8a5 100644 --- a/testsuites/validation/tc-timer-reset.c +++ b/testsuites/validation/tc-timer-reset.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqReset + * @ingroup RtemsTimerReqReset */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqReset spec:/rtems/timer/req/reset + * @defgroup RtemsTimerReqReset spec:/rtems/timer/req/reset * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -225,7 +225,7 @@ typedef struct { * @brief This member contains a reference to the user data to be used in the * next call to the Timer Service Routine. */ - void **scheduled_user_data;; + void **scheduled_user_data; /** * @brief This member contains 1 if the Timer Service Routine "A" has been diff --git a/testsuites/validation/tc-timer-server-fire-after.c b/testsuites/validation/tc-timer-server-fire-after.c index 50e639e7c1..3ee91d8461 100644 --- a/testsuites/validation/tc-timer-server-fire-after.c +++ b/testsuites/validation/tc-timer-server-fire-after.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqServerFireAfter + * @ingroup RtemsTimerReqServerFireAfter */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqServerFireAfter \ + * @defgroup RtemsTimerReqServerFireAfter \ * spec:/rtems/timer/req/server-fire-after * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer-server-fire-when.c b/testsuites/validation/tc-timer-server-fire-when.c index a918405058..d9c5ba8221 100644 --- a/testsuites/validation/tc-timer-server-fire-when.c +++ b/testsuites/validation/tc-timer-server-fire-when.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerReqServerFireWhen + * @ingroup RtemsTimerReqServerFireWhen */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerReqServerFireWhen \ - * spec:/rtems/timer/req/server-fire-when + * @defgroup RtemsTimerReqServerFireWhen spec:/rtems/timer/req/server-fire-when * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-timer.c b/testsuites/validation/tc-timer.c index a7a25222bb..d33ad6b440 100644 --- a/testsuites/validation/tc-timer.c +++ b/testsuites/validation/tc-timer.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTimerValTimer + * @ingroup RtemsTimerValTimer */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTimerValTimer spec:/rtems/timer/val/timer + * @defgroup RtemsTimerValTimer spec:/rtems/timer/val/timer * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests general timer behaviour. * diff --git a/testsuites/validation/tc-type.c b/testsuites/validation/tc-type.c index a19048746b..14f9aa1743 100644 --- a/testsuites/validation/tc-type.c +++ b/testsuites/validation/tc-type.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsTypeValType + * @ingroup RtemsTypeValType */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2023 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsTypeValType spec:/rtems/type/val/type + * @defgroup RtemsTypeValType spec:/rtems/type/val/type * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests some @ref RTEMSAPIClassicTypes interfaces. * @@ -71,6 +71,13 @@ * - Assert that RTEMS_ID_NONE cannot be associated with an object because it * has an object index outside the range of valid object indices. * + * - Validate the RTEMS_NO_TIMEOUT constant. + * + * - Assert that RTEMS_NO_TIMEOUT is a compile time constant which evaluates + * to a value of zero. + * + * - Check that RTEMS_NO_TIMEOUT evaluates to a value of zero. + * * @{ */ @@ -93,11 +100,31 @@ static void RtemsTypeValType_Action_0( void ) } /** + * @brief Validate the RTEMS_NO_TIMEOUT constant. + */ +static void RtemsTypeValType_Action_1( void ) +{ + /* Nothing to do */ + + /* + * Assert that RTEMS_NO_TIMEOUT is a compile time constant which evaluates to + * a value of zero. + */ + RTEMS_STATIC_ASSERT( RTEMS_NO_TIMEOUT == 0, NO_TIMEOUT ); + + /* + * Check that RTEMS_NO_TIMEOUT evaluates to a value of zero. + */ + T_eq_u32( RTEMS_NO_TIMEOUT, 0 ); +} + +/** * @fn void T_case_body_RtemsTypeValType( void ) */ T_TEST_CASE( RtemsTypeValType ) { RtemsTypeValType_Action_0(); + RtemsTypeValType_Action_1(); } /** @} */ diff --git a/testsuites/validation/tc-userext-create.c b/testsuites/validation/tc-userext-create.c index 0ffcd12972..a15ccf6c1a 100644 --- a/testsuites/validation/tc-userext-create.c +++ b/testsuites/validation/tc-userext-create.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsUserextReqCreate + * @ingroup RtemsUserextReqCreate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsUserextReqCreate spec:/rtems/userext/req/create + * @defgroup RtemsUserextReqCreate spec:/rtems/userext/req/create * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -129,13 +129,13 @@ typedef struct { typedef struct { void *seized_objects; - rtems_extensions_table table_variable;; + rtems_extensions_table table_variable; rtems_id id_value; rtems_name name; - rtems_extensions_table *table;; + rtems_extensions_table *table; rtems_id *id; diff --git a/testsuites/validation/tc-userext-delete.c b/testsuites/validation/tc-userext-delete.c index b264b34792..9827d715bc 100644 --- a/testsuites/validation/tc-userext-delete.c +++ b/testsuites/validation/tc-userext-delete.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsUserextReqDelete + * @ingroup RtemsUserextReqDelete */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsUserextReqDelete spec:/rtems/userext/req/delete + * @defgroup RtemsUserextReqDelete spec:/rtems/userext/req/delete * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ diff --git a/testsuites/validation/tc-userext-ident.c b/testsuites/validation/tc-userext-ident.c index 2ece528953..24646b6a54 100644 --- a/testsuites/validation/tc-userext-ident.c +++ b/testsuites/validation/tc-userext-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsUserextValIdent + * @ingroup RtemsUserextValIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,16 +57,16 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsUserextValIdent spec:/rtems/userext/val/ident + * @defgroup RtemsUserextValIdent spec:/rtems/userext/val/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Test the rtems_extension_ident() directive. * * This test case performs the following actions: * * - Run the generic object identification tests for Classic API user extension - * class objects defined by /rtems/req/ident-local. + * class objects defined by spec:/rtems/req/ident-local. * * @{ */ @@ -83,7 +83,7 @@ static rtems_status_code ClassicUserExtIdentAction( /** * @brief Run the generic object identification tests for Classic API user - * extension class objects defined by /rtems/req/ident-local. + * extension class objects defined by spec:/rtems/req/ident-local. */ static void RtemsUserextValIdent_Action_0( void ) { diff --git a/testsuites/validation/tc-userext.c b/testsuites/validation/tc-userext.c index 252946e026..192be30669 100644 --- a/testsuites/validation/tc-userext.c +++ b/testsuites/validation/tc-userext.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsUserextValUserext + * @ingroup RtemsUserextValUserext */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsUserextValUserext \ - * spec:/rtems/userext/val/userext + * @defgroup RtemsUserextValUserext spec:/rtems/userext/val/userext * - * @ingroup RTEMSTestSuiteTestsuitesUserext + * @ingroup TestsuitesUserext * * @brief Tests the thread user extensions. * @@ -160,6 +159,18 @@ * - Check that the thread terminate extension of the extension set deleted * before its turn in the invocation was not invoked. * + * - Create five dynamic extensions. Let an idle thread return from its entry. + * Delete three dynamic extension during the thread exitted invocation. + * Clean up the used resources. + * + * - Check that the thread exitted extensions were invoked in the right + * order. + * + * - Check that the other extensions were not invoked. + * + * - Check that the thread exitted extension of the extension set deleted + * before its turn in the invocation was not invoked. + * * @{ */ @@ -294,7 +305,13 @@ static void Extension( if ( index == 6 && ( kind == THREAD_EXITTED || kind == THREAD_RESTART ) ) { StopTestCase(); - rtems_task_exit(); + + if ( GetExecuting()->is_idle ) { + SetSelfPriority( RTEMS_MAXIMUM_PRIORITY ); + _CPU_Thread_Idle_body( 0 ); + } else { + rtems_task_exit(); + } } if ( index == 0 && kind == THREAD_TERMINATE ) { @@ -517,6 +534,18 @@ static void TerminateWorker( rtems_task_argument arg ) rtems_task_exit(); } +void *IdleBody( uintptr_t arg ) +{ + rtems_event_set events; + + do { + events = PollAnyEvents(); + } while ( events == 0 ); + + (void) StartTestCase( THREAD_EXITTED ); + return (void *) arg; +} + static void RtemsUserextValUserext_Setup( void *ctx ) { SetSelfPriority( PRIO_NORMAL ); @@ -833,6 +862,45 @@ static void RtemsUserextValUserext_Action_6( void ) } /** + * @brief Create five dynamic extensions. Let an idle thread return from its + * entry. Delete three dynamic extension during the thread exitted + * invocation. Clean up the used resources. + */ +static void RtemsUserextValUserext_Action_7( void ) +{ + rtems_tcb *thread; + rtems_id id; + + /* ID of idle thread of processor 0 */ + id = 0x09010001; + thread = GetThread( id ); + SendEvents( id, RTEMS_EVENT_0 ); + SetPriority( id, PRIO_HIGH ); + + /* + * Check that the thread exitted extensions were invoked in the right order. + */ + CheckForward( THREAD_EXITTED, 1, 1, thread, NULL ); + + /* + * Check that the other extensions were not invoked. + */ + CheckForward( THREAD_BEGIN, 0, 0, NULL, NULL ); + CheckForward( THREAD_CREATE, 0, 0, NULL, NULL ); + CheckReverse( THREAD_DELETE, 0, 0, NULL, NULL ); + CheckForward( THREAD_RESTART, 0, 0, NULL, NULL ); + CheckForward( THREAD_START, 0, 0, NULL, NULL ); + CheckForward( THREAD_SWITCH, 0, 0, NULL, NULL ); + CheckReverse( THREAD_TERMINATE, 0, 0, NULL, NULL ); + + /* + * Check that the thread exitted extension of the extension set deleted + * before its turn in the invocation was not invoked. + */ + CheckDeletedNotInvoked( THREAD_EXITTED ); +} + +/** * @fn void T_case_body_RtemsUserextValUserext( void ) */ T_TEST_CASE_FIXTURE( RtemsUserextValUserext, &RtemsUserextValUserext_Fixture ) @@ -844,6 +912,7 @@ T_TEST_CASE_FIXTURE( RtemsUserextValUserext, &RtemsUserextValUserext_Fixture ) RtemsUserextValUserext_Action_4(); RtemsUserextValUserext_Action_5(); RtemsUserextValUserext_Action_6(); + RtemsUserextValUserext_Action_7(); } /** @} */ diff --git a/testsuites/validation/tc-userext.h b/testsuites/validation/tc-userext.h index dbe9e30b67..538180dfd4 100644 --- a/testsuites/validation/tc-userext.h +++ b/testsuites/validation/tc-userext.h @@ -3,13 +3,13 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreInterrValTerminate + * @ingroup ScoreInterrValTerminate * * @brief This header file provides functions used by corresponding test suite. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tr-event-constant.c b/testsuites/validation/tr-event-constant.c index 6895fcc821..a0327973de 100644 --- a/testsuites/validation/tr-event-constant.c +++ b/testsuites/validation/tr-event-constant.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventValEventConstant + * @ingroup RtemsEventValEventConstant */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsEventValEventConstant \ - * spec:/rtems/event/val/event-constant + * @defgroup RtemsEventValEventConstant spec:/rtems/event/val/event-constant * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests an event constant and number of the Event Manager using the * Classic and system event sets of the executing task. @@ -682,6 +681,11 @@ static void RtemsEventValEventConstant_Action_16( static T_fixture_node RtemsEventValEventConstant_Node; +static T_remark RtemsEventValEventConstant_Remark = { + .next = NULL, + .remark = "RtemsEventValEventConstant" +}; + void RtemsEventValEventConstant_Run( rtems_event_set event, int number ) { RtemsEventValEventConstant_Context *ctx; @@ -715,6 +719,7 @@ void RtemsEventValEventConstant_Run( rtems_event_set event, int number ) RtemsEventValEventConstant_Action_15( ctx ); RtemsEventValEventConstant_Action_16( ctx ); + T_add_remark( &RtemsEventValEventConstant_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-event-constant.h b/testsuites/validation/tr-event-constant.h index b6484874d5..9c57ca2d8a 100644 --- a/testsuites/validation/tr-event-constant.h +++ b/testsuites/validation/tr-event-constant.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventValEventConstant + * @ingroup RtemsEventValEventConstant */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsEventValEventConstant + * @addtogroup RtemsEventValEventConstant * * @{ */ diff --git a/testsuites/validation/tr-event-send-receive.c b/testsuites/validation/tr-event-send-receive.c index e7c48dae70..85d0040615 100644 --- a/testsuites/validation/tr-event-send-receive.c +++ b/testsuites/validation/tr-event-send-receive.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventReqSendReceive + * @ingroup RtemsEventReqSendReceive */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsEventReqSendReceive \ - * spec:/rtems/event/req/send-receive + * @defgroup RtemsEventReqSendReceive spec:/rtems/event/req/send-receive * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 * * @{ */ @@ -1251,6 +1250,11 @@ static void RtemsEventReqSendReceive_TestVariant( static T_fixture_node RtemsEventReqSendReceive_Node; +static T_remark RtemsEventReqSendReceive_Remark = { + .next = NULL, + .remark = "RtemsEventReqSendReceive" +}; + void RtemsEventReqSendReceive_Run( rtems_status_code ( *send )( rtems_id, rtems_event_set ), rtems_status_code ( *receive )( rtems_event_set, rtems_option, rtems_interval, rtems_event_set * ), @@ -1310,6 +1314,7 @@ void RtemsEventReqSendReceive_Run( } } + T_add_remark( &RtemsEventReqSendReceive_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-event-send-receive.h b/testsuites/validation/tr-event-send-receive.h index b246a815ed..f6dee4ddca 100644 --- a/testsuites/validation/tr-event-send-receive.h +++ b/testsuites/validation/tr-event-send-receive.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsEventReqSendReceive + * @ingroup RtemsEventReqSendReceive */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,7 +59,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsEventReqSendReceive + * @addtogroup RtemsEventReqSendReceive * * @{ */ diff --git a/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.c b/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.c index f7cf1e1eb8..d02e2df8b6 100644 --- a/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.c +++ b/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalBootProcessorNotAssignedToScheduler + * @ingroup ScoreSmpValFatalBootProcessorNotAssignedToScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatalBootProcessorNotAssignedToScheduler \ + * @defgroup ScoreSmpValFatalBootProcessorNotAssignedToScheduler \ * spec:/score/smp/val/fatal-boot-processor-not-assigned-to-scheduler * - * @ingroup RTEMSTestSuiteTestsuitesFatalBootProcessorNotAssignedToScheduler + * @ingroup TestsuitesFatalBootProcessorNotAssignedToScheduler * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.h b/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.h index 3cf19f5322..77299a5b39 100644 --- a/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.h +++ b/testsuites/validation/tr-fatal-boot-processor-not-assigned-to-scheduler.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalBootProcessorNotAssignedToScheduler + * @ingroup ScoreSmpValFatalBootProcessorNotAssignedToScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatalBootProcessorNotAssignedToScheduler + * @addtogroup ScoreSmpValFatalBootProcessorNotAssignedToScheduler * * @{ */ diff --git a/testsuites/validation/tr-fatal-idle-thread-create-failed.c b/testsuites/validation/tr-fatal-idle-thread-create-failed.c new file mode 100644 index 0000000000..60a400c43d --- /dev/null +++ b/testsuites/validation/tr-fatal-idle-thread-create-failed.c @@ -0,0 +1,158 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreThreadValFatalIdleThreadCreateFailed + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> + +#include "tr-fatal-idle-thread-create-failed.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreThreadValFatalIdleThreadCreateFailed \ + * spec:/score/thread/val/fatal-idle-thread-create-failed + * + * @ingroup TestsuitesFatalIdleThreadCreateFailed + * + * @brief Tests a fatal error caused by a failing task create extension. + * + * This test case performs the following actions: + * + * - The test action is carried out by configuring a task create extension + * which always fails. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * @{ + */ + +/** + * @brief Test context for + * spec:/score/thread/val/fatal-idle-thread-create-failed test case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * ScoreThreadValFatalIdleThreadCreateFailed_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * ScoreThreadValFatalIdleThreadCreateFailed_Run() parameter. + */ + rtems_fatal_code code; +} ScoreThreadValFatalIdleThreadCreateFailed_Context; + +static ScoreThreadValFatalIdleThreadCreateFailed_Context + ScoreThreadValFatalIdleThreadCreateFailed_Instance; + +static T_fixture ScoreThreadValFatalIdleThreadCreateFailed_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &ScoreThreadValFatalIdleThreadCreateFailed_Instance +}; + +/** + * @brief The test action is carried out by configuring a task create extension + * which always fails. + */ +static void ScoreThreadValFatalIdleThreadCreateFailed_Action_0( + ScoreThreadValFatalIdleThreadCreateFailed_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, INTERNAL_ERROR_CORE ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED + ); +} + +void ScoreThreadValFatalIdleThreadCreateFailed_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + ScoreThreadValFatalIdleThreadCreateFailed_Context *ctx; + + ctx = &ScoreThreadValFatalIdleThreadCreateFailed_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "ScoreThreadValFatalIdleThreadCreateFailed", + &ScoreThreadValFatalIdleThreadCreateFailed_Fixture + ); + + T_plan( 2 ); + + ScoreThreadValFatalIdleThreadCreateFailed_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/tr-fatal-idle-thread-create-failed.h b/testsuites/validation/tr-fatal-idle-thread-create-failed.h new file mode 100644 index 0000000000..d521f3ed29 --- /dev/null +++ b/testsuites/validation/tr-fatal-idle-thread-create-failed.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreThreadValFatalIdleThreadCreateFailed + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_IDLE_THREAD_CREATE_FAILED_H +#define _TR_FATAL_IDLE_THREAD_CREATE_FAILED_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup ScoreThreadValFatalIdleThreadCreateFailed + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is the fatal source. + * + * @param code is the fatal code. + */ +void ScoreThreadValFatalIdleThreadCreateFailed_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_IDLE_THREAD_CREATE_FAILED_H */ diff --git a/testsuites/validation/tr-fatal-idle-thread-stack-too-small.c b/testsuites/validation/tr-fatal-idle-thread-stack-too-small.c new file mode 100644 index 0000000000..34a428c883 --- /dev/null +++ b/testsuites/validation/tr-fatal-idle-thread-stack-too-small.c @@ -0,0 +1,175 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreThreadValFatalIdleThreadStackTooSmall + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> + +#include "tr-fatal-idle-thread-stack-too-small.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreThreadValFatalIdleThreadStackTooSmall \ + * spec:/score/thread/val/fatal-idle-thread-stack-too-small + * + * @ingroup TestsuitesFatalIdleThreadStackTooSmall + * + * @brief Tests a fatal error caused by a too small idle thread stack size. + * + * This test case performs the following actions: + * + * - The test action is carried out by configuring a thread-local storage + * demand which leads to a too small idle thread stack size. + * + * - Check that the expected fatal source is present. + * + * - Check that the expected fatal code is present. + * + * - Check the configured value of CONFIGURE_IDLE_TASK_STORAGE_SIZE. + * + * @{ + */ + +/** + * @brief Test context for + * spec:/score/thread/val/fatal-idle-thread-stack-too-small test case. + */ +typedef struct { + /** + * @brief This member contains a copy of the corresponding + * ScoreThreadValFatalIdleThreadStackTooSmall_Run() parameter. + */ + rtems_fatal_source source; + + /** + * @brief This member contains a copy of the corresponding + * ScoreThreadValFatalIdleThreadStackTooSmall_Run() parameter. + */ + rtems_fatal_code code; +} ScoreThreadValFatalIdleThreadStackTooSmall_Context; + +static ScoreThreadValFatalIdleThreadStackTooSmall_Context + ScoreThreadValFatalIdleThreadStackTooSmall_Instance; + +static T_fixture ScoreThreadValFatalIdleThreadStackTooSmall_Fixture = { + .setup = NULL, + .stop = NULL, + .teardown = NULL, + .scope = NULL, + .initial_context = &ScoreThreadValFatalIdleThreadStackTooSmall_Instance +}; + +/** + * @brief The test action is carried out by configuring a thread-local storage + * demand which leads to a too small idle thread stack size. + */ +static void ScoreThreadValFatalIdleThreadStackTooSmall_Action_0( + ScoreThreadValFatalIdleThreadStackTooSmall_Context *ctx +) +{ + /* Nothing to do */ + + /* + * Check that the expected fatal source is present. + */ + T_step_eq_int( 0, ctx->source, INTERNAL_ERROR_CORE ); + + /* + * Check that the expected fatal code is present. + */ + T_step_eq_ulong( + 1, + ctx->code, + INTERNAL_ERROR_IDLE_THREAD_STACK_TOO_SMALL + ); + + /* + * Check the configured value of CONFIGURE_IDLE_TASK_STORAGE_SIZE. + */ + T_step_eq_sz( + 2, + _Stack_Allocator_allocate_for_idle_storage_size, + RTEMS_ALIGN_UP( + RTEMS_TASK_STORAGE_SIZE( + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_ATTRIBUTES + ), + CPU_INTERRUPT_STACK_ALIGNMENT + ) + ); +} + +void ScoreThreadValFatalIdleThreadStackTooSmall_Run( + rtems_fatal_source source, + rtems_fatal_code code +) +{ + ScoreThreadValFatalIdleThreadStackTooSmall_Context *ctx; + + ctx = &ScoreThreadValFatalIdleThreadStackTooSmall_Instance; + ctx->source = source; + ctx->code = code; + + ctx = T_case_begin( + "ScoreThreadValFatalIdleThreadStackTooSmall", + &ScoreThreadValFatalIdleThreadStackTooSmall_Fixture + ); + + T_plan( 3 ); + + ScoreThreadValFatalIdleThreadStackTooSmall_Action_0( ctx ); + + T_case_end(); +} + +/** @} */ diff --git a/testsuites/validation/tr-fatal-idle-thread-stack-too-small.h b/testsuites/validation/tr-fatal-idle-thread-stack-too-small.h new file mode 100644 index 0000000000..be29df8a39 --- /dev/null +++ b/testsuites/validation/tr-fatal-idle-thread-stack-too-small.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreThreadValFatalIdleThreadStackTooSmall + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifndef _TR_FATAL_IDLE_THREAD_STACK_TOO_SMALL_H +#define _TR_FATAL_IDLE_THREAD_STACK_TOO_SMALL_H + +#include <rtems.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup ScoreThreadValFatalIdleThreadStackTooSmall + * + * @{ + */ + +/** + * @brief Runs the parameterized test case. + * + * @param source is the fatal source. + * + * @param code is the fatal code. + */ +void ScoreThreadValFatalIdleThreadStackTooSmall_Run( + rtems_fatal_source source, + rtems_fatal_code code +); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _TR_FATAL_IDLE_THREAD_STACK_TOO_SMALL_H */ diff --git a/testsuites/validation/tr-fatal-init-task-construct-failed.c b/testsuites/validation/tr-fatal-init-task-construct-failed.c index a7ee911f08..2bef7b73d8 100644 --- a/testsuites/validation/tr-fatal-init-task-construct-failed.c +++ b/testsuites/validation/tr-fatal-init-task-construct-failed.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValFatalInitTaskConstructFailed + * @ingroup AcfgValFatalInitTaskConstructFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValFatalInitTaskConstructFailed \ + * @defgroup AcfgValFatalInitTaskConstructFailed \ * spec:/acfg/val/fatal-init-task-construct-failed * - * @ingroup RTEMSTestSuiteTestsuitesFatalInitTaskConstructFailed + * @ingroup TestsuitesFatalInitTaskConstructFailed * * @brief Tests a fatal error caused by an invalid application configuration. * diff --git a/testsuites/validation/tr-fatal-init-task-construct-failed.h b/testsuites/validation/tr-fatal-init-task-construct-failed.h index 1685ed567f..9288a7f724 100644 --- a/testsuites/validation/tr-fatal-init-task-construct-failed.h +++ b/testsuites/validation/tr-fatal-init-task-construct-failed.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValFatalInitTaskConstructFailed + * @ingroup AcfgValFatalInitTaskConstructFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseAcfgValFatalInitTaskConstructFailed + * @addtogroup AcfgValFatalInitTaskConstructFailed * * @{ */ diff --git a/testsuites/validation/tr-fatal-mandatory-processor-not-present.c b/testsuites/validation/tr-fatal-mandatory-processor-not-present.c index 0f2435d0d5..00b5678e1c 100644 --- a/testsuites/validation/tr-fatal-mandatory-processor-not-present.c +++ b/testsuites/validation/tr-fatal-mandatory-processor-not-present.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalMandatoryProcessorNotPresent + * @ingroup ScoreSmpValFatalMandatoryProcessorNotPresent */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatalMandatoryProcessorNotPresent \ + * @defgroup ScoreSmpValFatalMandatoryProcessorNotPresent \ * spec:/score/smp/val/fatal-mandatory-processor-not-present * - * @ingroup RTEMSTestSuiteTestsuitesFatalMandatoryProcessorNotPresent + * @ingroup TestsuitesFatalMandatoryProcessorNotPresent * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-mandatory-processor-not-present.h b/testsuites/validation/tr-fatal-mandatory-processor-not-present.h index fd41d1b961..46d1581cc2 100644 --- a/testsuites/validation/tr-fatal-mandatory-processor-not-present.h +++ b/testsuites/validation/tr-fatal-mandatory-processor-not-present.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalMandatoryProcessorNotPresent + * @ingroup ScoreSmpValFatalMandatoryProcessorNotPresent */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatalMandatoryProcessorNotPresent + * @addtogroup ScoreSmpValFatalMandatoryProcessorNotPresent * * @{ */ diff --git a/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.c b/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.c index aefe76bb31..8ac69193fa 100644 --- a/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.c +++ b/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalSchedulerRequiresExactlyOneProcessor + * @ingroup ScoreSmpValFatalSchedulerRequiresExactlyOneProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatalSchedulerRequiresExactlyOneProcessor \ + * @defgroup ScoreSmpValFatalSchedulerRequiresExactlyOneProcessor \ * spec:/score/smp/val/fatal-scheduler-requires-exactly-one-processor * - * @ingroup RTEMSTestSuiteTestsuitesFatalSchedulerRequiresExactlyOneProcessor + * @ingroup TestsuitesFatalSchedulerRequiresExactlyOneProcessor * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.h b/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.h index 2d0e3f32b2..6bfb18fcfd 100644 --- a/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.h +++ b/testsuites/validation/tr-fatal-scheduler-requires-exactly-one-processor.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalSchedulerRequiresExactlyOneProcessor + * @ingroup ScoreSmpValFatalSchedulerRequiresExactlyOneProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatalSchedulerRequiresExactlyOneProcessor + * @addtogroup ScoreSmpValFatalSchedulerRequiresExactlyOneProcessor * * @{ */ diff --git a/testsuites/validation/tr-fatal-smp.c b/testsuites/validation/tr-fatal-smp.c index 425a95ade0..c2369d0ae7 100644 --- a/testsuites/validation/tr-fatal-smp.c +++ b/testsuites/validation/tr-fatal-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatal + * @ingroup ScoreSmpValFatal */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -64,9 +64,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatal spec:/score/smp/val/fatal + * @defgroup ScoreSmpValFatal spec:/score/smp/val/fatal * - * @ingroup RTEMSTestSuiteTestsuitesFatalSmp + * @ingroup TestsuitesFatalSmp * * @brief Tests four fatal errors. * diff --git a/testsuites/validation/tr-fatal-smp.h b/testsuites/validation/tr-fatal-smp.h index 5b36498d29..ff7406a47f 100644 --- a/testsuites/validation/tr-fatal-smp.h +++ b/testsuites/validation/tr-fatal-smp.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatal + * @ingroup ScoreSmpValFatal */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatal + * @addtogroup ScoreSmpValFatal * * @{ */ diff --git a/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.c b/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.c index cc0de8c83c..5c1be8271a 100644 --- a/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.c +++ b/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalStartOfMandatoryProcessorFailed + * @ingroup ScoreSmpValFatalStartOfMandatoryProcessorFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatalStartOfMandatoryProcessorFailed \ + * @defgroup ScoreSmpValFatalStartOfMandatoryProcessorFailed \ * spec:/score/smp/val/fatal-start-of-mandatory-processor-failed * - * @ingroup RTEMSTestSuiteTestsuitesFatalStartOfMandatoryProcessorFailed + * @ingroup TestsuitesFatalStartOfMandatoryProcessorFailed * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.h b/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.h index c80456bd77..b233ddc00c 100644 --- a/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.h +++ b/testsuites/validation/tr-fatal-start-of-mandatory-processor-failed.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalStartOfMandatoryProcessorFailed + * @ingroup ScoreSmpValFatalStartOfMandatoryProcessorFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatalStartOfMandatoryProcessorFailed + * @addtogroup ScoreSmpValFatalStartOfMandatoryProcessorFailed * * @{ */ diff --git a/testsuites/validation/tr-fatal-start-on-not-online-processor.c b/testsuites/validation/tr-fatal-start-on-not-online-processor.c index 55081bc25d..2773b00783 100644 --- a/testsuites/validation/tr-fatal-start-on-not-online-processor.c +++ b/testsuites/validation/tr-fatal-start-on-not-online-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalStartOnNotOnlineProcessor + * @ingroup ScoreSmpValFatalStartOnNotOnlineProcessor */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSmpValFatalStartOnNotOnlineProcessor \ + * @defgroup ScoreSmpValFatalStartOnNotOnlineProcessor \ * spec:/score/smp/val/fatal-start-on-not-online-processor * - * @ingroup RTEMSTestSuiteTestsuitesFatalStartOnNotOnlineProcessor + * @ingroup TestsuitesFatalStartOnNotOnlineProcessor * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-start-on-not-online-processor.h b/testsuites/validation/tr-fatal-start-on-not-online-processor.h index 65a8a308f7..58e9641c4f 100644 --- a/testsuites/validation/tr-fatal-start-on-not-online-processor.h +++ b/testsuites/validation/tr-fatal-start-on-not-online-processor.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSmpValFatalStartOnNotOnlineProcessor + * @ingroup ScoreSmpValFatalStartOnNotOnlineProcessor */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSmpValFatalStartOnNotOnlineProcessor + * @addtogroup ScoreSmpValFatalStartOnNotOnlineProcessor * * @{ */ diff --git a/testsuites/validation/tr-fatal-too-large-tls-size.c b/testsuites/validation/tr-fatal-too-large-tls-size.c index 12beeaef90..9bf5dcda97 100644 --- a/testsuites/validation/tr-fatal-too-large-tls-size.c +++ b/testsuites/validation/tr-fatal-too-large-tls-size.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValFatalTooLargeTlsSize + * @ingroup AcfgValFatalTooLargeTlsSize */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseAcfgValFatalTooLargeTlsSize \ + * @defgroup AcfgValFatalTooLargeTlsSize \ * spec:/acfg/val/fatal-too-large-tls-size * - * @ingroup RTEMSTestSuiteTestsuitesFatalTooLargeTlsSize + * @ingroup TestsuitesFatalTooLargeTlsSize * * @brief Tests a fatal error. * diff --git a/testsuites/validation/tr-fatal-too-large-tls-size.h b/testsuites/validation/tr-fatal-too-large-tls-size.h index 1b5c24e469..c1504261d2 100644 --- a/testsuites/validation/tr-fatal-too-large-tls-size.h +++ b/testsuites/validation/tr-fatal-too-large-tls-size.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseAcfgValFatalTooLargeTlsSize + * @ingroup AcfgValFatalTooLargeTlsSize */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseAcfgValFatalTooLargeTlsSize + * @addtogroup AcfgValFatalTooLargeTlsSize * * @{ */ diff --git a/testsuites/validation/tr-io-kernel.c b/testsuites/validation/tr-io-kernel.c index c31cf374e0..bbebfe5a26 100644 --- a/testsuites/validation/tr-io-kernel.c +++ b/testsuites/validation/tr-io-kernel.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIoValKernel + * @ingroup RtemsIoValKernel */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,9 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsIoValKernel spec:/rtems/io/val/kernel + * @defgroup RtemsIoValKernel spec:/rtems/io/val/kernel * - * @ingroup RTEMSTestSuiteTestsuitesValidationIoKernel + * @ingroup TestsuitesValidationIoKernel * * @brief Tests the functions referenced by BSP_output_char and BSP_poll_char. * @@ -82,7 +82,9 @@ */ static void RtemsIoValKernel_Action_0( void ) { + T_report_hash_sha256_update( 'X' ); ( *BSP_output_char )( 'X' ); + T_report_hash_sha256_update( '\n' ); ( *BSP_output_char )( '\n' ); } diff --git a/testsuites/validation/tr-io-kernel.h b/testsuites/validation/tr-io-kernel.h index 88b12a0645..ef878982dc 100644 --- a/testsuites/validation/tr-io-kernel.h +++ b/testsuites/validation/tr-io-kernel.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsIoValKernel + * @ingroup RtemsIoValKernel */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -56,7 +56,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsIoValKernel + * @addtogroup RtemsIoValKernel * * @{ */ diff --git a/testsuites/validation/tr-mtx-seize-try.c b/testsuites/validation/tr-mtx-seize-try.c index 8279780bff..ddc995c2e1 100644 --- a/testsuites/validation/tr-mtx-seize-try.c +++ b/testsuites/validation/tr-mtx-seize-try.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSeizeTry + * @ingroup ScoreMtxReqSeizeTry */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -53,17 +53,13 @@ #endif #include "tr-mtx-seize-try.h" -#include "tr-tq-enqueue-ceiling.h" -#include "tr-tq-enqueue-fifo.h" -#include "tr-tq-enqueue-mrsp.h" -#include "tr-tq-enqueue-priority.h" #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreMtxReqSeizeTry spec:/score/mtx/req/seize-try + * @defgroup ScoreMtxReqSeizeTry spec:/score/mtx/req/seize-try * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -88,19 +84,19 @@ typedef struct { * @brief If this member is true, then the calling thread shall be the owner * of the mutex. */ - bool owner_caller;; + bool owner_caller; /** * @brief If this member is true, then a thread other than the calling thread * shall be the owner of the mutex. */ - bool owner_other;; + bool owner_other; /** * @brief This member contains the current priority of the calling thread * before the directive call. */ - rtems_task_priority priority_before;; + rtems_task_priority priority_before; /** * @brief This member contains the owner of the mutex after the directive @@ -112,7 +108,7 @@ typedef struct { * @brief This member contains the current priority of the calling thread * after the directive call. */ - rtems_task_priority priority_after;; + rtems_task_priority priority_after; /** * @brief This member contains a copy of the corresponding @@ -805,6 +801,11 @@ static void ScoreMtxReqSeizeTry_TestVariant( ScoreMtxReqSeizeTry_Context *ctx ) static T_fixture_node ScoreMtxReqSeizeTry_Node; +static T_remark ScoreMtxReqSeizeTry_Remark = { + .next = NULL, + .remark = "ScoreMtxReqSeizeTry" +}; + void ScoreMtxReqSeizeTry_Run( TQMtxContext *tq_ctx ) { ScoreMtxReqSeizeTry_Context *ctx; @@ -860,6 +861,7 @@ void ScoreMtxReqSeizeTry_Run( TQMtxContext *tq_ctx ) } } + T_add_remark( &ScoreMtxReqSeizeTry_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-mtx-seize-try.h b/testsuites/validation/tr-mtx-seize-try.h index 84e7cd6849..28bac7d25d 100644 --- a/testsuites/validation/tr-mtx-seize-try.h +++ b/testsuites/validation/tr-mtx-seize-try.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSeizeTry + * @ingroup ScoreMtxReqSeizeTry */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreMtxReqSeizeTry + * @addtogroup ScoreMtxReqSeizeTry * * @{ */ diff --git a/testsuites/validation/tr-mtx-seize-wait.c b/testsuites/validation/tr-mtx-seize-wait.c index 367ca0da32..2e2fe9d1ec 100644 --- a/testsuites/validation/tr-mtx-seize-wait.c +++ b/testsuites/validation/tr-mtx-seize-wait.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSeizeWait + * @ingroup ScoreMtxReqSeizeWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -56,16 +56,15 @@ #include "tr-tq-enqueue-ceiling.h" #include "tr-tq-enqueue-deadlock.h" #include "tr-tq-enqueue-fifo.h" -#include "tr-tq-enqueue-mrsp.h" #include "tr-tq-enqueue-priority-inherit.h" #include "tr-tq-enqueue-priority.h" #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreMtxReqSeizeWait spec:/score/mtx/req/seize-wait + * @defgroup ScoreMtxReqSeizeWait spec:/score/mtx/req/seize-wait * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -92,24 +91,24 @@ typedef struct { * @brief If this member is true, then the calling thread shall be the owner * of the mutex. */ - bool owner_caller;; + bool owner_caller; /** * @brief If this member is true, then a thread other than the calling thread * shall be the owner of the mutex. */ - bool owner_other;; + bool owner_other; /** * @brief If this member is true, then a deadlock shall occur. */ - bool deadlock;; + bool deadlock; /** * @brief This member contains the current priority of the calling thread * before the directive call. */ - rtems_task_priority priority_before;; + rtems_task_priority priority_before; /** * @brief This member contains the owner of the mutex after the directive @@ -121,7 +120,7 @@ typedef struct { * @brief This member contains the current priority of the calling thread * after the directive call. */ - rtems_task_priority priority_after;; + rtems_task_priority priority_after; /** * @brief This member contains a copy of the corresponding @@ -218,6 +217,10 @@ static const char * const * const ScoreMtxReqSeizeWait_PreDesc[] = { NULL }; +#if defined(RTEMS_SMP) +#include "tr-tq-enqueue-mrsp.h" +#endif + typedef ScoreMtxReqSeizeWait_Context Context; static Status_Control Status( const Context *ctx, Status_Control status ) @@ -707,7 +710,7 @@ static void ScoreMtxReqSeizeWait_Post_Enqueued_Check( case ScoreMtxReqSeizeWait_Post_Enqueued_PriorityInherit: { /* - * The calling thread shall be enqueued in priority order with priorit + * The calling thread shall be enqueued in priority order with priority * inheritance. */ ScoreTqReqEnqueuePriorityInherit_Run( &ctx->tq_ctx->base ); @@ -728,7 +731,11 @@ static void ScoreMtxReqSeizeWait_Post_Enqueued_Check( * The calling thread shall be enqueued in priority order according to * the MrsP locking protocol. */ + #if defined(RTEMS_SMP) ScoreTqReqEnqueueMrsp_Run( &ctx->tq_ctx->base ); + #else + T_unreachable(); + #endif break; } @@ -1072,6 +1079,11 @@ static void ScoreMtxReqSeizeWait_TestVariant( static T_fixture_node ScoreMtxReqSeizeWait_Node; +static T_remark ScoreMtxReqSeizeWait_Remark = { + .next = NULL, + .remark = "ScoreMtxReqSeizeWait" +}; + void ScoreMtxReqSeizeWait_Run( TQMtxContext *tq_ctx ) { ScoreMtxReqSeizeWait_Context *ctx; @@ -1133,6 +1145,7 @@ void ScoreMtxReqSeizeWait_Run( TQMtxContext *tq_ctx ) } } + T_add_remark( &ScoreMtxReqSeizeWait_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-mtx-seize-wait.h b/testsuites/validation/tr-mtx-seize-wait.h index 1ac532b1ce..0d3beeb97b 100644 --- a/testsuites/validation/tr-mtx-seize-wait.h +++ b/testsuites/validation/tr-mtx-seize-wait.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSeizeWait + * @ingroup ScoreMtxReqSeizeWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreMtxReqSeizeWait + * @addtogroup ScoreMtxReqSeizeWait * * @{ */ diff --git a/testsuites/validation/tr-mtx-surrender.c b/testsuites/validation/tr-mtx-surrender.c index 6e27ff2bc9..3c60726803 100644 --- a/testsuites/validation/tr-mtx-surrender.c +++ b/testsuites/validation/tr-mtx-surrender.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSurrender + * @ingroup ScoreMtxReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -53,16 +53,15 @@ #endif #include "tr-mtx-surrender.h" -#include "tr-tq-surrender-mrsp.h" #include "tr-tq-surrender-priority-inherit.h" #include "tr-tq-surrender.h" #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreMtxReqSurrender spec:/score/mtx/req/surrender + * @defgroup ScoreMtxReqSurrender spec:/score/mtx/req/surrender * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -252,6 +251,10 @@ static const char * const * const ScoreMtxReqSurrender_PreDesc[] = { NULL }; +#if defined(RTEMS_SMP) +#include "tr-tq-surrender-mrsp.h" +#endif + typedef ScoreMtxReqSurrender_Context Context; static Status_Control Status( const Context *ctx, Status_Control status ) @@ -810,8 +813,12 @@ static void ScoreMtxReqSurrender_Post_Surrender_Check( * The thread queue of the mutex shall be surrendered in priority order * with MrsP. */ + #if defined(RTEMS_SMP) T_eq_u32( ctx->counter, 1 ); ScoreTqReqSurrenderMrsp_Run( &ctx->tq_ctx->base ); + #else + T_unreachable(); + #endif break; } @@ -1154,6 +1161,11 @@ static void ScoreMtxReqSurrender_TestVariant( static T_fixture_node ScoreMtxReqSurrender_Node; +static T_remark ScoreMtxReqSurrender_Remark = { + .next = NULL, + .remark = "ScoreMtxReqSurrender" +}; + void ScoreMtxReqSurrender_Run( TQMtxContext *tq_ctx ) { ScoreMtxReqSurrender_Context *ctx; @@ -1227,6 +1239,7 @@ void ScoreMtxReqSurrender_Run( TQMtxContext *tq_ctx ) } } + T_add_remark( &ScoreMtxReqSurrender_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-mtx-surrender.h b/testsuites/validation/tr-mtx-surrender.h index 79b044d184..1b732d5e73 100644 --- a/testsuites/validation/tr-mtx-surrender.h +++ b/testsuites/validation/tr-mtx-surrender.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreMtxReqSurrender + * @ingroup ScoreMtxReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreMtxReqSurrender + * @addtogroup ScoreMtxReqSurrender * * @{ */ diff --git a/testsuites/validation/tr-object-ident-local.c b/testsuites/validation/tr-object-ident-local.c index 1b3943fdb1..5cf521fbd6 100644 --- a/testsuites/validation/tr-object-ident-local.c +++ b/testsuites/validation/tr-object-ident-local.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsReqIdentLocal + * @ingroup RtemsReqIdentLocal */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsReqIdentLocal spec:/rtems/req/ident-local + * @defgroup RtemsReqIdentLocal spec:/rtems/req/ident-local * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -350,6 +350,11 @@ static void RtemsReqIdentLocal_TestVariant( RtemsReqIdentLocal_Context *ctx ) static T_fixture_node RtemsReqIdentLocal_Node; +static T_remark RtemsReqIdentLocal_Remark = { + .next = NULL, + .remark = "RtemsReqIdentLocal" +}; + void RtemsReqIdentLocal_Run( rtems_id id_local_object, rtems_name name_local_object, @@ -382,6 +387,7 @@ void RtemsReqIdentLocal_Run( } } + T_add_remark( &RtemsReqIdentLocal_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-object-ident-local.h b/testsuites/validation/tr-object-ident-local.h index 83ad7e7416..d3cf1c307a 100644 --- a/testsuites/validation/tr-object-ident-local.h +++ b/testsuites/validation/tr-object-ident-local.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsReqIdentLocal + * @ingroup RtemsReqIdentLocal */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsReqIdentLocal + * @addtogroup RtemsReqIdentLocal * * @{ */ diff --git a/testsuites/validation/tr-object-ident.c b/testsuites/validation/tr-object-ident.c index 438c1f3333..df66d51437 100644 --- a/testsuites/validation/tr-object-ident.c +++ b/testsuites/validation/tr-object-ident.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsReqIdent + * @ingroup RtemsReqIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsReqIdent spec:/rtems/req/ident + * @defgroup RtemsReqIdent spec:/rtems/req/ident * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -454,6 +454,11 @@ static void RtemsReqIdent_TestVariant( RtemsReqIdent_Context *ctx ) static T_fixture_node RtemsReqIdent_Node; +static T_remark RtemsReqIdent_Remark = { + .next = NULL, + .remark = "RtemsReqIdent" +}; + void RtemsReqIdent_Run( rtems_id id_local_object, rtems_name name_local_object, @@ -492,6 +497,7 @@ void RtemsReqIdent_Run( } } + T_add_remark( &RtemsReqIdent_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-object-ident.h b/testsuites/validation/tr-object-ident.h index 7917562eab..404d56c707 100644 --- a/testsuites/validation/tr-object-ident.h +++ b/testsuites/validation/tr-object-ident.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsReqIdent + * @ingroup RtemsReqIdent */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsReqIdent + * @addtogroup RtemsReqIdent * * @{ */ diff --git a/testsuites/validation/tr-sem-seize-try.c b/testsuites/validation/tr-sem-seize-try.c index e723230288..3470f832fd 100644 --- a/testsuites/validation/tr-sem-seize-try.c +++ b/testsuites/validation/tr-sem-seize-try.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSeizeTry + * @ingroup ScoreSemReqSeizeTry */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSemReqSeizeTry spec:/score/sem/req/seize-try + * @defgroup ScoreSemReqSeizeTry spec:/score/sem/req/seize-try * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -294,6 +294,11 @@ static void ScoreSemReqSeizeTry_TestVariant( ScoreSemReqSeizeTry_Context *ctx ) static T_fixture_node ScoreSemReqSeizeTry_Node; +static T_remark ScoreSemReqSeizeTry_Remark = { + .next = NULL, + .remark = "ScoreSemReqSeizeTry" +}; + void ScoreSemReqSeizeTry_Run( TQSemContext *tq_ctx ) { ScoreSemReqSeizeTry_Context *ctx; @@ -317,6 +322,7 @@ void ScoreSemReqSeizeTry_Run( TQSemContext *tq_ctx ) ScoreSemReqSeizeTry_TestVariant( ctx ); } + T_add_remark( &ScoreSemReqSeizeTry_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-sem-seize-try.h b/testsuites/validation/tr-sem-seize-try.h index 155bf59cf8..347c8aa61d 100644 --- a/testsuites/validation/tr-sem-seize-try.h +++ b/testsuites/validation/tr-sem-seize-try.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSeizeTry + * @ingroup ScoreSemReqSeizeTry */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSemReqSeizeTry + * @addtogroup ScoreSemReqSeizeTry * * @{ */ diff --git a/testsuites/validation/tr-sem-seize-wait.c b/testsuites/validation/tr-sem-seize-wait.c index b4c4266103..bbc1cfd252 100644 --- a/testsuites/validation/tr-sem-seize-wait.c +++ b/testsuites/validation/tr-sem-seize-wait.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSeizeWait + * @ingroup ScoreSemReqSeizeWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSemReqSeizeWait spec:/score/sem/req/seize-wait + * @defgroup ScoreSemReqSeizeWait spec:/score/sem/req/seize-wait * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -368,6 +368,11 @@ static void ScoreSemReqSeizeWait_TestVariant( static T_fixture_node ScoreSemReqSeizeWait_Node; +static T_remark ScoreSemReqSeizeWait_Remark = { + .next = NULL, + .remark = "ScoreSemReqSeizeWait" +}; + void ScoreSemReqSeizeWait_Run( TQSemContext *tq_ctx ) { ScoreSemReqSeizeWait_Context *ctx; @@ -392,6 +397,7 @@ void ScoreSemReqSeizeWait_Run( TQSemContext *tq_ctx ) ScoreSemReqSeizeWait_TestVariant( ctx ); } + T_add_remark( &ScoreSemReqSeizeWait_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-sem-seize-wait.h b/testsuites/validation/tr-sem-seize-wait.h index 91d1790347..68156abbc7 100644 --- a/testsuites/validation/tr-sem-seize-wait.h +++ b/testsuites/validation/tr-sem-seize-wait.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSeizeWait + * @ingroup ScoreSemReqSeizeWait */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSemReqSeizeWait + * @addtogroup ScoreSemReqSeizeWait * * @{ */ diff --git a/testsuites/validation/tr-sem-surrender.c b/testsuites/validation/tr-sem-surrender.c index 8226093dda..d554a33dd2 100644 --- a/testsuites/validation/tr-sem-surrender.c +++ b/testsuites/validation/tr-sem-surrender.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSurrender + * @ingroup ScoreSemReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreSemReqSurrender spec:/score/sem/req/surrender + * @defgroup ScoreSemReqSurrender spec:/score/sem/req/surrender * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -528,6 +528,11 @@ static void ScoreSemReqSurrender_TestVariant( static T_fixture_node ScoreSemReqSurrender_Node; +static T_remark ScoreSemReqSurrender_Remark = { + .next = NULL, + .remark = "ScoreSemReqSurrender" +}; + void ScoreSemReqSurrender_Run( TQSemContext *tq_ctx ) { ScoreSemReqSurrender_Context *ctx; @@ -564,6 +569,7 @@ void ScoreSemReqSurrender_Run( TQSemContext *tq_ctx ) } } + T_add_remark( &ScoreSemReqSurrender_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-sem-surrender.h b/testsuites/validation/tr-sem-surrender.h index 06ab4c20c1..d03fe56b54 100644 --- a/testsuites/validation/tr-sem-surrender.h +++ b/testsuites/validation/tr-sem-surrender.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreSemReqSurrender + * @ingroup ScoreSemReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreSemReqSurrender + * @addtogroup ScoreSemReqSurrender * * @{ */ diff --git a/testsuites/validation/tr-signal-constant.c b/testsuites/validation/tr-signal-constant.c index 323f977272..c8aeb463fd 100644 --- a/testsuites/validation/tr-signal-constant.c +++ b/testsuites/validation/tr-signal-constant.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSignalValSignalConstant + * @ingroup RtemsSignalValSignalConstant */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseRtemsSignalValSignalConstant \ + * @defgroup RtemsSignalValSignalConstant \ * spec:/rtems/signal/val/signal-constant * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @brief Tests a signal constant of the @ref RTEMSAPIClassicSignal using the * signal set of the executing task. @@ -176,6 +176,11 @@ static void RtemsSignalValSignalConstant_Action_1( static T_fixture_node RtemsSignalValSignalConstant_Node; +static T_remark RtemsSignalValSignalConstant_Remark = { + .next = NULL, + .remark = "RtemsSignalValSignalConstant" +}; + void RtemsSignalValSignalConstant_Run( rtems_signal_set signal, int number ) { RtemsSignalValSignalConstant_Context *ctx; @@ -194,6 +199,7 @@ void RtemsSignalValSignalConstant_Run( rtems_signal_set signal, int number ) RtemsSignalValSignalConstant_Action_0( ctx ); RtemsSignalValSignalConstant_Action_1( ctx ); + T_add_remark( &RtemsSignalValSignalConstant_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-signal-constant.h b/testsuites/validation/tr-signal-constant.h index 99b43f159b..a957426213 100644 --- a/testsuites/validation/tr-signal-constant.h +++ b/testsuites/validation/tr-signal-constant.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseRtemsSignalValSignalConstant + * @ingroup RtemsSignalValSignalConstant */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseRtemsSignalValSignalConstant + * @addtogroup RtemsSignalValSignalConstant * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-ceiling.c b/testsuites/validation/tr-tq-enqueue-ceiling.c index 5309b31260..a0b4077689 100644 --- a/testsuites/validation/tr-tq-enqueue-ceiling.c +++ b/testsuites/validation/tr-tq-enqueue-ceiling.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueCeiling + * @ingroup ScoreTqReqEnqueueCeiling */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueueCeiling \ - * spec:/score/tq/req/enqueue-ceiling + * @defgroup ScoreTqReqEnqueueCeiling spec:/score/tq/req/enqueue-ceiling * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -87,7 +86,7 @@ typedef struct { * @brief This member specifies the priority of a thread with an eligible * scheduler equal to an eligible scheduler of the enqueueing thread. */ - rtems_task_priority priority;; + rtems_task_priority priority; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -95,7 +94,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_before;; + size_t other_before; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -103,7 +102,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_after;; + size_t other_after; /** * @brief This member contains a copy of the corresponding @@ -455,7 +454,9 @@ static void ScoreTqReqEnqueueCeiling_Prepare( ScoreTqReqEnqueueCeiling_Context *ctx ) { - ctx->priority = PRIO_PSEUDO_ISR; ctx->other_before = false; ctx->other_after = false; + ctx->priority = PRIO_PSEUDO_ISR; + ctx->other_before = false; + ctx->other_after = false; } static void ScoreTqReqEnqueueCeiling_Action( @@ -644,6 +645,11 @@ static void ScoreTqReqEnqueueCeiling_TestVariant( static T_fixture_node ScoreTqReqEnqueueCeiling_Node; +static T_remark ScoreTqReqEnqueueCeiling_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueueCeiling" +}; + void ScoreTqReqEnqueueCeiling_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueueCeiling_Context *ctx; @@ -680,6 +686,7 @@ void ScoreTqReqEnqueueCeiling_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqEnqueueCeiling_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-ceiling.h b/testsuites/validation/tr-tq-enqueue-ceiling.h index 3eca5033db..3f61865791 100644 --- a/testsuites/validation/tr-tq-enqueue-ceiling.h +++ b/testsuites/validation/tr-tq-enqueue-ceiling.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueCeiling + * @ingroup ScoreTqReqEnqueueCeiling */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueueCeiling + * @addtogroup ScoreTqReqEnqueueCeiling * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-deadlock.c b/testsuites/validation/tr-tq-enqueue-deadlock.c index afe4ef864e..7f61cbc444 100644 --- a/testsuites/validation/tr-tq-enqueue-deadlock.c +++ b/testsuites/validation/tr-tq-enqueue-deadlock.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueDeadlock + * @ingroup ScoreTqReqEnqueueDeadlock */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueueDeadlock \ - * spec:/score/tq/req/enqueue-deadlock + * @defgroup ScoreTqReqEnqueueDeadlock spec:/score/tq/req/enqueue-deadlock * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -406,6 +405,11 @@ static void ScoreTqReqEnqueueDeadlock_TestVariant( static T_fixture_node ScoreTqReqEnqueueDeadlock_Node; +static T_remark ScoreTqReqEnqueueDeadlock_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueueDeadlock" +}; + void ScoreTqReqEnqueueDeadlock_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueueDeadlock_Context *ctx; @@ -436,6 +440,7 @@ void ScoreTqReqEnqueueDeadlock_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqEnqueueDeadlock_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-deadlock.h b/testsuites/validation/tr-tq-enqueue-deadlock.h index be23bcf879..1fe580a19c 100644 --- a/testsuites/validation/tr-tq-enqueue-deadlock.h +++ b/testsuites/validation/tr-tq-enqueue-deadlock.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueDeadlock + * @ingroup ScoreTqReqEnqueueDeadlock */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueueDeadlock + * @addtogroup ScoreTqReqEnqueueDeadlock * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-fifo.c b/testsuites/validation/tr-tq-enqueue-fifo.c index b64a99c0d1..27ac064797 100644 --- a/testsuites/validation/tr-tq-enqueue-fifo.c +++ b/testsuites/validation/tr-tq-enqueue-fifo.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueFifo + * @ingroup ScoreTqReqEnqueueFifo */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueueFifo spec:/score/tq/req/enqueue-fifo + * @defgroup ScoreTqReqEnqueueFifo spec:/score/tq/req/enqueue-fifo * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -305,6 +305,11 @@ static void ScoreTqReqEnqueueFifo_TestVariant( static T_fixture_node ScoreTqReqEnqueueFifo_Node; +static T_remark ScoreTqReqEnqueueFifo_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueueFifo" +}; + void ScoreTqReqEnqueueFifo_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueueFifo_Context *ctx; @@ -328,6 +333,7 @@ void ScoreTqReqEnqueueFifo_Run( TQContext *tq_ctx ) ScoreTqReqEnqueueFifo_TestVariant( ctx ); } + T_add_remark( &ScoreTqReqEnqueueFifo_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-fifo.h b/testsuites/validation/tr-tq-enqueue-fifo.h index 776cded8b9..16a37ecf2b 100644 --- a/testsuites/validation/tr-tq-enqueue-fifo.h +++ b/testsuites/validation/tr-tq-enqueue-fifo.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueFifo + * @ingroup ScoreTqReqEnqueueFifo */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueueFifo + * @addtogroup ScoreTqReqEnqueueFifo * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-mrsp.c b/testsuites/validation/tr-tq-enqueue-mrsp.c index d48455b2eb..14f1f17713 100644 --- a/testsuites/validation/tr-tq-enqueue-mrsp.c +++ b/testsuites/validation/tr-tq-enqueue-mrsp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueMrsp + * @ingroup ScoreTqReqEnqueueMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueueMrsp spec:/score/tq/req/enqueue-mrsp + * @defgroup ScoreTqReqEnqueueMrsp spec:/score/tq/req/enqueue-mrsp * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -88,7 +88,7 @@ typedef struct { * with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - rtems_task_priority priority;; + rtems_task_priority priority; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -96,7 +96,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_before;; + size_t other_before; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -104,7 +104,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_after;; + size_t other_after; /** * @brief This member contains a copy of the corresponding @@ -611,6 +611,11 @@ static void ScoreTqReqEnqueueMrsp_TestVariant( static T_fixture_node ScoreTqReqEnqueueMrsp_Node; +static T_remark ScoreTqReqEnqueueMrsp_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueueMrsp" +}; + void ScoreTqReqEnqueueMrsp_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueueMrsp_Context *ctx; @@ -646,6 +651,7 @@ void ScoreTqReqEnqueueMrsp_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqEnqueueMrsp_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-mrsp.h b/testsuites/validation/tr-tq-enqueue-mrsp.h index 98cb8b9883..1c38b4b238 100644 --- a/testsuites/validation/tr-tq-enqueue-mrsp.h +++ b/testsuites/validation/tr-tq-enqueue-mrsp.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueueMrsp + * @ingroup ScoreTqReqEnqueueMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueueMrsp + * @addtogroup ScoreTqReqEnqueueMrsp * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-priority-inherit.c b/testsuites/validation/tr-tq-enqueue-priority-inherit.c index fc9a75e4fa..160e2d7825 100644 --- a/testsuites/validation/tr-tq-enqueue-priority-inherit.c +++ b/testsuites/validation/tr-tq-enqueue-priority-inherit.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueuePriorityInherit + * @ingroup ScoreTqReqEnqueuePriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueuePriorityInherit \ + * @defgroup ScoreTqReqEnqueuePriorityInherit \ * spec:/score/tq/req/enqueue-priority-inherit * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -1668,6 +1668,11 @@ static void ScoreTqReqEnqueuePriorityInherit_TestVariant( static T_fixture_node ScoreTqReqEnqueuePriorityInherit_Node; +static T_remark ScoreTqReqEnqueuePriorityInherit_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueuePriorityInherit" +}; + void ScoreTqReqEnqueuePriorityInherit_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueuePriorityInherit_Context *ctx; @@ -1730,6 +1735,7 @@ void ScoreTqReqEnqueuePriorityInherit_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqEnqueuePriorityInherit_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-priority-inherit.h b/testsuites/validation/tr-tq-enqueue-priority-inherit.h index 526766a981..c2ffa59902 100644 --- a/testsuites/validation/tr-tq-enqueue-priority-inherit.h +++ b/testsuites/validation/tr-tq-enqueue-priority-inherit.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueuePriorityInherit + * @ingroup ScoreTqReqEnqueuePriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueuePriorityInherit + * @addtogroup ScoreTqReqEnqueuePriorityInherit * * @{ */ diff --git a/testsuites/validation/tr-tq-enqueue-priority.c b/testsuites/validation/tr-tq-enqueue-priority.c index 6487c13aa2..18818e34cd 100644 --- a/testsuites/validation/tr-tq-enqueue-priority.c +++ b/testsuites/validation/tr-tq-enqueue-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueuePriority + * @ingroup ScoreTqReqEnqueuePriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqEnqueuePriority \ - * spec:/score/tq/req/enqueue-priority + * @defgroup ScoreTqReqEnqueuePriority spec:/score/tq/req/enqueue-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -87,7 +86,7 @@ typedef struct { * @brief This member specifies the priority of a thread with an eligible * scheduler equal to an eligible scheduler of the enqueueing thread. */ - rtems_task_priority priority;; + rtems_task_priority priority; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -95,7 +94,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_before;; + size_t other_before; /** * @brief If this member is true, then a thread those eligible schedulers are @@ -103,7 +102,7 @@ typedef struct { * thread with an eligible scheduler equal to an eligible scheduler of the * enqueueing thread. */ - size_t other_after;; + size_t other_after; /** * @brief This member contains a copy of the corresponding @@ -704,6 +703,11 @@ static void ScoreTqReqEnqueuePriority_TestVariant( static T_fixture_node ScoreTqReqEnqueuePriority_Node; +static T_remark ScoreTqReqEnqueuePriority_Remark = { + .next = NULL, + .remark = "ScoreTqReqEnqueuePriority" +}; + void ScoreTqReqEnqueuePriority_Run( TQContext *tq_ctx ) { ScoreTqReqEnqueuePriority_Context *ctx; @@ -740,6 +744,7 @@ void ScoreTqReqEnqueuePriority_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqEnqueuePriority_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-enqueue-priority.h b/testsuites/validation/tr-tq-enqueue-priority.h index 97f5f883de..141c8a122c 100644 --- a/testsuites/validation/tr-tq-enqueue-priority.h +++ b/testsuites/validation/tr-tq-enqueue-priority.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqEnqueuePriority + * @ingroup ScoreTqReqEnqueuePriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqEnqueuePriority + * @addtogroup ScoreTqReqEnqueuePriority * * @{ */ diff --git a/testsuites/validation/tr-tq-flush-fifo.c b/testsuites/validation/tr-tq-flush-fifo.c index 9b6821ac27..785d7b37a1 100644 --- a/testsuites/validation/tr-tq-flush-fifo.c +++ b/testsuites/validation/tr-tq-flush-fifo.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushFifo + * @ingroup ScoreTqReqFlushFifo */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,16 +58,19 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqFlushFifo spec:/score/tq/req/flush-fifo + * @defgroup ScoreTqReqFlushFifo spec:/score/tq/req/flush-fifo * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ typedef struct { uint8_t Skip : 1; - uint8_t Pre_Queue_NA : 1; + uint8_t Pre_MayStop_NA : 1; + uint8_t Pre_QueueEmpty_NA : 1; + uint8_t Pre_Stop_NA : 1; + uint8_t Pre_WaitState_NA : 1; uint8_t Post_Operation : 2; } ScoreTqReqFlushFifo_Entry; @@ -76,9 +79,20 @@ typedef struct { */ typedef struct { /** + * @brief If this member is true, then the flush filter shall return NULL. + */ + bool stop; + + /** + * @brief If this member is true, then the least recently enqueued thread + * shall be in the intend to block wait state. + */ + bool intend_to_block; + + /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member contains a copy of the corresponding @@ -86,11 +100,23 @@ typedef struct { */ TQContext *tq_ctx; + /** + * @brief This member contains a copy of the corresponding + * ScoreTqReqFlushFifo_Run() parameter. + */ + bool may_stop; + struct { /** + * @brief This member defines the pre-condition indices for the next + * action. + */ + size_t pci[ 4 ]; + + /** * @brief This member defines the pre-condition states for the next action. */ - size_t pcs[ 1 ]; + size_t pcs[ 4 ]; /** * @brief If this member is true, then the test action loop is executed. @@ -118,14 +144,35 @@ typedef struct { static ScoreTqReqFlushFifo_Context ScoreTqReqFlushFifo_Instance; -static const char * const ScoreTqReqFlushFifo_PreDesc_Queue[] = { - "Empty", - "NonEmpty", +static const char * const ScoreTqReqFlushFifo_PreDesc_MayStop[] = { + "Yes", + "No", + "NA" +}; + +static const char * const ScoreTqReqFlushFifo_PreDesc_QueueEmpty[] = { + "Yes", + "No", + "NA" +}; + +static const char * const ScoreTqReqFlushFifo_PreDesc_Stop[] = { + "Yes", + "No", + "NA" +}; + +static const char * const ScoreTqReqFlushFifo_PreDesc_WaitState[] = { + "Blocked", + "IntendToBlock", "NA" }; static const char * const * const ScoreTqReqFlushFifo_PreDesc[] = { - ScoreTqReqFlushFifo_PreDesc_Queue, + ScoreTqReqFlushFifo_PreDesc_MayStop, + ScoreTqReqFlushFifo_PreDesc_QueueEmpty, + ScoreTqReqFlushFifo_PreDesc_Stop, + ScoreTqReqFlushFifo_PreDesc_WaitState, NULL }; @@ -141,13 +188,24 @@ static const rtems_tcb *GetTCB( Context *ctx, TQWorkerKind worker ) return ctx->tq_ctx->worker_tcb[ worker ]; } -static void Flush( void *arg ) +static void BlockerAFlush( Context *ctx ) +{ + TQSchedulerRecordStart( ctx->tq_ctx ); + + if ( ctx->stop ) { + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH_PARTIAL ); + } else { + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH_ALL ); + } +} + +static void InterruptFlush( void *arg ) { Context *ctx; ctx = arg; TQSchedulerRecordStart( ctx->tq_ctx ); - TQFlush( ctx->tq_ctx ); + TQFlush( ctx->tq_ctx, !ctx->stop ); } static void SchedulerEvent( @@ -164,20 +222,109 @@ static void SchedulerEvent( when == T_SCHEDULER_BEFORE && event->operation == T_SCHEDULER_BLOCK ) { - ctx->request.handler = Flush; - ctx->request.arg = ctx; - CallWithinISRSubmit( &ctx->request ); T_scheduler_set_event_handler( NULL, NULL ); + ctx->request.handler = InterruptFlush; + CallWithinISRSubmit( &ctx->request ); } } -static void ScoreTqReqFlushFifo_Pre_Queue_Prepare( - ScoreTqReqFlushFifo_Context *ctx, - ScoreTqReqFlushFifo_Pre_Queue state +static uint32_t CheckExtractions( Context *ctx ) +{ + uint32_t extracted_threads; + size_t i; + const T_scheduler_event *event; + + extracted_threads = 0; + i = 0; + + if ( !ctx->intend_to_block ) { + /* Event receive */ + T_eq_ptr( GetUnblock( ctx, &i )->thread, GetTCB( ctx, TQ_BLOCKER_A ) ); + } + + event = GetUnblock( ctx, &i ); + + if ( event != &T_scheduler_event_null ) { + if ( ctx->intend_to_block ) { + T_eq_ptr( event->executing, NULL ); + } else { + T_eq_ptr( event->executing, GetTCB( ctx, TQ_BLOCKER_A ) ); + } + + T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_B ) ); + ++extracted_threads; + } + + event = GetUnblock( ctx, &i ); + + if ( event != &T_scheduler_event_null ) { + if ( ctx->intend_to_block ) { + T_eq_ptr( event->executing, NULL ); + } else { + T_eq_ptr( event->executing, GetTCB( ctx, TQ_BLOCKER_A ) ); + } + + T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_C ) ); + ++extracted_threads; + } + + event = GetUnblock( ctx, &i ); + + if ( event != &T_scheduler_event_null ) { + if ( ctx->intend_to_block ) { + T_eq_ptr( event->executing, GetTCB( ctx, TQ_BLOCKER_D ) ); + } else { + T_eq_ptr( event->executing, GetTCB( ctx, TQ_BLOCKER_A ) ); + } + + T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_D ) ); + ++extracted_threads; + } + + T_eq_ptr( GetUnblock( ctx, &i ), &T_scheduler_event_null ); + T_eq_u32( extracted_threads, ctx->tq_ctx->flush_count ); + + return extracted_threads; +} + +static void ScoreTqReqFlushFifo_Pre_MayStop_Prepare( + ScoreTqReqFlushFifo_Context *ctx, + ScoreTqReqFlushFifo_Pre_MayStop state ) { switch ( state ) { - case ScoreTqReqFlushFifo_Pre_Queue_Empty: { + case ScoreTqReqFlushFifo_Pre_MayStop_Yes: { + /* + * Where the flush filter may return NULL. + */ + if ( !ctx->may_stop ) { + ctx->Map.skip = true; + } + break; + } + + case ScoreTqReqFlushFifo_Pre_MayStop_No: { + /* + * Where the flush filter does not return NULL. + */ + if ( ctx->may_stop ) { + ctx->Map.skip = true; + } + break; + } + + case ScoreTqReqFlushFifo_Pre_MayStop_NA: + break; + } +} + +static void ScoreTqReqFlushFifo_Pre_QueueEmpty_Prepare( + ScoreTqReqFlushFifo_Context *ctx, + ScoreTqReqFlushFifo_Pre_QueueEmpty state +) +{ + switch ( state ) { + case ScoreTqReqFlushFifo_Pre_QueueEmpty_Yes: { /* * While the thread queue is empty. */ @@ -185,7 +332,7 @@ static void ScoreTqReqFlushFifo_Pre_Queue_Prepare( break; } - case ScoreTqReqFlushFifo_Pre_Queue_NonEmpty: { + case ScoreTqReqFlushFifo_Pre_QueueEmpty_No: { /* * While the thread queue has at least one enqueued thread. */ @@ -193,7 +340,63 @@ static void ScoreTqReqFlushFifo_Pre_Queue_Prepare( break; } - case ScoreTqReqFlushFifo_Pre_Queue_NA: + case ScoreTqReqFlushFifo_Pre_QueueEmpty_NA: + break; + } +} + +static void ScoreTqReqFlushFifo_Pre_Stop_Prepare( + ScoreTqReqFlushFifo_Context *ctx, + ScoreTqReqFlushFifo_Pre_Stop state +) +{ + switch ( state ) { + case ScoreTqReqFlushFifo_Pre_Stop_Yes: { + /* + * While the flush filter returns NULL for an enqueued thread. + */ + ctx->stop = true; + break; + } + + case ScoreTqReqFlushFifo_Pre_Stop_No: { + /* + * While the flush filter does not return NULL for an enqueued thread. + */ + ctx->stop = false; + break; + } + + case ScoreTqReqFlushFifo_Pre_Stop_NA: + break; + } +} + +static void ScoreTqReqFlushFifo_Pre_WaitState_Prepare( + ScoreTqReqFlushFifo_Context *ctx, + ScoreTqReqFlushFifo_Pre_WaitState state +) +{ + switch ( state ) { + case ScoreTqReqFlushFifo_Pre_WaitState_Blocked: { + /* + * While the least recently enqueued thread on the thread queue is in the + * blocked wait state. + */ + ctx->intend_to_block = false; + break; + } + + case ScoreTqReqFlushFifo_Pre_WaitState_IntendToBlock: { + /* + * While the least recently enqueued thread on the thread queue is in the + * intend to block wait state. + */ + ctx->intend_to_block = true; + break; + } + + case ScoreTqReqFlushFifo_Pre_WaitState_NA: break; } } @@ -203,40 +406,39 @@ static void ScoreTqReqFlushFifo_Post_Operation_Check( ScoreTqReqFlushFifo_Post_Operation state ) { - size_t i; - const T_scheduler_event *event; - - i = 0; + size_t i; + uint32_t extracted_threads; switch ( state ) { case ScoreTqReqFlushFifo_Post_Operation_Nop: { /* - * No operation shall be performed. + * No thread queue extraction operation shall be performed. */ /* Event receive */ + i = 0; T_eq_ptr( GetUnblock( ctx, &i )->thread, GetTCB( ctx, TQ_BLOCKER_A ) ); T_eq_ptr( GetUnblock( ctx, &i ), &T_scheduler_event_null ); break; } - case ScoreTqReqFlushFifo_Post_Operation_TryExtract: { + case ScoreTqReqFlushFifo_Post_Operation_ExtractAll: { /* - * The enqueued threads of the thread queue may be extracted in FIFO + * The enqueued threads shall be extracted from the thread queue in FIFO * order. */ - event = GetUnblock( ctx, &i ); - T_eq_ptr( event->executing, NULL ); - T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_B ) ); - - event = GetUnblock( ctx, &i ); - T_eq_ptr( event->executing, NULL ); - T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_C ) ); - - event = GetUnblock( ctx, &i ); - T_eq_ptr( event->executing, GetTCB( ctx, TQ_BLOCKER_D ) ); - T_eq_ptr( event->thread, GetTCB( ctx, TQ_BLOCKER_D ) ); + extracted_threads = CheckExtractions( ctx ); + T_eq_sz( extracted_threads, ctx->tq_ctx->how_many ); + break; + } - T_eq_ptr( GetUnblock( ctx, &i ), &T_scheduler_event_null ); + case ScoreTqReqFlushFifo_Post_Operation_ExtractPartial: { + /* + * The enqueued threads which precede in FIFO order the enqueued thread + * for which the flush filter returned NULL shall be extracted from the + * thread queue in FIFO order. + */ + extracted_threads = CheckExtractions( ctx ); + T_lt_sz( extracted_threads, ctx->tq_ctx->how_many ); break; } @@ -247,6 +449,7 @@ static void ScoreTqReqFlushFifo_Post_Operation_Check( static void ScoreTqReqFlushFifo_Setup( ScoreTqReqFlushFifo_Context *ctx ) { + ctx->request.arg = ctx; TQReset( ctx->tq_ctx ); TQSetPriority( ctx->tq_ctx, TQ_BLOCKER_A, PRIO_ULTRA_HIGH ); TQSetPriority( ctx->tq_ctx, TQ_BLOCKER_B, PRIO_VERY_HIGH ); @@ -279,31 +482,45 @@ static void ScoreTqReqFlushFifo_Teardown_Wrap( void *arg ) static void ScoreTqReqFlushFifo_Action( ScoreTqReqFlushFifo_Context *ctx ) { + uint32_t flush_count; + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_ENQUEUE_PREPARE ); if ( ctx->tq_ctx->how_many > 0 ) { TQSend( ctx->tq_ctx, TQ_BLOCKER_B, TQ_EVENT_ENQUEUE ); TQSend( ctx->tq_ctx, TQ_BLOCKER_C, TQ_EVENT_ENQUEUE ); - T_scheduler_set_event_handler( SchedulerEvent, ctx ); + + if ( ctx->intend_to_block ) { + T_scheduler_set_event_handler( SchedulerEvent, ctx ); + } + TQSend( ctx->tq_ctx, TQ_BLOCKER_D, TQ_EVENT_ENQUEUE ); + + if ( !ctx->intend_to_block ) { + BlockerAFlush( ctx ); + } } else { - TQSchedulerRecordStart( ctx->tq_ctx ); - TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH ); + BlockerAFlush( ctx ); } + flush_count = ctx->tq_ctx->flush_count; TQSchedulerRecordStop( ctx->tq_ctx ); + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH_ALL ); TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_ENQUEUE_DONE ); + ctx->tq_ctx->flush_count = flush_count; } static const ScoreTqReqFlushFifo_Entry ScoreTqReqFlushFifo_Entries[] = { - { 0, 0, ScoreTqReqFlushFifo_Post_Operation_Nop }, - { 0, 0, ScoreTqReqFlushFifo_Post_Operation_TryExtract } + { 0, 0, 0, 1, 1, ScoreTqReqFlushFifo_Post_Operation_Nop }, + { 0, 0, 0, 0, 0, ScoreTqReqFlushFifo_Post_Operation_ExtractAll }, + { 0, 0, 0, 0, 0, ScoreTqReqFlushFifo_Post_Operation_ExtractPartial }, + { 1, 0, 0, 0, 0, ScoreTqReqFlushFifo_Post_Operation_NA } }; static const uint8_t ScoreTqReqFlushFifo_Map[] = { - 0, 1 + 0, 0, 0, 0, 2, 2, 1, 1, 0, 0, 0, 0, 3, 3, 1, 1 }; static size_t ScoreTqReqFlushFifo_Scope( void *arg, char *buf, size_t n ) @@ -327,22 +544,86 @@ static T_fixture ScoreTqReqFlushFifo_Fixture = { .initial_context = &ScoreTqReqFlushFifo_Instance }; +static const uint8_t ScoreTqReqFlushFifo_Weights[] = { + 8, 4, 2, 1 +}; + +static void ScoreTqReqFlushFifo_Skip( + ScoreTqReqFlushFifo_Context *ctx, + size_t index +) +{ + switch ( index + 1 ) { + case 1: + ctx->Map.pci[ 1 ] = ScoreTqReqFlushFifo_Pre_QueueEmpty_NA - 1; + /* Fall through */ + case 2: + ctx->Map.pci[ 2 ] = ScoreTqReqFlushFifo_Pre_Stop_NA - 1; + /* Fall through */ + case 3: + ctx->Map.pci[ 3 ] = ScoreTqReqFlushFifo_Pre_WaitState_NA - 1; + break; + } +} + static inline ScoreTqReqFlushFifo_Entry ScoreTqReqFlushFifo_PopEntry( ScoreTqReqFlushFifo_Context *ctx ) { size_t index; - index = ctx->Map.index; + if ( ctx->Map.skip ) { + size_t i; + + ctx->Map.skip = false; + index = 0; + + for ( i = 0; i < 4; ++i ) { + index += ScoreTqReqFlushFifo_Weights[ i ] * ctx->Map.pci[ i ]; + } + } else { + index = ctx->Map.index; + } + ctx->Map.index = index + 1; + return ScoreTqReqFlushFifo_Entries[ ScoreTqReqFlushFifo_Map[ index ] ]; } +static void ScoreTqReqFlushFifo_SetPreConditionStates( + ScoreTqReqFlushFifo_Context *ctx +) +{ + ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; + ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; + + if ( ctx->Map.entry.Pre_Stop_NA ) { + ctx->Map.pcs[ 2 ] = ScoreTqReqFlushFifo_Pre_Stop_NA; + } else { + ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ]; + } + + if ( ctx->Map.entry.Pre_WaitState_NA ) { + ctx->Map.pcs[ 3 ] = ScoreTqReqFlushFifo_Pre_WaitState_NA; + } else { + ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ]; + } +} + static void ScoreTqReqFlushFifo_TestVariant( ScoreTqReqFlushFifo_Context *ctx ) { - ScoreTqReqFlushFifo_Pre_Queue_Prepare( ctx, ctx->Map.pcs[ 0 ] ); + ScoreTqReqFlushFifo_Pre_MayStop_Prepare( ctx, ctx->Map.pcs[ 0 ] ); + + if ( ctx->Map.skip ) { + ScoreTqReqFlushFifo_Skip( ctx, 0 ); + return; + } + + ScoreTqReqFlushFifo_Pre_QueueEmpty_Prepare( ctx, ctx->Map.pcs[ 1 ] ); + ScoreTqReqFlushFifo_Pre_Stop_Prepare( ctx, ctx->Map.pcs[ 2 ] ); + ScoreTqReqFlushFifo_Pre_WaitState_Prepare( ctx, ctx->Map.pcs[ 3 ] ); ScoreTqReqFlushFifo_Action( ctx ); ScoreTqReqFlushFifo_Post_Operation_Check( ctx, @@ -352,12 +633,18 @@ static void ScoreTqReqFlushFifo_TestVariant( ScoreTqReqFlushFifo_Context *ctx ) static T_fixture_node ScoreTqReqFlushFifo_Node; -void ScoreTqReqFlushFifo_Run( TQContext *tq_ctx ) +static T_remark ScoreTqReqFlushFifo_Remark = { + .next = NULL, + .remark = "ScoreTqReqFlushFifo" +}; + +void ScoreTqReqFlushFifo_Run( TQContext *tq_ctx, bool may_stop ) { ScoreTqReqFlushFifo_Context *ctx; ctx = &ScoreTqReqFlushFifo_Instance; ctx->tq_ctx = tq_ctx; + ctx->may_stop = may_stop; ctx = T_push_fixture( &ScoreTqReqFlushFifo_Node, @@ -365,16 +652,42 @@ void ScoreTqReqFlushFifo_Run( TQContext *tq_ctx ) ); ctx->Map.in_action_loop = true; ctx->Map.index = 0; + ctx->Map.skip = false; for ( - ctx->Map.pcs[ 0 ] = ScoreTqReqFlushFifo_Pre_Queue_Empty; - ctx->Map.pcs[ 0 ] < ScoreTqReqFlushFifo_Pre_Queue_NA; - ++ctx->Map.pcs[ 0 ] + ctx->Map.pci[ 0 ] = ScoreTqReqFlushFifo_Pre_MayStop_Yes; + ctx->Map.pci[ 0 ] < ScoreTqReqFlushFifo_Pre_MayStop_NA; + ++ctx->Map.pci[ 0 ] ) { - ctx->Map.entry = ScoreTqReqFlushFifo_PopEntry( ctx ); - ScoreTqReqFlushFifo_TestVariant( ctx ); + for ( + ctx->Map.pci[ 1 ] = ScoreTqReqFlushFifo_Pre_QueueEmpty_Yes; + ctx->Map.pci[ 1 ] < ScoreTqReqFlushFifo_Pre_QueueEmpty_NA; + ++ctx->Map.pci[ 1 ] + ) { + for ( + ctx->Map.pci[ 2 ] = ScoreTqReqFlushFifo_Pre_Stop_Yes; + ctx->Map.pci[ 2 ] < ScoreTqReqFlushFifo_Pre_Stop_NA; + ++ctx->Map.pci[ 2 ] + ) { + for ( + ctx->Map.pci[ 3 ] = ScoreTqReqFlushFifo_Pre_WaitState_Blocked; + ctx->Map.pci[ 3 ] < ScoreTqReqFlushFifo_Pre_WaitState_NA; + ++ctx->Map.pci[ 3 ] + ) { + ctx->Map.entry = ScoreTqReqFlushFifo_PopEntry( ctx ); + + if ( ctx->Map.entry.Skip ) { + continue; + } + + ScoreTqReqFlushFifo_SetPreConditionStates( ctx ); + ScoreTqReqFlushFifo_TestVariant( ctx ); + } + } + } } + T_add_remark( &ScoreTqReqFlushFifo_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-flush-fifo.h b/testsuites/validation/tr-tq-flush-fifo.h index dca1444891..8d5bb8b8d6 100644 --- a/testsuites/validation/tr-tq-flush-fifo.h +++ b/testsuites/validation/tr-tq-flush-fifo.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushFifo + * @ingroup ScoreTqReqFlushFifo */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,20 +58,39 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqFlushFifo + * @addtogroup ScoreTqReqFlushFifo * * @{ */ typedef enum { - ScoreTqReqFlushFifo_Pre_Queue_Empty, - ScoreTqReqFlushFifo_Pre_Queue_NonEmpty, - ScoreTqReqFlushFifo_Pre_Queue_NA -} ScoreTqReqFlushFifo_Pre_Queue; + ScoreTqReqFlushFifo_Pre_MayStop_Yes, + ScoreTqReqFlushFifo_Pre_MayStop_No, + ScoreTqReqFlushFifo_Pre_MayStop_NA +} ScoreTqReqFlushFifo_Pre_MayStop; + +typedef enum { + ScoreTqReqFlushFifo_Pre_QueueEmpty_Yes, + ScoreTqReqFlushFifo_Pre_QueueEmpty_No, + ScoreTqReqFlushFifo_Pre_QueueEmpty_NA +} ScoreTqReqFlushFifo_Pre_QueueEmpty; + +typedef enum { + ScoreTqReqFlushFifo_Pre_Stop_Yes, + ScoreTqReqFlushFifo_Pre_Stop_No, + ScoreTqReqFlushFifo_Pre_Stop_NA +} ScoreTqReqFlushFifo_Pre_Stop; + +typedef enum { + ScoreTqReqFlushFifo_Pre_WaitState_Blocked, + ScoreTqReqFlushFifo_Pre_WaitState_IntendToBlock, + ScoreTqReqFlushFifo_Pre_WaitState_NA +} ScoreTqReqFlushFifo_Pre_WaitState; typedef enum { ScoreTqReqFlushFifo_Post_Operation_Nop, - ScoreTqReqFlushFifo_Post_Operation_TryExtract, + ScoreTqReqFlushFifo_Post_Operation_ExtractAll, + ScoreTqReqFlushFifo_Post_Operation_ExtractPartial, ScoreTqReqFlushFifo_Post_Operation_NA } ScoreTqReqFlushFifo_Post_Operation; @@ -79,8 +98,10 @@ typedef enum { * @brief Runs the parameterized test case. * * @param[in,out] tq_ctx is the thread queue test context. + * + * @param may_stop is true, if a partial flush is supported. */ -void ScoreTqReqFlushFifo_Run( TQContext *tq_ctx ); +void ScoreTqReqFlushFifo_Run( TQContext *tq_ctx, bool may_stop ); /** @} */ diff --git a/testsuites/validation/tr-tq-flush-priority-inherit.c b/testsuites/validation/tr-tq-flush-priority-inherit.c index beb48ebbe7..903dc20cf2 100644 --- a/testsuites/validation/tr-tq-flush-priority-inherit.c +++ b/testsuites/validation/tr-tq-flush-priority-inherit.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushPriorityInherit + * @ingroup ScoreTqReqFlushPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqFlushPriorityInherit \ + * @defgroup ScoreTqReqFlushPriorityInherit \ * spec:/score/tq/req/flush-priority-inherit * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -81,7 +81,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief If this member is true, then a minimum priority of the owner of the @@ -179,7 +179,7 @@ static void Flush( void *arg ) ctx = arg; TQSchedulerRecordStart( ctx->tq_ctx ); - TQFlush( ctx->tq_ctx ); + TQFlush( ctx->tq_ctx, true ); } static void SchedulerEvent( @@ -434,7 +434,7 @@ static void ScoreTqReqFlushPriorityInherit_Action( ); } else { TQSchedulerRecordStart( ctx->tq_ctx ); - TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH ); + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH_ALL ); } TQSchedulerRecordStop( ctx->tq_ctx ); @@ -535,6 +535,11 @@ static void ScoreTqReqFlushPriorityInherit_TestVariant( static T_fixture_node ScoreTqReqFlushPriorityInherit_Node; +static T_remark ScoreTqReqFlushPriorityInherit_Remark = { + .next = NULL, + .remark = "ScoreTqReqFlushPriorityInherit" +}; + void ScoreTqReqFlushPriorityInherit_Run( TQContext *tq_ctx ) { ScoreTqReqFlushPriorityInherit_Context *ctx; @@ -565,6 +570,7 @@ void ScoreTqReqFlushPriorityInherit_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqFlushPriorityInherit_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-flush-priority-inherit.h b/testsuites/validation/tr-tq-flush-priority-inherit.h index 1b12f1afb0..277084244c 100644 --- a/testsuites/validation/tr-tq-flush-priority-inherit.h +++ b/testsuites/validation/tr-tq-flush-priority-inherit.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushPriorityInherit + * @ingroup ScoreTqReqFlushPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqFlushPriorityInherit + * @addtogroup ScoreTqReqFlushPriorityInherit * * @{ */ diff --git a/testsuites/validation/tr-tq-flush-priority.c b/testsuites/validation/tr-tq-flush-priority.c index 26e2a7fc3b..b8a06c2340 100644 --- a/testsuites/validation/tr-tq-flush-priority.c +++ b/testsuites/validation/tr-tq-flush-priority.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushPriority + * @ingroup ScoreTqReqFlushPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqFlushPriority \ - * spec:/score/tq/req/flush-priority + * @defgroup ScoreTqReqFlushPriority spec:/score/tq/req/flush-priority * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -79,7 +78,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member contains a copy of the corresponding @@ -154,7 +153,7 @@ static void Flush( void *arg ) ctx = arg; TQSchedulerRecordStart( ctx->tq_ctx ); - TQFlush( ctx->tq_ctx ); + TQFlush( ctx->tq_ctx, true ); } static void SchedulerEvent( @@ -315,7 +314,7 @@ static void ScoreTqReqFlushPriority_Action( ); } else { TQSchedulerRecordStart( ctx->tq_ctx ); - TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH ); + TQSend( ctx->tq_ctx, TQ_BLOCKER_A, TQ_EVENT_FLUSH_ALL ); } TQSchedulerRecordStop( ctx->tq_ctx ); @@ -386,6 +385,11 @@ static void ScoreTqReqFlushPriority_TestVariant( static T_fixture_node ScoreTqReqFlushPriority_Node; +static T_remark ScoreTqReqFlushPriority_Remark = { + .next = NULL, + .remark = "ScoreTqReqFlushPriority" +}; + void ScoreTqReqFlushPriority_Run( TQContext *tq_ctx, bool supports_multiple_priority_queues @@ -413,6 +417,7 @@ void ScoreTqReqFlushPriority_Run( ScoreTqReqFlushPriority_TestVariant( ctx ); } + T_add_remark( &ScoreTqReqFlushPriority_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-flush-priority.h b/testsuites/validation/tr-tq-flush-priority.h index 72bc372ca1..ae700ca192 100644 --- a/testsuites/validation/tr-tq-flush-priority.h +++ b/testsuites/validation/tr-tq-flush-priority.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqFlushPriority + * @ingroup ScoreTqReqFlushPriority */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqFlushPriority + * @addtogroup ScoreTqReqFlushPriority * * @{ */ diff --git a/testsuites/validation/tr-tq-surrender-mrsp.c b/testsuites/validation/tr-tq-surrender-mrsp.c index 156d4c4a5b..903146ccbe 100644 --- a/testsuites/validation/tr-tq-surrender-mrsp.c +++ b/testsuites/validation/tr-tq-surrender-mrsp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrenderMrsp + * @ingroup ScoreTqReqSurrenderMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,10 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqSurrenderMrsp \ - * spec:/score/tq/req/surrender-mrsp + * @defgroup ScoreTqReqSurrenderMrsp spec:/score/tq/req/surrender-mrsp * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -354,7 +353,7 @@ static void ScoreTqReqSurrenderMrsp_Pre_Suspended_Prepare( switch ( state ) { case ScoreTqReqSurrenderMrsp_Pre_Suspended_Yes: { /* - * Whiel the new owner is suspended. + * While the new owner is suspended. */ ctx->suspended = true; break; @@ -362,7 +361,7 @@ static void ScoreTqReqSurrenderMrsp_Pre_Suspended_Prepare( case ScoreTqReqSurrenderMrsp_Pre_Suspended_No: { /* - * Whiel the new owner is not suspended. + * While the new owner is not suspended. */ ctx->suspended = false; break; @@ -975,6 +974,11 @@ static void ScoreTqReqSurrenderMrsp_TestVariant( static T_fixture_node ScoreTqReqSurrenderMrsp_Node; +static T_remark ScoreTqReqSurrenderMrsp_Remark = { + .next = NULL, + .remark = "ScoreTqReqSurrenderMrsp" +}; + void ScoreTqReqSurrenderMrsp_Run( TQContext *tq_ctx ) { ScoreTqReqSurrenderMrsp_Context *ctx; @@ -1030,6 +1034,7 @@ void ScoreTqReqSurrenderMrsp_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqSurrenderMrsp_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-surrender-mrsp.h b/testsuites/validation/tr-tq-surrender-mrsp.h index 66be73adbb..eff865e612 100644 --- a/testsuites/validation/tr-tq-surrender-mrsp.h +++ b/testsuites/validation/tr-tq-surrender-mrsp.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrenderMrsp + * @ingroup ScoreTqReqSurrenderMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqSurrenderMrsp + * @addtogroup ScoreTqReqSurrenderMrsp * * @{ */ diff --git a/testsuites/validation/tr-tq-surrender-priority-inherit.c b/testsuites/validation/tr-tq-surrender-priority-inherit.c index 75b93e40d2..d0a580f988 100644 --- a/testsuites/validation/tr-tq-surrender-priority-inherit.c +++ b/testsuites/validation/tr-tq-surrender-priority-inherit.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrenderPriorityInherit + * @ingroup ScoreTqReqSurrenderPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqSurrenderPriorityInherit \ + * @defgroup ScoreTqReqSurrenderPriorityInherit \ * spec:/score/tq/req/surrender-priority-inherit * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -96,7 +96,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member contains the barrier to synchronize the runner and the @@ -921,7 +921,7 @@ static void ScoreTqReqSurrenderPriorityInherit_Pre_Suspended_Prepare( switch ( state ) { case ScoreTqReqSurrenderPriorityInherit_Pre_Suspended_Yes: { /* - * Whiel the new owner is suspended. + * While the new owner is suspended. */ ctx->suspended = true; break; @@ -929,7 +929,7 @@ static void ScoreTqReqSurrenderPriorityInherit_Pre_Suspended_Prepare( case ScoreTqReqSurrenderPriorityInherit_Pre_Suspended_No: { /* - * Whiel the new owner is not suspended. + * While the new owner is not suspended. */ ctx->suspended = false; break; @@ -2435,6 +2435,11 @@ static void ScoreTqReqSurrenderPriorityInherit_TestVariant( static T_fixture_node ScoreTqReqSurrenderPriorityInherit_Node; +static T_remark ScoreTqReqSurrenderPriorityInherit_Remark = { + .next = NULL, + .remark = "ScoreTqReqSurrenderPriorityInherit" +}; + void ScoreTqReqSurrenderPriorityInherit_Run( TQContext *tq_ctx ) { ScoreTqReqSurrenderPriorityInherit_Context *ctx; @@ -2510,6 +2515,7 @@ void ScoreTqReqSurrenderPriorityInherit_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqSurrenderPriorityInherit_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-surrender-priority-inherit.h b/testsuites/validation/tr-tq-surrender-priority-inherit.h index b792de1b2e..941e9eb545 100644 --- a/testsuites/validation/tr-tq-surrender-priority-inherit.h +++ b/testsuites/validation/tr-tq-surrender-priority-inherit.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrenderPriorityInherit + * @ingroup ScoreTqReqSurrenderPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqSurrenderPriorityInherit + * @addtogroup ScoreTqReqSurrenderPriorityInherit * * @{ */ diff --git a/testsuites/validation/tr-tq-surrender.c b/testsuites/validation/tr-tq-surrender.c index 60091c2d0c..ce680d71d2 100644 --- a/testsuites/validation/tr-tq-surrender.c +++ b/testsuites/validation/tr-tq-surrender.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrender + * @ingroup ScoreTqReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqSurrender spec:/score/tq/req/surrender + * @defgroup ScoreTqReqSurrender spec:/score/tq/req/surrender * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -84,7 +84,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member contains the barrier to synchronize the runner and the @@ -637,6 +637,11 @@ static void ScoreTqReqSurrender_TestVariant( ScoreTqReqSurrender_Context *ctx ) static T_fixture_node ScoreTqReqSurrender_Node; +static T_remark ScoreTqReqSurrender_Remark = { + .next = NULL, + .remark = "ScoreTqReqSurrender" +}; + void ScoreTqReqSurrender_Run( TQContext *tq_ctx ) { ScoreTqReqSurrender_Context *ctx; @@ -678,6 +683,7 @@ void ScoreTqReqSurrender_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqSurrender_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-surrender.h b/testsuites/validation/tr-tq-surrender.h index fd64bbfa02..8155387069 100644 --- a/testsuites/validation/tr-tq-surrender.h +++ b/testsuites/validation/tr-tq-surrender.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqSurrender + * @ingroup ScoreTqReqSurrender */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqSurrender + * @addtogroup ScoreTqReqSurrender * * @{ */ diff --git a/testsuites/validation/tr-tq-timeout-mrsp.c b/testsuites/validation/tr-tq-timeout-mrsp.c index 2ee4960495..7362e1943b 100644 --- a/testsuites/validation/tr-tq-timeout-mrsp.c +++ b/testsuites/validation/tr-tq-timeout-mrsp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeoutMrsp + * @ingroup ScoreTqReqTimeoutMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqTimeoutMrsp spec:/score/tq/req/timeout-mrsp + * @defgroup ScoreTqReqTimeoutMrsp spec:/score/tq/req/timeout-mrsp * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -439,6 +439,11 @@ static void ScoreTqReqTimeoutMrsp_TestVariant( static T_fixture_node ScoreTqReqTimeoutMrsp_Node; +static T_remark ScoreTqReqTimeoutMrsp_Remark = { + .next = NULL, + .remark = "ScoreTqReqTimeoutMrsp" +}; + void ScoreTqReqTimeoutMrsp_Run( TQContext *tq_ctx ) { ScoreTqReqTimeoutMrsp_Context *ctx; @@ -470,6 +475,7 @@ void ScoreTqReqTimeoutMrsp_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqTimeoutMrsp_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-timeout-mrsp.h b/testsuites/validation/tr-tq-timeout-mrsp.h index a08ef170c5..56df23d88b 100644 --- a/testsuites/validation/tr-tq-timeout-mrsp.h +++ b/testsuites/validation/tr-tq-timeout-mrsp.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeoutMrsp + * @ingroup ScoreTqReqTimeoutMrsp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqTimeoutMrsp + * @addtogroup ScoreTqReqTimeoutMrsp * * @{ */ diff --git a/testsuites/validation/tr-tq-timeout-priority-inherit.c b/testsuites/validation/tr-tq-timeout-priority-inherit.c index 6e744ba7d9..12ac70df90 100644 --- a/testsuites/validation/tr-tq-timeout-priority-inherit.c +++ b/testsuites/validation/tr-tq-timeout-priority-inherit.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeoutPriorityInherit + * @ingroup ScoreTqReqTimeoutPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,10 +61,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqTimeoutPriorityInherit \ + * @defgroup ScoreTqReqTimeoutPriorityInherit \ * spec:/score/tq/req/timeout-priority-inherit * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -93,7 +93,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member specifies the scheduler of the thread. @@ -2071,6 +2071,11 @@ static void ScoreTqReqTimeoutPriorityInherit_TestVariant( static T_fixture_node ScoreTqReqTimeoutPriorityInherit_Node; +static T_remark ScoreTqReqTimeoutPriorityInherit_Remark = { + .next = NULL, + .remark = "ScoreTqReqTimeoutPriorityInherit" +}; + void ScoreTqReqTimeoutPriorityInherit_Run( TQContext *tq_ctx ) { ScoreTqReqTimeoutPriorityInherit_Context *ctx; @@ -2148,6 +2153,7 @@ void ScoreTqReqTimeoutPriorityInherit_Run( TQContext *tq_ctx ) } } + T_add_remark( &ScoreTqReqTimeoutPriorityInherit_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-timeout-priority-inherit.h b/testsuites/validation/tr-tq-timeout-priority-inherit.h index a75665f659..149ca69755 100644 --- a/testsuites/validation/tr-tq-timeout-priority-inherit.h +++ b/testsuites/validation/tr-tq-timeout-priority-inherit.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeoutPriorityInherit + * @ingroup ScoreTqReqTimeoutPriorityInherit */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqTimeoutPriorityInherit + * @addtogroup ScoreTqReqTimeoutPriorityInherit * * @{ */ diff --git a/testsuites/validation/tr-tq-timeout.c b/testsuites/validation/tr-tq-timeout.c index 5575abdd57..c9bc13a937 100644 --- a/testsuites/validation/tr-tq-timeout.c +++ b/testsuites/validation/tr-tq-timeout.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeout + * @ingroup ScoreTqReqTimeout */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -60,9 +60,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestCaseScoreTqReqTimeout spec:/score/tq/req/timeout + * @defgroup ScoreTqReqTimeout spec:/score/tq/req/timeout * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 * * @{ */ @@ -81,7 +81,7 @@ typedef struct { /** * @brief This member contains the call within ISR request. */ - CallWithinISRRequest request;; + CallWithinISRRequest request; /** * @brief This member contains a copy of the corresponding @@ -427,6 +427,11 @@ static void ScoreTqReqTimeout_TestVariant( ScoreTqReqTimeout_Context *ctx ) static T_fixture_node ScoreTqReqTimeout_Node; +static T_remark ScoreTqReqTimeout_Remark = { + .next = NULL, + .remark = "ScoreTqReqTimeout" +}; + void ScoreTqReqTimeout_Run( TQContext *tq_ctx ) { ScoreTqReqTimeout_Context *ctx; @@ -447,6 +452,7 @@ void ScoreTqReqTimeout_Run( TQContext *tq_ctx ) ScoreTqReqTimeout_TestVariant( ctx ); } + T_add_remark( &ScoreTqReqTimeout_Remark ); T_pop_fixture(); } diff --git a/testsuites/validation/tr-tq-timeout.h b/testsuites/validation/tr-tq-timeout.h index 487c32743d..825ba798ea 100644 --- a/testsuites/validation/tr-tq-timeout.h +++ b/testsuites/validation/tr-tq-timeout.h @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestCaseScoreTqReqTimeout + * @ingroup ScoreTqReqTimeout */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,7 +58,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestCaseScoreTqReqTimeout + * @addtogroup ScoreTqReqTimeout * * @{ */ diff --git a/testsuites/validation/ts-acfg.h b/testsuites/validation/ts-acfg.h index 3ee9951ebd..60d1833857 100644 --- a/testsuites/validation/ts-acfg.h +++ b/testsuites/validation/ts-acfg.h @@ -3,12 +3,14 @@ /** * @file * + * @ingroup RTEMSTestSuitesValidation + * * @brief This header file provides a validation test suite runner for * validation test cases specific to the application configuration. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/ts-config.h b/testsuites/validation/ts-config.h index 7685fee278..f5f46738f0 100644 --- a/testsuites/validation/ts-config.h +++ b/testsuites/validation/ts-config.h @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This header file provides the constants used by the test suite * configuration. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -44,7 +44,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestSuites + * @addtogroup RTEMSTestSuitesValidation * * @{ */ @@ -109,7 +109,7 @@ void *test_task_stack_allocate( size_t size ); void test_task_stack_deallocate( void *stack ); -void *test_idle_task_stack_allocate( uint32_t cpu_index, size_t size ); +void *test_idle_task_stack_allocate( uint32_t cpu_index, size_t *size ); extern rtems_task_argument test_runner_argument; diff --git a/testsuites/validation/ts-default.h b/testsuites/validation/ts-default.h index 9f317abf80..86c0b4e345 100644 --- a/testsuites/validation/ts-default.h +++ b/testsuites/validation/ts-default.h @@ -3,12 +3,14 @@ /** * @file * + * @ingroup RTEMSTestSuitesValidation + * * @brief This header file provides the default validation test suite runner * and application configuration. */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -296,25 +298,38 @@ T_scheduler_operations[ CONFIGURE_MAXIMUM_PROCESSORS ] = { #define SCHEDULER_PRIORITY_ENTRY_POINTS T_SCHEDULER_ENTRY_POINTS -#define CONFIGURE_SCHEDULER_NAME TEST_SCHEDULER_A_NAME - #define CONFIGURE_SCHEDULER_PRIORITY +#if defined(CONFIGURE_SCHEDULER_TABLE_ENTRIES) + +#include <rtems/scheduler.h> + +RTEMS_SCHEDULER_PRIORITY( a, 64 ); + +#else /* CONFIGURE_SCHEDULER_TABLE_ENTRIES */ + +#define CONFIGURE_SCHEDULER_NAME TEST_SCHEDULER_A_NAME + #define CONFIGURE_MAXIMUM_PRIORITY 127 +#endif /* CONFIGURE_SCHEDULER_TABLE_ENTRIES */ + #endif #define CONFIGURE_IDLE_TASK_STACK_SIZE TEST_IDLE_STACK_SIZE static char test_idle_stacks[ CONFIGURE_MAXIMUM_PROCESSORS ][ - ( TEST_IDLE_STACK_SIZE + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE ) + RTEMS_ALIGN_UP( + MAX_TLS_SIZE + TEST_IDLE_STACK_SIZE + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE, + CPU_INTERRUPT_STACK_ALIGNMENT + ) ] RTEMS_ALIGNED( CPU_INTERRUPT_STACK_ALIGNMENT ) RTEMS_SECTION( ".rtemsstack.idle" ); -void *test_idle_task_stack_allocate( uint32_t cpu_index, size_t size ) +void *test_idle_task_stack_allocate( uint32_t cpu_index, size_t *size ) { - if ( size > sizeof( test_idle_stacks[ 0 ] ) ) { + if ( *size > sizeof( test_idle_stacks[ 0 ] ) ) { rtems_fatal( RTEMS_FATAL_SOURCE_APPLICATION, 0xABAD1DEA ); } diff --git a/testsuites/validation/ts-fatal-boot-processor-not-assigned-to-scheduler.c b/testsuites/validation/ts-fatal-boot-processor-not-assigned-to-scheduler.c index 1222b26b2e..c983cfd406 100644 --- a/testsuites/validation/ts-fatal-boot-processor-not-assigned-to-scheduler.c +++ b/testsuites/validation/ts-fatal-boot-processor-not-assigned-to-scheduler.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalBootProcessorNotAssignedToScheduler + * @ingroup TestsuitesFatalBootProcessorNotAssignedToScheduler */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalBootProcessorNotAssignedToScheduler \ + * @defgroup TestsuitesFatalBootProcessorNotAssignedToScheduler \ * spec:/testsuites/fatal-boot-processor-not-assigned-to-scheduler * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite uses an application configuration which * triggers a fatal error during system initialization. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "FatalBootProcessorNotAssignedToScheduler"; +const char rtems_test_name[] = "TestsuitesFatalBootProcessorNotAssignedToScheduler"; #define FATAL_SYSINIT_RUN \ ScoreSmpValFatalBootProcessorNotAssignedToScheduler_Run diff --git a/testsuites/validation/ts-fatal-idle-thread-create-failed.c b/testsuites/validation/ts-fatal-idle-thread-create-failed.c new file mode 100644 index 0000000000..fb7a36c11a --- /dev/null +++ b/testsuites/validation/ts-fatal-idle-thread-create-failed.c @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesFatalIdleThreadCreateFailed + */ + +/* + * Copyright (C) 2022 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-idle-thread-create-failed.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesFatalIdleThreadCreateFailed \ + * spec:/testsuites/fatal-idle-thread-create-failed + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which is triggered by + * a fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesFatalIdleThreadCreateFailed"; + +static bool CreateTask( rtems_tcb *executing, rtems_tcb *created ) +{ + (void) executing; + (void) created; + return false; +} + +#define FATAL_SYSINIT_RUN ScoreThreadValFatalIdleThreadCreateFailed_Run + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION + +#define FATAL_SYSINIT_INITIAL_EXTENSION { .thread_create = CreateTask } + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/ts-fatal-idle-thread-stack-too-small.c b/testsuites/validation/ts-fatal-idle-thread-stack-too-small.c new file mode 100644 index 0000000000..ddfe59df13 --- /dev/null +++ b/testsuites/validation/ts-fatal-idle-thread-stack-too-small.c @@ -0,0 +1,97 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup TestsuitesFatalIdleThreadStackTooSmall + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tr-fatal-idle-thread-stack-too-small.h" + +#include <rtems/test.h> + +/** + * @defgroup TestsuitesFatalIdleThreadStackTooSmall \ + * spec:/testsuites/fatal-idle-thread-stack-too-small + * + * @ingroup RTEMSTestSuitesValidation + * + * @brief This validation test suite contains a test case which triggers a + * fatal error during system initialization. + * + * @{ + */ + +const char rtems_test_name[] = "TestsuitesFatalIdleThreadStackTooSmall"; + +#define FATAL_SYSINIT_RUN ScoreThreadValFatalIdleThreadStackTooSmall_Run + +static _Thread_local volatile uint8_t zero[ RTEMS_MINIMUM_STACK_SIZE ]; + +static void Init( rtems_task_argument arg ) +{ + (void) arg; + rtems_fatal( RTEMS_FATAL_SOURCE_EXIT, zero[ 0 ] + 1 ); +} + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER + +#define CONFIGURE_MAXIMUM_TASKS 1 + +#define CONFIGURE_MINIMUM_TASKS_WITH_USER_PROVIDED_STORAGE 1 + +#define CONFIGURE_INIT_TASK_PRIORITY 0 + +#define CONFIGURE_INIT_TASK_CONSTRUCT_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE + +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE + +#include "ts-fatal-sysinit.h" + +/** @} */ diff --git a/testsuites/validation/ts-fatal-init-task-construct-failed.c b/testsuites/validation/ts-fatal-init-task-construct-failed.c index 8efd2b32ce..d8c87428e8 100644 --- a/testsuites/validation/ts-fatal-init-task-construct-failed.c +++ b/testsuites/validation/ts-fatal-init-task-construct-failed.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalInitTaskConstructFailed + * @ingroup TestsuitesFatalInitTaskConstructFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalInitTaskConstructFailed \ + * @defgroup TestsuitesFatalInitTaskConstructFailed \ * spec:/testsuites/fatal-init-task-construct-failed * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers a * fatal error during system initialization. @@ -68,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "FatalInitTaskConstructFailed"; +const char rtems_test_name[] = "TestsuitesFatalInitTaskConstructFailed"; #define FATAL_SYSINIT_RUN AcfgValFatalInitTaskConstructFailed_Run diff --git a/testsuites/validation/ts-fatal-mandatory-processor-not-present.c b/testsuites/validation/ts-fatal-mandatory-processor-not-present.c index 3645313755..f9629d9699 100644 --- a/testsuites/validation/ts-fatal-mandatory-processor-not-present.c +++ b/testsuites/validation/ts-fatal-mandatory-processor-not-present.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalMandatoryProcessorNotPresent + * @ingroup TestsuitesFatalMandatoryProcessorNotPresent */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalMandatoryProcessorNotPresent \ + * @defgroup TestsuitesFatalMandatoryProcessorNotPresent \ * spec:/testsuites/fatal-mandatory-processor-not-present * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers a * fatal error during system initialization. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "FatalMandatoryProcessorNotPresent"; +const char rtems_test_name[] = "TestsuitesFatalMandatoryProcessorNotPresent"; #define FATAL_SYSINIT_RUN ScoreSmpValFatalMandatoryProcessorNotPresent_Run diff --git a/testsuites/validation/ts-fatal-scheduler-requires-exactly-one-processor.c b/testsuites/validation/ts-fatal-scheduler-requires-exactly-one-processor.c index d9eed5b092..d1de45d836 100644 --- a/testsuites/validation/ts-fatal-scheduler-requires-exactly-one-processor.c +++ b/testsuites/validation/ts-fatal-scheduler-requires-exactly-one-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalSchedulerRequiresExactlyOneProcessor + * @ingroup TestsuitesFatalSchedulerRequiresExactlyOneProcessor */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalSchedulerRequiresExactlyOneProcessor \ + * @defgroup TestsuitesFatalSchedulerRequiresExactlyOneProcessor \ * spec:/testsuites/fatal-scheduler-requires-exactly-one-processor * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite uses an application configuration which * triggers a fatal error during system initialization. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "FatalSchedulerRequiresExactlyOneProcessor"; +const char rtems_test_name[] = "TestsuitesFatalSchedulerRequiresExactlyOneProcessor"; #define FATAL_SYSINIT_RUN \ ScoreSmpValFatalSchedulerRequiresExactlyOneProcessor_Run diff --git a/testsuites/validation/ts-fatal-smp.c b/testsuites/validation/ts-fatal-smp.c index c1c4844643..ff6fd19d42 100644 --- a/testsuites/validation/ts-fatal-smp.c +++ b/testsuites/validation/ts-fatal-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalSmp + * @ingroup TestsuitesFatalSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,9 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalSmp spec:/testsuites/fatal-smp + * @defgroup TestsuitesFatalSmp spec:/testsuites/fatal-smp * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers * SMP-specific fatal errors. @@ -68,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "FatalSmp"; +const char rtems_test_name[] = "TestsuitesFatalSmp"; #define FATAL_SYSINIT_RUN ScoreSmpValFatal_Run diff --git a/testsuites/validation/ts-fatal-start-of-mandatory-processor-failed.c b/testsuites/validation/ts-fatal-start-of-mandatory-processor-failed.c index 76e96f50ef..8ab860eea2 100644 --- a/testsuites/validation/ts-fatal-start-of-mandatory-processor-failed.c +++ b/testsuites/validation/ts-fatal-start-of-mandatory-processor-failed.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalStartOfMandatoryProcessorFailed + * @ingroup TestsuitesFatalStartOfMandatoryProcessorFailed */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalStartOfMandatoryProcessorFailed \ + * @defgroup TestsuitesFatalStartOfMandatoryProcessorFailed \ * spec:/testsuites/fatal-start-of-mandatory-processor-failed * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers a * fatal error during system initialization. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "FatalStartOfMandatoryProcessorFailed"; +const char rtems_test_name[] = "TestsuitesFatalStartOfMandatoryProcessorFailed"; #define FATAL_SYSINIT_RUN ScoreSmpValFatalStartOfMandatoryProcessorFailed_Run diff --git a/testsuites/validation/ts-fatal-start-on-not-online-processor.c b/testsuites/validation/ts-fatal-start-on-not-online-processor.c index 9cc981e381..794983823c 100644 --- a/testsuites/validation/ts-fatal-start-on-not-online-processor.c +++ b/testsuites/validation/ts-fatal-start-on-not-online-processor.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalStartOnNotOnlineProcessor + * @ingroup TestsuitesFatalStartOnNotOnlineProcessor */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalStartOnNotOnlineProcessor \ + * @defgroup TestsuitesFatalStartOnNotOnlineProcessor \ * spec:/testsuites/fatal-start-on-not-online-processor * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers a * fatal error during system initialization. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "FatalStartOnNotOnlineProcessor"; +const char rtems_test_name[] = "TestsuitesFatalStartOnNotOnlineProcessor"; #define FATAL_SYSINIT_RUN ScoreSmpValFatalStartOnNotOnlineProcessor_Run diff --git a/testsuites/validation/ts-fatal-sysinit.h b/testsuites/validation/ts-fatal-sysinit.h index 5744bc6fea..0b8f735f54 100644 --- a/testsuites/validation/ts-fatal-sysinit.h +++ b/testsuites/validation/ts-fatal-sysinit.h @@ -3,13 +3,15 @@ /** * @file * + * @ingroup RTEMSTestSuitesValidation + * * @brief This header file provides a configurable validation test suite runner * and application configuration for fatal error tests which occur during * system initialization. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -122,10 +124,19 @@ RTEMS_SYSINIT_ITEM( #define CONFIGURE_APPLICATION_DISABLE_FILESYSTEM +#ifdef FATAL_SYSINIT_INITIAL_EXTENSION +#define OPTIONAL_FATAL_SYSINIT_INITIAL_EXTENSION FATAL_SYSINIT_INITIAL_EXTENSION, +#else +#define OPTIONAL_FATAL_SYSINIT_INITIAL_EXTENSION +#endif + #define CONFIGURE_INITIAL_EXTENSIONS \ + OPTIONAL_FATAL_SYSINIT_INITIAL_EXTENSION \ { .fatal = FatalInitialExtension }, \ { .fatal = TestSuiteFatalExtension } +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE + #if !defined(CONFIGURE_RTEMS_INIT_TASKS_TABLE) #define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION diff --git a/testsuites/validation/ts-fatal-too-large-tls-size.c b/testsuites/validation/ts-fatal-too-large-tls-size.c index ba41390680..ba2cc512df 100644 --- a/testsuites/validation/ts-fatal-too-large-tls-size.c +++ b/testsuites/validation/ts-fatal-too-large-tls-size.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesFatalTooLargeTlsSize + * @ingroup TestsuitesFatalTooLargeTlsSize */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesFatalTooLargeTlsSize \ + * @defgroup TestsuitesFatalTooLargeTlsSize \ * spec:/testsuites/fatal-too-large-tls-size * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case which triggers a * fatal error during system initialization. @@ -68,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "FatalTooLargeTlsSize"; +const char rtems_test_name[] = "TestsuitesFatalTooLargeTlsSize"; #define FATAL_SYSINIT_RUN AcfgValFatalTooLargeTlsSize_Run diff --git a/testsuites/validation/ts-idle.h b/testsuites/validation/ts-idle.h index 071209b5ef..6c4c8955f1 100644 --- a/testsuites/validation/ts-idle.h +++ b/testsuites/validation/ts-idle.h @@ -3,13 +3,15 @@ /** * @file * + * @ingroup RTEMSTestSuitesValidation + * * @brief This header file provides a configurable validation test suite runner * and application configuration for tests which should run within an idle * task without a user initialization task. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -72,6 +74,10 @@ static const T_config test_config = { #define CONFIGURE_INITIAL_EXTENSIONS \ { .fatal = FatalInitialExtension } +#ifndef CONFIGURE_IDLE_TASK_STORAGE_SIZE +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE +#endif + #define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION void *IdleBody( uintptr_t ignored ) diff --git a/testsuites/validation/ts-performance-no-clock-0.c b/testsuites/validation/ts-performance-no-clock-0.c index e43b3a6327..b50276a46e 100644 --- a/testsuites/validation/ts-performance-no-clock-0.c +++ b/testsuites/validation/ts-performance-no-clock-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 + * @ingroup TestsuitesPerformanceNoClock0 */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesPerformanceNoClock0 \ + * @defgroup TestsuitesPerformanceNoClock0 \ * spec:/testsuites/performance-no-clock-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose performance test suite provides enough resources * to run basic performance tests for all specified managers and functions. @@ -71,7 +71,7 @@ * @{ */ -const char rtems_test_name[] = "PerformanceNoClock0"; +const char rtems_test_name[] = "TestsuitesPerformanceNoClock0"; #define CONFIGURE_MAXIMUM_PROCESSORS 4 diff --git a/testsuites/validation/ts-terminate.c b/testsuites/validation/ts-terminate.c index 52676db6d9..670c7ec6a2 100644 --- a/testsuites/validation/ts-terminate.c +++ b/testsuites/validation/ts-terminate.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesTerminate + * @ingroup TestsuitesTerminate */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesTerminate spec:/testsuites/terminate + * @defgroup TestsuitesTerminate spec:/testsuites/terminate * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test case for the system * termination procedure. @@ -67,7 +67,7 @@ * @{ */ -const char rtems_test_name[] = "Terminate"; +const char rtems_test_name[] = "TestsuitesTerminate"; #define CONFIGURE_MAXIMUM_PROCESSORS 2 diff --git a/testsuites/validation/ts-userext.c b/testsuites/validation/ts-userext.c index 5d41f52093..461a1ddc0e 100644 --- a/testsuites/validation/ts-userext.c +++ b/testsuites/validation/ts-userext.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesUserext + * @ingroup TestsuitesUserext */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,9 +57,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesUserext spec:/testsuites/userext + * @defgroup TestsuitesUserext spec:/testsuites/userext * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains a test cases related to the * invocation of user extensions. @@ -67,7 +67,7 @@ * @{ */ -const char rtems_test_name[] = "Userext"; +const char rtems_test_name[] = "TestsuitesUserext"; #define CONFIGURE_MAXIMUM_PROCESSORS 2 @@ -92,6 +92,8 @@ const char rtems_test_name[] = "Userext"; .thread_terminate = ThreadTerminateExtension1 \ } +#define CONFIGURE_IDLE_TASK_BODY IdleBody + #include "ts-default.h" /** @} */ diff --git a/testsuites/validation/ts-validation-0.c b/testsuites/validation/ts-validation-0.c index b80c09d47f..7f7dfb9215 100644 --- a/testsuites/validation/ts-validation-0.c +++ b/testsuites/validation/ts-validation-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidation0 + * @ingroup TestsuitesValidation0 */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,9 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidation0 spec:/testsuites/validation-0 + * @defgroup TestsuitesValidation0 spec:/testsuites/validation-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests for all specified managers and functions. @@ -68,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "Validation0"; +const char rtems_test_name[] = "TestsuitesValidation0"; #define CONFIGURE_MAXIMUM_PROCESSORS 5 diff --git a/testsuites/validation/ts-validation-1.c b/testsuites/validation/ts-validation-1.c index 6f396dc873..a33593afb1 100644 --- a/testsuites/validation/ts-validation-1.c +++ b/testsuites/validation/ts-validation-1.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidation1 + * @ingroup TestsuitesValidation1 */ /* - * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2020 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,9 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidation1 spec:/testsuites/validation-1 + * @defgroup TestsuitesValidation1 spec:/testsuites/validation-1 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests for all specified managers and functions. @@ -68,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "Validation1"; +const char rtems_test_name[] = "TestsuitesValidation1"; #define CONFIGURE_MAXIMUM_PROCESSORS 5 diff --git a/testsuites/validation/ts-validation-acfg-0.c b/testsuites/validation/ts-validation-acfg-0.c index e1144dd95d..2afd0dae86 100644 --- a/testsuites/validation/ts-validation-acfg-0.c +++ b/testsuites/validation/ts-validation-acfg-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationAcfg0 + * @ingroup TestsuitesValidationAcfg0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -58,10 +58,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationAcfg0 \ - * spec:/testsuites/validation-acfg-0 + * @defgroup TestsuitesValidationAcfg0 spec:/testsuites/validation-acfg-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite is used to validate the default value of * application configuration options taking the optional BSP provided @@ -70,7 +69,9 @@ * @{ */ -const char rtems_test_name[] = "ValidationAcfg0"; +const char rtems_test_name[] = "TestsuitesValidationAcfg0"; + +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE #define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION diff --git a/testsuites/validation/ts-validation-acfg-1.c b/testsuites/validation/ts-validation-acfg-1.c index 863a672b23..d1b44cf1ec 100644 --- a/testsuites/validation/ts-validation-acfg-1.c +++ b/testsuites/validation/ts-validation-acfg-1.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationAcfg1 + * @ingroup TestsuitesValidationAcfg1 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -59,10 +59,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationAcfg1 \ - * spec:/testsuites/validation-acfg-1 + * @defgroup TestsuitesValidationAcfg1 spec:/testsuites/validation-acfg-1 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite is used to validate the default value of * application configuration options where all optional BSP provided settings @@ -71,7 +70,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationAcfg1"; +const char rtems_test_name[] = "TestsuitesValidationAcfg1"; static void FatalExtension( rtems_fatal_source source, @@ -94,6 +93,8 @@ static void Init( rtems_task_argument arg ) #define CONFIGURE_DISABLE_BSP_SETTINGS +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE + #define CONFIGURE_MAXIMUM_TASKS 1 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/validation/ts-validation-cache.c b/testsuites/validation/ts-validation-cache.c index cbc6a8ddb9..3522c02db7 100644 --- a/testsuites/validation/ts-validation-cache.c +++ b/testsuites/validation/ts-validation-cache.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationCache + * @ingroup TestsuitesValidationCache */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationCache \ - * spec:/testsuites/validation-cache + * @defgroup TestsuitesValidationCache spec:/testsuites/validation-cache * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite provides enough resources to run tests for * the directives of the @ref RTEMSAPIClassicCache. @@ -69,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationCache"; +const char rtems_test_name[] = "TestsuitesValidationCache"; #define CONFIGURE_MAXIMUM_PROCESSORS 4 diff --git a/testsuites/validation/ts-validation-intr.c b/testsuites/validation/ts-validation-intr.c index 1a79608f78..74f849441a 100644 --- a/testsuites/validation/ts-validation-intr.c +++ b/testsuites/validation/ts-validation-intr.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationIntr + * @ingroup TestsuitesValidationIntr */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationIntr \ - * spec:/testsuites/validation-intr + * @defgroup TestsuitesValidationIntr spec:/testsuites/validation-intr * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite provides enough resources to run tests for * the interrupt controller related directives of the @ref @@ -70,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationIntr"; +const char rtems_test_name[] = "TestsuitesValidationIntr"; #define CONFIGURE_MAXIMUM_PROCESSORS 5 diff --git a/testsuites/validation/ts-validation-io-kernel.c b/testsuites/validation/ts-validation-io-kernel.c index 83234ecfff..35779f6060 100644 --- a/testsuites/validation/ts-validation-io-kernel.c +++ b/testsuites/validation/ts-validation-io-kernel.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationIoKernel + * @ingroup TestsuitesValidationIoKernel */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -62,10 +62,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationIoKernel \ - * spec:/testsuites/validation-io-kernel + * @defgroup TestsuitesValidationIoKernel spec:/testsuites/validation-io-kernel * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains test cases which test the kernel * character input/output device provided by the BSP before the system @@ -74,7 +73,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationIoKernel"; +const char rtems_test_name[] = "TestsuitesValidationIoKernel"; static char buffer[ 512 ]; @@ -138,6 +137,8 @@ static void *IdleBody( uintptr_t ignored ) #define CONFIGURE_SCHEDULER_TABLE_ENTRIES { } +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE + #define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION #define CONFIGURE_IDLE_TASK_BODY IdleBody diff --git a/testsuites/validation/ts-validation-no-clock-0.c b/testsuites/validation/ts-validation-no-clock-0.c index 5ff630b6c3..1fa610a3b4 100644 --- a/testsuites/validation/ts-validation-no-clock-0.c +++ b/testsuites/validation/ts-validation-no-clock-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0 + * @ingroup TestsuitesValidationNoClock0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationNoClock0 \ + * @defgroup TestsuitesValidationNoClock0 \ * spec:/testsuites/validation-no-clock-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests without a Clock Driver for all specified managers and @@ -70,7 +70,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationNoClock0"; +const char rtems_test_name[] = "TestsuitesValidationNoClock0"; #define CONFIGURE_MAXIMUM_PROCESSORS 5 diff --git a/testsuites/validation/ts-validation-non-smp.c b/testsuites/validation/ts-validation-non-smp.c index 163223f18b..b7460222b5 100644 --- a/testsuites/validation/ts-validation-non-smp.c +++ b/testsuites/validation/ts-validation-non-smp.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationNonSmp + * @ingroup TestsuitesValidationNonSmp */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationNonSmp \ - * spec:/testsuites/validation-non-smp + * @defgroup TestsuitesValidationNonSmp spec:/testsuites/validation-non-smp * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This test suite for non-SMP test cases provides enough resources to * run basic tests for all specified managers and functions. @@ -66,7 +65,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationNonSMP"; +const char rtems_test_name[] = "TestsuitesValidationNonSmp"; #define CONFIGURE_MAXIMUM_PROCESSORS 1 diff --git a/testsuites/validation/ts-validation-one-cpu-0.c b/testsuites/validation/ts-validation-one-cpu-0.c index d281b59d01..6eefe21b15 100644 --- a/testsuites/validation/ts-validation-one-cpu-0.c +++ b/testsuites/validation/ts-validation-one-cpu-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0 + * @ingroup TestsuitesValidationOneCpu0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationOneCpu0 \ - * spec:/testsuites/validation-one-cpu-0 + * @defgroup TestsuitesValidationOneCpu0 spec:/testsuites/validation-one-cpu-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests with exactly one processor and without a Clock Driver. @@ -69,7 +68,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationOneCpu0"; +const char rtems_test_name[] = "TestsuitesValidationOneCpu0"; #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER diff --git a/testsuites/validation/ts-validation-one-cpu-1.c b/testsuites/validation/ts-validation-one-cpu-1.c index e1be3ddd02..29288686b1 100644 --- a/testsuites/validation/ts-validation-one-cpu-1.c +++ b/testsuites/validation/ts-validation-one-cpu-1.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu1 + * @ingroup TestsuitesValidationOneCpu1 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -52,13 +52,14 @@ #include "config.h" #endif +#include "ts-config.h" + #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationOneCpu1 \ - * spec:/testsuites/validation-one-cpu-1 + * @defgroup TestsuitesValidationOneCpu1 spec:/testsuites/validation-one-cpu-1 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests with exactly one processor and without a Clock Driver. @@ -69,12 +70,15 @@ * @{ */ -const char rtems_test_name[] = "ValidationOneCpu1"; +const char rtems_test_name[] = "TestsuitesValidationOneCpu1"; #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER #define CONFIGURE_MAXIMUM_PROCESSORS 1 +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_PRIORITY( a, TEST_SCHEDULER_A_NAME ) + #include "ts-default.h" /** @} */ diff --git a/testsuites/validation/ts-validation-smp-one-cpu-0.c b/testsuites/validation/ts-validation-smp-one-cpu-0.c index 88c2370d5c..c5be91fb9e 100644 --- a/testsuites/validation/ts-validation-smp-one-cpu-0.c +++ b/testsuites/validation/ts-validation-smp-one-cpu-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOneCpu0 + * @ingroup TestsuitesValidationSmpOneCpu0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationSmpOneCpu0 \ + * @defgroup TestsuitesValidationSmpOneCpu0 \ * spec:/testsuites/validation-smp-one-cpu-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This general purpose validation test suite provides enough resources * to run basic tests for all specified managers and functions in a @@ -67,7 +67,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationSmpOneCpu0"; +const char rtems_test_name[] = "TestsuitesValidationSmpOneCpu0"; #define CONFIGURE_MAXIMUM_PROCESSORS 1 diff --git a/testsuites/validation/ts-validation-smp-only-0.c b/testsuites/validation/ts-validation-smp-only-0.c index 9907365cd9..30b1f705ed 100644 --- a/testsuites/validation/ts-validation-smp-only-0.c +++ b/testsuites/validation/ts-validation-smp-only-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 + * @ingroup TestsuitesValidationSmpOnly0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationSmpOnly0 \ + * @defgroup TestsuitesValidationSmpOnly0 \ * spec:/testsuites/validation-smp-only-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This test suite for SMP-only test cases provides enough resources to * run basic tests for all specified managers and functions. @@ -69,7 +69,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationSMPOnly0"; +const char rtems_test_name[] = "TestsuitesValidationSmpOnly0"; #define CONFIGURE_MAXIMUM_PROCESSORS 5 diff --git a/testsuites/validation/ts-validation-smp-only-1.c b/testsuites/validation/ts-validation-smp-only-1.c deleted file mode 100644 index a1f9eeb413..0000000000 --- a/testsuites/validation/ts-validation-smp-only-1.c +++ /dev/null @@ -1,94 +0,0 @@ -/* SPDX-License-Identifier: BSD-2-Clause */ - -/** - * @file - * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly1 - */ - -/* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/* - * This file is part of the RTEMS quality process and was automatically - * generated. If you find something that needs to be fixed or - * worded better please post a report or patch to an RTEMS mailing list - * or raise a bug report: - * - * https://www.rtems.org/bugs.html - * - * For information on updating and regenerating please refer to the How-To - * section in the Software Requirements Engineering chapter of the - * RTEMS Software Engineering manual. The manual is provided as a part of - * a release. For development sources please refer to the online - * documentation at: - * - * https://docs.rtems.org - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include "ts-config.h" - -#include <rtems/test.h> - -/** - * @defgroup RTEMSTestSuiteTestsuitesValidationSmpOnly1 \ - * spec:/testsuites/validation-smp-only-1 - * - * @ingroup RTEMSTestSuites - * - * @brief This SMP-only test suite validates the clustered scheduler - * configuration through an application configuration with a processor - * maximum of two, however, only the first processor has a scheduler - * assigned. - * - * @{ - */ - -const char rtems_test_name[] = "ValidationSMPOnly1"; - -#define CONFIGURE_MAXIMUM_PROCESSORS 2 - -#include <rtems/score/scheduleredfsmp.h> - -#define CONFIGURE_SCHEDULER_EDF_SMP - -#include <rtems/scheduler.h> - -RTEMS_SCHEDULER_EDF_SMP( a ); - -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP( a, TEST_SCHEDULER_A_NAME ) - -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER - -#include "ts-default.h" - -/** @} */ diff --git a/testsuites/validation/ts-validation-smp-only-2.c b/testsuites/validation/ts-validation-smp-only-2.c index 74cf5e1db8..62f0cd95d6 100644 --- a/testsuites/validation/ts-validation-smp-only-2.c +++ b/testsuites/validation/ts-validation-smp-only-2.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationSmpOnly2 + * @ingroup TestsuitesValidationSmpOnly2 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -57,10 +57,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationSmpOnly2 \ + * @defgroup TestsuitesValidationSmpOnly2 \ * spec:/testsuites/validation-smp-only-2 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This SMP-only test suite validates the clustered scheduler * configuration through an application configuration with a processor @@ -70,7 +70,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationSMPOnly2"; +const char rtems_test_name[] = "TestsuitesValidationSmpOnly2"; bool __wrap__CPU_SMP_Start_processor( uint32_t cpu_index ); diff --git a/testsuites/validation/ts-validation-timecounter-0.c b/testsuites/validation/ts-validation-timecounter-0.c index 9e4abeeab0..7a042c75ae 100644 --- a/testsuites/validation/ts-validation-timecounter-0.c +++ b/testsuites/validation/ts-validation-timecounter-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounter0 + * @ingroup TestsuitesValidationTimecounter0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationTimecounter0 \ + * @defgroup TestsuitesValidationTimecounter0 \ * spec:/testsuites/validation-timecounter-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite is intended test cases related to the * installation of timecouters. The Clock Driver is disabled. @@ -66,7 +66,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationTimecounter0"; +const char rtems_test_name[] = "TestsuitesValidationTimecounter0"; #define CONFIGURE_MAXIMUM_PROCESSORS 1 diff --git a/testsuites/validation/ts-validation-timecounter-1.c b/testsuites/validation/ts-validation-timecounter-1.c index ec0ff027ee..918d6d093c 100644 --- a/testsuites/validation/ts-validation-timecounter-1.c +++ b/testsuites/validation/ts-validation-timecounter-1.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounter1 + * @ingroup TestsuitesValidationTimecounter1 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationTimecounter1 \ + * @defgroup TestsuitesValidationTimecounter1 \ * spec:/testsuites/validation-timecounter-1 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite is intended test cases related to the use * of timecouters. The Clock Driver is enabled. @@ -66,7 +66,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationTimecounter1"; +const char rtems_test_name[] = "TestsuitesValidationTimecounter1"; #define CONFIGURE_MAXIMUM_PROCESSORS 4 diff --git a/testsuites/validation/ts-validation-timecounter-smp-0.c b/testsuites/validation/ts-validation-timecounter-smp-0.c index 6ae0311b59..849a64d94b 100644 --- a/testsuites/validation/ts-validation-timecounter-smp-0.c +++ b/testsuites/validation/ts-validation-timecounter-smp-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationTimecounterSmp0 + * @ingroup TestsuitesValidationTimecounterSmp0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,10 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationTimecounterSmp0 \ + * @defgroup TestsuitesValidationTimecounterSmp0 \ * spec:/testsuites/validation-timecounter-smp-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite is intended test cases related to the use * of timecouters. The Clock Driver is disabled. @@ -66,7 +66,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationTimecounterSmp0"; +const char rtems_test_name[] = "TestsuitesValidationTimecounterSmp0"; #define CONFIGURE_MAXIMUM_PROCESSORS 4 diff --git a/testsuites/validation/ts-validation-tls-0.c b/testsuites/validation/ts-validation-tls-0.c index 09e4d2fd2b..fe32bf35bd 100644 --- a/testsuites/validation/ts-validation-tls-0.c +++ b/testsuites/validation/ts-validation-tls-0.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationTls0 + * @ingroup TestsuitesValidationTls0 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationTls0 \ - * spec:/testsuites/validation-tls-0 + * @defgroup TestsuitesValidationTls0 spec:/testsuites/validation-tls-0 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains test cases related to the * thread-local storage support. @@ -66,7 +65,7 @@ * @{ */ -const char rtems_test_name[] = "ValidationTls0"; +const char rtems_test_name[] = "TestsuitesValidationTls0"; #define MAX_TLS_SIZE 1024 diff --git a/testsuites/validation/ts-validation-tls-1.c b/testsuites/validation/ts-validation-tls-1.c index b9b4adc31e..00b74008b2 100644 --- a/testsuites/validation/ts-validation-tls-1.c +++ b/testsuites/validation/ts-validation-tls-1.c @@ -3,11 +3,11 @@ /** * @file * - * @ingroup RTEMSTestSuiteTestsuitesValidationTls1 + * @ingroup TestsuitesValidationTls1 */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -55,10 +55,9 @@ #include <rtems/test.h> /** - * @defgroup RTEMSTestSuiteTestsuitesValidationTls1 \ - * spec:/testsuites/validation-tls-1 + * @defgroup TestsuitesValidationTls1 spec:/testsuites/validation-tls-1 * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This validation test suite contains test cases related to the * thread-local storage support. @@ -66,7 +65,10 @@ * @{ */ -const char rtems_test_name[] = "ValidationTls1"; +const char rtems_test_name[] = "TestsuitesValidationTls1"; + +#define CONFIGURE_IDLE_TASK_STORAGE_SIZE \ + ( RTEMS_MINIMUM_STACK_SIZE + 4096 ) #include "ts-idle.h" diff --git a/testsuites/validation/tx-call-within-isr.c b/testsuites/validation/tx-call-within-isr.c index 3b5d1e139d..8bbe0e7c29 100644 --- a/testsuites/validation/tx-call-within-isr.c +++ b/testsuites/validation/tx-call-within-isr.c @@ -3,14 +3,15 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * - * @brief This source file contains the implementation of CallWithinISR(), + * @brief This source file contains the implementation of CallWithinISRClear(), + * CallWithinISRGetVector(), CallWithinISR(), CallWithinISRRaise(), * CallWithinISRSubmit(), and CallWithinISRWait(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021, 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -44,6 +45,7 @@ #include <rtems/score/chainimpl.h> #include <bsp.h> +#include <bsp/irq-generic.h> /* Some target architectures need this variable for <tm27.h> */ uint32_t Interrupt_nest; @@ -64,14 +66,28 @@ static CallWithinISRContext CallWithinISRInstance = { .pending = CHAIN_INITIALIZER_EMPTY( CallWithinISRInstance.pending ) }; -static void CallWithinISRHandler( rtems_vector_number vector ) +void CallWithinISRRaise( void ) +{ + Cause_tm27_intr(); +} + +void CallWithinISRClear( void ) +{ + Clear_tm27_intr(); +} + +#ifdef TM27_USE_VECTOR_HANDLER +static rtems_isr CallWithinISRHandler( rtems_vector_number arg ) +#else +static void CallWithinISRHandler( void *arg ) +#endif { CallWithinISRContext *ctx; - (void) vector; + (void) arg; ctx = &CallWithinISRInstance; - Clear_tm27_intr(); + CallWithinISRClear(); while ( true ) { rtems_interrupt_lock_context lock_context; @@ -114,7 +130,7 @@ void CallWithinISRSubmit( CallWithinISRRequest *request ) _Chain_Append_unprotected( &ctx->pending, &request->node ); rtems_interrupt_lock_release( &ctx->lock, &lock_context ); - Cause_tm27_intr(); + CallWithinISRRaise(); } void CallWithinISRWait( const CallWithinISRRequest *request ) @@ -124,6 +140,82 @@ void CallWithinISRWait( const CallWithinISRRequest *request ) } } +#if !defined( TM27_INTERRUPT_VECTOR_DEFAULT ) +static void CallWithinISRIsHandlerInstalled( + void *arg, + const char *info, + rtems_option option, + rtems_interrupt_handler handler, + void *handler_arg +) +{ + (void) info; + (void) option; + (void) handler_arg; + + if ( handler == CallWithinISRHandler && handler_arg == NULL ) { + *(bool *) arg = true; + } +} +#endif + +rtems_vector_number CallWithinISRGetVector( void ) +{ +#if defined( TM27_INTERRUPT_VECTOR_DEFAULT ) + return TM27_INTERRUPT_VECTOR_DEFAULT; +#else + rtems_vector_number vector; + + for ( vector = 0; vector < BSP_INTERRUPT_VECTOR_COUNT; ++vector ) { + bool installed; + + installed = false; + (void) rtems_interrupt_handler_iterate( + vector, + CallWithinISRIsHandlerInstalled, + &installed + ); + + if ( installed ) { + return vector; + } + } + + return UINT32_MAX; +#endif +} + +rtems_vector_number GetSoftwareInterruptVector( void ) +{ +#if defined( TM27_INTERRUPT_VECTOR_ALTERNATIVE ) + return TM27_INTERRUPT_VECTOR_ALTERNATIVE; +#else + return UINT32_MAX; +#endif +} + +rtems_status_code RaiseSoftwareInterrupt( rtems_vector_number vector ) +{ +#if defined( TM27_INTERRUPT_VECTOR_ALTERNATIVE ) + if ( vector == TM27_INTERRUPT_VECTOR_ALTERNATIVE ) { + return _TM27_Raise_alternative(); + } +#endif + + return rtems_interrupt_raise( vector ); +} + +rtems_status_code ClearSoftwareInterrupt( rtems_vector_number vector ) +{ +#if defined( TM27_INTERRUPT_VECTOR_ALTERNATIVE ) + if ( vector == TM27_INTERRUPT_VECTOR_ALTERNATIVE ) { + return _TM27_Clear_alternative(); + } +#endif + + return rtems_interrupt_clear( vector ); +} + static void CallWithinISRInitialize( void ) { Install_tm27_vector( CallWithinISRHandler ); diff --git a/testsuites/validation/tx-default-task-config.c b/testsuites/validation/tx-default-task-config.c index 59a0fd0ed3..0facc78298 100644 --- a/testsuites/validation/tx-default-task-config.c +++ b/testsuites/validation/tx-default-task-config.c @@ -3,13 +3,13 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the definition of ::DefaultTaskConfig. */ /* - * Copyright (C) 2022 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2022 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-interrupt.c b/testsuites/validation/tx-interrupt.c index 16f1e18c47..c5ea4142c2 100644 --- a/testsuites/validation/tx-interrupt.c +++ b/testsuites/validation/tx-interrupt.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of * HasInterruptVectorEntriesInstalled(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -139,6 +139,10 @@ rtems_vector_number GetTestableInterruptVector( } } + if ( vector == BSP_INTERRUPT_VECTOR_COUNT ) { + vector = GetSoftwareInterruptVector(); + } + return vector; } diff --git a/testsuites/validation/tx-io-relax.c b/testsuites/validation/tx-io-relax.c index 1930c66b19..30cc097b3a 100644 --- a/testsuites/validation/tx-io-relax.c +++ b/testsuites/validation/tx-io-relax.c @@ -3,13 +3,13 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of SetIORelaxHandler(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-memory-alloc.c b/testsuites/validation/tx-memory-alloc.c index 82b79bc558..8959dbbdc5 100644 --- a/testsuites/validation/tx-memory-alloc.c +++ b/testsuites/validation/tx-memory-alloc.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of * MemoryAllocationFailWhen() and __wrap_rtems_malloc(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-preemption-intervention.c b/testsuites/validation/tx-preemption-intervention.c index 612190567e..f66ab839e5 100644 --- a/testsuites/validation/tx-preemption-intervention.c +++ b/testsuites/validation/tx-preemption-intervention.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of * SetPreemptionIntervention(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-support.c b/testsuites/validation/tx-support.c index f576373eb1..64ebe260f6 100644 --- a/testsuites/validation/tx-support.c +++ b/testsuites/validation/tx-support.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of support functions for * the validation test cases. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-support.h b/testsuites/validation/tx-support.h index 20f74faa2d..378bc4c466 100644 --- a/testsuites/validation/tx-support.h +++ b/testsuites/validation/tx-support.h @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This header file provides the support functions for the validation * test cases. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -47,7 +47,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestSuites + * @addtogroup RTEMSTestSuitesValidation * * @{ */ @@ -390,6 +390,14 @@ void CallWithinISRSubmit( CallWithinISRRequest *request ); void CallWithinISRWait( const CallWithinISRRequest *request ); +void CallWithinISRRaise( void ); + +void CallWithinISRClear( void ); + +rtems_vector_number CallWithinISRGetVector( void ); + +rtems_vector_number GetSoftwareInterruptVector( void ); + typedef struct { Thread_queue_Operations tq_ops; const Thread_queue_Operations *wrapped_ops; @@ -431,6 +439,10 @@ rtems_vector_number GetTestableInterruptVector( const rtems_interrupt_attributes *required ); +rtems_status_code RaiseSoftwareInterrupt( rtems_vector_number vector ); + +rtems_status_code ClearSoftwareInterrupt( rtems_vector_number vector ); + bool HasInterruptVectorEntriesInstalled( rtems_vector_number vector ); /** diff --git a/testsuites/validation/tx-thread-queue.c b/testsuites/validation/tx-thread-queue.c index 1b0e8665c7..ee9d2cf96d 100644 --- a/testsuites/validation/tx-thread-queue.c +++ b/testsuites/validation/tx-thread-queue.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of the thread queue test * support. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -333,8 +333,12 @@ static void Worker( rtems_task_argument arg, TQWorkerKind worker ) _Thread_Dispatch_direct( cpu_self ); } - if ( ( events & TQ_EVENT_FLUSH ) != 0 ) { - TQFlush( ctx ); + if ( ( events & TQ_EVENT_FLUSH_ALL ) != 0 ) { + TQFlush( ctx, true ); + } + + if ( ( events & TQ_EVENT_FLUSH_PARTIAL ) != 0 ) { + TQFlush( ctx, false ); } if ( ( events & TQ_EVENT_ENQUEUE_DONE ) != 0 ) { @@ -647,9 +651,9 @@ Status_Control TQSurrender( TQContext *ctx ) return ( *ctx->surrender )( ctx ); } -void TQFlush( TQContext *ctx ) +void TQFlush( TQContext *ctx, bool flush_all ) { - ( *ctx->flush )( ctx ); + ctx->flush_count = ( *ctx->flush )( ctx, ctx->how_many, flush_all ); } rtems_tcb *TQGetOwner( TQContext *ctx ) diff --git a/testsuites/validation/tx-thread-queue.h b/testsuites/validation/tx-thread-queue.h index d9a1a4db8d..f95fcb790b 100644 --- a/testsuites/validation/tx-thread-queue.h +++ b/testsuites/validation/tx-thread-queue.h @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This header file provides the functions to test the * @ref RTEMSScoreThreadQueue. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -50,7 +50,7 @@ extern "C" { #endif /** - * @addtogroup RTEMSTestSuites + * @addtogroup RTEMSTestSuitesValidation * * @{ */ @@ -120,23 +120,24 @@ typedef enum { TQ_EVENT_MUTEX_B_OBTAIN = RTEMS_EVENT_10, TQ_EVENT_MUTEX_B_RELEASE = RTEMS_EVENT_11, TQ_EVENT_BUSY_WAIT = RTEMS_EVENT_12, - TQ_EVENT_FLUSH = RTEMS_EVENT_13, - TQ_EVENT_SCHEDULER_RECORD_START = RTEMS_EVENT_14, - TQ_EVENT_SCHEDULER_RECORD_STOP = RTEMS_EVENT_15, - TQ_EVENT_TIMEOUT = RTEMS_EVENT_16, - TQ_EVENT_MUTEX_NO_PROTOCOL_OBTAIN = RTEMS_EVENT_17, - TQ_EVENT_MUTEX_NO_PROTOCOL_RELEASE = RTEMS_EVENT_18, - TQ_EVENT_ENQUEUE_FATAL = RTEMS_EVENT_19, - TQ_EVENT_MUTEX_C_OBTAIN = RTEMS_EVENT_20, - TQ_EVENT_MUTEX_C_RELEASE = RTEMS_EVENT_21, - TQ_EVENT_MUTEX_FIFO_OBTAIN = RTEMS_EVENT_22, - TQ_EVENT_MUTEX_FIFO_RELEASE = RTEMS_EVENT_23, - TQ_EVENT_ENQUEUE_TIMED = RTEMS_EVENT_24, - TQ_EVENT_MUTEX_D_OBTAIN = RTEMS_EVENT_25, - TQ_EVENT_MUTEX_D_RELEASE = RTEMS_EVENT_26, - TQ_EVENT_PIN = RTEMS_EVENT_27, - TQ_EVENT_UNPIN = RTEMS_EVENT_28, - TQ_EVENT_COUNT = RTEMS_EVENT_29 + TQ_EVENT_FLUSH_ALL = RTEMS_EVENT_13, + TQ_EVENT_FLUSH_PARTIAL = RTEMS_EVENT_14, + TQ_EVENT_SCHEDULER_RECORD_START = RTEMS_EVENT_15, + TQ_EVENT_SCHEDULER_RECORD_STOP = RTEMS_EVENT_16, + TQ_EVENT_TIMEOUT = RTEMS_EVENT_17, + TQ_EVENT_MUTEX_NO_PROTOCOL_OBTAIN = RTEMS_EVENT_18, + TQ_EVENT_MUTEX_NO_PROTOCOL_RELEASE = RTEMS_EVENT_19, + TQ_EVENT_ENQUEUE_FATAL = RTEMS_EVENT_20, + TQ_EVENT_MUTEX_C_OBTAIN = RTEMS_EVENT_21, + TQ_EVENT_MUTEX_C_RELEASE = RTEMS_EVENT_22, + TQ_EVENT_MUTEX_FIFO_OBTAIN = RTEMS_EVENT_23, + TQ_EVENT_MUTEX_FIFO_RELEASE = RTEMS_EVENT_24, + TQ_EVENT_ENQUEUE_TIMED = RTEMS_EVENT_25, + TQ_EVENT_MUTEX_D_OBTAIN = RTEMS_EVENT_26, + TQ_EVENT_MUTEX_D_RELEASE = RTEMS_EVENT_27, + TQ_EVENT_PIN = RTEMS_EVENT_28, + TQ_EVENT_UNPIN = RTEMS_EVENT_29, + TQ_EVENT_COUNT = RTEMS_EVENT_30 } TQEvent; typedef enum { @@ -263,6 +264,12 @@ typedef struct TQContext { uint32_t how_many; /** + * @brief This this member contains the count of the least recently flushed + * threads. + */ + uint32_t flush_count; + + /** * @brief This this member provides a context to jump back to before the * enqueue. */ @@ -290,8 +297,13 @@ typedef struct TQContext { /** * @brief This member provides the thread queue flush handler. + * + * The second parameter specifies the count of enqueued threads. While the + * third parameter is true, all enqueued threads shall be extracted, + * otherwise the thread queue shall be partially flushed. The handler shall + * return the count of flushed threads. */ - void ( *flush )( struct TQContext * ); + uint32_t ( *flush )( struct TQContext *, uint32_t, bool ); /** * @brief This member provides the get owner handler. @@ -390,7 +402,7 @@ void TQEnqueueDone( TQContext *ctx ); Status_Control TQSurrender( TQContext *ctx ); -void TQFlush( TQContext *ctx ); +void TQFlush( TQContext *ctx, bool flush_all ); rtems_tcb *TQGetOwner( TQContext *ctx ); diff --git a/testsuites/validation/tx-timecounter.c b/testsuites/validation/tx-timecounter.c index c6738914a4..01b55f2578 100644 --- a/testsuites/validation/tx-timecounter.c +++ b/testsuites/validation/tx-timecounter.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the definition of SetGetTimecountHandler(), * GetTimecountCounter(), and SetTimecountCounter(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-timer-server.c b/testsuites/validation/tx-timer-server.c index 80ba853fb1..29575eb490 100644 --- a/testsuites/validation/tx-timer-server.c +++ b/testsuites/validation/tx-timer-server.c @@ -3,13 +3,13 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the definition of DeleteTimerServer(). */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/testsuites/validation/tx-wrap-thread-queue.c b/testsuites/validation/tx-wrap-thread-queue.c index 93b7b55f37..39d7b38129 100644 --- a/testsuites/validation/tx-wrap-thread-queue.c +++ b/testsuites/validation/tx-wrap-thread-queue.c @@ -3,14 +3,14 @@ /** * @file * - * @ingroup RTEMSTestSuites + * @ingroup RTEMSTestSuitesValidation * * @brief This source file contains the implementation of the thread queue * wrapper. */ /* - * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de) + * Copyright (C) 2021 embedded brains GmbH & Co. KG * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions |