@micro-os-plus/micro-test-plus 3.2.3 → 3.3.1

package/CHANGELOG.md

@@ -6,10 +6,84 @@ Please check
 [GitHub](https://github.com/micro-os-plus/micro-test-plus-xpack/issues/)
 and close existing issues and pull requests.
 
+## 2026-03-23
+
+* v3.3.1 published on npmjs.com
+* v3.3.1 prepared
+* f1be263 tests: add suite-test
+* df22b28 #16: fix static inits
+* 511f8cf re-generate website commons
+* c700756 tests meson update usage
+* 759051f move tests to sources
+
+## 2026-03-22
+
+* fd91598 website: blog post release 3.3.0 published
+* a116185 3.3.0
+* c412e55 CHANGELOG: publish npm v3.3.0
+* 394c679 prepare v3.3.0
+* 8d33c3e website update for tap
+* 181b428 website/doxygen rewrites
+* 14bea0a cli.dox update to tap
+* 4a4f840 #9: fix empty line
+* ae54b12 cmake cosmetics
+* 3cb5a08 #10: fix not ok messages
+* 2fda6fc #10: fix rounding
+
+## 2026-03-21
+
+* 1e2c980 empty .npmignore in tests
+* 2242fd0 test-reporter-tap.cpp cosmetics
+* a3ecec4 try timespec_get only on win32
+* 7ba0701 try timespec_get
+* 9ead310 #if defined(CLOCK_MONOTONIC)
+* 4e9478c Revert "try -lwinpthread on windows"
+* 951742a try -lwinpthread on windows
+* 5bce849 #10: fix long long warning
+
+## 2026-03-20
+
+* f9c0293 Revert "#10: use defined(__linux__)"
+* 574ff65 #10: fix duplicate struct timespec
+* cbdc8ed #10: use defined(__linux__)
+* 15a191d #10: show total time
+* 3bae621 make runner default_test_suite public
+* e25dbf3 #10: add elapsed time to suites
+* 0139c5e test-reporter-*.cpp plurals
+
+## 2026-03-19
+
+* 9258c55 cli.dox update
+* 022cbed test-reporter: fix syntax
+* cc95083 website update
+* e4c6be1 #9: default tap
+* 84b34d3 native cmake with explicit --reporter
+* e35ad6a #9: functional test-reporter-tap
+* 7aa70ac test-runner: add totals
+* f6a2bc1 add begin/end_test
+* 7d6f684 test-suite.h: size_t analytics
+* 1e7a54c detail.h: reformat
+
+## 2026-03-18
+
+* 7bae711 add suite index
+* 6619d3b default basic
+* 5465c38 rename test_suites_
+* c60d2b5 rename test_cases_count
+* 459d10c #9: process --reporter=tap or basic
+* 2c8cc51 #9: add a test-reporter-tap as a duplicate of base
+* 122c76a #11: make the test_reporter_basic class final to avoid warnings
+* d84d2b8 #11: extract test_runner_basic in separate files
+* 75b8fb1 #11: move operator implementations back to the base class
+* 096d136 #11: make the test_reporter an abstract class
+* 8f20d22 #13: access the reporter via a pointer
+
 ## 2026-03-17
 
-* v3.2.3 published on npmjs.com
-* v3.2.3 prepared
+* 42e0810 website: blog post release 3.2.3 published
+* b84b446 3.2.3
+* aeda731 CHANGELOG: publish npm v3.2.3
+* 7d877be prepare v3.2.3
 * 7943290 package.json update
 * d40573b settings.json update
 * 6eaed82 re-generate website

package/CMakeLists.txt

@@ -53,7 +53,8 @@ target_include_directories(
 target_sources(
   micro-os-plus-micro-test-plus-interface
   INTERFACE "src/micro-test-plus.cpp" "src/test-runner.cpp"
-            "src/test-reporter.cpp" "src/test-suite.cpp"
+            "src/test-reporter.cpp" "src/test-reporter-basic.cpp"
+            "src/test-reporter-tap.cpp" "src/test-suite.cpp"
 )
 
 target_compile_definitions(

package/README.md

@@ -15,7 +15,7 @@ For information on how to install and use this project, please refer to the
 ## Project source
 
 The source code of the current release is available on
-[GitHub tag v3.2.3 tree](https://github.com/micro-os-plus/micro-test-plus-xpack/tree/v3.2.3).
+[GitHub tag v3.3.1 tree](https://github.com/micro-os-plus/micro-test-plus-xpack/tree/v3.3.1).
 
 ## License
 

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

@@ -270,11 +270,13 @@ namespace micro_os_plus::micro_test_plus
        * result is stored in the `value_` member for efficient access.
        */
       constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              // This lambda is called in the constructor to
-              // evaluate the comparison.
-              using std::operator==;
-              using std::operator<;
+          : lhs_{ lhs }, rhs_{ rhs }, value_{
+              [&]
+                {
+                  // This lambda is called in the constructor to
+                  // evaluate the comparison.
+                  using std::operator==;
+                  using std::operator<;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -287,41 +289,45 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  // If both types have values (like numeric constants),
-                  // compare them directly.
-                  return Lhs_T::value == Rhs_T::value;
-                }
-              else if constexpr (type_traits::has_epsilon_v<Lhs_T>
-                                 and type_traits::has_epsilon_v<Rhs_T>)
-                {
-                  // If both values have precision, compare them using
-                  // the smalles precision.
-                  return math::abs (get (lhs) - get (rhs))
-                         < math::min_value (Lhs_T::epsilon, Rhs_T::epsilon);
-                }
-              else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
-                {
-                  // If only the left operand has precision, use it.
-                  return math::abs (get (lhs) - get (rhs)) < Lhs_T::epsilon;
-                }
-              else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
-                {
-                  // If only the right operand has precision, use it.
-                  return math::abs (get (lhs) - get (rhs)) < Rhs_T::epsilon;
-                }
-              else
-                {
-                  // Call the generic getters, which might
-                  // either call the type get() or return the value.
-                  return get (lhs) == get (rhs);
-                }
+                  if constexpr (type_traits::has_value_v<Lhs_T>
+                                and type_traits::has_value_v<Rhs_T>)
+                    {
+                      // If both types have values (like numeric constants),
+                      // compare them directly.
+                      return Lhs_T::value == Rhs_T::value;
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
+                                     and type_traits::has_epsilon_v<Rhs_T>)
+                    {
+                      // If both values have precision, compare them using
+                      // the smalles precision.
+                      return math::abs (get (lhs) - get (rhs))
+                             < math::min_value (Lhs_T::epsilon,
+                                                Rhs_T::epsilon);
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
+                    {
+                      // If only the left operand has precision, use it.
+                      return math::abs (get (lhs) - get (rhs))
+                             < Lhs_T::epsilon;
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
+                    {
+                      // If only the right operand has precision, use it.
+                      return math::abs (get (lhs) - get (rhs))
+                             < Rhs_T::epsilon;
+                    }
+                  else
+                    {
+                      // Call the generic getters, which might
+                      // either call the type get() or return the value.
+                      return get (lhs) == get (rhs);
+                    }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                }()
+            }
       {
       }
 
@@ -442,10 +448,12 @@ namespace micro_os_plus::micro_test_plus
        * result is stored in the `value_` member for efficient access.
        */
       constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              using std::operator==;
-              using std::operator!=;
-              using std::operator>;
+          : lhs_{ lhs }, rhs_{ rhs }, value_{
+              [&]
+                {
+                  using std::operator==;
+                  using std::operator!=;
+                  using std::operator>;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -458,33 +466,37 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  return Lhs_T::value != Rhs_T::value;
-                }
-              else if constexpr (type_traits::has_epsilon_v<Lhs_T>
-                                 and type_traits::has_epsilon_v<Rhs_T>)
-                {
-                  return math::abs (get (lhs_) - get (rhs_))
-                         > math::min_value (Lhs_T::epsilon, Rhs_T::epsilon);
-                }
-              else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
-                {
-                  return math::abs (get (lhs_) - get (rhs_)) > Lhs_T::epsilon;
-                }
-              else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
-                {
-                  return math::abs (get (lhs_) - get (rhs_)) > Rhs_T::epsilon;
-                }
-              else
-                {
-                  return get (lhs_) != get (rhs_);
-                }
+                  if constexpr (type_traits::has_value_v<Lhs_T>
+                                and type_traits::has_value_v<Rhs_T>)
+                    {
+                      return Lhs_T::value != Rhs_T::value;
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
+                                     and type_traits::has_epsilon_v<Rhs_T>)
+                    {
+                      return math::abs (get (lhs_) - get (rhs_))
+                             > math::min_value (Lhs_T::epsilon,
+                                                Rhs_T::epsilon);
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
+                    {
+                      return math::abs (get (lhs_) - get (rhs_))
+                             > Lhs_T::epsilon;
+                    }
+                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
+                    {
+                      return math::abs (get (lhs_) - get (rhs_))
+                             > Rhs_T::epsilon;
+                    }
+                  else
+                    {
+                      return get (lhs_) != get (rhs_);
+                    }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                }()
+            }
       {
       }
 
@@ -603,8 +615,10 @@ namespace micro_os_plus::micro_test_plus
        * The result is stored in the `value_` member for efficient access.
        */
       constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              using std::operator>;
+          : lhs_{ lhs }, rhs_{ rhs },
+            value_{ [&]
+                      {
+                        using std::operator>;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -616,19 +630,19 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  return Lhs_T::value > Rhs_T::value;
-                }
-              else
-                {
-                  return get (lhs_) > get (rhs_);
-                }
+                        if constexpr (type_traits::has_value_v<Lhs_T>
+                                      and type_traits::has_value_v<Rhs_T>)
+                          {
+                            return Lhs_T::value > Rhs_T::value;
+                          }
+                        else
+                          {
+                            return get (lhs_) > get (rhs_);
+                          }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                      }() }
       {
       }
 
@@ -750,8 +764,10 @@ namespace micro_os_plus::micro_test_plus
        * efficient access.
        */
       constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              using std::operator>=;
+          : lhs_{ lhs }, rhs_{ rhs },
+            value_{ [&]
+                      {
+                        using std::operator>=;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -763,19 +779,19 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  return Lhs_T::value >= Rhs_T::value;
-                }
-              else
-                {
-                  return get (lhs_) >= get (rhs_);
-                }
+                        if constexpr (type_traits::has_value_v<Lhs_T>
+                                      and type_traits::has_value_v<Rhs_T>)
+                          {
+                            return Lhs_T::value >= Rhs_T::value;
+                          }
+                        else
+                          {
+                            return get (lhs_) >= get (rhs_);
+                          }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                      }() }
       {
       }
 
@@ -895,8 +911,10 @@ namespace micro_os_plus::micro_test_plus
        * The result is stored in the `value_` member for efficient access.
        */
       constexpr lt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              using std::operator<;
+          : lhs_{ lhs }, rhs_{ rhs },
+            value_{ [&]
+                      {
+                        using std::operator<;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -908,19 +926,19 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  return Lhs_T::value < Rhs_T::value;
-                }
-              else
-                {
-                  return get (lhs_) < get (rhs_);
-                }
+                        if constexpr (type_traits::has_value_v<Lhs_T>
+                                      and type_traits::has_value_v<Rhs_T>)
+                          {
+                            return Lhs_T::value < Rhs_T::value;
+                          }
+                        else
+                          {
+                            return get (lhs_) < get (rhs_);
+                          }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                      }() }
       {
       }
 
@@ -1043,8 +1061,10 @@ namespace micro_os_plus::micro_test_plus
        * efficient access.
        */
       constexpr le_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ [&] {
-              using std::operator<=;
+          : lhs_{ lhs }, rhs_{ rhs },
+            value_{ [&]
+                      {
+                        using std::operator<=;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -1056,19 +1076,19 @@ namespace micro_os_plus::micro_test_plus
 #pragma clang diagnostic ignored "-Wpedantic"
 #endif
 #endif
-              if constexpr (type_traits::has_value_v<Lhs_T>
-                            and type_traits::has_value_v<Rhs_T>)
-                {
-                  return Lhs_T::value <= Rhs_T::value;
-                }
-              else
-                {
-                  return get (lhs_) <= get (rhs_);
-                }
+                        if constexpr (type_traits::has_value_v<Lhs_T>
+                                      and type_traits::has_value_v<Rhs_T>)
+                          {
+                            return Lhs_T::value <= Rhs_T::value;
+                          }
+                        else
+                          {
+                            return get (lhs_) <= get (rhs_);
+                          }
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-            }() }
+                      }() }
       {
       }
 
@@ -1522,21 +1542,22 @@ namespace micro_os_plus::micro_test_plus
        * member for efficient access.
        */
       constexpr explicit throws_ (const Callable_T& func)
-          : value_{ [&func] {
-              try
-                {
-                  func ();
-                }
-              catch (const Exception_T&)
-                {
-                  return true;
-                }
-              catch (...)
-                {
-                  return false;
-                }
-              return false;
-            }() }
+          : value_{ [&func]
+                      {
+                        try
+                          {
+                            func ();
+                          }
+                        catch (const Exception_T&)
+                          {
+                            return true;
+                          }
+                        catch (...)
+                          {
+                            return false;
+                          }
+                        return false;
+                      }() }
       {
       }
 
@@ -1605,17 +1626,18 @@ namespace micro_os_plus::micro_test_plus
        * @param func The callable object to be invoked.
        */
       constexpr explicit throws_ (const Callable_T& func)
-          : value_{ [&func] {
-              try
-                {
-                  func ();
-                }
-              catch (...)
-                {
-                  return true;
-                }
-              return false;
-            }() }
+          : value_{ [&func]
+                      {
+                        try
+                          {
+                            func ();
+                          }
+                        catch (...)
+                          {
+                            return true;
+                          }
+                        return false;
+                      }() }
       {
       }
 
@@ -1682,17 +1704,18 @@ namespace micro_os_plus::micro_test_plus
        * member for efficient access.
        */
       constexpr explicit nothrow_ (const Callable_T& func)
-          : value_{ [&func] {
-              try
-                {
-                  func ();
-                }
-              catch (...)
-                {
-                  return false;
-                }
-              return true;
-            }() }
+          : value_{ [&func]
+                      {
+                        try
+                          {
+                            func ();
+                          }
+                        catch (...)
+                          {
+                            return false;
+                          }
+                        return true;
+                      }() }
       {
       }
 

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

@@ -143,11 +143,11 @@ namespace micro_os_plus::micro_test_plus
     {
       if (value_)
         {
-          reporter.pass (expr_, message_);
+          reporter->pass (expr_, message_);
         }
       else
         {
-          reporter.fail (expr_, abort_, message_, location_);
+          reporter->fail (expr_, abort_, message_, location_);
         }
     }
 

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

@@ -418,6 +418,8 @@ namespace micro_os_plus::micro_test_plus
   void
   test_reporter::pass (Expr_T& expr, std::string& message)
   {
+    current_test_suite->current_test_case.index++;
+
     output_pass_prefix_ (message);
 
     if (message.empty ())
@@ -443,14 +445,17 @@ namespace micro_os_plus::micro_test_plus
   test_reporter::fail (Expr_T& expr, bool abort, std::string& message,
                        const reflection::source_location& location)
   {
-    output_fail_prefix_ (message, location);
+    current_test_suite->current_test_case.index++;
+
+    const bool hasExpression = type_traits::is_op_v<Expr_T>;
+    output_fail_prefix_ (message, hasExpression, location);
 
     if constexpr (type_traits::is_op_v<Expr_T>)
       {
-        *this << ", " << expr;
+        *this << expr;
       }
 
-    output_fail_suffix_ (abort);
+    output_fail_suffix_ (location, abort);
   }
 
   // --------------------------------------------------------------------------