RhodeCode

  /// @{

  ///\e

  class AssertionFailedError : public LogicError {

  protected:

    const char *_assertion;

    const char *_file;

    int _line;

    const char *_function;

    const char *_message;

    mutable ExceptionMember<std::string> _message_holder;

  public:

    ///\e

    AssertionFailedError(const char *file, int line, const char *function,

			 const char *msg, const char *assertion = 0) :

      _assertion(assertion), _file(file), _line(line), 

      _function(function), _message(msg) {}

    ///\e

    const char* assertion() const { return _assertion; }

    ///\e

    const char* message() const { return _message; }

    ///\e

    const char* file() const { return _file; }

    ///\e

    const char* function() const { return _function; }

    ///\e

    int line() const { return _line; }

    virtual const char* what() const throw() {

      try {

	std::ostringstream ostr;

	ostr << _file << ":" << _line << ": ";

	if (_function)

	  ostr << _function << ": ";

	ostr << _message;

	if (_assertion)

	   ostr << " (assertion '" << _assertion << "' failed)";

	_message_holder.set(ostr.str());

	return ostr.str().c_str();

      }

      catch(...) {}

      if( _message_holder.valid() ) return _message_holder.get().c_str();

      return "lemon::AssertionFailedError";

    }

    virtual ~AssertionFailedError() throw() {}

  };

  inline void assert_fail_log(const char *file, int line,

			      const char *function,

			      const std::exception& exception, 

			      const char *assertion)

  {

    std::cerr << file << ":" << line << ": ";

    if (function)

      std::cerr << function << ": ";

    std::cerr << exception.what();

    if (assertion)

      std::cerr << " (assertion '" << assertion << "' failed)";

    std::cerr << std::endl;

  }

  inline void assert_fail_log(const char *file, int line, const char *function, 

			      const std::string& message, const char *assertion)

  {

    assert_fail_log(file, line, function, message.c_str(), assertion);

  }

  inline void assert_fail_abort(const char *file, int line, 

				const char *function,

				const std::exception& exception,

				const char *assertion)

  {

    assert_fail_log(file, line, function, exception, assertion);

    std::abort();

  }

  inline void assert_fail_abort(const char *file, int line, 

				const char *function, 

				const std::string& message,

				const char *assertion)

  {

    assert_fail_log(file, line, function, message.c_str(), assertion);

    std::abort();

  inline void assert_fail_error(const char *file, int line, 

				  const char *function,

				  const std::exception& exception,

				  const char *assertion)

  {

    throw AssertionFailedError(file, line, function, 

			       exception.what(), assertion);

  }

  inline void assert_fail_error(const char *file, int line,

				  const char *function, const char *message,

				  const char *assertion)

  {

    throw AssertionFailedError(file, line, function, message, assertion);

  }

  inline void assert_fail_error(const char *file, int line,

				  const char *function, 

				  const std::string& message,

				  const char *assertion)

  {

    throw AssertionFailedError(file, line, function, message.c_str(), assertion);

  }

  template <typename Exception>

  inline void assert_fail_exception(const char *, int, const char *,

				    const Exception& exception,

				    const char *, const std::exception* = 

				    static_cast<const Exception*>(0))

  {

    throw exception;

  }

  inline void assert_fail_exception(const char *file, int line,

				    const char *function, const char *message,

				    const char *assertion)

  {

    throw AssertionFailedError(file, line, function, message, assertion);

  }

  inline void assert_fail_exception(const char *file, int line, 

				    const char *function, 

				    const std::string& message,

				    const char *assertion)

  {

    throw AssertionFailedError(file, line, function, message.c_str(), assertion);

  }

/// @}

}

  (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +		\

  (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +		\

     (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +		\

     (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +	\

  defined(LEMON_DISABLE_ASSERTS)

#elif defined LEMON_ASSERT_ERROR

#  undef LEMON_ASSERT_HANDLER

#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_error

#elif defined LEMON_ASSERT_EXCEPTION

#  undef LEMON_ASSERT_HANDLER

#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception

#elif defined LEMON_ENABLE_ASSERTS

#else

#  undef LEMON_ASSERT_HANDLER

/// Macro for assertion with customizable message.  

/// \param exp An expression that must be convertible to \c bool.

/// If it is \c false, then an assertion is raised. The concrete

/// behaviour depends on the settings of the assertion system.

/// \param msg A <tt>const char*</tt>, a <tt>const std::string&</tt> or

/// a <tt>const std::exception&</tt> parameter, which can be used to

/// provide information about the circumstances of the failed assertion.

/// The assertions are disabled in the default behaviour.

/// You can enable them with the following code:

/// #define LEMON_ENABLE_ASSERTS

/// g++ -DLEMON_ENABLE_ASSERTS

/// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'

/// - \c LEMON_ASSERT_ABORT This mode is similar to the

///   \c LEMON_ASSERT_LOG, but it aborts the program. It is the default

///   behaviour mode when the assertions are enabled with

///   \c LEMON_ENABLE_ASSERTS.

/// - \c LEMON_ASSERT_ERROR The assertion throws an

///   \ref lemon::AssertionFailedError "AssertionFailedError".

///   If the \c msg parameter is an exception, then the result of the

///   \ref lemon::Exception::what() "what()" member function is passed

///   as error message.

/// - \c LEMON_ASSERT_EXCEPTION If the specified \c msg is an

///   exception, then it raised directly (solving that the exception

///   can not be thrown polymorphically), otherwise an \ref

///   lemon::AssertionFailedError "AssertionFailedError" is thrown with

///   the given parameters.

///   functions. Three overloaded functions should be defined with the

///   following parameter lists:

///     void custom_assert_handler(const char* file, int line, const char* function,

///                                const std::string& message, const char* assertion);

///     void custom_assert_handler(const char* file, int line, const char* function,

///                                const std::exception& message, const char* assertion);

///   The name of the functions should be defined as the \c

///   Whenever an assertion is occured, one of the custom assertion

///   handlers is called with appropiate parameters.

			 msg, #exp), 0)))

       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\

			     "FIXME: " msg, static_cast<const char*>(0)))

#    define LEMON_ASSERT(exp, msg)                 \

       (static_cast<void> (!!(exp) ? 0 : (         \

         LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                              LEMON_FUNCTION_NAME, \

                              msg, #exp), 0)))

#    define LEMON_FIXME(msg) \

			     "FIXME: " msg,  static_cast<const char*>(0)))

void no_assertion_exception_disable() {

  LEMON_ASSERT(true, Exception());

}

void assertion_exception_disable() {

  LEMON_ASSERT(false, Exception());

}

  no_assertion_exception_disable();

  assertion_exception_disable();

#define LEMON_ASSERT_ERROR

#include <lemon/assert.h>

void no_assertion_text_error() {

  LEMON_ASSERT(true, "This is a fault message");

}

void no_assertion_exception_error() {

  LEMON_ASSERT(true, Exception());

}

void assertion_text_error() {

  LEMON_ASSERT(false, "This is a fault message");

}

void assertion_exception_error() {

  LEMON_ASSERT(false, Exception());

}

void fixme_error() {

  LEMON_FIXME("fixme_error() is fixme!");

}

void check_assertion_error() {

  no_assertion_text_error();

  no_assertion_exception_error();

  try {

    assertion_exception_error();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

  try {

    assertion_text_error();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

  try {

    fixme_error();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

}

#undef LEMON_ASSERT_ERROR

#define LEMON_ASSERT_EXCEPTION

#include <lemon/assert.h>

void no_assertion_text_exception() {

  LEMON_ASSERT(true, "This is a fault message");

}

void no_assertion_exception_exception() {

  LEMON_ASSERT(true, Exception());

}

void assertion_text_exception() {

  LEMON_ASSERT(false, "This is a fault message");

}

void assertion_exception_exception() {

  LEMON_ASSERT(false, Exception());

}

void fixme_exception() {

  LEMON_FIXME("fixme_exception() is fixme!");

}

void check_assertion_exception() {

  no_assertion_text_exception();

  no_assertion_exception_exception();

  try {

    assertion_exception_exception();

    check(false, "Assertion error");

  } catch (const Exception& e) {

  }

  try {

    assertion_text_exception();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

  try {

    assertion_text_exception();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

  try {

    fixme_exception();

    check(false, "Assertion error");

  } catch (const AssertionFailedError& e) {

  }

}

#undef LEMON_ASSERT_EXCEPTION

#define LEMON_ASSERT_LOG

#include <lemon/assert.h>

void no_assertion_text_log() {

  LEMON_ASSERT(true, "This is a fault message");

}

void no_assertion_exception_log() {

  LEMON_ASSERT(true, Exception());

}

void assertion_text_log() {

  LEMON_ASSERT(false, "This is a fault message");

}

void assertion_exception_log() {

  LEMON_ASSERT(false, Exception());

}

void fixme_log() {

  LEMON_FIXME("fixme_log() is fixme!");

}

void check_assertion_log() {

  no_assertion_text_log();

  no_assertion_exception_log();

  std::cerr << "The next 3 failure messages are expected: " << std::endl;

  assertion_exception_log();

  assertion_text_log();

  fixme_log();

  std::cerr << "End of expected error messages" << std::endl;

}

#undef LEMON_ASSERT_LOG

void my_assert_handler(const char*, int, const char*, 

		       const std::exception&, const char*) {

  ++cnt;

}

void my_assert_handler(const char*, int, const char*, 

		       const std::string&, const char*) {

  ++cnt;

}

void no_assertion_exception_custom() {

  LEMON_ASSERT(true, Exception());

}

void assertion_exception_custom() {

  LEMON_ASSERT(false, Exception());

}

  no_assertion_exception_custom();

  assertion_exception_custom();

  check(cnt == 3, "The custom assert handler does not work");

  check_assertion_error();

  check_assertion_exception();

  check_assertion_log();