[rtems commit] validation: Test <rtems/score/basedefs.h>
Sebastian Huber
sebh at rtems.org
Thu Mar 24 10:01:58 UTC 2022
Module: rtems
Branch: master
Commit: 99544e3f87c8b5a364899d3a355b10f0323bc7e0
Changeset: http://git.rtems.org/rtems/commit/?id=99544e3f87c8b5a364899d3a355b10f0323bc7e0
Author: Frank Kühndel <frank.kuehndel at embedded-brains.de>
Date: Thu Dec 9 16:09:47 2021 +0100
validation: Test <rtems/score/basedefs.h>
The test source code is generated from specification items
by the "./spec2modules.py" script contained in the
git://git.rtems.org/rtems-central.git Git repository.
Please read the "How-To" section in the "Software Requirements Engineering"
chapter of the RTEMS Software Engineering manual to get more information about
the process.
Update #3716.
---
.../validation/validation-no-clock-0.yml | 2 +
testsuites/validation/tc-basedefs-pendant.c | 122 ++
testsuites/validation/tc-basedefs-pendant.h | 93 +
testsuites/validation/tc-basedefs.c | 2024 ++++++++++++++++++++
4 files changed, 2241 insertions(+)
diff --git a/spec/build/testsuites/validation/validation-no-clock-0.yml b/spec/build/testsuites/validation/validation-no-clock-0.yml
index 7a783d6..3b456b8 100644
--- a/spec/build/testsuites/validation/validation-no-clock-0.yml
+++ b/spec/build/testsuites/validation/validation-no-clock-0.yml
@@ -18,6 +18,8 @@ source:
- testsuites/validation/tc-barrier-ident.c
- testsuites/validation/tc-barrier-release.c
- testsuites/validation/tc-barrier-wait.c
+- testsuites/validation/tc-basedefs.c
+- testsuites/validation/tc-basedefs-pendant.c
- testsuites/validation/tc-score-fatal.c
- testsuites/validation/tr-mtx-seize-try.c
- testsuites/validation/tr-mtx-seize-wait.c
diff --git a/testsuites/validation/tc-basedefs-pendant.c b/testsuites/validation/tc-basedefs-pendant.c
new file mode 100644
index 0000000..e9a7552
--- /dev/null
+++ b/testsuites/validation/tc-basedefs-pendant.c
@@ -0,0 +1,122 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs
+ *
+ * @brief Helper file to verify the requirements towards the basedefs.
+ *
+ * The specification items in
+ * (rtems-central/)spec/rtems/basedefs/req/[*] represent
+ * requirements towards the basedefs in
+ * (rtems/)cpukit/include/rtems/score/basedefs.h.
+ * There are automated verification tests generated from
+ * (rtems-central/)spec/rtems/basedefs/val/[*] and placed
+ * in (rtems/)testsuites/validation/tc-basedefs-0.c.
+ *
+ * Yet, not every test can be placed in the same compilation unit
+ * (tc-basedefs-0.c). Hence, the code which must be placed
+ * in an extra compilation unit is put here and this file
+ * is linked to tc-basedefs-0.c to be accessible from the tests.
+ */
+
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "tc-basedefs-pendant.h"
+
+/* For the RTEMS_SYMBOL_NAME tests */
+#undef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__ SyMbOl_
+#define SyMbOl_symbol_id prefix_symbol_id
+#define SYMBOL_NAME symbol_name
+
+uintptr_t basedefs_get_global_symbol( void )
+{
+ return (uintptr_t) global_symbol;
+}
+
+int basedefs_use_prefixed_symbol_name( void )
+{
+ const int SyMbOl_symbol_name = 124;
+ return RTEMS_SYMBOL_NAME( symbol_name );
+}
+
+int basedefs_use_prefixed_upper_symbol_name( void )
+{
+ const int SyMbOl_symbol_name = 125;
+ return RTEMS_SYMBOL_NAME( SYMBOL_NAME );
+}
+
+int basedefs_use_prefixed_symbol_id( void )
+{
+ const int prefix_symbol_id = 126;
+ return RTEMS_SYMBOL_NAME( symbol_id );
+}
+
+int basedefs_weak_alias_1_func( int i )
+{
+ return 10 * i;
+}
+
+const volatile int basedefs_weak_1_var = 62;
+
+int basedefs_weak_1_func( void )
+{
+ return 65;
+}
+
+static RTEMS_ALIGNED( 64 ) int allocated_memory_dummy;
+
+void *basedefs_malloclike_func( size_t size )
+{
+ return &allocated_memory_dummy;
+}
+
+void *basedefs_alloc_align_func( size_t size, void **p, size_t alignment )
+{
+ *p = &allocated_memory_dummy;
+ return &allocated_memory_dummy;
+}
+
+void *basedefs_alloc_size_func( size_t size )
+{
+ return &allocated_memory_dummy;
+}
+
+void *basedefs_alloc_size_2_func( size_t size0, size_t size1 )
+{
+ return &allocated_memory_dummy;
+}
+
+void basedefs_free( void *ptr )
+{
+ (void) ptr;
+}
diff --git a/testsuites/validation/tc-basedefs-pendant.h b/testsuites/validation/tc-basedefs-pendant.h
new file mode 100644
index 0000000..591e0e6
--- /dev/null
+++ b/testsuites/validation/tc-basedefs-pendant.h
@@ -0,0 +1,93 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs
+ *
+ * @brief Helper file to verify the requirements towards the basedefs.
+ *
+ * This file contains solely *private* declarations shared by
+ * (rtems/)testsuites/validation/tc-basedefs-0.c and
+ * (rtems/)testsuites/validation/tc-basedefs-pendant.c.
+ */
+
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#ifndef _TC_BASEDEFS_PENDANT_H
+#define _TC_BASEDEFS_PENDANT_H
+
+/* The define is for the RTEMS_SYMBOL_NAME tests */
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#include <rtems.h>
+
+/* Remove for C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GLOBAL_SYMBOL global_symbol
+RTEMS_DECLARE_GLOBAL_SYMBOL( GLOBAL_SYMBOL );
+
+uintptr_t basedefs_get_global_symbol( void );
+int basedefs_use_prefixed_symbol_name( void );
+int basedefs_use_prefixed_upper_symbol_name( void );
+int basedefs_use_prefixed_symbol_id( void );
+int basedefs_weak_alias_0_func( int i );
+int basedefs_weak_alias_1_func( int i );
+int basedefs_weak_0_func( void );
+int basedefs_weak_1_func( void );
+
+extern const volatile int basedefs_weak_0_var;
+
+extern const volatile int basedefs_weak_1_var;
+
+RTEMS_MALLOCLIKE void *
+basedefs_malloclike_func( size_t size );
+
+RTEMS_ALLOC_SIZE_2( 1, 2 ) void *
+basedefs_alloc_size_2_func( size_t size0, size_t size1 );
+
+RTEMS_ALLOC_ALIGN( 3 ) void *
+basedefs_alloc_align_func( size_t size, void **p, size_t alignment );
+
+RTEMS_ALLOC_SIZE( 1 ) void *
+basedefs_alloc_size_func( size_t size );
+
+RTEMS_ALLOC_SIZE_2( 1, 2 ) void *
+basedefs_alloc_size_2_func( size_t size0, size_t size1 );
+
+void basedefs_free( void *ptr );
+
+/* Remove for C++ code */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TC_BASEDEFS_PENDANT_H */
diff --git a/testsuites/validation/tc-basedefs.c b/testsuites/validation/tc-basedefs.c
new file mode 100644
index 0000000..bec43fa
--- /dev/null
+++ b/testsuites/validation/tc-basedefs.c
@@ -0,0 +1,2024 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsBasedefsValBasedefs
+ */
+
+/*
+ * Copyright (C) 2020, 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 <rtems.h>
+
+#include "tc-basedefs-pendant.h"
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsBasedefsValBasedefs \
+ * spec:/rtems/basedefs/val/basedefs
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
+ *
+ * @brief Tests the basedefs macros of the Classic API.
+ *
+ * This test case performs the following actions:
+ *
+ * - Use the RTEMS_ALIAS() macro.
+ *
+ * - Check that ori_func() and alias_func() are the same function.
+ *
+ * - Use the RTEMS_ALIGN_DOWN() macro in various examples.
+ *
+ * - Check that RTEMS_ALIGN_DOWN() calculates the expected result and is
+ * side-effect free.
+ *
+ * - Use the RTEMS_ALIGN_UP() macro in various examples.
+ *
+ * - Check that RTEMS_ALIGN_UP() calculates the expected result and is
+ * side-effect free.
+ *
+ * - Use the RTEMS_ALIGNED() macro.
+ *
+ * - Check that RTEMS_ALIGNED() correctly aligns a variable on the stack and
+ * a structure member.
+ *
+ * - Use the RTEMS_ALIGNOF() macro.
+ *
+ * - Check that the RTEMS_ALIGNOF() macro results in the alignment of the
+ * type.
+ *
+ * - If the RTEMS_ALIGNOF() macro would evaluate its argument, it could not
+ * figure out how much menory to reserve for it.
+ *
+ * - If the RTEMS_ALIGNOF() macro would evaluate the size expression, the
+ * division by zero would cause an error.
+ *
+ * - Ensure the constant value of the RTEMS_ALIGNOF() macro is of type
+ * size_t.
+ *
+ * - Use a function declared with the RTEMS_ALLOC_ALIGN() macro.
+ *
+ * - It cannot be checked that the RTEMS_ALLOC_ALIGN() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts
+ * at 1.
+ *
+ * - Use a function declared with the RTEMS_ALLOC_SIZE() macro.
+ *
+ * - It cannot be checked that the RTEMS_ALLOC_SIZE() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts
+ * at 1.
+ *
+ * - Use a function declared with the RTEMS_ALLOC_SIZE_2() macro.
+ *
+ * - It cannot be checked that the RTEMS_ALLOC_SIZE_2() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts
+ * at 1.
+ *
+ * - Use the RTEMS_ARRAY_SIZE() macro.
+ *
+ * - Check that the calculated size of the arrays fit their definition.
+ *
+ * - Use the RTEMS_COMPILER_DEPRECATED_ATTRIBUTE macro.
+ *
+ * - It cannot automatically be checked that the
+ * RTEMS_COMPILER_DEPRECATED_ATTRIBUTE macro has the desired effect. The
+ * gcc compiler should issue a warning about the use of a deprecated
+ * variable on the above line where the ``compiler_deprecated_attribute``
+ * is used.
+ *
+ * - Use the RTEMS_COMPILER_MEMORY_BARRIER() macro.
+ *
+ * - It cannot be checked that the RTEMS_COMPILER_MEMORY_BARRIER() macro has
+ * the desired effect. It is only checked that such a macro exists.
+ *
+ * - Use of the RTEMS_COMPILER_NO_RETURN_ATTRIBUTE macro at the beginning of
+ * this file.
+ *
+ * - It cannot be checked that the RTEMS_COMPILER_NO_RETURN_ATTRIBUTE macro
+ * has the desired effect. It is only checked that such a macro exists.
+ *
+ * - Use the RTEMS_COMPILER_PACKED_ATTRIBUTE macro.
+ *
+ * - Check that RTEMS_COMPILER_PACKED_ATTRIBUTE correctly aligns a structure
+ * member.
+ *
+ * - Use the RTEMS_COMPILER_PURE_ATTRIBUTE macro at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_COMPILER_PURE_ATTRIBUTE macro has
+ * the desired effect. It is checked that such a macro exists.
+ *
+ * - Use the RTEMS_COMPILER_UNUSED_ATTRIBUTE macro.
+ *
+ * - It cannot automatically be checked that the
+ * RTEMS_COMPILER_UNUSED_ATTRIBUTE macro has the desired effect. It is
+ * checked that such a macro exists and one can manually check that no
+ * compiler warnings are produced for the compiler_unused_attribute_var.
+ *
+ * - Invoke the RTEMS_CONCAT() macro on examples.
+ *
+ * - Check that the two arguments of RTEMS_CONCAT() are concatenated to a new
+ * token.
+ *
+ * - Check that the result of the RTEMS_CONCAT() expansion is subject to a
+ * further pre-processor substitution.
+ *
+ * - Use the RTEMS_CONST macro at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_CONST macro has the desired effect.
+ * It is checked that such a macro exists.
+ *
+ * - Use the RTEMS_CONTAINER_OF() macro.
+ *
+ * - Check that the RTEMS_CONTAINER_OF() macro evaluates to a pointer to
+ * container_of_struct_var.
+ *
+ * - Use the RTEMS_DECLARE_GLOBAL_SYMBOL() macro in the file
+ * tc-basedefs-pendant.h.
+ *
+ * - Check that the RTEMS_DECLARE_GLOBAL_SYMBOL() macro declares a global
+ * symbol which can be accessed by function basedefs_get_global_symbol()
+ * which is defined in a file different from the file in which the gobal
+ * symbol is defined.
+ *
+ * - Use the RTEMS_DECONST() macro.
+ *
+ * - Check that the RTEMS_DECONST() macro returns a pointer which allows to
+ * write into an otherwise const value.
+ *
+ * - Use the RTEMS_DEFINE_GLOBAL_SYMBOL() macro at the beginning of this file.
+ *
+ * - Check that the RTEMS_DEFINE_GLOBAL_SYMBOL() macro defines a global
+ * symbol with the correct value.
+ *
+ * - Use a function declared with the RTEMS_DEPRECATED macro.
+ *
+ * - It cannot automatically be checked that the RTEMS_DEPRECATED macro has
+ * the desired effect. The gcc compiler should issue a warning about the
+ * use of a deprecated function on the above line where the
+ * ``deprecated_func`` is used.
+ *
+ * - Use the RTEMS_DEQUALIFY_DEPTHX() macro.
+ *
+ * - Check that the RTEMS_DEQUALIFY_DEPTHX() macro returns a pointer which
+ * allows to write into an otherwise const (volatile) value.
+ *
+ * - Use the RTEMS_DEQUALIFY() macro.
+ *
+ * - Check that the RTEMS_DEQUALIFY() macro returns a pointer which allows to
+ * write into an otherwise const volatile value.
+ *
+ * - Use the RTEMS_DEVOLATILE() macro.
+ *
+ * - Check that the RTEMS_DEVOLATILE() macro returns a pointer which allows
+ * to write into an otherwise volatile value.
+ *
+ * - Invoke the RTEMS_EXPAND() macro on an example.
+ *
+ * - Check that the argument of RTEMS_EXPAND() is expanded and returned.
+ *
+ * - Invoke the FALSE macro on an example.
+ *
+ * - Check that of FALSE is substituted by 0.
+ *
+ * - Invoke the RTEMS_HAVE_MEMBER_SAME_TYPE() macro on examples.
+ *
+ * - Check that of RTEMS_HAVE_MEMBER_SAME_TYPE() returns 0 and 1 depending on
+ * whether these types are compatible.
+ *
+ * - Use the RTEMS_INLINE_ROUTINE in the definition of function
+ * inline_routine_func() at the beginning of this file. Obtain the text the
+ * macro RTEMS_INLINE_ROUTINE produces.
+ *
+ * - Check that the RTEMS_INLINE_ROUTINE exists and that it produces the
+ * desired text.
+ *
+ * - Use a function declared with the RTEMS_MALLOCLIKE macro.
+ *
+ * - It cannot be checked that the RTEMS_MALLOCLIKE macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that it produces the correct code.
+ *
+ * - Use a function declared with the RTEMS_NO_INLINE macro.
+ *
+ * - It cannot be checked that the RTEMS_NO_INLINE macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a function and that it produces the correct code.
+ *
+ * - Use of the RTEMS_NO_RETURN macro at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_NO_RETURN macro has the desired
+ * effect. It is only checked that such a macro exists.
+ *
+ * - Use the RTEMS_NOINIT macro on ``noinit_variable`` at the beginning of this
+ * file.
+ *
+ * - It cannot be checked that the RTEMS_NOINIT macro has the desired effect.
+ * Yet, the check confirms that such a macro exists and can be used.
+ *
+ * - Use the RTEMS_OBFUSCATE_VARIABLE() macro.
+ *
+ * - It cannot be checked that the RTEMS_OBFUSCATE_VARIABLE() macro has the
+ * desired effect. Yet, the check confirms that such a macro exists and can
+ * be used.
+ *
+ * - Use the RTEMS_PACKED macro.
+ *
+ * - Check that RTEMS_PACKED correctly aligns a structure member.
+ *
+ * - Check that RTEMS_PACKED correctly aligns all structure members.
+ *
+ * - Check that RTEMS_PACKED correctly enforces a minimal enum type.
+ *
+ * - Use the RTEMS_PREDICT_FALSE() macro.
+ *
+ * - It cannot be checked that the RTEMS_PREDICT_FALSE() macro has the
+ * desired effect. Yet, the check confirms that such a macro exists and can
+ * be used.
+ *
+ * - Use the RTEMS_PREDICT_TRUE() macro.
+ *
+ * - It cannot be checked that the RTEMS_PREDICT_TRUE() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and can be
+ * used.
+ *
+ * - Use a function declared with the RTEMS_PRINTFLIKE() macro.
+ *
+ * - It cannot automatically be checked that the RTEMS_PRINTFLIKE() macro has
+ * the desired effect. Yet, the check confirms that such a macro exists and
+ * that it can be used on such a printf-like function and that the argument
+ * numbers are correct.
+ *
+ * - Use the RTEMS_PURE macro at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_PURE macro has the desired effect.
+ * It is checked that such a macro exists.
+ *
+ * - Get the code the RTEMS_RETURN_ADDRESS() macro produces as string.
+ *
+ * - The check confirms that a RTEMS_RETURN_ADDRESS() macro exists and that
+ * it produces the correct code.
+ *
+ * - Use the RTEMS_SECTION() macro on ``section_variable`` and ``section_func``
+ * at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_SECTION() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and can be
+ * used.
+ *
+ * - Use the RTEMS_STATIC_ANALYSIS macro.
+ *
+ * - 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.
+ *
+ * - Use the RTEMS_STATIC_ASSERT() macro.
+ *
+ * - It cannot be automatically check that the RTEMS_STATIC_ASSERT() macro
+ * has the desired effect. Yet, it can be checked that the macro exists and
+ * accepts the specified arguments.
+ *
+ * - Use the RTEMS_STRING() macro.
+ *
+ * - Check that the RTEMS_STRING() macro converts its arguments into a single
+ * string without applying pre-processor substitutions on its arguments.
+ *
+ * - Use the RTEMS_SYMBOL_NAME() macro with an example object.
+ *
+ * - Check that the RTEMS_SYMBOL_NAME() macro expands to the expected symbol
+ * name.
+ *
+ * - Invoke the TRUE macro on an example.
+ *
+ * - Check that of TRUE is substituted by 0.
+ *
+ * - Use of the RTEMS_TYPEOF_REFX() macro on several examples. This use is
+ * already the test as the statements will not compile without error if the
+ * macro did not evaluate to the correct type.
+ *
+ * - 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.
+ *
+ * - Use the RTEMS_UNUSED macro. See also unused_func() at the beginning of
+ * this file.
+ *
+ * - It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_func().
+ *
+ * - It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_lable.
+ *
+ * - It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_struct.
+ *
+ * - It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the unused
+ * items unused_var and the unused argument and variable in unused_func().
+ *
+ * - Use of the RTEMS_UNREACHABLE() macro in function definition of
+ * unreachable_func() at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_UNREACHABLE() macro has the desired
+ * effect. It is checked that such a macro exists and the compiler warning
+ * about the missing return statement is suppressed.
+ *
+ * - Use of the RTEMS_USED macro in function definition of used_func() at the
+ * beginning of this file and with used_var above.
+ *
+ * - It cannot be checked that the RTEMS_USED macro has the desired effect.
+ * It is checked that such a macro exists.
+ *
+ * - Use of the RTEMS_WARN_UNUSED_RESULT macro in function definition of
+ * warn_unused_func() at the beginning of this file.
+ *
+ * - It cannot be checked that the RTEMS_WARN_UNUSED_RESULT macro has the
+ * desired effect. The GNU C compiler should issue a warning about the
+ * disregarded result returned by the call to the ``warn_unused_func()``
+ * function.
+ *
+ * - Use of ``basedefs_weak_alias_0/1_func()`` which are defined with the
+ * RTEMS_WEAK_ALIAS() macro at the beginning of this file.
+ *
+ * - 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.
+ *
+ * - 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.
+ *
+ * - 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.
+ *
+ * - For ``basedefs_weak_0_var`` and ``basedefs_weak_0_func()`` there exists
+ * no other symbols with the same name. Hence, the checks test that the
+ * weak symbols are used.
+ *
+ * - ``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.
+ *
+ * - Invoke the RTEMS_XCONCAT() macro on examples.
+ *
+ * - Check that the two arguments of RTEMS_XCONCAT() are concatenated without
+ * inserting new characters.
+ *
+ * - Check that the two arguments of RTEMS_XCONCAT() are substituted before
+ * they are concatenated.
+ *
+ * - Check that the two arguments of RTEMS_XCONCAT() are can be the macro
+ * itself.
+ *
+ * - Check that the result of the RTEMS_XCONCAT() expansion is subject to a
+ * further pre-processor substitution.
+ *
+ * - Use the RTEMS_XSTRING() macro.
+ *
+ * - Check that the RTEMS_XSTRING() macro applies pre-processor substitutions
+ * on its arguments and converts its arguments into a single string.
+ *
+ * - Use of the RTEMS_ZERO_LENGTH_ARRAY macro in a declaration of a structure.
+ *
+ * - Checked that the RTEMS_ZERO_LENGTH_ARRAY macro produces a structure
+ * similar to a structure with one element.
+ *
+ * @{
+ */
+
+#define WHITE_SPACE_STRING_MAX_LENGTH 80
+#define abccat concat
+#define abc ABC
+#define CON con
+#define CAT cat
+#define defcat concat
+#define GLOBAL_SYMBOL_VALULE( _hex ) 0x ## _hex
+#define EXPAND expand
+#define PREDICT_FALSE 1 -
+#define SECTION_NAME ".rtemsroset.test"
+#define STATIC_ASSERT_COND 0 +
+#define STRING_PREFIX str
+#define SYMBOL_NAME global_object
+#define _TO_STR2( _text ) #_text
+#define _TO_STR( _text ) _TO_STR2( _text )
+
+int global_object;
+
+extern int address_of_global_object;
+
+__asm__(
+ "\n\t.set " RTEMS_XSTRING( RTEMS_SYMBOL_NAME( address_of_global_object ) )
+ ", " RTEMS_XSTRING( RTEMS_SYMBOL_NAME( SYMBOL_NAME ) ) "\n"
+);
+
+/*
+ * For some reasons - which I fail to fully understand - _TO_STR()
+ * seems to remove spaces around `()` at times and at other times
+ * not. For example, I get
+ *
+ * * "__attribute__(( __malloc__ ))" or
+ * * "__attribute__((__malloc__))".
+ *
+ * To avoid trouble, the function below returns a version of a
+ * string without any spaces. Albeit, the implementation is rather
+ * brute and raw. It returns a pointer to a static buffer of fixed
+ * size. That will do for tests but not serve as generic function.
+ */
+static const char *remove_white_space( const char *str )
+{
+ char c;
+ int i = 0;
+ static char buffer[WHITE_SPACE_STRING_MAX_LENGTH] = {};
+
+ /* Sanity check */
+ if( strlen( str ) >= sizeof( buffer ) ) {
+ T_assert_true( false,
+ "Buffer too small; increase WHITE_SPACE_STRING_MAX_LENGTH" );
+ }
+
+ /* Copy string but skip white spaces */
+ do {
+ c = *( str++ );
+ if ( ' ' != c && '\t' !=c ) {
+ buffer[i++] = c;
+ }
+ } while ( '\0' != c );
+
+ return buffer;
+}
+
+static int alias_func( int i ) RTEMS_ALIAS( ori_func );
+
+typedef struct {
+ uint8_t c;
+ uint8_t aligned_member RTEMS_ALIGNED( 8 );
+} aligned_member_struct;
+
+static int concat( void )
+{
+ return 91;
+}
+
+RTEMS_CONST static int const_func( int arg )
+{
+ return 4 * arg;
+}
+
+RTEMS_COMPILER_NO_RETURN_ATTRIBUTE
+ static void compiler_no_return_attribute_func( int i );
+static void compiler_no_return_attribute_func( int i )
+{
+ while ( true ) {
+ /* Loop forever */
+ }
+}
+
+RTEMS_COMPILER_PURE_ATTRIBUTE static int compiler_pure_attribute_func( void )
+{
+ return 21;
+}
+
+RTEMS_DEFINE_GLOBAL_SYMBOL(
+ GLOBAL_SYMBOL, GLOBAL_SYMBOL_VALULE( abc ) );
+
+static int deprecated_func( int i ) RTEMS_DEPRECATED;
+static int deprecated_func( int i )
+{
+ return 3 * i;
+}
+
+static int expand( void )
+{
+ return 82;
+}
+
+RTEMS_INLINE_ROUTINE int inline_routine_func( int arg )
+{
+ return 1 << arg;
+}
+
+RTEMS_NO_INLINE static int no_inline_func( void )
+{
+ asm ("");
+ return 75;
+}
+
+RTEMS_NO_RETURN static void no_return_func( int i )
+{
+ while ( true ) {
+ /* Loop forever */
+ }
+}
+
+RTEMS_NOINIT static uint32_t noinit_variable;
+
+static int ori_func( int x )
+{
+ return 2 * x;
+}
+
+RTEMS_PRINTFLIKE(2, 3) static int printflike_func(
+ const char *prefix,
+ const char *fmt,
+ ...
+)
+{
+ int result;
+ va_list va_list;
+
+ T_printf( "%s: ", prefix );
+ va_start( va_list, fmt );
+ result = T_vprintf( fmt, va_list );
+ va_end( va_list );
+
+ return result;
+}
+
+RTEMS_PURE static int pure_func( void )
+{
+ return 21;
+}
+
+RTEMS_SECTION( ".rtemsrwset.test" ) static int section_var = 28;
+RTEMS_SECTION( SECTION_NAME ) static int section_func( int arg )
+{
+ return arg % 100;
+}
+
+static int unreachable_func( int arg )
+{
+ if ( 1 == arg % 100 ) {
+ return arg;
+ } else {
+ T_assert_true( false,
+ "Oops! Function caled with bad argument." );
+ RTEMS_UNREACHABLE();
+ }
+}
+
+RTEMS_USED static int used_var = 4711;
+RTEMS_USED static int used_func( void )
+{
+ return 35;
+}
+
+static int warn_unused_func( int arg ) RTEMS_WARN_UNUSED_RESULT;
+static int warn_unused_func( int arg )
+{
+ return arg / 3;
+}
+
+int basedefs_weak_alias_0_func( int i ) RTEMS_WEAK_ALIAS( ori_func );
+int basedefs_weak_alias_1_func( int i ) RTEMS_WEAK_ALIAS( ori_func );
+
+RTEMS_WEAK const volatile int basedefs_weak_0_var = 60;
+RTEMS_WEAK const volatile int basedefs_weak_1_var = 61;
+RTEMS_WEAK int basedefs_weak_0_func( void )
+{
+ return 63;
+}
+
+RTEMS_WEAK int basedefs_weak_1_func( void )
+{
+ return 64;
+}
+
+/**
+ * @brief Use the RTEMS_ALIAS() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_0( void )
+{
+ int alias_result;
+
+ alias_result = ori_func( 3 ) + alias_func( 5 );
+
+ /*
+ * Check that ori_func() and alias_func() are the same function.
+ */
+ T_step_eq_int( 0, alias_result, 16 );
+}
+
+/**
+ * @brief Use the RTEMS_ALIGN_DOWN() macro in various examples.
+ */
+static void RtemsBasedefsValBasedefs_Action_1( void )
+{
+ int align_down0_result;
+ int align_down1_result;
+ int align_down2_result;
+ int align_down3_result;
+ int align_down4_result;
+ int align_down5_result;
+ int align_down6_result;
+ int align_down7_result;
+ int align_down8_result;
+ int align_down9_result;
+
+ align_down0_result = RTEMS_ALIGN_DOWN( 0, 1 );
+ align_down1_result = RTEMS_ALIGN_DOWN( 0, 4 );
+ align_down2_result = RTEMS_ALIGN_DOWN( 1, 2 );
+ align_down3_result = RTEMS_ALIGN_DOWN( 2, 2 );
+ align_down4_result = RTEMS_ALIGN_DOWN( 3, 2 );
+ align_down5_result = RTEMS_ALIGN_DOWN( 4, 2 );
+ align_down6_result = RTEMS_ALIGN_DOWN( 5, 2 );
+ align_down7_result = RTEMS_ALIGN_DOWN( 255, 16 );
+ align_down8_result = RTEMS_ALIGN_DOWN( 256, 16 );
+ align_down9_result = RTEMS_ALIGN_DOWN( 257, 16 );
+
+ /*
+ * Check that RTEMS_ALIGN_DOWN() calculates the expected result and is
+ * side-effect free.
+ */
+ T_step_eq_int( 1, align_down0_result, 0 );
+ T_step_eq_int( 2, align_down1_result, 0 );
+ T_step_eq_int( 3, align_down2_result, 0 );
+ T_step_eq_int( 4, align_down3_result, 2 );
+ T_step_eq_int( 5, align_down4_result, 2 );
+ T_step_eq_int( 6, align_down5_result, 4 );
+ T_step_eq_int( 7, align_down6_result, 4 );
+ T_step_eq_int( 8, align_down7_result, 240 );
+ T_step_eq_int( 9, align_down8_result, 256 );
+ T_step_eq_int( 10, align_down9_result, 256 );
+}
+
+/**
+ * @brief Use the RTEMS_ALIGN_UP() macro in various examples.
+ */
+static void RtemsBasedefsValBasedefs_Action_2( void )
+{
+ int align_up0_result;
+ int align_up1_result;
+ int align_up2_result;
+ int align_up3_result;
+ int align_up4_result;
+ int align_up5_result;
+ int align_up6_result;
+ int align_up7_result;
+ int align_up8_result;
+ int align_up9_result;
+
+ align_up0_result = RTEMS_ALIGN_UP( 0, 1 );
+ align_up1_result = RTEMS_ALIGN_UP( 0, 4 );
+ align_up2_result = RTEMS_ALIGN_UP( 1, 2 );
+ align_up3_result = RTEMS_ALIGN_UP( 2, 2 );
+ align_up4_result = RTEMS_ALIGN_UP( 3, 2 );
+ align_up5_result = RTEMS_ALIGN_UP( 4, 2 );
+ align_up6_result = RTEMS_ALIGN_UP( 5, 2 );
+ align_up7_result = RTEMS_ALIGN_UP( 255, 16 );
+ align_up8_result = RTEMS_ALIGN_UP( 256, 16 );
+ align_up9_result = RTEMS_ALIGN_UP( 257, 16 );
+
+ /*
+ * Check that RTEMS_ALIGN_UP() calculates the expected result and is
+ * side-effect free.
+ */
+ T_step_eq_int( 11, align_up0_result, 0 );
+ T_step_eq_int( 12, align_up1_result, 0 );
+ T_step_eq_int( 13, align_up2_result, 2 );
+ T_step_eq_int( 14, align_up3_result, 2 );
+ T_step_eq_int( 15, align_up4_result, 4 );
+ T_step_eq_int( 16, align_up5_result, 4 );
+ T_step_eq_int( 17, align_up6_result, 6 );
+ T_step_eq_int( 18, align_up7_result, 256 );
+ T_step_eq_int( 19, align_up8_result, 256 );
+ T_step_eq_int( 20, align_up9_result, 272 );
+}
+
+/**
+ * @brief Use the RTEMS_ALIGNED() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_3( void )
+{
+ char unaligned_var = 'c';
+ char aligned_var RTEMS_ALIGNED( 8 ) = 'd';
+
+ (void) unaligned_var;
+
+ /*
+ * Check that RTEMS_ALIGNED() correctly aligns a variable on the stack and a
+ * structure member.
+ */
+ T_step_eq_int( 21, ( ( uintptr_t ) &aligned_var ) % 8, 0 );
+ T_step_eq_int( 22,
+ offsetof( aligned_member_struct, aligned_member ) % 8, 0 );
+}
+
+/**
+ * @brief Use the RTEMS_ALIGNOF() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_4( void )
+{
+ size_t alignof_char = RTEMS_ALIGNOF( char );
+ size_t alignof_long = RTEMS_ALIGNOF( long );
+ size_t alignof_long_array = RTEMS_ALIGNOF( long[3] );
+ size_t alignof_not_eval_array = RTEMS_ALIGNOF( long[7 / 0] );
+
+ /*
+ * Check that the RTEMS_ALIGNOF() macro results in the alignment of the type.
+ */
+ T_step_eq_sz( 23, alignof_char, 1 );
+ T_step_eq_sz( 24, alignof_long, alignof_long_array );
+
+ /*
+ * If the RTEMS_ALIGNOF() macro would evaluate its argument, it could not
+ * figure out how much menory to reserve for it.
+ */
+ T_step_eq_sz( 25, alignof_long, alignof_not_eval_array );
+
+ /*
+ * If the RTEMS_ALIGNOF() macro would evaluate the size expression, the
+ * division by zero would cause an error.
+ */
+ T_step_eq_sz( 26, alignof_long, alignof_not_eval_array );
+
+ /*
+ * Ensure the constant value of the RTEMS_ALIGNOF() macro is of type size_t.
+ */
+ T_step_true( 27,
+ __builtin_types_compatible_p( __typeof__( RTEMS_ALIGNOF( char ) ),
+ size_t ) );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_ALLOC_ALIGN() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_5( void )
+{
+ void *free_ptr;
+ void *alloc_align_ptr;
+ alloc_align_ptr = basedefs_alloc_align_func( 1024, &free_ptr, 64 );
+ basedefs_free( free_ptr );
+
+ /*
+ * It cannot be checked that the RTEMS_ALLOC_ALIGN() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts at
+ * 1.
+ */
+ T_step_not_null( 28, alloc_align_ptr );
+ T_step_eq_int( 29, ( ( uintptr_t ) alloc_align_ptr ) % 64, 0 );
+ T_step_ge_uptr( 30, ( ( uintptr_t ) alloc_align_ptr ),
+ ( ( uintptr_t ) free_ptr ) );
+ T_step_lt_uptr( 31, ( ( uintptr_t ) alloc_align_ptr ),
+ ( ( uintptr_t ) free_ptr ) + 64 );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_ALLOC_SIZE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_6( void )
+{
+ void *alloc_size_ptr;
+ alloc_size_ptr = basedefs_alloc_size_func( 1024 );
+ basedefs_free( alloc_size_ptr );
+
+ /*
+ * It cannot be checked that the RTEMS_ALLOC_SIZE() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts at
+ * 1.
+ */
+ T_step_not_null( 32, alloc_size_ptr );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_ALLOC_SIZE_2() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_7( void )
+{
+ void *alloc_size_2_ptr;
+ alloc_size_2_ptr = basedefs_alloc_size_2_func( 8, 128 );
+ basedefs_free( alloc_size_2_ptr );
+
+ /*
+ * It cannot be checked that the RTEMS_ALLOC_SIZE_2() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that the argument counting starts at
+ * 1.
+ */
+ T_step_not_null( 33, alloc_size_2_ptr );
+}
+
+/**
+ * @brief Use the RTEMS_ARRAY_SIZE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_8( void )
+{
+ int array[] = { 10, 20, 30, 40, 50 };
+ unsigned char array2[12];
+ int array_size = RTEMS_ARRAY_SIZE(array);
+ int array2_size = RTEMS_ARRAY_SIZE(array2);
+
+ /*
+ * Check that the calculated size of the arrays fit their definition.
+ */
+ T_step_eq_sz( 34, array_size, 5 );
+ T_step_eq_sz( 35, array2_size, 12 );
+}
+
+/**
+ * @brief Use the RTEMS_COMPILER_DEPRECATED_ATTRIBUTE macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_9( void )
+{
+ int compiler_deprecated_attribute RTEMS_COMPILER_DEPRECATED_ATTRIBUTE = 42;
+
+ /*
+ * It cannot automatically be checked that the
+ * RTEMS_COMPILER_DEPRECATED_ATTRIBUTE macro has the desired effect. The gcc
+ * compiler should issue a warning about the use of a deprecated variable on
+ * the above line where the ``compiler_deprecated_attribute`` is used.
+ */
+ /*
+ * Derivation from Coding Style:
+ * The following code suppresses a compiler warning (instead of fixing
+ * it).
+ * Rational: The variable compiler_deprecated_attribute is not really
+ * deprecated but its purpose is to test the RTEMS_DEPRECATED macro.
+ * The RTEMS_DEPRECATED macro must result in a compiler warning here.
+ */
+ _Pragma( "GCC diagnostic push" )
+ _Pragma( "GCC diagnostic ignored \"-Wdeprecated-declarations\"" )
+ T_step_eq_int( 36, compiler_deprecated_attribute, 42 );
+ _Pragma( "GCC diagnostic pop" )
+}
+
+/**
+ * @brief Use the RTEMS_COMPILER_MEMORY_BARRIER() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_10( void )
+{
+ RTEMS_COMPILER_MEMORY_BARRIER();
+
+ /*
+ * It cannot be checked that the RTEMS_COMPILER_MEMORY_BARRIER() macro has
+ * the desired effect. It is only checked that such a macro exists.
+ */
+
+}
+
+/**
+ * @brief Use of the RTEMS_COMPILER_NO_RETURN_ATTRIBUTE macro at the beginning
+ * of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_11( void )
+{
+ (void) compiler_no_return_attribute_func;
+
+ /*
+ * It cannot be checked that the RTEMS_COMPILER_NO_RETURN_ATTRIBUTE macro has
+ * the desired effect. It is only checked that such a macro exists.
+ */
+
+}
+
+/**
+ * @brief Use the RTEMS_COMPILER_PACKED_ATTRIBUTE macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_12( void )
+{
+ typedef struct {
+ uint8_t c;
+ RTEMS_COMPILER_PACKED_ATTRIBUTE uint32_t i;
+ } compiler_packed_attribute_struct;
+ int compiler_packed_attribute_offset =
+ offsetof( compiler_packed_attribute_struct, i );
+
+ /*
+ * Check that RTEMS_COMPILER_PACKED_ATTRIBUTE correctly aligns a structure
+ * member.
+ */
+ T_step_eq_int( 37, compiler_packed_attribute_offset, 1 );
+}
+
+/**
+ * @brief Use the RTEMS_COMPILER_PURE_ATTRIBUTE macro at the beginning of this
+ * file.
+ */
+static void RtemsBasedefsValBasedefs_Action_13( void )
+{
+ int compiler_pure_attribute_result;
+ int compiler_pure_attribute_result_2;
+ compiler_pure_attribute_result = compiler_pure_attribute_func();
+ compiler_pure_attribute_result_2 =
+ compiler_pure_attribute_func();
+
+ /*
+ * It cannot be checked that the RTEMS_COMPILER_PURE_ATTRIBUTE macro has the
+ * desired effect. It is checked that such a macro exists.
+ */
+ T_step_eq_int( 38, compiler_pure_attribute_result, 21 );
+ T_step_eq_int( 39, compiler_pure_attribute_result_2, 21 );
+}
+
+/**
+ * @brief Use the RTEMS_COMPILER_UNUSED_ATTRIBUTE macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_14( void )
+{
+ int compiler_unused_attribute_var RTEMS_COMPILER_UNUSED_ATTRIBUTE;
+
+ /*
+ * It cannot automatically be checked that the
+ * RTEMS_COMPILER_UNUSED_ATTRIBUTE macro has the desired effect. It is
+ * checked that such a macro exists and one can manually check that no
+ * compiler warnings are produced for the compiler_unused_attribute_var.
+ */
+
+}
+
+/**
+ * @brief Invoke the RTEMS_CONCAT() macro on examples.
+ */
+static void RtemsBasedefsValBasedefs_Action_15( void )
+{
+ int concat0_result;
+ int concat1_result;
+ concat0_result = RTEMS_CONCAT( con, cat )();
+ concat1_result = RTEMS_CONCAT( abc, cat )();
+
+ /*
+ * Check that the two arguments of RTEMS_CONCAT() are concatenated to a new
+ * token.
+ */
+ T_step_eq_int( 40, concat0_result, 91 );
+
+ /*
+ * Check that the result of the RTEMS_CONCAT() expansion is subject to a
+ * further pre-processor substitution.
+ */
+ T_step_eq_int( 41, concat1_result, 91 );
+}
+
+/**
+ * @brief Use the RTEMS_CONST macro at the beginning of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_16( void )
+{
+ int const_result;
+ int const_result_2;
+ const_result = const_func( 7 );
+ const_result_2 = const_func( 7 );
+
+ /*
+ * It cannot be checked that the RTEMS_CONST macro has the desired effect. It
+ * is checked that such a macro exists.
+ */
+ T_step_eq_int( 42, const_result, 28 );
+ T_step_eq_int( 43, const_result_2, 28 );
+}
+
+/**
+ * @brief Use the RTEMS_CONTAINER_OF() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_17( void )
+{
+ typedef struct {
+ int a;
+ int b;
+ } container_of_struct;
+
+ container_of_struct container_of_struct_var;
+ int *container_of_struct_b_adr = &container_of_struct_var.b;
+ container_of_struct *container_of_struct_adr;
+ container_of_struct_adr =
+ RTEMS_CONTAINER_OF( container_of_struct_b_adr, container_of_struct, b );
+
+ /*
+ * Check that the RTEMS_CONTAINER_OF() macro evaluates to a pointer to
+ * container_of_struct_var.
+ */
+ T_step_eq_ptr( 44,
+ container_of_struct_adr, &container_of_struct_var );
+}
+
+/**
+ * @brief Use the RTEMS_DECLARE_GLOBAL_SYMBOL() macro in the file
+ * tc-basedefs-pendant.h.
+ */
+static void RtemsBasedefsValBasedefs_Action_18( void )
+{
+ /* No action */
+
+ /*
+ * Check that the RTEMS_DECLARE_GLOBAL_SYMBOL() macro declares a global
+ * symbol which can be accessed by function basedefs_get_global_symbol()
+ * 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 );
+}
+
+/**
+ * @brief Use the RTEMS_DECONST() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_19( void )
+{
+ const int deconst_array[] = { 52, 55 };
+ int *deconst_pointer;
+ deconst_pointer = RTEMS_DECONST( int *, deconst_array );
+
+ /*
+ * Check that the RTEMS_DECONST() macro returns a pointer which allows to
+ * write into an otherwise const value.
+ */
+ T_step_eq_int( 46, deconst_pointer[0], 52 );
+ T_step_eq_int( 47, deconst_pointer[1], 55 );
+ deconst_pointer[1] = 13;
+ T_step_eq_int( 48, deconst_pointer[1], 13 );
+}
+
+/**
+ * @brief Use the RTEMS_DEFINE_GLOBAL_SYMBOL() macro at the beginning of this
+ * file.
+ */
+static void RtemsBasedefsValBasedefs_Action_20( void )
+{
+ /* No action */
+
+ /*
+ * 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 );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_DEPRECATED macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_21( void )
+{
+ int deprecated_result;
+ /*
+ * Derivation from Coding Style:
+ * The following code suppresses a compiler warning (instead of fixing it).
+ * Rational: The function deprecated_func() is not really deprecated
+ * but its purpose is to test the RTEMS_DEPRECATED macro.
+ * The RTEMS_DEPRECATED macro must result in a compiler warning here.
+ */
+ _Pragma( "GCC diagnostic push" )
+ _Pragma( "GCC diagnostic ignored \"-Wdeprecated-declarations\"" )
+ deprecated_result = deprecated_func( 5 );
+ _Pragma( "GCC diagnostic pop" )
+
+ /*
+ * It cannot automatically be checked that the RTEMS_DEPRECATED macro has the
+ * desired effect. The gcc compiler should issue a warning about the use of a
+ * deprecated function on the above line where the ``deprecated_func`` is
+ * used.
+ */
+ T_step_eq_int( 50, deprecated_result, 15 );
+}
+
+/**
+ * @brief Use the RTEMS_DEQUALIFY_DEPTHX() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_22( void )
+{
+ const volatile int dequalify_depthx_array[] = { 52, 55 };
+ const char dequalify_depthx_var = 'a';
+ const char *dequalify_depthx_one_pointer = &dequalify_depthx_var;
+ const char **dequalify_depthx_two_pointer =
+ &dequalify_depthx_one_pointer;
+ int *dequalify_depthx_pointer;
+ volatile char **dequalify_depthx_twice_pointer;
+ dequalify_depthx_pointer =
+ RTEMS_DEQUALIFY_DEPTHX( *, int *, dequalify_depthx_array );
+ dequalify_depthx_twice_pointer = RTEMS_DEQUALIFY_DEPTHX(
+ **, volatile char **, dequalify_depthx_two_pointer );
+
+ /*
+ * Check that the RTEMS_DEQUALIFY_DEPTHX() macro returns a pointer which
+ * allows to write into an otherwise const (volatile) value.
+ */
+ T_step_eq_int( 51, dequalify_depthx_pointer[0], 52 );
+ T_step_eq_int( 52, dequalify_depthx_pointer[1], 55 );
+ dequalify_depthx_pointer[0] = 13;
+ T_step_eq_int( 53, dequalify_depthx_pointer[0], 13 );
+ T_step_eq_char( 54, **dequalify_depthx_twice_pointer, 'a' );
+ **dequalify_depthx_twice_pointer = 'Z';
+ T_step_eq_char( 55, **dequalify_depthx_twice_pointer, 'Z' );
+}
+
+/**
+ * @brief Use the RTEMS_DEQUALIFY() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_23( void )
+{
+ const volatile int dequalify_array[] = { 52, 55 };
+ int *dequalify_pointer;
+ dequalify_pointer = RTEMS_DECONST( int *, dequalify_array );
+
+ /*
+ * Check that the RTEMS_DEQUALIFY() macro returns a pointer which allows to
+ * write into an otherwise const volatile value.
+ */
+ T_step_eq_int( 56, dequalify_pointer[0], 52 );
+ T_step_eq_int( 57, dequalify_pointer[1], 55 );
+ dequalify_pointer[0] = 13;
+ T_step_eq_int( 58, dequalify_pointer[0], 13 );
+}
+
+/**
+ * @brief Use the RTEMS_DEVOLATILE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_24( void )
+{
+ volatile int devolatile_array[] = { 52, 55 };
+ int *devolatile_pointer;
+ devolatile_pointer = RTEMS_DEVOLATILE( int *, devolatile_array );
+
+ /*
+ * Check that the RTEMS_DEVOLATILE() macro returns a pointer which allows to
+ * write into an otherwise volatile value.
+ */
+ T_step_eq_int( 59, devolatile_pointer[0], 52 );
+ T_step_eq_int( 60, devolatile_pointer[1], 55 );
+ devolatile_pointer[1] = 13;
+ T_step_eq_int( 61, devolatile_pointer[1], 13 );
+}
+
+/**
+ * @brief Invoke the RTEMS_EXPAND() macro on an example.
+ */
+static void RtemsBasedefsValBasedefs_Action_25( void )
+{
+ int expand_result;
+ expand_result = RTEMS_EXPAND( EXPAND )();
+
+ /*
+ * Check that the argument of RTEMS_EXPAND() is expanded and returned.
+ */
+ T_step_eq_int( 62, expand_result, 82 );
+}
+
+/**
+ * @brief Invoke the FALSE macro on an example.
+ */
+static void RtemsBasedefsValBasedefs_Action_26( void )
+{
+ char *false_result;
+ false_result = _TO_STR( FALSE );
+
+ /*
+ * Check that of FALSE is substituted by 0.
+ */
+ T_step_eq_str( 63, false_result, "0" );
+}
+
+/**
+ * @brief Invoke the RTEMS_HAVE_MEMBER_SAME_TYPE() macro on examples.
+ */
+static void RtemsBasedefsValBasedefs_Action_27( void )
+{
+ typedef union {
+ short s;
+ int **i;
+ char *c;
+ int a[5];
+ } same_type_union;
+ typedef struct {
+ const short u;
+ short v;
+ int *w;
+ char *x;
+ volatile int y[5];
+ int z;
+ } same_type_struct;
+ int same_type_result_0 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, s, same_type_struct, v );
+ int same_type_result_1 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, s, same_type_struct, z );
+ int same_type_result_2 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, i, same_type_struct, w );
+ int same_type_result_3 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, c, same_type_struct, x );
+ int same_type_result_4 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, a, same_type_struct, y );
+ int same_type_result_5 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, s, same_type_union, s );
+ int same_type_result_6 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, i, same_type_union, i );
+ int same_type_result_7 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, s, same_type_struct, y );
+ int same_type_result_8 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, a, same_type_struct, w );
+ int same_type_result_9 = RTEMS_HAVE_MEMBER_SAME_TYPE(
+ same_type_union, s, same_type_struct, u );
+
+ /*
+ * Check that of RTEMS_HAVE_MEMBER_SAME_TYPE() returns 0 and 1 depending on
+ * whether these types are compatible.
+ */
+ T_step_eq_int( 64, same_type_result_0, 1 );
+ T_step_eq_int( 65, same_type_result_1, 0 );
+ T_step_eq_int( 66, same_type_result_2, 0 );
+ T_step_eq_int( 67, same_type_result_3, 1 );
+ T_step_eq_int( 68, same_type_result_4, 1 );
+ T_step_eq_int( 69, same_type_result_5, 1 );
+ T_step_eq_int( 70, same_type_result_6, 1 );
+ T_step_eq_int( 71, same_type_result_7, 0 );
+ T_step_eq_int( 72, same_type_result_8, 0 );
+ T_step_eq_int( 73, same_type_result_9, 1 );
+}
+
+/**
+ * @brief Use the RTEMS_INLINE_ROUTINE in the definition of function
+ * inline_routine_func() at the beginning of this file. Obtain the text the
+ * macro RTEMS_INLINE_ROUTINE produces.
+ */
+static void RtemsBasedefsValBasedefs_Action_28( void )
+{
+ const int inline_routine_step = 74;
+ int inline_routine_result;
+ char *inline_routine_text;
+ inline_routine_result = inline_routine_func( 3 );
+ inline_routine_text = _TO_STR( RTEMS_INLINE_ROUTINE );
+
+ /*
+ * Check that the RTEMS_INLINE_ROUTINE exists and that it produces the
+ * desired text.
+ */
+ if( 0 == strcmp( "static inline", inline_routine_text ) ) {
+ T_step_eq_str( inline_routine_step,
+ inline_routine_text, "static inline" );
+ } else {
+ T_step_eq_str( inline_routine_step,
+ inline_routine_text, "static __inline__" );
+ }
+ T_step_eq_int( 75, inline_routine_result, 8 );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_MALLOCLIKE macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_29( void )
+{
+ void *malloclike_ptr;
+ /*
+ * If this code is not compiled using GNU C, I still have to run a check
+ * to avoid trouble with the {step} counter of the checks.
+ */
+ const char *malloclike_text = "__attribute__((__malloc__))";
+ malloclike_ptr = basedefs_malloclike_func( 102 );
+ basedefs_free( malloclike_ptr );
+ #if defined( __GNUC__ )
+ malloclike_text = remove_white_space( _TO_STR( RTEMS_MALLOCLIKE ) );
+ #endif
+
+ /*
+ * It cannot be checked that the RTEMS_MALLOCLIKE macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a memory function and that it produces the correct code.
+ */
+ T_step_not_null( 76, malloclike_ptr );
+ T_step_eq_str( 77, malloclike_text, "__attribute__((__malloc__))" );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_NO_INLINE macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_30( void )
+{
+ int no_inline_result;
+ /*
+ * If this code is not compiled using GNU C, I still have to run a check
+ * to avoid trouble with the {step} counter of the checks.
+ */
+ const char *no_inline_text = "__attribute__((__noinline__))";
+ no_inline_result = no_inline_func();
+ #if defined( __GNUC__ )
+ no_inline_text = remove_white_space( _TO_STR( RTEMS_NO_INLINE ) );
+ #endif
+
+ /*
+ * It cannot be checked that the RTEMS_NO_INLINE macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and that it can
+ * be used on such a function and that it produces the correct code.
+ */
+ T_step_eq_int( 78, no_inline_result, 75 );
+ T_step_eq_str( 79, no_inline_text, "__attribute__((__noinline__))" );
+}
+
+/**
+ * @brief Use of the RTEMS_NO_RETURN macro at the beginning of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_31( void )
+{
+ (void) no_return_func;
+
+ /*
+ * It cannot be checked that the RTEMS_NO_RETURN macro has the desired
+ * effect. It is only checked that such a macro exists.
+ */
+
+}
+
+/**
+ * @brief Use the RTEMS_NOINIT macro on ``noinit_variable`` at the beginning of
+ * this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_32( void )
+{
+ /* No action */
+
+ /*
+ * It cannot be checked that the RTEMS_NOINIT macro has the desired effect.
+ * Yet, the check confirms that such a macro exists and can be used.
+ */
+ T_step_not_null( 80, &noinit_variable );
+}
+
+/**
+ * @brief Use the RTEMS_OBFUSCATE_VARIABLE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_33( void )
+{
+ short obfuscate_variable = 66;
+ RTEMS_OBFUSCATE_VARIABLE( obfuscate_variable );
+
+ /*
+ * It cannot be checked that the RTEMS_OBFUSCATE_VARIABLE() macro has the
+ * desired effect. Yet, the check confirms that such a macro exists and can
+ * be used.
+ */
+ T_step_eq_int( 81, obfuscate_variable, 66 );
+}
+
+/**
+ * @brief Use the RTEMS_PACKED macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_34( void )
+{
+ int packed_offset;
+ int packed_full_i_offset;
+ int packed_full_j_offset;
+ int packed_enum_size;
+ typedef struct {
+ uint8_t c;
+ RTEMS_PACKED uint32_t i;
+ } packed_struct;
+ typedef struct RTEMS_PACKED {
+ uint8_t c;
+ uint32_t i;
+ uint32_t j;
+ } packed_full_struct;
+ typedef enum RTEMS_PACKED {
+ red = 1,
+ green,
+ yellow,
+ blue = 255
+ } packed_enum;
+ packed_offset = offsetof( packed_struct, i );
+ packed_full_i_offset = offsetof( packed_full_struct, i );
+ packed_full_j_offset = offsetof( packed_full_struct, j );
+ packed_enum_size = sizeof( packed_enum );
+
+ /*
+ * Check that RTEMS_PACKED correctly aligns a structure member.
+ */
+ T_step_eq_int( 82, packed_offset, 1 );
+
+ /*
+ * Check that RTEMS_PACKED correctly aligns all structure members.
+ */
+ T_step_eq_int( 83, packed_full_i_offset, 1 );
+ T_step_eq_int( 84, packed_full_j_offset, 5 );
+
+ /*
+ * Check that RTEMS_PACKED correctly enforces a minimal enum type.
+ */
+ T_step_eq_int( 85, packed_enum_size, 1 );
+}
+
+/**
+ * @brief Use the RTEMS_PREDICT_FALSE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_35( void )
+{
+ /* No action */
+
+ /*
+ * It cannot be checked that the RTEMS_PREDICT_FALSE() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and can be used.
+ */
+ T_step_eq_int( 86, RTEMS_PREDICT_FALSE( PREDICT_FALSE 1 ), 0 );
+}
+
+/**
+ * @brief Use the RTEMS_PREDICT_TRUE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_36( void )
+{
+ /* No action */
+
+ /*
+ * It cannot be checked that the RTEMS_PREDICT_TRUE() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and can be used.
+ */
+ T_step_eq_int( 87, RTEMS_PREDICT_TRUE( 6 - 5 ), 1 );
+}
+
+/**
+ * @brief Use a function declared with the RTEMS_PRINTFLIKE() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_37( void )
+{
+ int printflike_result;
+ printflike_result = printflike_func(
+ "RTEMS_PRINTFLIKE",
+ "%d %lx %s\n",
+ 123,
+ 0xABCDEFL,
+ "test output"
+ );
+
+ /*
+ * It cannot automatically be checked that the RTEMS_PRINTFLIKE() macro has
+ * the desired effect. Yet, the check confirms that such a macro exists and
+ * that it can be used on such a printf-like function and that the argument
+ * numbers are correct.
+ */
+ T_step_eq_int( 88, printflike_result, 23 );
+}
+
+/**
+ * @brief Use the RTEMS_PURE macro at the beginning of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_38( void )
+{
+ int pure_result;
+ int pure_result_2;
+ pure_result = pure_func();
+ pure_result_2 = pure_func();
+
+ /*
+ * It cannot be checked that the RTEMS_PURE macro has the desired effect. It
+ * is checked that such a macro exists.
+ */
+ T_step_eq_int( 89, pure_result, 21 );
+ T_step_eq_int( 90, pure_result_2, 21 );
+}
+
+/**
+ * @brief Get the code the RTEMS_RETURN_ADDRESS() macro produces as string.
+ */
+static void RtemsBasedefsValBasedefs_Action_39( void )
+{
+ /*
+ * If this code is not compiled using GNU C, I still have to run a check
+ * to avoid trouble with the {step} counter of the checks.
+ */
+ const char *return_address_text = "__builtin_return_address(0)";
+ #if defined( __GNUC__ )
+ return_address_text =
+ remove_white_space( _TO_STR( RTEMS_RETURN_ADDRESS() ) );
+ #endif
+
+ /*
+ * The check confirms that a RTEMS_RETURN_ADDRESS() macro exists and that it
+ * produces the correct code.
+ */
+ T_step_eq_str( 91,
+ return_address_text, "__builtin_return_address(0)" );
+}
+
+/**
+ * @brief Use the RTEMS_SECTION() macro on ``section_variable`` and
+ * ``section_func`` at the beginning of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_40( void )
+{
+ short section_result;
+ section_result = section_func( 1234567 );
+
+ /*
+ * It cannot be checked that the RTEMS_SECTION() macro has the desired
+ * effect. Yet, the check confirms that such a macro exists and can be used.
+ */
+ T_step_eq_int( 92, section_var, 28 );
+ T_step_eq_int( 93, section_result, 67 );
+}
+
+/**
+ * @brief Use the RTEMS_STATIC_ANALYSIS macro.
+ */
+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
+ #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.
+ */
+ #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
+}
+
+/**
+ * @brief Use the RTEMS_STATIC_ASSERT() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_43( void )
+{
+ RTEMS_STATIC_ASSERT( STATIC_ASSERT_COND 1, RTEMS_STATIC_ASSERT_test );
+
+ /*
+ * It cannot be automatically check that the RTEMS_STATIC_ASSERT() macro has
+ * the desired effect. Yet, it can be checked that the macro exists and
+ * accepts the specified arguments.
+ */
+
+}
+
+/**
+ * @brief Use the RTEMS_STRING() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_44( void )
+{
+ const char *string_var;
+ const char *string_empty_var;
+ const char *string_multi_args_var;
+ /* strange spacing and tabs belong to the test */
+ string_var = RTEMS_STRING( \\ STRING_PREFIX cat""\n );
+ string_empty_var = RTEMS_STRING();
+ string_multi_args_var = RTEMS_STRING( STRING_PREFIX, "abc", DEF );
+
+ /*
+ * 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,
+ "STRING_PREFIX, \"abc\", DEF" );
+}
+
+/**
+ * @brief Use the RTEMS_SYMBOL_NAME() macro with an example object.
+ */
+static void RtemsBasedefsValBasedefs_Action_45( void )
+{
+ /* Nothing to do */
+
+ /*
+ * Check that the RTEMS_SYMBOL_NAME() macro expands to the expected symbol
+ * name.
+ */
+ T_step_eq_ptr( 97, &global_object, &address_of_global_object );
+}
+
+/**
+ * @brief Invoke the TRUE macro on an example.
+ */
+static void RtemsBasedefsValBasedefs_Action_46( void )
+{
+ char *true_result;
+ true_result = _TO_STR( TRUE );
+
+ /*
+ * Check that of TRUE is substituted by 0.
+ */
+ T_step_eq_str( 98, true_result, "1" );
+}
+
+/**
+ * @brief Use of the RTEMS_TYPEOF_REFX() macro on several examples. This use
+ * 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 )
+{
+ int type_refx_val = 7;
+ char type_refx_chr = 'c';
+ char *type_refx_chr_p = &type_refx_chr;
+ char **type_refx_chr_pp = &type_refx_chr_p;
+ const short type_refx_const_val = 333;
+ RTEMS_TYPEOF_REFX( *, int *) type_refx_x_int = 8;
+ RTEMS_TYPEOF_REFX( **, int **) type_refx_xx_int = 9;
+ RTEMS_TYPEOF_REFX( ***, int ***) type_refx_xxx_int = 10;
+ RTEMS_TYPEOF_REFX( **, int ***) type_refx_xxx_int_p = &type_refx_val;
+ RTEMS_TYPEOF_REFX( **, &type_refx_chr_p) type_refx_ax_char = 'd';
+ RTEMS_TYPEOF_REFX( *, type_refx_chr_p) type_refx_x_char = 'e';
+ RTEMS_TYPEOF_REFX( , *type_refx_chr_p) type_refx_char = 'f';
+ RTEMS_TYPEOF_REFX( *, type_refx_chr_pp[0]) type_refx_xx_char = 'g';
+ RTEMS_TYPEOF_REFX( *, const short **)
+ type_refx_xx_const_short_p = &type_refx_const_val;
+
+ /*
+ * 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 );
+}
+
+/**
+ * @brief Use the RTEMS_UNUSED macro. See also unused_func() at the beginning
+ * of this file.
+ */
+static void RtemsBasedefsValBasedefs_Action_48( void )
+{
+ int unused_var RTEMS_UNUSED;
+ typedef struct RTEMS_UNUSED {
+ char c;
+ int i;
+ } unused_struct_t;
+ unused_struct_t unused_struct = { '@', 13 };
+
+ /*
+ * It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_func().
+ */
+
+
+ /*
+ * It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_lable.
+ */
+ unused_lable:
+ RTEMS_UNUSED;
+
+ /*
+ * It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the
+ * unused_struct.
+ */
+
+
+ /*
+ * It cannot automatically be checked that the RTEMS_UNUSED macro has the
+ * desired effect. It is checked that such a macro exists and one can
+ * manually check that no compiler warnings are produced for the unused items
+ * unused_var and the unused argument and variable in unused_func().
+ */
+
+}
+
+/**
+ * @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 )
+{
+ int unreachable_result;
+ unreachable_result = unreachable_func(2101);
+
+ /*
+ * It cannot be checked that the RTEMS_UNREACHABLE() macro has the desired
+ * 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 );
+}
+
+/**
+ * @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 )
+{
+ /* No action */
+
+ /*
+ * It cannot be checked that the RTEMS_USED macro has the desired effect. It
+ * is checked that such a macro exists.
+ */
+
+}
+
+/**
+ * @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 )
+{
+ int warn_unused_result;
+ warn_unused_result = warn_unused_func( 33 );
+ /*
+ * Derivation from Coding Style:
+ * The following code suppresses a compiler warning (instead of fixing
+ * it).
+ * Rational: Ignoring the function warn_unused_func() result is not really
+ * a bug but its purpose is to test the RTEMS_WARN_UNUSED_RESULT macro.
+ * The RTEMS_WARN_UNUSED_RESULT macro must result in a compiler warning
+ * here.
+ */
+ _Pragma( "GCC diagnostic push" )
+ _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
+ warn_unused_func( 66 );
+ _Pragma( "GCC diagnostic pop" )
+
+ /*
+ * It cannot be checked that the RTEMS_WARN_UNUSED_RESULT macro has the
+ * desired effect. The GNU C compiler should issue a warning about the
+ * disregarded result returned by the call to the ``warn_unused_func()``
+ * function.
+ */
+ T_step_eq_int( 111, 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 )
+{
+ int weak_alias_0_result;
+ int weak_alias_1_result;
+ weak_alias_0_result = ori_func( 3 ) + basedefs_weak_alias_0_func( 5 );
+ weak_alias_1_result = ori_func( 3 ) + basedefs_weak_alias_1_func( 5 );
+
+ /*
+ * 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 );
+
+ /*
+ * 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 );
+}
+
+/**
+ * @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 )
+{
+ int weak_0_result;
+ int weak_1_result;
+ weak_0_result = basedefs_weak_0_func();
+ weak_1_result = basedefs_weak_1_func();
+
+ /*
+ * For ``basedefs_weak_0_var`` and ``basedefs_weak_0_func()`` there exists no
+ * 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 );
+
+ /*
+ * ``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 );
+}
+
+/**
+ * @brief Invoke the RTEMS_XCONCAT() macro on examples.
+ */
+static void RtemsBasedefsValBasedefs_Action_54( void )
+{
+ int xconcat0_result;
+ int xconcat1_result;
+ int xconcat2_result;
+ int xconcat3_result;
+ xconcat0_result = RTEMS_XCONCAT( con, cat )();
+ xconcat1_result = RTEMS_XCONCAT( CON, CAT )();
+ xconcat2_result =
+ RTEMS_XCONCAT( RTEMS_XCONCAT( CO, N ), RTEMS_XCONCAT( ca, t ) )();
+ xconcat3_result = RTEMS_CONCAT( def, cat )();
+
+ /*
+ * Check that the two arguments of RTEMS_XCONCAT() are concatenated without
+ * inserting new characters.
+ */
+ T_step_eq_int( 118, 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 );
+
+ /*
+ * Check that the two arguments of RTEMS_XCONCAT() are can be the macro
+ * itself.
+ */
+ T_step_eq_int( 120, 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 );
+}
+
+/**
+ * @brief Use the RTEMS_XSTRING() macro.
+ */
+static void RtemsBasedefsValBasedefs_Action_55( void )
+{
+ const char *xstring_var;
+ const char *xstring_empty_var;
+ const char *string_multi_args_var;
+ /* strange spacing and tabs belong to the test */
+ xstring_var = RTEMS_XSTRING( \\ STRING_PREFIX cat""\n );
+ xstring_empty_var = RTEMS_XSTRING();
+ string_multi_args_var = RTEMS_XSTRING( STRING_PREFIX, abc, "abc", DEF );
+
+ /*
+ * 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,
+ "str, ABC, \"abc\", DEF" );
+}
+
+/**
+ * @brief Use of the RTEMS_ZERO_LENGTH_ARRAY macro in a declaration of a
+ * structure.
+ */
+static void RtemsBasedefsValBasedefs_Action_56( void )
+{
+ typedef struct {
+ char chr;
+ int array[RTEMS_ZERO_LENGTH_ARRAY];
+ } zero_length_struct_0;
+ typedef struct {
+ char chr;
+ int array[1];
+ } zero_length_struct_1;
+
+ /*
+ * 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 ),
+ sizeof( zero_length_struct_1 ) - sizeof( int ) );
+ T_step_eq_sz( 126, offsetof( zero_length_struct_0, chr ),
+ offsetof( zero_length_struct_1, chr ) );
+ T_step_eq_sz( 127, offsetof( zero_length_struct_0, array ),
+ offsetof( zero_length_struct_1, array ) );
+}
+
+/**
+ * @fn void T_case_body_RtemsBasedefsValBasedefs( void )
+ */
+T_TEST_CASE( RtemsBasedefsValBasedefs )
+{
+ T_plan( 128 );
+
+ RtemsBasedefsValBasedefs_Action_0();
+ RtemsBasedefsValBasedefs_Action_1();
+ RtemsBasedefsValBasedefs_Action_2();
+ RtemsBasedefsValBasedefs_Action_3();
+ RtemsBasedefsValBasedefs_Action_4();
+ RtemsBasedefsValBasedefs_Action_5();
+ RtemsBasedefsValBasedefs_Action_6();
+ RtemsBasedefsValBasedefs_Action_7();
+ RtemsBasedefsValBasedefs_Action_8();
+ RtemsBasedefsValBasedefs_Action_9();
+ RtemsBasedefsValBasedefs_Action_10();
+ RtemsBasedefsValBasedefs_Action_11();
+ RtemsBasedefsValBasedefs_Action_12();
+ RtemsBasedefsValBasedefs_Action_13();
+ RtemsBasedefsValBasedefs_Action_14();
+ RtemsBasedefsValBasedefs_Action_15();
+ RtemsBasedefsValBasedefs_Action_16();
+ RtemsBasedefsValBasedefs_Action_17();
+ RtemsBasedefsValBasedefs_Action_18();
+ RtemsBasedefsValBasedefs_Action_19();
+ RtemsBasedefsValBasedefs_Action_20();
+ RtemsBasedefsValBasedefs_Action_21();
+ RtemsBasedefsValBasedefs_Action_22();
+ RtemsBasedefsValBasedefs_Action_23();
+ RtemsBasedefsValBasedefs_Action_24();
+ RtemsBasedefsValBasedefs_Action_25();
+ RtemsBasedefsValBasedefs_Action_26();
+ RtemsBasedefsValBasedefs_Action_27();
+ RtemsBasedefsValBasedefs_Action_28();
+ RtemsBasedefsValBasedefs_Action_29();
+ RtemsBasedefsValBasedefs_Action_30();
+ RtemsBasedefsValBasedefs_Action_31();
+ RtemsBasedefsValBasedefs_Action_32();
+ RtemsBasedefsValBasedefs_Action_33();
+ RtemsBasedefsValBasedefs_Action_34();
+ RtemsBasedefsValBasedefs_Action_35();
+ RtemsBasedefsValBasedefs_Action_36();
+ RtemsBasedefsValBasedefs_Action_37();
+ RtemsBasedefsValBasedefs_Action_38();
+ RtemsBasedefsValBasedefs_Action_39();
+ RtemsBasedefsValBasedefs_Action_40();
+ RtemsBasedefsValBasedefs_Action_41();
+ RtemsBasedefsValBasedefs_Action_42();
+ RtemsBasedefsValBasedefs_Action_43();
+ RtemsBasedefsValBasedefs_Action_44();
+ RtemsBasedefsValBasedefs_Action_45();
+ RtemsBasedefsValBasedefs_Action_46();
+ RtemsBasedefsValBasedefs_Action_47();
+ RtemsBasedefsValBasedefs_Action_48();
+ RtemsBasedefsValBasedefs_Action_49();
+ RtemsBasedefsValBasedefs_Action_50();
+ RtemsBasedefsValBasedefs_Action_51();
+ RtemsBasedefsValBasedefs_Action_52();
+ RtemsBasedefsValBasedefs_Action_53();
+ RtemsBasedefsValBasedefs_Action_54();
+ RtemsBasedefsValBasedefs_Action_55();
+ RtemsBasedefsValBasedefs_Action_56();
+}
+
+/** @} */
More information about the vc
mailing list