micro_os_plus::micro_test_plus::reflection Namespace Reference

Reflection utilities for the µTest++ testing framework. More...

Classes
class	source_location
	Local implementation of source location information for diagnostics. More...

Functions
const char *	short_name (const char *name) noexcept
	Extract a short type or function name from a fully qualified name.
template<class T>
constexpr auto	type_name (void) -> std::string_view
	Extract the type name from the __PRETTY_FUNCTION__ macro.

Detailed Description

The reflection namespace provides facilities for obtaining source location information and type names at compile time, thereby supporting advanced reporting and diagnostics within the µTest++ framework.

It includes a local implementation of source_location for environments lacking C++20 standard support, as well as utilities for extracting concise type names from compiler-specific macros such as __PRETTY_FUNCTION__.

All definitions within this namespace are intended to facilitate advanced reflection and reporting capabilities.

Function Documentation

short_name()

const char * micro_os_plus::micro_test_plus::reflection::short_name ( const char * name )

noexcept

Parameters

name	The fully qualified name as a C-string.

Returns

A pointer to the short name within the input string.

This function extracts the short name from a given file path by locating the final folder separator ('/'). If a separator is found, it returns a pointer to the character immediately following it, effectively providing the file or folder name. If no separator is present, the original input string is returned. This utility is useful for reporting concise file or folder names in test output.

Definition at line 74 of file reflection.cpp.

    {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
#endif
      const char* p = strrchr (name, '/');
      if (p != nullptr)
        return p + 1;
      else
        return name;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
    }

Referenced by micro_os_plus::micro_test_plus::runner::abort(), micro_os_plus::micro_test_plus::reporter_human::output_fail_prefix_(), and micro_os_plus::micro_test_plus::reporter_tap::output_fail_suffix_().

type_name()

template<class T>

auto micro_os_plus::micro_test_plus::reflection::type_name ( void ) -> std::string_view

nodiscardconstexpr

This function template parses the compiler-specific __PRETTY_FUNCTION__ macro to extract a concise type name for the template parameter T.

Rather than relying on fixed character offsets (which are fragile across compiler versions and namespace changes), the implementation searches for well-known marker characters in the function signature string:

• Clang formats the signature as "... [T = <typename>]", so the type name lies between the last '[' (skipping "[T = ") and the last ']'.
• GCC formats the signature as "... [with T = <typename>]", so the type name lies between the last '=' (skipping the trailing space) and the last ']'.

This approach is resilient to namespace renaming, namespace nesting changes, and compiler format updates.

Template Parameters

T	The type whose name is to be extracted.

Parameters

None.

Returns

A std::string_view containing the extracted type name.

Definition at line 145 of file reflection-inlines.h.

    {
      const std::string_view sv = __PRETTY_FUNCTION__;
#if defined(__clang__)
      // Clang: "... [T = <typename>]"
      // rfind('[') locates the opening bracket of "[T = ...]".
      const auto start = sv.rfind ('[') + 5; // skip "[T = "
      const auto end = sv.rfind (']');
#elif defined(__GNUC__)
      // GCC: "... [with T = <typename>]" or, on some versions,
      //      "... [with T = <typename>; std::string_view = ...]"
      // Search for "T = " explicitly to avoid landing on a later '='.
      const auto t_eq = sv.find ("T = ");
      const auto start = t_eq + 4; // skip "T = "
      const auto semi = sv.find (';', start);
      const auto end
          = (semi != std::string_view::npos) ? semi : sv.rfind (']');
#else
// Note: MSVC uses __FUNCSIG__ instead of __PRETTY_FUNCTION__.
// MSVC is not a supported target for this framework.
#error "Unsupported compiler"
#endif
      return sv.substr (start, end - start);
    }

Referenced by micro_os_plus::micro_test_plus::detail::expression_formatter::operator<<().