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

package/include/micro-os-plus/inlines.h

@@ -0,0 +1,161 @@
+/*
+ * 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_INLINES_H_
+#define MICRO_TEST_PLUS_INLINES_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggregate-return"
+#pragma GCC diagnostic ignored "-Wpadded"
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-c++11-c++14-c++17-compat-pedantic"
+#endif
+#endif
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  template <typename Callable_T, typename... Args_T>
+  test_suite::test_suite (const char* name, Callable_T&& callable,
+                          Args_T&&... arguments)
+      : test_suite_base{ name }, callable_{ std::bind (callable,
+                                                       arguments...) }
+  {
+#if defined(MICRO_TEST_PLUS_TRACE)
+    printf ("%s\n", __PRETTY_FUNCTION__);
+#endif // MICRO_TEST_PLUS_TRACE
+
+    runner.register_test_suite (this);
+  }
+
+  // --------------------------------------------------------------------------
+
+  template <typename Callable_T, typename... Args_T>
+  void
+  test_case (const char* name, Callable_T&& func, Args_T&&... arguments)
+  {
+#if 0 // defined(MICRO_TEST_PLUS_TRACE)
+    printf ("%s\n", __PRETTY_FUNCTION__);
+#endif // MICRO_TEST_PLUS_TRACE
+
+    current_test_suite->begin_test_case (name);
+    std::invoke (std::forward<Callable_T> (func),
+                 std::forward<Args_T> (arguments)...);
+    current_test_suite->end_test_case ();
+  }
+
+  // --------------------------------------------------------------------------
+  namespace detail
+  {
+    // ------------------------------------------------------------------------
+
+    template <class T>
+    auto&
+    deferred_reporter_base::operator<< (const T& msg)
+    {
+      if constexpr (std::is_arithmetic_v<T>)
+        {
+          message_.append (std::to_string (msg));
+        }
+      else
+        {
+          message_.append (msg);
+        }
+      return *this;
+    }
+
+    // ------------------------------------------------------------------------
+
+    template <class Expr_T>
+    constexpr deferred_reporter<Expr_T>::deferred_reporter (
+        const Expr_T& expr, bool abort,
+        const reflection::source_location& location)
+        : deferred_reporter_base{ static_cast<bool> (expr), location }, expr_{
+            expr
+          }
+    {
+#if 0 // defined(MICRO_TEST_PLUS_TRACE)
+      printf ("%s\n", __PRETTY_FUNCTION__);
+#endif // MICRO_TEST_PLUS_TRACE
+      abort_ = abort;
+    }
+
+    template <class Expr_T>
+    deferred_reporter<Expr_T>::~deferred_reporter ()
+    {
+      if (value_)
+        {
+          reporter.pass (expr_, message_);
+        }
+      else
+        {
+          reporter.fail (expr_, abort_, message_, location_);
+        }
+    }
+
+    // ------------------------------------------------------------------------
+  } // namespace detail
+
+  // --------------------------------------------------------------------------
+  namespace utility
+  {
+    template <class T = std::string_view, class Delim_T>
+    [[nodiscard]] auto
+    split (T input, Delim_T delim) -> std::vector<T>
+    {
+      std::vector<T> output{};
+      std::size_t first{};
+      while (first < std::size (input))
+        {
+          const auto second = input.find_first_of (delim, first);
+          if (first != second)
+            {
+              output.emplace_back (input.substr (first, second - first));
+            }
+          if (second == T::npos)
+            {
+              break;
+            }
+          first = second + 1;
+        }
+      return output;
+    }
+  } // namespace utility
+
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_INLINES_H_
+
+// ----------------------------------------------------------------------------

package/include/micro-os-plus/literals.h

@@ -0,0 +1,285 @@
+/*
+ * 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_LITERALS_H_
+#define MICRO_TEST_PLUS_LITERALS_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include "type-traits.h"
+#include "math.h"
+
+// ----------------------------------------------------------------------------
+
+#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
+#endif
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief User Defined Literals (UDL). Use them to suffix
+   * constants and obtain specific explicit types, like `1_i`.
+   */
+  namespace literals
+  {
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_i ()
+    {
+      return type_traits::integral_constant<math::num<int, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_s ()
+    {
+      return type_traits::integral_constant<math::num<short, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_c ()
+    {
+      return type_traits::integral_constant<math::num<char, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_sc ()
+    {
+      return type_traits::integral_constant<
+          math::num<signed char, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_l ()
+    {
+      return type_traits::integral_constant<math::num<long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_ll ()
+    {
+      return type_traits::integral_constant<math::num<long long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_u ()
+    {
+      return type_traits::integral_constant<math::num<unsigned, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_uc ()
+    {
+      return type_traits::integral_constant<
+          math::num<unsigned char, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_us ()
+    {
+      return type_traits::integral_constant<
+          math::num<unsigned short, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_ul ()
+    {
+      return type_traits::integral_constant<
+          math::num<unsigned long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_ull ()
+    {
+      return type_traits::integral_constant<
+          math::num<unsigned long long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_i8 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::int8_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_i16 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::int16_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_i32 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::int32_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_i64 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::int64_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_u8 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::uint8_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_u16 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::uint16_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_u32 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::uint32_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_u64 ()
+    {
+      return type_traits::integral_constant<
+          math::num<std::uint64_t, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_f ()
+    {
+      return type_traits::floating_point_constant<
+          float, math::num<unsigned long, Cs...> (),
+          math::den<unsigned long, Cs...> (),
+          math::den_size<unsigned long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_d ()
+    {
+      return type_traits::floating_point_constant<
+          double, math::num<unsigned long, Cs...> (),
+          math::den<unsigned long, Cs...> (),
+          math::den_size<unsigned long, Cs...> ()>{};
+    }
+
+    template <char... Cs>
+    [[nodiscard]] constexpr auto operator""_ld ()
+    {
+      return type_traits::floating_point_constant<
+          long double, math::num<unsigned long long, Cs...> (),
+          math::den<unsigned long long, Cs...> (),
+          math::den_size<unsigned long long, Cs...> ()>{};
+    }
+
+    constexpr auto operator""_b (const char* name, decltype (sizeof ("")) size)
+    {
+      struct named : std::string_view, type_traits::op
+      {
+        using value_type = bool;
+        [[nodiscard]] constexpr operator value_type () const
+        {
+          return true;
+        }
+
+        [[nodiscard]] constexpr auto
+        operator== (const named&) const
+        {
+          return true;
+        }
+
+        [[nodiscard]] constexpr auto
+        operator== (const bool other) const
+        {
+          return other;
+        }
+      };
+
+      return named{ { name, size }, {} };
+    }
+  } // namespace literals
+
+  // --------------------------------------------------------------------------
+
+  // Wrappers that can be used to convert dynamic values to specific types
+  // that are recognised by the comparators.
+  // The syntax is similar to function calls, like `_i(expression)`, but the
+  // results have custom types expected by comparators.
+  using _b = type_traits::value<bool>;
+  using _c = type_traits::value<char>;
+  using _sc = type_traits::value<signed char>;
+  using _s = type_traits::value<short>;
+  using _i = type_traits::value<int>;
+  using _l = type_traits::value<long>;
+  using _ll = type_traits::value<long long>;
+  using _u = type_traits::value<unsigned>;
+  using _uc = type_traits::value<unsigned char>;
+  using _us = type_traits::value<unsigned short>;
+  using _ul = type_traits::value<unsigned long>;
+  using _ull = type_traits::value<unsigned long long>;
+  using _i8 = type_traits::value<std::int8_t>;
+  using _i16 = type_traits::value<std::int16_t>;
+  using _i32 = type_traits::value<std::int32_t>;
+  using _i64 = type_traits::value<std::int64_t>;
+  using _u8 = type_traits::value<std::uint8_t>;
+  using _u16 = type_traits::value<std::uint16_t>;
+  using _u32 = type_traits::value<std::uint32_t>;
+  using _u64 = type_traits::value<std::uint64_t>;
+  using _f = type_traits::value<float>;
+  using _d = type_traits::value<double>;
+  using _ld = type_traits::value<long double>;
+
+  // Template for wrapping any other type.
+  template <class T>
+  struct _t : type_traits::value<T>
+  {
+    constexpr explicit _t (const T& t) : type_traits::value<T>{ t }
+    {
+    }
+  };
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_LITERALS_H_
+
+// ----------------------------------------------------------------------------

package/include/micro-os-plus/math.h

@@ -0,0 +1,205 @@
+/*
+ * 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_MATH_H_
+#define MICRO_TEST_PLUS_MATH_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include <array>
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+#endif
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief Local mathematical functions.
+   *
+   * Some may have equivalents in the standard library, but may be
+   * more complicated to use, or have only floating point variants, or
+   * not be constexpr.
+   */
+  namespace math
+  {
+    /**
+     * @brief Generic absolute of any value.
+     */
+    template <class T>
+    [[nodiscard]] constexpr auto
+    abs (const T t) -> T
+    {
+      return t < T{} ? -t : t;
+    }
+
+    /**
+     * @brief Generic minimum of two values.
+     */
+    template <class T>
+    [[nodiscard]] constexpr auto
+    min_value (const T& lhs, const T& rhs) -> const T&
+    {
+      return (rhs < lhs) ? rhs : lhs;
+    }
+
+    /**
+     * @brief Generic 'power of', to raise base to exponent (base ^ exp).
+     */
+    template <class T, class Exp_T>
+    [[nodiscard]] constexpr auto
+    pow (const T base, const Exp_T exp) -> T
+    {
+      // If the exponent is 0, return 1, otherwise recurse.
+      return exp ? T (base * pow (base, exp - Exp_T (1))) : T (1);
+    }
+
+    /**
+     * @brief Compute the integral value of a number represented as
+     * an array of characters.
+     */
+    template <class T, char... Cs>
+    [[nodiscard]] constexpr auto
+    num () -> T
+    {
+      // Assume all are digits or dot or apostrophe.
+      static_assert (
+          ((Cs == '.' or Cs == '\'' or (Cs >= '0' and Cs <= '9')) and ...));
+      T result{};
+      for (const char c : { Cs... })
+        {
+          if (c == '.')
+            {
+              break;
+            }
+          if (c >= '0' and c <= '9')
+            {
+              result = result * T (10) + T (c - '0');
+            }
+        }
+      return result;
+    }
+
+    /**
+     * @brief Compute the decimals of a number represented as
+     * an array of characters.
+     */
+    template <class T, char... Cs>
+    [[nodiscard]] constexpr auto
+    den () -> T
+    {
+      constexpr const std::array cs{ Cs... };
+      T result{};
+      auto i = 0u;
+      while (cs[i++] != '.')
+        {
+        }
+
+      for (auto j = i; j < sizeof...(Cs); ++j)
+        {
+          result += pow (T (10), sizeof...(Cs) - j) * T (cs[j] - '0');
+        }
+      return result;
+    }
+
+    /**
+     * @brief Compute the number of decimal places of a number represented as
+     * an array of characters.
+     */
+    template <class T, char... Cs>
+    [[nodiscard]] constexpr auto
+    den_size () -> T
+    {
+      constexpr const std::array cs{ Cs... };
+      T i{};
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+      while (cs[i++] != '.')
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+        {
+        }
+
+      return T (sizeof...(Cs)) - i + T (1);
+    }
+
+    /**
+     * @brief Compute the number of decimal places of a value,
+     * up to 7 digits.
+     */
+    template <class T, class Value_T>
+    [[nodiscard]] constexpr auto
+    den_size (Value_T value) -> T
+    {
+      constexpr auto precision = Value_T (1e-7);
+      T result{};
+      Value_T tmp{};
+      do
+        {
+          value *= 10;
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#if !defined(__clang__) // GCC only
+#pragma GCC diagnostic ignored "-Warith-conversion"
+#endif
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
+#endif
+#endif
+          tmp = value - T (value);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+          ++result;
+        }
+      while (tmp > precision);
+
+      return result;
+    }
+
+  } // namespace math
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_MATH_H_
+
+// ----------------------------------------------------------------------------