reporter.cpp

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.
 */
 
// ----------------------------------------------------------------------------

 
// ----------------------------------------------------------------------------
 
#include "micro-os-plus/micro-test-plus/reporter.h"
 
#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")
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunknown-warning-option"
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// =============================================================================
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  reporter::reporter (std::unique_ptr<std::vector<std::string_view>> argvs)
  {
#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
 
    std::string_view output_file_sv{};
 
    argvs_ = std::move (argvs);
 
    static constexpr std::string_view output_file_prefix{ "--output-file=" };
    if (argvs_)
      {
        const auto& args = *argvs_;
        for (size_t i = 0; i < args.size (); ++i)
          {
            if (args[i] == "--verbose")
              {
                verbosity_ = verbosity::verbose;
              }
            else if (args[i] == "--quiet")
              {
                verbosity_ = verbosity::quiet;
              }
            else if (args[i] == "--silent")
              {
                verbosity_ = verbosity::silent;
              }
            else if (args[i].starts_with (output_file_prefix))
              {
                output_file_sv = args[i].substr (output_file_prefix.size ());
              }
            else if (args[i]
                     == output_file_prefix.substr (
                         0, output_file_prefix.size () - 1))
              {
                if (i + 1 < args.size ())
                  {
                    output_file_sv = args[++i];
                  }
                else
                  {
                    fprintf (stderr, "error: --output-file option requires a "
                                     "file path argument\n");
                    exit (1);
                  }
              }
          }
      }
 
    if (!output_file_sv.empty ())
      {
        // .data() is safe: all string_views are views into argv[]
        // entries, which are null-terminated C strings.
        output_file_ = fopen (output_file_sv.data (), "w");
        if (output_file_ == nullptr)
          {
            fprintf (stderr, "error: Failed to open output file '%.*s'\n",
                     static_cast<int> (output_file_sv.size ()),
                     output_file_sv.data ());
            exit (1);
          }
        // The original string is zero terminated, so we can safely use .data()
        // here.
        output_file_path_ = output_file_sv.data ();
      }
 
    // Pre-allocate buffer to reduce dynamic allocations.
    buffer_.reserve (128);
  }

  reporter::~reporter ()
  {
#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
 
    if (output_file_ != nullptr)
      {
        fflush (output_file_);
        fclose (output_file_);
 
        printf ("Test output written to '%s'.\n", output_file_path_);
 
        output_file_ = nullptr;
        output_file_path_ = nullptr;
      }
  }
 
  // --------------------------------------------------------------------------

  reporter&
  endl (reporter& stream)
  {
    stream.endline ();
    return stream;
  }

  void
  reporter::endline (void)
  {
    buffer_.append ("\n");
    flush ();
  }

   */
  void
  reporter::write_buffer_to_stdout (void)
  {
    // Pass only the string, do not add an `\n` here.
    printf ("%s", buffer_.c_str ());
  }

   * @details
   * Writes the contents of `buffer_` to `output_file_` using `fprintf`
   * without appending a newline. If `output_file_` is null, the call is
   * a no-op.
   */
  void
  reporter::write_buffer_to_file_ (void)
  {
    // Pass only the string, do not add an `\n` here.
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s", buffer_.c_str ());
      }
  }

  void
  reporter::write_info_ (void)
  {
    if (argvs_ && !argvs_->empty ())
      {
        const auto& args = *argvs_;
        std::string line;
        line.reserve (256);
        line.append (get_comment_prefix ());
        line.append ("Running: ");
 
        // Append only the file name part of argv[0].
        const std::string_view arg0 = args[0];
        const auto sep = arg0.rfind ('/');
        line.append ((sep != std::string_view::npos) ? arg0.substr (sep + 1)
                                                     : arg0);
 
        for (size_t i = 1; i < args.size (); ++i)
          {
            line.append (" ");
            line.append (args[i]);
          }
        line.append ("\n");
 
        if (output_file_ != nullptr)
          fprintf (output_file_, "%s", line.c_str ());
 
#if !(defined(MICRO_OS_PLUS_STARTUP_ENABLED) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
        if (verbosity_ == verbosity::normal
            || verbosity_ == verbosity::verbose)
          printf ("%s", line.c_str ());
#endif // !defined(MICRO_OS_PLUS_STARTUP_ENABLED)
      }
 
    {
      // Build the "Built with ..." line. For the output file the compiler
      // version is omitted; for stdout it is appended via __VERSION__.
      std::string line;
      line.reserve (256);
      line.append (get_comment_prefix ());
      line.append ("Built with ");
#if defined(__clang__)
      line.append ("clang " __VERSION__);
#elif defined(__GNUC__)
      line.append ("GCC " __VERSION__);
#elif defined(_MSC_VER)
      line.append ("MSVC");
      char msvc_ver[16];
      snprintf (msvc_ver, sizeof (msvc_ver), " - %d", _MSC_VER);
      line.append (msvc_ver);
#else
      line.append ("an unknown compiler");
#endif // defined(__clang__)
#if !(defined(__APPLE__) || defined(__linux__) || defined(__unix__) \
      || defined(WIN32))
      // This is relevant only on bare-metal.
#if defined(__ARM_PCS_VFP) || defined(__ARM_FP)
      line.append (", with FP");
#else
      line.append (", no FP");
#endif // defined(__ARM_PCS_VFP) || defined(__ARM_FP)
#endif // !(defined(__APPLE__) || defined(__linux__) || defined(__unix__) || defined(WIN32))
#if defined(__EXCEPTIONS)
      line.append (", with exceptions");
#else
      line.append (", no exceptions");
#endif // defined(__EXCEPTIONS)
#if defined(MICRO_OS_PLUS_DEBUG_ENABLED)
      line.append (", with MICRO_OS_PLUS_DEBUG_ENABLED");
#endif // defined(MICRO_OS_PLUS_DEBUG_ENABLED)
#if defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
      line.append (", with MICRO_OS_PLUS_DIAG_TRACE_ENABLED");
#endif // defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
 
      if (output_file_ != nullptr)
        {
          fprintf (output_file_, "%s\n", line.c_str ());
        }
 
#if !(defined(MICRO_OS_PLUS_STARTUP_ENABLED) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
      if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
        {
          printf ("%s\n", line.c_str ());
        }
#endif // !defined(MICRO_OS_PLUS_STARTUP_ENABLED)
    }
  }

  void
  reporter::flush (void)
  {
    fflush (stdout);
    if (output_file_ != nullptr)
      {
        fflush (output_file_);
      }
  }
 
  // --------------------------------------------------------------------------

  reporter&
  reporter::operator<< (reporter& (*func) (reporter&))
  {
    // Call the endl function.
    (*func) (*this);
    return *this;
  }

  reporter&
  reporter::operator<< (std::string_view sv)
  {
    buffer_.append (sv);
    return *this;
  }

  reporter&
  reporter::operator<< (char c)
  {
    buffer_.append (1, c);
    return *this;
  }

  reporter&
  reporter::operator<< (const char* s)
  {
    buffer_.append (s);
    return *this;
  }

  void
  reporter::pass (std::string& message, const std::string& expression,
                  subtest& subtest)
  {
    output_pass_prefix_ (message, subtest);
 
    if (message.empty ())
      {
        *this << expression;
      }
 
    output_pass_suffix_ (subtest);
  }

  void
  reporter::fail (bool abort, std::string& message,
                  const std::string& expression, bool has_expression,
                  const reflection::source_location& location,
                  subtest& subtest)
  {
    output_fail_prefix_ (message, has_expression, location, subtest);
 
    if (has_expression)
      {
        *this << expression;
      }
 
    output_fail_suffix_ (location, abort, subtest);
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------