check-result-inlines.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.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_CHECK_RESULT_INLINES_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_CHECK_RESULT_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if __has_include("micro-os-plus/diag/trace.h")
#include "micro-os-plus/diag/trace.h"
#endif // __has_include("micro-os-plus/diag/trace.h")
 
#include <concepts>
#include <cstdio>
#include <functional>
#include <utility>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------
 
  namespace detail
  {
    // ========================================================================

    template <class Expr_T>
    void
    check_result::init (const Expr_T& expr, check_kind kind,
                        const reflection::source_location& location,
                        test_case& test_case, expression_formatter& expression,
                        bool writes_passed)
    {
      start (static_cast<bool> (expr), kind, extension::is_op<Expr_T>,
             location, test_case, writes_passed);
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
      trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
      // The same address is used by the destructor, to retrieve the text,
      // even if other checks used the formatter in the meantime.
      expression.begin_check (this);
 
      if (is_written_)
        {
          if constexpr (extension::is_op<Expr_T>
                        or std::convertible_to<Expr_T, bool>)
            {
              expression << expr;
            }
          else
            {
              expression << static_cast<bool> (expr);
            }
        }
    }
 
    // ------------------------------------------------------------------------

    inline bool
    check_result::value (void) const&& noexcept
    {
      return value_;
    }
 
    // ------------------------------------------------------------------------

    template <class T>
      requires detail::message_argument<T>
    check_result&&
    check_result::operator<< (const T& msg) &&
    {
      if constexpr (detail::lazy_message<T>)
        {
          if (value_)
            {
              return std::move (*this);
            }
        }
      else
        {
          if (!is_written_)
            {
              return std::move (*this);
            }
        }
 
      expression_formatter formatter{ std::move (info_.message) };
      if constexpr (detail::lazy_message<T>)
        {
          formatter << std::invoke (msg);
        }
      else
        {
          formatter << msg;
        }
      info_.message = std::move (formatter.buffer_);
      return std::move (*this);
    }
 
#if !defined(__DOXYGEN__)
    template <class T>
      requires (not detail::message_argument<T>)
    check_result&&
    check_result::operator<< ([[maybe_unused]] const T& msg) &&
    {
      if constexpr (std::is_class_v<T> and std::invocable<const T&>)
        {
          static_assert (
              not std::is_same_v<T, T>,
              "a message that is a callable object must be callable "
              "without arguments and return a value that can be "
              "written, not void");
        }
      else
        {
          static_assert (not std::is_same_v<T, T>,
                         "a message argument must be a value that can be "
                         "written: define an operator<< (mt::"
                         "expression_formatter&, const T&) in the namespace "
                         "of the type, or pass a callable object that returns "
                         "such a value");
        }
      return std::move (*this);
    }
#endif // !defined(__DOXYGEN__)
 
    // ------------------------------------------------------------------------
  } // 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_INLINES_CHECK_RESULT_INLINES_H_
 
// ----------------------------------------------------------------------------