@micro-os-plus/micro-test-plus 2.1.1 → 3.0.2

package/include/micro-os-plus/test-runner.h

@@ -0,0 +1,132 @@
+/*
+ * This file is part of the µOS++ distribution.
+ *   (https://github.com/micro-os-plus/)
+ * Copyright (c) 2021 Liviu Ionescu.
+ *
+ * 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_RUNNER_H_
+#define MICRO_TEST_PLUS_TEST_RUNNER_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include <functional>
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpadded"
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+#endif
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  class test_suite_base;
+
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief The test runner. It maintaines a list of test suites which
+   * automatically register themselves in their constructors.
+   */
+  class test_runner
+  {
+  public:
+    test_runner ();
+
+    // The rule of five.
+    test_runner (const test_runner&) = delete;
+    test_runner (test_runner&&) = delete;
+    test_runner&
+    operator= (const test_runner&)
+        = delete;
+    test_runner&
+    operator= (test_runner&&)
+        = delete;
+
+    ~test_runner () = default;
+
+    /**
+     * @brief Pass the main arguments explicitly, if the default
+     * contructor was used.
+     */
+    void
+    initialize (int argc, char* argv[], const char* name);
+
+    /**
+     * @brief Return 0 if the all tests were successful, 1 otherwise.
+     */
+    int
+    exit_code (void);
+
+    /**
+     * @brief Called by test suite constructors to register them
+     * to the runner.
+     */
+    void
+    register_test_suite (test_suite_base* suite);
+
+    constexpr const char*
+    name (void)
+    {
+      return default_suite_name_;
+    }
+
+    [[noreturn]] void
+    abort (void);
+
+  protected:
+    int argc_ = 0;
+    char** argv_ = nullptr;
+
+    const char* default_suite_name_ = "Test";
+
+    /**
+     * @brief Pointer to the default test suite which groups
+     * the main tests.
+     */
+    test_suite_base* default_test_suite_;
+
+    /**
+     * @brief Pointer to array of registered test suites.
+     * Statically initialised to zero as BSS, such that
+     * test suites defined as static objects in different
+     * compilation units can  be automatically executed.
+     */
+    std::vector<test_suite_base*>* suites_;
+  };
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_TEST_RUNNER_H_
+
+// ----------------------------------------------------------------------------

package/include/micro-os-plus/test-suite.h

@@ -0,0 +1,241 @@
+/*
+ * This file is part of the µOS++ distribution.
+ *   (https://github.com/micro-os-plus/)
+ * Copyright (c) 2021 Liviu Ionescu.
+ *
+ * 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_
+
+// ----------------------------------------------------------------------------
+
+#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
+{
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief Test suites are classes that represent a named group of
+   * test cases which self registers to the runner.
+   */
+  class test_suite_base
+  {
+  public:
+    /**
+     * @brief Construct the default suite used in main().
+     */
+    test_suite_base (const char* name);
+
+    // The rule of five.
+    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 ();
+
+    /**
+     * @brief Run the sequence of test cases in the suite.
+     */
+    virtual void
+    run (void);
+
+    /**
+     * @brief Mark the begining of a named test case.
+     */
+    void
+    begin_test_case (const char* name);
+
+    /**
+     * @brief Mark the end of a test case.
+     */
+    void
+    end_test_case (void);
+
+    /**
+     * @brief Get the suite name.
+     */
+    [[nodiscard]] constexpr const char*
+    name ()
+    {
+      return name_;
+    }
+
+    /**
+     * @brief Count one more passed test condition.
+     */
+    void
+    increment_successful (void);
+
+    /**
+     * @brief Count one more failed test condition.
+     */
+    void
+    increment_failed (void);
+
+    /**
+     * @brief Get the number of conditions that passed.
+     */
+    [[nodiscard]] constexpr int
+    successful_checks (void)
+    {
+      return successful_checks_;
+    }
+
+    /**
+     * @brief Get the number of conditions that failed.
+     */
+    [[nodiscard]] constexpr int
+    failed_checks (void)
+    {
+      return failed_checks_;
+    }
+
+    /**
+     * @brief Get the number of test cases.
+     */
+    [[nodiscard]] constexpr int
+    test_cases (void)
+    {
+      return test_cases_;
+    }
+
+    /**
+     * @brief Begin the execution of the test suite.
+     */
+    void
+    begin_test_suite (void);
+
+    /**
+     * @brief Mark the end of the test suite.
+     */
+    void
+    end_test_suite (void);
+
+    /**
+     * @brief Get the test suite result.
+     */
+    [[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_ == 0);
+    }
+
+  protected:
+    /**
+     * @brief The test suite name.
+     */
+    const char* name_;
+
+    /**
+     * @brief The current test case name.
+     */
+    const char* test_case_name_;
+
+    /**
+     * @brief Count of test conditions that passed.
+     */
+    int successful_checks_ = 0;
+
+    /**
+     * @brief Count of test conditions that failed.
+     */
+    int failed_checks_ = 0;
+
+    /**
+     * @brief Count of test cases in the test suite.
+     */
+    int test_cases_ = 0;
+
+  public:
+    bool process_deferred_begin = true;
+    struct
+    {
+      int successful_checks;
+      int failed_checks;
+    } 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);
+
+    // The rule of five.
+    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_
+
+// ----------------------------------------------------------------------------

package/include/micro-os-plus/type-traits.h

@@ -0,0 +1,346 @@
+/*
+ * This file is part of the µOS++ distribution.
+ *   (https://github.com/micro-os-plus/)
+ * Copyright (c) 2021 Liviu Ionescu.
+ *
+ * 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_TYPE_TRAITS_H_
+#define MICRO_TEST_PLUS_TYPE_TRAITS_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include "math.h"
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#endif
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief Local type traits. Some may have standard equivalents, but
+   * better keep them locally.
+   */
+  namespace type_traits
+  {
+    template <class...>
+    struct list
+    {
+    };
+
+    template <class T, class...>
+    struct identity
+    {
+      using type = T;
+    };
+
+    template <class T>
+    struct function_traits : function_traits<decltype (&T::operator())>
+    {
+    };
+
+    template <class R, class... Args_T>
+    struct function_traits<R (*) (Args_T...)>
+    {
+      using result_type = R;
+      using args = list<Args_T...>;
+    };
+
+    template <class R, class... Args_T>
+    struct function_traits<R (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...)>
+    {
+      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...>;
+    };
+
+    template <class T>
+    T&&
+    declval ();
+    template <class... Ts, class Expr_T>
+    constexpr auto
+    is_valid (Expr_T expr) -> decltype (expr (declval<Ts...> ()), bool ())
+    {
+      return true;
+    }
+
+    template <class...>
+    constexpr auto
+    is_valid (...) -> bool
+    {
+      return false;
+    }
+
+    template <class T>
+    static constexpr auto is_container_v
+        = is_valid<T> ([] (auto t) -> decltype (t.begin (), t.end (),
+                                                void ()) {});
+
+    template <class T>
+    static constexpr auto has_npos_v
+        = is_valid<T> ([] (auto t) -> decltype (void (t.npos)) {});
+
+    template <class T>
+    static constexpr auto has_value_v
+        = is_valid<T> ([] (auto t) -> decltype (void (t.value)) {});
+
+    template <class T>
+    static constexpr auto has_epsilon_v
+        = is_valid<T> ([] (auto t) -> decltype (void (t.epsilon)) {});
+
+    template <class T>
+    inline constexpr auto is_floating_point_v = false;
+    template <>
+    inline constexpr auto is_floating_point_v<float> = true;
+    template <>
+    inline constexpr auto is_floating_point_v<double> = true;
+    template <>
+    inline constexpr auto is_floating_point_v<long double> = true;
+
+#if defined(__clang__) or defined(_MSC_VER)
+    template <class From, class To>
+    static constexpr auto is_convertible_v = __is_convertible_to(From, To);
+#else
+    template <class From, class To>
+    constexpr auto
+    is_convertible (int) -> decltype (bool (To (declval<From> ())))
+    {
+      return true;
+    }
+    template <class...>
+    constexpr auto
+    is_convertible (...)
+    {
+      return false;
+    }
+    template <class From, class To>
+    constexpr auto is_convertible_v = is_convertible<From, To> (0);
+#endif
+
+    template <bool>
+    struct requires_
+    {
+    };
+
+    template <>
+    struct requires_<true>
+    {
+      using type = int;
+    };
+
+    template <bool Cond>
+    using requires_t = typename requires_<Cond>::type;
+
+    /**
+     * @brief Empty base class of all operators.
+     */
+    struct op
+    {
+    };
+
+    /**
+     * @brief A generic integral constant.
+     * It has a getter and a '-' operator to return the negative value.
+     */
+    template <auto N>
+    struct integral_constant : op
+    {
+      using value_type = decltype (N);
+      static constexpr auto value = N;
+
+      [[nodiscard]] constexpr auto
+      operator- () const
+      {
+        return integral_constant<-N>{};
+      }
+
+      [[nodiscard]] constexpr explicit operator value_type () const
+      {
+        return N;
+      }
+
+      [[nodiscard]] constexpr auto
+      get () const
+      {
+        return N;
+      }
+    };
+
+    /**
+     * @brief A generic floating point constant, with custom size
+     * and precision.
+     * It has a getter and a '-' operator to return the negative value.
+     */
+    template <class T, auto N, auto D, auto Size, auto P = 1>
+    struct floating_point_constant : op
+    {
+      using value_type = T;
+
+      static constexpr auto epsilon = T (1) / math::pow (T (10), Size - 1);
+      static constexpr auto value
+          = T (P) * (T (N) + (T (D) / math::pow (T (10), Size)));
+
+      [[nodiscard]] constexpr auto
+      operator- () const
+      {
+        return floating_point_constant<T, N, D, Size, -1>{};
+      }
+
+      [[nodiscard]] constexpr explicit operator value_type () const
+      {
+        return value;
+      }
+
+      [[nodiscard]] constexpr auto
+      get () const
+      {
+        return value;
+      }
+    };
+
+    template <class T>
+    struct genuine_integral_value : op
+    {
+      using value_type = T;
+
+      constexpr genuine_integral_value (const T& _value) : value_{ _value }
+      {
+      }
+
+      [[nodiscard]] constexpr explicit operator T () const
+      {
+        return value_;
+      }
+
+      [[nodiscard]] constexpr decltype (auto)
+      get () const
+      {
+        return value_;
+      }
+
+      T value_{};
+    };
+
+    template <class T>
+    inline constexpr auto is_op_v = __is_base_of(type_traits::op, T);
+
+    /**
+     * @brief Class defining a generic value, accessible via a getter.
+     */
+    template <class T, class = int>
+    struct value : type_traits::op
+    {
+      using value_type = T;
+
+      constexpr value (const T& _value) : value_{ _value }
+      {
+      }
+
+      [[nodiscard]] constexpr explicit operator T () const
+      {
+        return value_;
+      }
+
+      [[nodiscard]] constexpr decltype (auto)
+      get () const
+      {
+        return value_;
+      }
+
+      T value_{};
+    };
+
+    /**
+     * @brief A generic value used to define floating points, which,
+     * in addition to the actual value, has an epsilon, to use the
+     * desired precision during comparisons.
+     * If missing, the default is 1 / (10^decimals).
+     */
+    template <class T>
+    struct value<T,
+                 type_traits::requires_t<type_traits::is_floating_point_v<T>>>
+        : type_traits::op
+    {
+      using value_type = T;
+      static inline auto epsilon = T{}; // Why static?
+
+      constexpr value (const T& _value, const T precision) : value_{ _value }
+      {
+        epsilon = precision;
+      }
+
+      constexpr /*explicit(false)*/ value (const T& val)
+          : value{ val,
+                   T (1)
+                       / math::pow (T (10),
+                                    math::den_size<unsigned long long> (val)) }
+      {
+      }
+
+      [[nodiscard]] constexpr explicit operator T () const
+      {
+        return value_;
+      }
+
+      [[nodiscard]] constexpr decltype (auto)
+      get () const
+      {
+        return value_;
+      }
+
+      T value_{};
+    };
+
+  } // namespace type_traits
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_TYPE_TRAITS_H_
+
+// ----------------------------------------------------------------------------