Utility Functions

Utility functions for advanced string handling in tests. More...

Functions
const char *	micro_os_plus::micro_test_plus::utility::extract_file_name (const char *path) noexcept
	Extracts the file name component from a full path.
bool	micro_os_plus::micro_test_plus::utility::is_match (std::string_view input, std::string_view pattern)
	Check if a string matches a pattern.
template<class T>
constexpr auto	micro_os_plus::micro_test_plus::mut (const T &t) noexcept -> T &
	Generic mutator to remove const qualification from any type.
template<class T = std::string_view, class Delim_T>
auto	micro_os_plus::micro_test_plus::utility::split (T input, Delim_T delim) -> std::vector< T >
	Split a string into a vector of sub-strings.

Detailed Description

These utilities simplify advanced string operations commonly required during test development. They support tasks such as partial string matching, splitting long strings for improved readability, and related manipulations that enhance the clarity and effectiveness of test code.

Function Documentation

extract_file_name()

const char * micro_os_plus::micro_test_plus::utility::extract_file_name ( const char * path )

nodiscardnoexcept

Parameters

[in]

path

A null-terminated file path string.

Returns

A pointer to the first character of the file name within path, or path itself if no directory separator is found.

The extract_file_name function extracts the file name from a given file path, handling both Unix-style (/) and Windows-style (\\endiskip) path separators. It returns a pointer to the start of the file name within the input string, or the original string if no separators are found.

This utility is particularly useful for test reporting, allowing for concise display of file names without full paths.

Example

const char* path = "/home/user/project/test.cpp";
const char* filename = utility::extract_file_name (path);
// filename now points to "test.cpp"

Definition at line 85 of file utility.cpp.

    {
      const std::string_view sv{ path };
      const auto pos = sv.find_last_of ("/\\");
      if (pos == std::string_view::npos)
        {
          return path; // No separators found, return original string.
        }
      return sv.substr (pos + 1).data ();
    }

Referenced by micro_os_plus::micro_test_plus::runner::initialise().

is_match()

bool micro_os_plus::micro_test_plus::utility::is_match ( std::string_view input, std::string_view pattern )

nodiscard

Parameters

[in]	input	The string view to be checked.
[in]	pattern	The string view containing the pattern to match.

Returns

true if the input string matches the pattern; otherwise, false.

This function enables pattern-based string comparison for tests, supporting both exact matches and wildcard patterns. The pattern may include * to match any sequence of characters and ? to match any single character. This allows for flexible validation of string content in test assertions, accommodating variable or partially known values.

Warning

The * wildcard is handled via recursion with a linear loop, giving $O(2^n)$ worst-case complexity in the number of * wildcards (e.g. a pattern such as "a*a*a*b" against a long string of 'a' characters). For the typical short suite-name patterns used in a test framework this is not a concern, but callers should avoid patterns with many consecutive wildcards against long input strings.

Examples

namespace mt = micro_os_plus::micro_test_plus;
 
t.expect (mt::utility::is_match ("abc", "a?c")) << "abc matches a?c";
t.expect (mt::utility::is_match ("abc", "a*c")) << "abc matches a*c";

Definition at line 124 of file utility.cpp.

    {
      if (std::empty (pattern))
        {
          return std::empty (input);
        }
 
      if (std::empty (input))
        {
          return pattern[0] == '*' ? is_match (input, pattern.substr (1))
                                   : false;
        }
 
      if (pattern[0] != '?' and pattern[0] != '*' and pattern[0] != input[0])
        {
          return false;
        }
 
      if (pattern[0] == '*')
        {
          for (decltype (std::size (input)) i = 0u; i <= std::size (input);
               ++i)
            {
              if (is_match (input.substr (i), pattern.substr (1)))
                {
                  return true;
                }
            }
          return false;
        }
 
      return is_match (input.substr (1), pattern.substr (1));
    }

References is_match().

Referenced by is_match().

mut()

template<class T>

auto micro_os_plus::micro_test_plus::mut ( const T & t ) -> T &

nodiscardconstexprnoexcept

Template Parameters

T	The type of the input object.

Parameters

[in]

t

The object from which to remove const qualification.

Returns

A non-const reference to the input object.

The mut function template provides a safe and generic mechanism to remove the const qualifier from any type. It returns a non-const reference to the input object, enabling modification of objects that were originally declared as const. This utility is particularly useful in testing scenarios where controlled mutation of test data is required.

Definition at line 325 of file function-comparators-inlines.h.

  {
    return const_cast<T&> (t);
  }

split()

template<class T = std::string_view, class Delim_T>

auto micro_os_plus::micro_test_plus::utility::split ( T input, Delim_T delim ) -> std::vector< T >

nodiscard

This function template facilitates string handling in tests by splitting a string into a vector of substrings, using the specified delimiter.

The function iterates through the input string, identifying delimiter positions and extracting substrings between them. Each resulting substring is added to the output vector. This approach supports flexible parsing of delimited data, which is particularly useful for validating string processing logic in test cases.

Example

namespace mt = micro_os_plus::micro_test_plus;
 
t.expect (std::vector<std::string_view>{ "a", "b" }
            == mt::utility::split<std::string_view> ("a.b", "."))
        << "a.b splits into [a,b]";

Template Parameters

T	Type of the input string.
Delim_T	Type of the delimiter.

Parameters

[in]	input	Input string to split.
[in]	delim	Delimiter string.

Returns

A vector containing the resulting sub-strings.

Definition at line 88 of file utility-inlines.h.

    {
      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;
    }