test-suite.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_TEST_PLUS_TEST_SUITE_H_
#define MICRO_TEST_PLUS_TEST_SUITE_H_
 
// ----------------------------------------------------------------------------
 
#include <time.h>
 
#ifdef __cplusplus
 
// ----------------------------------------------------------------------------
 
#include <functional>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpadded"
#if !defined(__clang__) // GCC only
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#endif
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
#endif
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  class test_suite_base
  {
  public:
    test_suite_base (const char* name);

    test_suite_base (const test_suite_base&) = delete;

    test_suite_base (test_suite_base&&) = delete;

    test_suite_base&
    operator= (const test_suite_base&)
        = delete;

    test_suite_base&
    operator= (test_suite_base&&)
        = delete;

    virtual ~test_suite_base ();

    virtual void
    run (void);

    void
    begin_test_case (const char* name);

    void
    end_test_case (void);

    [[nodiscard]] constexpr const char*
    name (void)
    {
      return name_;
    }

    void
    increment_successful (void);

    void
    increment_failed (void);

    [[nodiscard]] constexpr size_t
    successful_checks (void)
    {
      return successful_checks_;
    }

    [[nodiscard]] constexpr size_t
    failed_checks (void)
    {
      return failed_checks_;
    }

    [[nodiscard]] constexpr size_t
    test_cases_count (void)
    {
      return test_cases_count_;
    }

    void
    begin_test_suite (void);

    void
    end_test_suite (void);
 
#if defined(_WIN32) || defined(CLOCK_MONOTONIC)
    void
    compute_elapsed_time (timespec& begin_time, timespec& end_time,
                          long& milliseconds, long& microseconds);
#endif

    [[nodiscard]] constexpr bool
    was_successful (void)
    {
      // Also fail if none passed.
      return (failed_checks_ == 0 && successful_checks_ != 0);
    }

    [[nodiscard]] constexpr bool
    unused (void)
    {
      return (failed_checks_ == 0 && successful_checks_ == 0
              && test_cases_count_ == 0);
    }
 
  protected:
    const char* name_;

    const char* test_case_name_;

    size_t successful_checks_ = 0;

    size_t failed_checks_ = 0;

    size_t test_cases_count_ = 0;
 
  public:
    size_t index = 1;
 
#if defined(_WIN32) || defined(CLOCK_MONOTONIC)
    timespec begin_time{};

    timespec end_time{};
#endif

    bool process_deferred_begin = true;

    struct
    {
      size_t successful_checks = 0;

      size_t failed_checks = 0;
 
      size_t index = 0;
    } current_test_case{};
  };

  class test_suite : public test_suite_base
  {
  public:
    template <typename Callable_T, typename... Args_T>
    test_suite (const char* name, Callable_T&& callable,
                Args_T&&... arguments);

    test_suite (const test_suite&) = delete;

    test_suite (test_suite&&) = delete;

    test_suite&
    operator= (const test_suite&)
        = delete;

    test_suite&
    operator= (test_suite&&)
        = delete;

    virtual ~test_suite () override;

    virtual void
    run (void) override;
 
  protected:
    std::function<void (void)> callable_;
  };
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// ----------------------------------------------------------------------------
 
#endif // __cplusplus
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_TEST_PLUS_TEST_SUITE_H_
 
// ----------------------------------------------------------------------------