Moose::UnitUtils Namespace Reference

Classes
class	TempFile
	Create a temporary file and delete it upon destruction. More...

Functions
template<class ExceptionType = std::exception, class Action = bool>
void	assertThrows (const Action &action, const std::optional< std::string > &contains={}, const bool set_throw_on_error=false)
	A helper for asserting that calling something throws an exception.
template<typename ExceptionType , bool exact, bool assert, bool set_throw_on_error, typename Func >
void	throwsWithMessage (Func &&fn, const std::string_view message, const char *file, int line)
	Helper for the [EXPECT,ASSERT]_[MOOSEERROR,THROW]_[MSG,MSG_CONTAINS] macros.

Function Documentation

assertThrows()

template<class ExceptionType = std::exception, class Action = bool>

void Moose::UnitUtils::assertThrows	(	const Action &	action,
		const std::optional< std::string > &	contains = {},
		const bool	set_throw_on_error = false
	)

A helper for asserting that calling something throws an exception.

Parameters

action	A function that calls the thing that should throw
contains	Optional argument to check that the assertion message contains this sub string
set_throw_on_error	Set to true to set moose to throw on error

Definition at line 33 of file MooseUnitUtils.h.

                                                       {},
             const bool set_throw_on_error = false)
{
  static_assert(std::is_base_of_v<std::exception, ExceptionType>, "Not an exception");
 
  std::unique_ptr<Moose::ScopedThrowOnError> scoped_throw_on_error;
  if (set_throw_on_error)
    scoped_throw_on_error = std::make_unique<Moose::ScopedThrowOnError>();
 
  try
  {
    action();
    FAIL() << "Expected " << MooseUtils::prettyCppType<ExceptionType>() << " not thrown";
  }
  catch (std::exception const & e)
  {
    if constexpr (!std::is_same_v<std::exception, ExceptionType>)
      if (!dynamic_cast<const ExceptionType *>(&e))
        FAIL() << "Threw " << demangle(typeid(e).name()) << " instead of "
               << MooseUtils::prettyCppType<ExceptionType>() << " with message '" << e.what()
               << "'";
 
    if (contains)
    {
      ASSERT_TRUE(std::string(e.what()).find(*contains) != std::string::npos)
          << "Exception \"" << e.what() << "\" does not contain \"" << *contains << "\"";
    }
  }
}

throwsWithMessage()

template<typename ExceptionType , bool exact, bool assert, bool set_throw_on_error, typename Func >

void Moose::UnitUtils::throwsWithMessage	(	Func &&	fn,
		const std::string_view	message,
		const char *	file,
		int	line
	)

Helper for the [EXPECT,ASSERT]_[MOOSEERROR,THROW]_[MSG,MSG_CONTAINS] macros.

Definition at line 69 of file MooseUnitUtils.h.

{
  static_assert(std::is_base_of_v<std::exception, ExceptionType>, "Not an exception");
 
  std::ostringstream error;
 
  try
  {
    std::unique_ptr<Moose::ScopedThrowOnError> scoped_throw_on_error;
    if constexpr (set_throw_on_error)
      scoped_throw_on_error = std::make_unique<Moose::ScopedThrowOnError>();
 
    fn();
 
    error << "Expected exception of type " << libMesh::demangle(typeid(ExceptionType).name())
          << " but no exception was thrown.";
  }
  catch (const ExceptionType & ex)
  {
    // Exact match
    if constexpr (exact)
    {
      if (std::string(ex.what()) == message)
        return;
    }
    // Partial match
    else
    {
      if (std::string(ex.what()).find(message) != std::string::npos)
        return;
    }
 
    error << "Expected" << (exact ? "" : " partial") << " exception message: \"" << message
          << "\"\n  Actual exception message: \"" << ex.what() << "\"";
  }
  catch (const std::exception & ex)
  {
    error << "Expected exception of type " << libMesh::demangle(typeid(ExceptionType).name())
          << " but exception of type " << libMesh::demangle(typeid(ex).name()) << " was thrown.";
  }
 
  ::testing::internal::AssertHelper(
      ::testing::TestPartResult::kNonFatalFailure, file, line, error.str().c_str()) =
      ::testing::Message();
}