extension.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_EXTENSION_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_EXTENSION_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 <concepts>
#include <iterator>
#include <memory>
#include <optional>
#include <string_view>
#include <type_traits>
#include <utility>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wdocumentation"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------
 
  namespace detail
  {
    // Forward definitions.
    class expression_formatter;
 
    // ========================================================================

    struct op
    {
      using op_type = op;
    };
 
    // ------------------------------------------------------------------------

    template <class T>
    struct is_bool_wrapper : std::false_type
    {
    };

    template <class T>
      requires std::is_same_v<std::remove_cv_t<T>, bool>
    struct is_bool_wrapper<std::optional<T>> : std::true_type
    {
    };

    template <class T, class Deleter_T>
      requires std::is_same_v<std::remove_cv_t<T>, bool>
    struct is_bool_wrapper<std::unique_ptr<T, Deleter_T>> : std::true_type
    {
    };

    template <class T>
      requires std::is_same_v<std::remove_cv_t<T>, bool>
    struct is_bool_wrapper<std::shared_ptr<T>> : std::true_type
    {
    };

    template <class T>
    concept ambiguous_condition = is_bool_wrapper<std::remove_cv_t<T>>::value;
 
    // ------------------------------------------------------------------------

    template <class T>
    concept suspicious_condition
        = std::is_array_v<T> or std::is_function_v<T>
          or std::is_member_pointer_v<T>
          or (std::is_pointer_v<T>
              and (std::is_function_v<std::remove_pointer_t<T>>
                   or std::is_same_v<
                       std::remove_cv_t<std::remove_pointer_t<T>>, char>
                   or std::is_same_v<
                       std::remove_cv_t<std::remove_pointer_t<T>>, wchar_t>
                   or std::is_same_v<
                       std::remove_cv_t<std::remove_pointer_t<T>>, char8_t>
                   or std::is_same_v<
                       std::remove_cv_t<std::remove_pointer_t<T>>, char16_t>
                   or std::is_same_v<
                       std::remove_cv_t<std::remove_pointer_t<T>>, char32_t>));
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------

  namespace extension
  {
    // ------------------------------------------------------------------------
    // Concepts.

    template <class T>
    concept is_op
        = requires { requires std::same_as<typename T::op_type, detail::op>; };
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
    template <class T>
    concept has_epsilon = is_op<T> and requires (const T& t) { t.epsilon; };
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

    template <class Lhs_T, class Rhs_T>
    concept any_op = is_op<Lhs_T> or is_op<Rhs_T>;

    template <class T>
    concept checkable = is_op<T>
                        or (not detail::suspicious_condition<T>
                            and not detail::ambiguous_condition<T>
                            and requires (const T& t) { t ? true : false; });

    template <class T>
    concept printable = requires (detail::expression_formatter& formatter,
                                  const T& value) { formatter << value; };

    template <class Tag_T, class Lhs_T, class Rhs_T>
    concept compare_tag = requires (const Lhs_T& lhs, const Rhs_T& rhs) {
      requires printable<std::remove_cvref_t<decltype (Tag_T::symbol)>>;
      { Tag_T::apply (lhs, rhs) } -> std::convertible_to<bool>;
    };

    template <class Tag_T, class T>
    concept predicate_tag = requires (const T& operand) {
      requires printable<std::remove_cvref_t<decltype (Tag_T::symbol)>>;
      { Tag_T::apply (operand) } -> std::convertible_to<bool>;
    };
 
    // ------------------------------------------------------------------------
  } // namespace extension
 
  // --------------------------------------------------------------------------
 
  namespace detail
  {
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
    template <class T>
    concept legacy_checkable
        = (not extension::checkable<T>) and suspicious_condition<T>
          and requires (const T& t) { t ? true : false; };
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
    // ------------------------------------------------------------------------
    // Concepts used only by the implementation.

    template <class T>
    concept container_like = requires (const T& t) {
      requires std::input_or_output_iterator<decltype (t.begin ())>;
      requires std::sentinel_for<decltype (t.end ()), decltype (t.begin ())>;
    };

    template <class T>
    concept string_like
        = std::convertible_to<const T&, std::basic_string_view<char>>
          or std::convertible_to<const T&, std::basic_string_view<wchar_t>>
          or std::convertible_to<const T&, std::basic_string_view<char8_t>>
          or std::convertible_to<const T&, std::basic_string_view<char16_t>>
          or std::convertible_to<const T&, std::basic_string_view<char32_t>>;

    template <class T>
    concept free_range = (not container_like<T>) and requires (const T& t) {
      requires std::input_or_output_iterator<decltype (begin (t))>;
      requires std::sentinel_for<decltype (end (t)), decltype (begin (t))>;
    };

    template <class T>
    struct range_element;

    template <class T>
      requires container_like<T>
    struct range_element<T>
    {
      using type = std::remove_cvref_t<
          decltype (*std::declval<const T&> ().begin ())>;
    };

    template <class T>
      requires free_range<T>
    struct range_element<T>
    {
      using type
          = std::remove_cvref_t<decltype (*begin (std::declval<const T&> ()))>;
    };

    template <class T>
    concept formattable_range
        = (container_like<T> or free_range<T>) and (not std::is_array_v<T>)
          and (not string_like<T>)
          and (not std::is_same_v<typename range_element<T>::type, T>)
          and extension::printable<typename range_element<T>::type>;

    template <class T>
    concept lazy_message
        = std::is_class_v<T> and std::invocable<const T&>
          and (not std::is_void_v<std::invoke_result_t<const T&>>)
          and extension::printable<std::invoke_result_t<const T&>>;

    template <class T>
    concept message_argument
        = lazy_message<T>
          or (extension::printable<T>
              and not(std::is_class_v<T> and std::invocable<const T&>));
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
    template <class T>
    concept has_value = extension::is_op<T> and requires { T::value; };
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
// ----------------------------------------------------------------------------
 
#endif // defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_EXTENSION_H_
 
// ----------------------------------------------------------------------------