deprecated.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can be
 * obtained from https://opensource.org/licenses/mit.
 *
 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
 * released under the terms of the Boost Version 1.0 Software License,
 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if __has_include("micro-os-plus/project-config.h")
#include "micro-os-plus/project-config.h"
#endif // __has_include("micro-os-plus/project-config.h")
 
#if __has_include("micro-os-plus/micro-test-plus-defines.h")
#include "micro-os-plus/micro-test-plus-defines.h"
#endif // __has_include("micro-os-plus/micro-test-plus-defines.h")
 
#include "counters.h"
#include "extension.h"
#include "function-comparators.h"
#include "math.h"
#include "reflection.h"
#include "runner.h"
#include "stopwatch.h"
#include "test.h"
 
#include <array>
#include <concepts>
#include <cstdint>
#include <ctime>
#include <limits>
#include <string_view>
#include <type_traits>
 
// ----------------------------------------------------------------------------
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#pragma GCC diagnostic ignored "-Waggregate-return"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wpadded"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wc++20-compat"
#pragma clang diagnostic ignored "-Wdocumentation"
#pragma clang diagnostic ignored "-Wpre-c++17-compat"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------
  // The value wrappers and the parsing of the numeric literals, used only
  // by the deprecated literals and value wrappers, and the constants that
  // they define (moved here from `values.h` and `math.h`).
 
  namespace detail::math
  {
    template <class T, class Exp_T>
    [[nodiscard]] constexpr auto
    pow (const T base, const Exp_T exp) noexcept -> T;

    template <bool Fraction, char... Cs>
    [[nodiscard]] consteval auto
    count_literal_digits (void) -> std::size_t;

    template <class T, char... Cs>
    [[nodiscard]] consteval auto
    num (void) -> T;

    template <class T, char... Cs>
    [[nodiscard]] consteval auto
    den (void) -> T;

    template <class T, char... Cs>
    [[nodiscard]] consteval auto
    den_size (void) -> T;

    template <class T, class Value_T>
    [[nodiscard]] constexpr auto
    count_decimals (Value_T value) -> T;

    template <class Value_T>
    [[nodiscard]] constexpr auto
    decimal_epsilon (Value_T value) -> Value_T;

    struct integer_literal
    {
      unsigned long long value;

      bool is_integer;

      bool is_too_large;
    };

    template <char... Cs>
    [[nodiscard]] consteval auto
    parse_integer_literal (void) -> integer_literal;

    template <class T, char... Cs>
    [[nodiscard]] consteval auto
    integer_magnitude (void) -> unsigned long long;
 
    // ------------------------------------------------------------------------
  } // namespace detail::math
 
  namespace detail
  {
    // ------------------------------------------------------------------------

    template <class T>
    struct value_base
    {
      using op_type = op;

      using value_type = T;

      constexpr explicit value_base (const T& v) noexcept;

      [[nodiscard]] constexpr explicit
      operator T () const noexcept;

      [[nodiscard]] constexpr const T&
      get (void) const noexcept;
 
    private:
      T value_{};
    };

    template <auto N>
    struct integral_constant : value_base<decltype (N)>
    {
      static constexpr auto value = N;

      constexpr integral_constant (void) noexcept;

      [[nodiscard]] constexpr auto
      operator- () const noexcept;
    };

    template <class T>
    struct integral_min_magnitude
    {
      [[nodiscard]] constexpr auto
      operator- () const noexcept;
    };

    template <class T, char... Cs>
    [[nodiscard]] constexpr auto
    integral_literal (void);

    template <class T, auto N, auto D, auto Size, auto P = 1>
    struct floating_point_constant : op
    {
      static_assert (P == 1 || P == -1,
                     "floating_point_constant: P must be +1 or -1");

      using value_type = T;

      static constexpr auto epsilon = T (1) / math::pow (T (10), Size);

      static constexpr auto value
          = T (P) * (T (N) + (T (D) / math::pow (T (10), Size)));

      [[nodiscard]] constexpr explicit
      operator T () const noexcept;

      [[nodiscard]] constexpr T
      get (void) const noexcept;

      [[nodiscard]] constexpr auto
      operator- () const noexcept;
    };

    template <class T>
    struct value : value_base<T>
    {
      constexpr value (const T& _value) noexcept;
    };

    template <class T>
      requires std::floating_point<T>
    struct value<T> : value_base<T>
    {
      T epsilon = T{};
 
      // Note: These constructor bodies are defined inline rather than
      // out-of-line in deprecated-inlines.h. Clang 16 has a deficiency where
      // it fails to match out-of-line constructor definitions to a
      // `requires`-constrained partial specialisation: it either rejects
      // the `requires` clause on the definition as differing from the
      // declaration, or — when the clause is omitted — incorrectly matches
      // the definition against the primary template instead of this
      // specialisation. Keeping the bodies here avoids both failure modes.

      constexpr value (const T& _value, const T precision) noexcept
          : value_base<T>{ _value }, epsilon{ precision }
      {
      }

      constexpr value (const T& val)
          : value{ val, math::decimal_epsilon (val) }
      {
      }
    };
 
    // ------------------------------------------------------------------------

    struct named_bool : op
    {
      using value_type = bool;

      constexpr explicit named_bool (std::string_view name) noexcept;

      [[nodiscard]] constexpr
      operator value_type () const noexcept;

      [[nodiscard]] constexpr std::string_view
      name (void) const noexcept;
 
    private:
      std::string_view name_;
    };
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------
  // The logical functions, now `negate()`, `all_of()`, and `any_of()`, in
  // `function-comparators.h`.


  template <class Expr_T>
  [[deprecated ("use negate() (since 6.0.0)"), nodiscard]] constexpr auto
  _not (Expr_T&& expr);

  template <class Lhs_T, class Rhs_T>
  [[deprecated ("use all_of() (since 6.0.0)"), nodiscard]] constexpr auto
  _and (Lhs_T&& lhs, Rhs_T&& rhs);

  template <class Lhs_T, class Rhs_T>
  [[deprecated ("use any_of() (since 6.0.0)"), nodiscard]] constexpr auto
  _or (Lhs_T&& lhs, Rhs_T&& rhs);
 
  // --------------------------------------------------------------------------
  // The `mut()` helper, not used by the framework.

  template <class T>
  [[deprecated ("use const_cast<T&> (since 6.0.0)"), nodiscard]] constexpr auto
  mut (const T& t) noexcept -> T&;

 
  // --------------------------------------------------------------------------

  namespace operators
  {
    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use eq() (since 6.0.0)"), nodiscard]] constexpr auto
    operator== (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use ne() (since 6.0.0)"), nodiscard]] constexpr auto
    operator!= (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use gt() (since 6.0.0)"), nodiscard]] constexpr auto
    operator> (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use ge() (since 6.0.0)"), nodiscard]] constexpr auto
    operator>= (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use lt() (since 6.0.0)"), nodiscard]] constexpr auto
    operator< (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use le() (since 6.0.0)"), nodiscard]] constexpr auto
    operator<= (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use all_of() (since 6.0.0)"), nodiscard]] constexpr auto
    operator and (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    [[deprecated ("use any_of() (since 6.0.0)"), nodiscard]] constexpr auto
    operator or (Lhs_T&& lhs, Rhs_T&& rhs);

    template <class T>
      requires extension::is_op<std::remove_cvref_t<T>>
    [[deprecated ("use negate() (since 6.0.0)"), nodiscard]] constexpr auto
    operator not(T&& t);
 
    // ------------------------------------------------------------------------
  } // namespace operators
 
  // --------------------------------------------------------------------------

  namespace literals
  {
    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_i ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_s ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_c ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_sc ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_l ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_ll ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_u ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_uc ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_us ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_ul ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_ull ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_i8 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_i16 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_i32 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_i64 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_u8 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_u16 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_u32 ();

    template <char... Cs>
    [[deprecated (
          "pass plain values to eq() and the other comparators (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_u64 ();

    template <char... Cs>
    [[deprecated ("use approx() for tolerances (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_f ();

    template <char... Cs>
    [[deprecated ("use approx() for tolerances (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_d ();

    template <char... Cs>
    [[deprecated ("use approx() for tolerances (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_ld ();

    [[deprecated ("use a plain bool and a check message (since 6.0.0)"),
      nodiscard]] constexpr auto
    operator""_b (const char* name, decltype (sizeof ("")) size);
 
    // ------------------------------------------------------------------------
  } // namespace literals
 
  // --------------------------------------------------------------------------



  using to_b [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<bool>;

  using to_c [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<char>;

  using to_sc [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<signed char>;

  using to_s [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<short>;

  using to_i [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<int>;

  using to_l [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<long>;

  using to_ll [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<long long>;

  using to_u [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<unsigned>;

  using to_uc [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<unsigned char>;

  using to_us [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<unsigned short>;

  using to_ul [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<unsigned long>;

  using to_ull [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<unsigned long long>;

  using to_i8 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::int8_t>;

  using to_i16 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::int16_t>;

  using to_i32 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::int32_t>;

  using to_i64 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::int64_t>;

  using to_u8 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::uint8_t>;

  using to_u16 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::uint16_t>;

  using to_u32 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::uint32_t>;

  using to_u64 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = detail::value<std::uint64_t>;

  using to_f [[deprecated ("use approx() for tolerances (since 6.0.0)")]]
  = detail::value<float>;

  using to_d [[deprecated ("use approx() for tolerances (since 6.0.0)")]]
  = detail::value<double>;

  using to_ld [[deprecated ("use approx() for tolerances (since 6.0.0)")]]
  = detail::value<long double>;



   * encapsulated value is treated as the specified type within the framework,
   * for the types without a `to_*` alias, including the application types;
   * with the operators of the `operators` namespace, the comparisons are
   * then reported with their operands.
   *
   * @par Example
   *
   * @code
   * namespace mt = micro_os_plus::micro_test_plus;
   *
   * MyType obj;
   * // Explicitly treat obj as MyType for test comparison.
   * auto wrapped = mt::to_t<MyType>{obj};
   * @endcode
   *
   * @par Replacement
   * Pass the plain value to the function comparators `eq()`, `ne()`,
   * `gt()`, `ge()`, `lt()`, and `le()` instead; the application types
   * are reported with the `operator<<` of `expression_formatter`.
   *
   * @headerfile micro-test-plus.h "micro-os-plus/micro-test-plus.h"
   */
  template <class T>
  struct [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  to_t : detail::value<T>
  {
    constexpr explicit to_t (const T& t);
  };


  template <class T>
    requires std::is_floating_point_v<T>
  [[deprecated ("use approx (lhs, rhs, epsilon) (since 6.0.0)"),
    nodiscard]] constexpr auto
  approx (T value, std::type_identity_t<T> epsilon) noexcept
      -> detail::value<T>;

 
#if defined(__GNUC__)
#pragma GCC diagnostic push
// The aliases refer to the `to_*` names, deprecated too.
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__)



  using _b [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_b;

  using _c [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_c;

  using _sc [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_sc;

  using _s [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_s;

  using _i [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_i;

  using _l [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_l;

  using _ll [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_ll;

  using _u [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_u;

  using _uc [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_uc;

  using _us [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_us;

  using _ul [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_ul;

  using _ull [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_ull;

  using _i8 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_i8;

  using _i16 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_i16;

  using _i32 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_i32;

  using _i64 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_i64;

  using _u8 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_u8;

  using _u16 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_u16;

  using _u32 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_u32;

  using _u64 [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_u64;

  using _f [[deprecated ("use approx() for tolerances (since 6.0.0)")]] = to_f;

  using _d [[deprecated ("use approx() for tolerances (since 6.0.0)")]] = to_d;

  using _ld [[deprecated ("use approx() for tolerances (since 6.0.0)")]]
  = to_ld;

  template <class T>
  using _t [[deprecated (
      "pass plain values to eq() and the other comparators (since 6.0.0)")]]
  = to_t<T>;


 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
  // ==========================================================================
  // The test case class, now `test_case`, in `test.h`.


  using subtest [[deprecated ("use test_case (since 6.0.0)")]] = test_case;
 
  // ==========================================================================
  // The runner class, now `runner`, in `runner.h`.

  using static_runner [[deprecated ("use runner (since 6.0.0)")]] = runner;
 
  // --------------------------------------------------------------------------
 
  namespace reflection
  {
    // ------------------------------------------------------------------------
    // Now `utility::extract_file_name()`, in `utility.h`.

    [[deprecated ("use utility::extract_file_name() (since 6.0.0)"),
      nodiscard]] const char*
    short_name (const char* name) noexcept;
 
    // ------------------------------------------------------------------------
  } // namespace reflection
 
  // --------------------------------------------------------------------------
 
  namespace detail
  {
    // ========================================================================
    // The counters class, now `counters`, in `counters.h`.

     *
     * @details
     * The v5.0.1 name of the class returned by `totals()`, renamed since
     * the suites and the test cases own one too, not only the runner.
     */
    using runner_totals [[deprecated ("use counters (since 6.0.0)")]]
    = counters;
 
    // ========================================================================
    // The timings classes, now `stopwatch`, in `stopwatch.h`.

    using timestamps [[deprecated ("the timings are internal (since 6.0.0)")]]
    = stopwatch;
 
    // ========================================================================

    class [[deprecated ("the timings are internal (since 6.0.0)")]] timestamp
    {
    public:
      timestamp (void) noexcept;

      timestamp (const timespec& ts) noexcept;

      timestamp (const timestamp&) = default;

      timestamp (timestamp&&) = default;

      timestamp&
      operator= (const timestamp&)
          = default;

      timestamp&
      operator= (timestamp&&)
          = default;


      ~timestamp () = default;

      [[nodiscard]] bool
      has_clock (void) const noexcept;

      [[nodiscard]] timespec&
      value (void) noexcept;

      [[nodiscard]] const timespec&
      value (void) const noexcept;
 
    protected:
      timespec value_{};
    };
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------
  // The concepts, now in the `extension` namespace, in `extension.h`.
  // Kept last, since the pragma below applies to the rest of the file.

 
  // --------------------------------------------------------------------------
 
#if defined(__GNUC__)
  // GCC reports the partial specialisations of `function_traits` below,
  // since they name the deprecated namespace.
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__)
 
  // --------------------------------------------------------------------------
 
  namespace
      [[deprecated ("use the extension namespace (since 6.0.0)")]] type_traits
  {
    // ------------------------------------------------------------------------
    // Concepts, now in the `extension` and `detail` namespaces.
 
    using extension::any_op;
    using extension::checkable;
    using extension::has_epsilon;
    using extension::is_op;
    using extension::printable;
 
    using detail::container_like;

    template <class T>
    concept has_npos = requires { T::npos; };

     * Restored with its v5.0.1 definition, satisfied by any type with a
     * member named `value`, static or not, including the application
     * types, so that the v5.0.1 code that uses it keeps its result. It
     * is not the concept used by the framework, `detail::has_value`,
     * which is satisfied only by the framework types, so that the
     * application types with a `value` member are compared as values.
     *
     * @deprecated there is no replacement; the concept used by the
     * framework is internal (since 6.0.0)
     */
    template <class T>
    concept has_value = requires (const T& t) { t.value; };

     * @tparam T The type to be checked.
     *
     * @details
     * The v5.0.1 name of `std::floating_point`, which the framework now
     * uses directly.
     *
     * @deprecated use `std::floating_point` (since 6.0.0)
     */
    template <class T>
    concept is_floating_point = std::floating_point<T>;
 
    // ------------------------------------------------------------------------
    // Helpers removed from the framework, restored as in v5.0.1.

    template <class... Types>
    struct list
    {
    };


    template <class T, class... Extra>
    struct identity
    {
       * @details
       * The additional template arguments do not affect it.
       */
      using type = T;
    };


    template <class T>
    struct function_traits
#if !defined(__DOXYGEN__)
        // Hidden from Doxygen, which reports a recursive class relation.
        // https://github.com/doxygen/doxygen/issues/9915
        : function_traits<decltype (&T::operator())>
#endif // !defined(__DOXYGEN__)
    {
    };

     * @brief Deprecated traits of the function pointers.
     *
     * @tparam R The return type.
     * @tparam Args_T The parameter types.
     *
     * @details
     * Exposes the return type and the parameter types of a pointer to a
     * free function.
     *
     * @deprecated not replaced (since 6.0.0)
     */
    template <class R, class... Args_T>
    struct function_traits<R (*) (Args_T...)>
    {

      using result_type = R;

      using args = list<Args_T...>;
    };

     *
     * @tparam R The return type.
     * @tparam Args_T The parameter types.
     *
     * @details
     * Exposes the return type and the parameter types of a function type.
     *
     * @deprecated not replaced (since 6.0.0)
     */
    template <class R, class... Args_T>
    struct function_traits<R (Args_T...)>
    {
      using result_type = R;

      using args = list<Args_T...>;
    };

     * @tparam Args_T The parameter types.
     *
     * @details
     * Exposes the return type and the parameter types of a pointer to a
     * non-`const` member function.
     *
     * @deprecated not replaced (since 6.0.0)
     */
    template <class R, class T, class... Args_T>
    struct function_traits<R (T::*) (Args_T...)>
    {
      using result_type = R;


      using args = list<Args_T...>;
    };

    template <class R, class T, class... Args_T>
    struct function_traits<R (T::*) (Args_T...) const>
    {
      using result_type = R;

      using args = list<Args_T...>;
    };
 
    // ------------------------------------------------------------------------
    // The base of the expressions and the value wrappers, now in `detail`.
 
    using detail::floating_point_constant;
    using detail::integral_constant;
    using detail::op;
    using detail::value;

    template <class T>
    using value_base_ = detail::value_base<T>;

    template <class T>
    using genuine_integral_value = detail::value<T>;
 
    // ------------------------------------------------------------------------
  } // namespace type_traits
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
// ----------------------------------------------------------------------------
 
#endif // defined(__cplusplus)
 
// ============================================================================
// Templates, inlines & constexpr implementations.
 
#include "inlines/deprecated-inlines.h"
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_H_
 
// ----------------------------------------------------------------------------