validation: Test IO Manager

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.

spec/build/testsuites/validation/grp.yml

@@ -42,6 +42,8 @@ links:
   uid: validation-cache
 - role: build-dependency
   uid: validation-intr
+- role: build-dependency
+  uid: validation-io-kernel
 - role: build-dependency
   uid: validation-no-clock-0
 - role: build-dependency

spec/build/testsuites/validation/validation-io-kernel.yml

@@ -0,0 +1,20 @@
+SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
+build-type: test-program
+cflags: []
+copyrights:
+- Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
+cppflags: []
+cxxflags: []
+enabled-by: true
+features: c cprogram
+includes: []
+ldflags: []
+links: []
+source:
+- testsuites/validation/tr-io-kernel.c
+- testsuites/validation/ts-validation-io-kernel.c
+stlib: []
+target: testsuites/validation/ts-validation-io-kernel.exe
+type: build
+use-after: []
+use-before: []

spec/build/testsuites/validation/validation-no-clock-0.yml

@@ -28,6 +28,9 @@ source:
 - testsuites/validation/tc-cpuuse.c
 - testsuites/validation/tc-events.c
 - testsuites/validation/tc-intr.c
+- testsuites/validation/tc-io-getchark.c
+- testsuites/validation/tc-io-putc.c
+- testsuites/validation/tc-io-put-char.c
 - testsuites/validation/tc-score-fatal.c
 - testsuites/validation/tr-event-constant.c
 - testsuites/validation/tr-mtx-seize-try.c

testsuites/validation/tc-io-getchark.c

@@ -0,0 +1,328 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsIoReqGetchark
+ */
+
+/*
+ * 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 <rtems/bspIo.h>
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsIoReqGetchark spec:/rtems/io/req/getchark
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsIoReqGetchark_Pre_PollChar_Valid,
+  RtemsIoReqGetchark_Pre_PollChar_Null,
+  RtemsIoReqGetchark_Pre_PollChar_NA
+} RtemsIoReqGetchark_Pre_PollChar;
+
+typedef enum {
+  RtemsIoReqGetchark_Post_Result_PollChar,
+  RtemsIoReqGetchark_Post_Result_MinusOne,
+  RtemsIoReqGetchark_Post_Result_NA
+} RtemsIoReqGetchark_Post_Result;
+
+typedef enum {
+  RtemsIoReqGetchark_Post_Calls_Once,
+  RtemsIoReqGetchark_Post_Calls_NA
+} RtemsIoReqGetchark_Post_Calls;
+
+typedef struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_PollChar_NA : 1;
+  uint8_t Post_Result : 2;
+  uint8_t Post_Calls : 1;
+} RtemsIoReqGetchark_Entry;
+
+/**
+ * @brief Test context for spec:/rtems/io/req/getchark test case.
+ */
+typedef struct {
+  /**
+   * @brief This member contains the character input count.
+   */
+  size_t input_count;
+
+  /**
+   * @brief This member specifies the value for BSP_poll_char.
+   */
+  BSP_polling_getchar_function_type poll_char;
+
+  /**
+   * @brief This member contains the return value of the getchark() 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.
+     */
+    RtemsIoReqGetchark_Entry entry;
+
+    /**
+     * @brief If this member is true, then the current transition variant
+     *   should be skipped.
+     */
+    bool skip;
+  } Map;
+} RtemsIoReqGetchark_Context;
+
+static RtemsIoReqGetchark_Context
+  RtemsIoReqGetchark_Instance;
+
+static const char * const RtemsIoReqGetchark_PreDesc_PollChar[] = {
+  "Valid",
+  "Null",
+  "NA"
+};
+
+static const char * const * const RtemsIoReqGetchark_PreDesc[] = {
+  RtemsIoReqGetchark_PreDesc_PollChar,
+  NULL
+};
+
+typedef RtemsIoReqGetchark_Context Context;
+
+static int PollChar( void )
+{
+  Context *ctx;
+
+  ctx = T_fixture_context();
+  ++ctx->input_count;
+
+  return 123;
+}
+
+static void RtemsIoReqGetchark_Pre_PollChar_Prepare(
+  RtemsIoReqGetchark_Context     *ctx,
+  RtemsIoReqGetchark_Pre_PollChar state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqGetchark_Pre_PollChar_Valid: {
+      /*
+       * While BSP_poll_char references a function.
+       */
+      ctx->poll_char = PollChar;
+      break;
+    }
+
+    case RtemsIoReqGetchark_Pre_PollChar_Null: {
+      /*
+       * While BSP_poll_char is equal to NULL.
+       */
+      ctx->poll_char = NULL;
+      break;
+    }
+
+    case RtemsIoReqGetchark_Pre_PollChar_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqGetchark_Post_Result_Check(
+  RtemsIoReqGetchark_Context    *ctx,
+  RtemsIoReqGetchark_Post_Result state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqGetchark_Post_Result_PollChar: {
+      /*
+       * The return value of getchark() shall be the return value of the
+       * function referenced by BSP_poll_char.
+       */
+      T_eq_int( ctx->result, 123 );
+      break;
+    }
+
+    case RtemsIoReqGetchark_Post_Result_MinusOne: {
+      /*
+       * The return value of getchark() shall be minus one.
+       */
+      T_eq_int( ctx->result, -1 );
+      T_eq_u32( ctx->input_count, 0 );
+      break;
+    }
+
+    case RtemsIoReqGetchark_Post_Result_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqGetchark_Post_Calls_Check(
+  RtemsIoReqGetchark_Context   *ctx,
+  RtemsIoReqGetchark_Post_Calls state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqGetchark_Post_Calls_Once: {
+      /*
+       * The function referenced by BSP_poll_char shall be called exactly once
+       * to get the return value for getchark().
+       */
+      T_eq_u32( ctx->input_count, 1 );
+      break;
+    }
+
+    case RtemsIoReqGetchark_Post_Calls_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqGetchark_Action( RtemsIoReqGetchark_Context *ctx )
+{
+  BSP_polling_getchar_function_type poll_char;
+
+  ctx->input_count = 0;
+  poll_char = BSP_poll_char;
+  BSP_poll_char = ctx->poll_char;
+  ctx->result = getchark();
+  BSP_poll_char = poll_char;
+}
+
+static const RtemsIoReqGetchark_Entry
+RtemsIoReqGetchark_Entries[] = {
+  { 0, 0, RtemsIoReqGetchark_Post_Result_PollChar,
+    RtemsIoReqGetchark_Post_Calls_Once },
+  { 0, 0, RtemsIoReqGetchark_Post_Result_MinusOne,
+    RtemsIoReqGetchark_Post_Calls_NA }
+};
+
+static const uint8_t
+RtemsIoReqGetchark_Map[] = {
+  0, 1
+};
+
+static size_t RtemsIoReqGetchark_Scope( void *arg, char *buf, size_t n )
+{
+  RtemsIoReqGetchark_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->Map.in_action_loop ) {
+    return T_get_scope( RtemsIoReqGetchark_PreDesc, buf, n, ctx->Map.pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsIoReqGetchark_Fixture = {
+  .setup = NULL,
+  .stop = NULL,
+  .teardown = NULL,
+  .scope = RtemsIoReqGetchark_Scope,
+  .initial_context = &RtemsIoReqGetchark_Instance
+};
+
+static inline RtemsIoReqGetchark_Entry RtemsIoReqGetchark_PopEntry(
+  RtemsIoReqGetchark_Context *ctx
+)
+{
+  size_t index;
+
+  index = ctx->Map.index;
+  ctx->Map.index = index + 1;
+  return RtemsIoReqGetchark_Entries[
+    RtemsIoReqGetchark_Map[ index ]
+  ];
+}
+
+static void RtemsIoReqGetchark_TestVariant( RtemsIoReqGetchark_Context *ctx )
+{
+  RtemsIoReqGetchark_Pre_PollChar_Prepare( ctx, ctx->Map.pcs[ 0 ] );
+  RtemsIoReqGetchark_Action( ctx );
+  RtemsIoReqGetchark_Post_Result_Check( ctx, ctx->Map.entry.Post_Result );
+  RtemsIoReqGetchark_Post_Calls_Check( ctx, ctx->Map.entry.Post_Calls );
+}
+
+/**
+ * @fn void T_case_body_RtemsIoReqGetchark( void )
+ */
+T_TEST_CASE_FIXTURE( RtemsIoReqGetchark, &RtemsIoReqGetchark_Fixture )
+{
+  RtemsIoReqGetchark_Context *ctx;
+
+  ctx = T_fixture_context();
+  ctx->Map.in_action_loop = true;
+  ctx->Map.index = 0;
+
+  for (
+    ctx->Map.pcs[ 0 ] = RtemsIoReqGetchark_Pre_PollChar_Valid;
+    ctx->Map.pcs[ 0 ] < RtemsIoReqGetchark_Pre_PollChar_NA;
+    ++ctx->Map.pcs[ 0 ]
+  ) {
+    ctx->Map.entry = RtemsIoReqGetchark_PopEntry( ctx );
+    RtemsIoReqGetchark_TestVariant( ctx );
+  }
+}
+
+/** @} */

testsuites/validation/tc-io-put-char.c

@@ -0,0 +1,319 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsIoReqPutChar
+ */
+
+/*
+ * 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 <rtems/bspIo.h>
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsIoReqPutChar spec:/rtems/io/req/put-char
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsIoReqPutChar_Pre_Char_Nl,
+  RtemsIoReqPutChar_Pre_Char_Other,
+  RtemsIoReqPutChar_Pre_Char_NA
+} RtemsIoReqPutChar_Pre_Char;
+
+typedef enum {
+  RtemsIoReqPutChar_Post_Output_CrNl,
+  RtemsIoReqPutChar_Post_Output_Other,
+  RtemsIoReqPutChar_Post_Output_NA
+} RtemsIoReqPutChar_Post_Output;
+
+typedef struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_Char_NA : 1;
+  uint8_t Post_Output : 2;
+} RtemsIoReqPutChar_Entry;
+
+/**
+ * @brief Test context for spec:/rtems/io/req/put-char test case.
+ */
+typedef struct {
+  /**
+   * @brief This member contains the character output.
+   */
+  int output[ 2 ];
+
+  /**
+   * @brief This member contains the character output count.
+   */
+  size_t output_count;
+
+  /**
+   * @brief This member specifies if the ``c`` parameter value.
+   */
+  int character;
+
+  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.
+     */
+    RtemsIoReqPutChar_Entry entry;
+
+    /**
+     * @brief If this member is true, then the current transition variant
+     *   should be skipped.
+     */
+    bool skip;
+  } Map;
+} RtemsIoReqPutChar_Context;
+
+static RtemsIoReqPutChar_Context
+  RtemsIoReqPutChar_Instance;
+
+static const char * const RtemsIoReqPutChar_PreDesc_Char[] = {
+  "Nl",
+  "Other",
+  "NA"
+};
+
+static const char * const * const RtemsIoReqPutChar_PreDesc[] = {
+  RtemsIoReqPutChar_PreDesc_Char,
+  NULL
+};
+
+typedef RtemsIoReqPutChar_Context Context;
+
+static void Output( int value )
+{
+  Context *ctx;
+
+  ctx = T_fixture_context();
+
+  if ( ctx->output_count < RTEMS_ARRAY_SIZE( ctx->output ) ) {
+    ctx->output[ ctx->output_count ] = value;
+  }
+
+  ++ctx->output_count;
+}
+
+static void WrongOutput( char c )
+{
+  (void) c;
+  Output( -1 );
+}
+
+static void OutputChar( char c )
+{
+  BSP_output_char = WrongOutput;
+  Output( (unsigned char) c );
+}
+
+static void RtemsIoReqPutChar_Pre_Char_Prepare(
+  RtemsIoReqPutChar_Context *ctx,
+  RtemsIoReqPutChar_Pre_Char state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqPutChar_Pre_Char_Nl: {
+      /*
+       * While the ``c`` parameter is equal to ``NL``.
+       */
+      ctx->character = '\n';
+      break;
+    }
+
+    case RtemsIoReqPutChar_Pre_Char_Other: {
+      /*
+       * While the ``c`` parameter is not equal to ``NL``.
+       */
+      ctx->character = 0xff;
+      break;
+    }
+
+    case RtemsIoReqPutChar_Pre_Char_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqPutChar_Post_Output_Check(
+  RtemsIoReqPutChar_Context    *ctx,
+  RtemsIoReqPutChar_Post_Output state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqPutChar_Post_Output_CrNl: {
+      /*
+       * The function referenced by BSP_output_char shall be called with a
+       * ``CR`` character followed by a call with a ``NL`` character.
+       */
+      T_eq_int( ctx->output[ 0 ], (unsigned char) '\r' );
+      T_eq_int( ctx->output[ 1 ], (unsigned char) '\n' );
+      T_eq_sz( ctx->output_count, 2 );
+      break;
+    }
+
+    case RtemsIoReqPutChar_Post_Output_Other: {
+      /*
+       * The function referenced by BSP_output_char shall be called with the
+       * character specified by ``c``.
+       */
+      T_eq_int( ctx->output[ 0 ], 0xff );
+      T_eq_sz( ctx->output_count, 1 );
+      break;
+    }
+
+    case RtemsIoReqPutChar_Post_Output_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqPutChar_Action( RtemsIoReqPutChar_Context *ctx )
+{
+  BSP_output_char_function_type output_char;
+
+  ctx->output[ 0 ] = -1;
+  ctx->output[ 1 ] = -1;
+  ctx->output_count = 0;
+  output_char = BSP_output_char;
+  BSP_output_char = OutputChar;
+  rtems_put_char( ctx->character, NULL );
+  BSP_output_char = output_char;
+}
+
+static const RtemsIoReqPutChar_Entry
+RtemsIoReqPutChar_Entries[] = {
+  { 0, 0, RtemsIoReqPutChar_Post_Output_CrNl },
+  { 0, 0, RtemsIoReqPutChar_Post_Output_Other }
+};
+
+static const uint8_t
+RtemsIoReqPutChar_Map[] = {
+  0, 1
+};
+
+static size_t RtemsIoReqPutChar_Scope( void *arg, char *buf, size_t n )
+{
+  RtemsIoReqPutChar_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->Map.in_action_loop ) {
+    return T_get_scope( RtemsIoReqPutChar_PreDesc, buf, n, ctx->Map.pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsIoReqPutChar_Fixture = {
+  .setup = NULL,
+  .stop = NULL,
+  .teardown = NULL,
+  .scope = RtemsIoReqPutChar_Scope,
+  .initial_context = &RtemsIoReqPutChar_Instance
+};
+
+static inline RtemsIoReqPutChar_Entry RtemsIoReqPutChar_PopEntry(
+  RtemsIoReqPutChar_Context *ctx
+)
+{
+  size_t index;
+
+  index = ctx->Map.index;
+  ctx->Map.index = index + 1;
+  return RtemsIoReqPutChar_Entries[
+    RtemsIoReqPutChar_Map[ index ]
+  ];
+}
+
+static void RtemsIoReqPutChar_TestVariant( RtemsIoReqPutChar_Context *ctx )
+{
+  RtemsIoReqPutChar_Pre_Char_Prepare( ctx, ctx->Map.pcs[ 0 ] );
+  RtemsIoReqPutChar_Action( ctx );
+  RtemsIoReqPutChar_Post_Output_Check( ctx, ctx->Map.entry.Post_Output );
+}
+
+/**
+ * @fn void T_case_body_RtemsIoReqPutChar( void )
+ */
+T_TEST_CASE_FIXTURE( RtemsIoReqPutChar, &RtemsIoReqPutChar_Fixture )
+{
+  RtemsIoReqPutChar_Context *ctx;
+
+  ctx = T_fixture_context();
+  ctx->Map.in_action_loop = true;
+  ctx->Map.index = 0;
+
+  for (
+    ctx->Map.pcs[ 0 ] = RtemsIoReqPutChar_Pre_Char_Nl;
+    ctx->Map.pcs[ 0 ] < RtemsIoReqPutChar_Pre_Char_NA;
+    ++ctx->Map.pcs[ 0 ]
+  ) {
+    ctx->Map.entry = RtemsIoReqPutChar_PopEntry( ctx );
+    RtemsIoReqPutChar_TestVariant( ctx );
+  }
+}
+
+/** @} */

testsuites/validation/tc-io-putc.c

@@ -0,0 +1,319 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsIoReqPutc
+ */
+
+/*
+ * 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 <rtems/bspIo.h>
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsIoReqPutc spec:/rtems/io/req/putc
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsIoReqPutc_Pre_Char_Nl,
+  RtemsIoReqPutc_Pre_Char_Other,
+  RtemsIoReqPutc_Pre_Char_NA
+} RtemsIoReqPutc_Pre_Char;
+
+typedef enum {
+  RtemsIoReqPutc_Post_Output_CrNl,
+  RtemsIoReqPutc_Post_Output_Other,
+  RtemsIoReqPutc_Post_Output_NA
+} RtemsIoReqPutc_Post_Output;
+
+typedef struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_Char_NA : 1;
+  uint8_t Post_Output : 2;
+} RtemsIoReqPutc_Entry;
+
+/**
+ * @brief Test context for spec:/rtems/io/req/putc test case.
+ */
+typedef struct {
+  /**
+   * @brief This member contains the character output.
+   */
+  int output[ 2 ];
+
+  /**
+   * @brief This member contains the character output count.
+   */
+  size_t output_count;
+
+  /**
+   * @brief This member specifies if the ``c`` parameter value.
+   */
+  char character;
+
+  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.
+     */
+    RtemsIoReqPutc_Entry entry;
+
+    /**
+     * @brief If this member is true, then the current transition variant
+     *   should be skipped.
+     */
+    bool skip;
+  } Map;
+} RtemsIoReqPutc_Context;
+
+static RtemsIoReqPutc_Context
+  RtemsIoReqPutc_Instance;
+
+static const char * const RtemsIoReqPutc_PreDesc_Char[] = {
+  "Nl",
+  "Other",
+  "NA"
+};
+
+static const char * const * const RtemsIoReqPutc_PreDesc[] = {
+  RtemsIoReqPutc_PreDesc_Char,
+  NULL
+};
+
+typedef RtemsIoReqPutc_Context Context;
+
+static void Output( int value )
+{
+  Context *ctx;
+
+  ctx = T_fixture_context();
+
+  if ( ctx->output_count < RTEMS_ARRAY_SIZE( ctx->output ) ) {
+    ctx->output[ ctx->output_count ] = value;
+  }
+
+  ++ctx->output_count;
+}
+
+static void WrongOutput( char c )
+{
+  (void) c;
+  Output( -1 );
+}
+
+static void OutputChar( char c )
+{
+  BSP_output_char = WrongOutput;
+  Output( (unsigned char) c );
+}
+
+static void RtemsIoReqPutc_Pre_Char_Prepare(
+  RtemsIoReqPutc_Context *ctx,
+  RtemsIoReqPutc_Pre_Char state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqPutc_Pre_Char_Nl: {
+      /*
+       * While the ``c`` parameter is equal to ``NL``.
+       */
+      ctx->character = '\n';
+      break;
+    }
+
+    case RtemsIoReqPutc_Pre_Char_Other: {
+      /*
+       * While the ``c`` parameter is not equal to ``NL``.
+       */
+      ctx->character = (char) 0xff;
+      break;
+    }
+
+    case RtemsIoReqPutc_Pre_Char_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqPutc_Post_Output_Check(
+  RtemsIoReqPutc_Context    *ctx,
+  RtemsIoReqPutc_Post_Output state
+)
+{
+  switch ( state ) {
+    case RtemsIoReqPutc_Post_Output_CrNl: {
+      /*
+       * The function referenced by BSP_output_char shall be called with a
+       * ``CR`` character followed by a call with a ``NL`` character.
+       */
+      T_eq_int( ctx->output[ 0 ], (unsigned char) '\r' );
+      T_eq_int( ctx->output[ 1 ], (unsigned char) '\n' );
+      T_eq_sz( ctx->output_count, 2 );
+      break;
+    }
+
+    case RtemsIoReqPutc_Post_Output_Other: {
+      /*
+       * The function referenced by BSP_output_char shall be called with the
+       * character specified by ``c``.
+       */
+      T_eq_int( ctx->output[ 0 ], 0xff );
+      T_eq_sz( ctx->output_count, 1 );
+      break;
+    }
+
+    case RtemsIoReqPutc_Post_Output_NA:
+      break;
+  }
+}
+
+static void RtemsIoReqPutc_Action( RtemsIoReqPutc_Context *ctx )
+{
+  BSP_output_char_function_type output_char;
+
+  ctx->output[ 0 ] = -1;
+  ctx->output[ 1 ] = -1;
+  ctx->output_count = 0;
+  output_char = BSP_output_char;
+  BSP_output_char = OutputChar;
+  rtems_putc( ctx->character );
+  BSP_output_char = output_char;
+}
+
+static const RtemsIoReqPutc_Entry
+RtemsIoReqPutc_Entries[] = {
+  { 0, 0, RtemsIoReqPutc_Post_Output_CrNl },
+  { 0, 0, RtemsIoReqPutc_Post_Output_Other }
+};
+
+static const uint8_t
+RtemsIoReqPutc_Map[] = {
+  0, 1
+};
+
+static size_t RtemsIoReqPutc_Scope( void *arg, char *buf, size_t n )
+{
+  RtemsIoReqPutc_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->Map.in_action_loop ) {
+    return T_get_scope( RtemsIoReqPutc_PreDesc, buf, n, ctx->Map.pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsIoReqPutc_Fixture = {
+  .setup = NULL,
+  .stop = NULL,
+  .teardown = NULL,
+  .scope = RtemsIoReqPutc_Scope,
+  .initial_context = &RtemsIoReqPutc_Instance
+};
+
+static inline RtemsIoReqPutc_Entry RtemsIoReqPutc_PopEntry(
+  RtemsIoReqPutc_Context *ctx
+)
+{
+  size_t index;
+
+  index = ctx->Map.index;
+  ctx->Map.index = index + 1;
+  return RtemsIoReqPutc_Entries[
+    RtemsIoReqPutc_Map[ index ]
+  ];
+}
+
+static void RtemsIoReqPutc_TestVariant( RtemsIoReqPutc_Context *ctx )
+{
+  RtemsIoReqPutc_Pre_Char_Prepare( ctx, ctx->Map.pcs[ 0 ] );
+  RtemsIoReqPutc_Action( ctx );
+  RtemsIoReqPutc_Post_Output_Check( ctx, ctx->Map.entry.Post_Output );
+}
+
+/**
+ * @fn void T_case_body_RtemsIoReqPutc( void )
+ */
+T_TEST_CASE_FIXTURE( RtemsIoReqPutc, &RtemsIoReqPutc_Fixture )
+{
+  RtemsIoReqPutc_Context *ctx;
+
+  ctx = T_fixture_context();
+  ctx->Map.in_action_loop = true;
+  ctx->Map.index = 0;
+
+  for (
+    ctx->Map.pcs[ 0 ] = RtemsIoReqPutc_Pre_Char_Nl;
+    ctx->Map.pcs[ 0 ] < RtemsIoReqPutc_Pre_Char_NA;
+    ++ctx->Map.pcs[ 0 ]
+  ) {
+    ctx->Map.entry = RtemsIoReqPutc_PopEntry( ctx );
+    RtemsIoReqPutc_TestVariant( ctx );
+  }
+}
+
+/** @} */

testsuites/validation/tr-io-kernel.c

@@ -0,0 +1,123 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsIoValKernel
+ */
+
+/*
+ * 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 <rtems/bspIo.h>
+
+#include "tr-io-kernel.h"
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsIoValKernel spec:/rtems/io/val/kernel
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationIoKernel
+ *
+ * @brief Tests the functions referenced by BSP_output_char and BSP_poll_char.
+ *
+ * This test case performs the following actions:
+ *
+ * - Call the function referenced by BSP_output_char.
+ *
+ * - If BSP_poll_char references a function, then call it.
+ *
+ *   - Check that the returned value is minus one or an unsigned character
+ *     value.
+ *
+ * @{
+ */
+
+/**
+ * @brief Call the function referenced by BSP_output_char.
+ */
+static void RtemsIoValKernel_Action_0( void )
+{
+  ( *BSP_output_char )( 'X' );
+  ( *BSP_output_char )( '\n' );
+}
+
+/**
+ * @brief If BSP_poll_char references a function, then call it.
+ */
+static void RtemsIoValKernel_Action_1( void )
+{
+  BSP_polling_getchar_function_type poll_char;
+  int c;
+
+  poll_char = BSP_poll_char;
+
+  if ( poll_char != NULL ) {
+    c = ( *poll_char )();
+  } else {
+    c = -1;
+  }
+
+  /*
+   * Check that the returned value is minus one or an unsigned character value.
+   */
+  T_step_true( 0, c == -1 || ( c & ~0xff ) == 0 );
+}
+
+void RtemsIoValKernel_Run( void )
+{
+  T_case_begin( "RtemsIoValKernel", &T_empty_fixture );
+
+  T_plan( 1 );
+
+  RtemsIoValKernel_Action_0();
+  RtemsIoValKernel_Action_1();
+
+  T_case_end();
+}
+
+/** @} */

testsuites/validation/tr-io-kernel.h

@@ -0,0 +1,75 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsIoValKernel
+ */
+
+/*
+ * 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
+ */
+
+#ifndef _TR_IO_KERNEL_H
+#define _TR_IO_KERNEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup RTEMSTestCaseRtemsIoValKernel
+ *
+ * @{
+ */
+
+/**
+ * @brief Runs the parameterized test case.
+ */
+void RtemsIoValKernel_Run( void );
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TR_IO_KERNEL_H */

testsuites/validation/ts-validation-io-kernel.c

@@ -0,0 +1,149 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationIoKernel
+ */
+
+/*
+ * 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 <bsp/bootcard.h>
+#include <rtems/test-info.h>
+#include <rtems/test.h>
+#include <rtems/testopts.h>
+
+#include "tr-io-kernel.h"
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestSuiteTestsuitesValidationIoKernel \
+ *   spec:/testsuites/validation-io-kernel
+ *
+ * @ingroup RTEMSTestSuites
+ *
+ * @brief This validation test suite contains test cases which test the kernel
+ *   character input/output device provided by the BSP before the system
+ *   initialization is performed.
+ *
+ * @{
+ */
+
+const char rtems_test_name[] = "ValidationIoKernel";
+
+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,
+  .action_count = T_ARRAY_SIZE( actions ),
+  .actions = actions
+};
+
+void boot_card( const char *cmdline )
+{
+  uint32_t exit_code;
+
+  (void) cmdline;
+
+  rtems_test_begin( rtems_test_name, TEST_STATE );
+  T_run_initialize( &test_config );
+  RtemsIoValKernel_Run();
+
+  if ( T_run_finalize() ) {
+    rtems_test_end( rtems_test_name );
+    exit_code = 0;
+  } else {
+    exit_code = 1;
+  }
+
+  rtems_fatal( RTEMS_FATAL_SOURCE_EXIT, exit_code );
+}
+
+static void *IdleBody( uintptr_t ignored )
+{
+  (void) ignored;
+
+  while ( true ) {
+    /* Do nothing */
+  }
+
+  return NULL;
+}
+
+#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
+
+#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 0
+
+#define CONFIGURE_DISABLE_NEWLIB_REENTRANCY
+
+#define CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
+
+#define CONFIGURE_SCHEDULER_USER
+
+#define CONFIGURE_SCHEDULER
+
+#define CONFIGURE_SCHEDULER_TABLE_ENTRIES { }
+
+#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
+
+#define CONFIGURE_IDLE_TASK_BODY IdleBody
+
+#define CONFIGURE_INIT
+
+#include <rtems/confdefs.h>
+
+/** @} */