LEMON/LEMON-main Changeset - r108:889d0c289d19

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r108:889d0c289d19

« 107:31a2e6

112:d2ee5e »
109:abddaa »

r108:889d0c289d19

Tue, 25 Mar 2008 16:36:44

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Reworking assertions and moving to distinict file

0 5 1

default

6 files changed with 225 insertions and 283 deletions:

lemon/Makefile.am

lemon/arg_parser.h

lemon/assert.h

bin

lemon/error.h

257

test/Makefile.am

test/error_test.cc

219

↑ Collapse diff ↑

lemon/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			lemon/Makefile \
 			lemon/lemon.pc.in
 		pkgconfig_DATA += lemon/lemon.pc
 		lib_LTLIBRARIES += lemon/libemon.la
 		lemon_libemon_la_SOURCES = \
 		        lemon/arg_parser.cc \
 		        lemon/base.cc \
 		        lemon/random.cc
 		lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)
 		lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
 		lemon_HEADERS += \
 		        lemon/arg_parser.h \
 			lemon/assert.h \
 		        lemon/bfs.h \
 		        lemon/bin_heap.h \
 		        lemon/dfs.h \
 		        lemon/dijkstra.h \
 		        lemon/dim2.h \
 			lemon/error.h \
 			lemon/graph_utils.h \
 			lemon/kruskal.h \
 			lemon/list_graph.h \
 			lemon/maps.h \
 			lemon/math.h \
 			lemon/path.h \
 		        lemon/random.h \
 		        lemon/tolerance.h \
 			lemon/unionfind.h
 		bits_HEADERS += \
 			lemon/bits/alteration_notifier.h \
 			lemon/bits/array_map.h \
 			lemon/bits/base_extender.h \
 			lemon/bits/default_map.h \
 			lemon/bits/graph_extender.h \
 		        lemon/bits/invalid.h \
 			lemon/bits/map_extender.h \
 			lemon/bits/path_dump.h \
 			lemon/bits/traits.h \
 		        lemon/bits/utility.h \
 			lemon/bits/vector_map.h
 		concept_HEADERS += \
 			lemon/concept_check.h \
 			lemon/concepts/digraph.h \
 			lemon/concepts/graph.h \
 			lemon/concepts/heap.h \
 			lemon/concepts/maps.h \
 			lemon/concepts/path.h \
 			lemon/concepts/graph_components.h

lemon/arg_parser.h

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_ARG_PARSER
 		#define LEMON_ARG_PARSER
 		#include <vector>
 		#include <map>
 		#include <list>
 		#include <string>
 		#include <iostream>
 		#include <sstream>
 		#include <algorithm>
-		#include <lemon/error.h>
+		#include <lemon/assert.h>
 		///\ingroup misc
 		///\file
 		///\brief A tool to parse command line arguments.
 		namespace lemon {
 		  ///Command line arguments parser
 		  ///\ingroup misc
 		  ///Command line arguments parser.
 		  ///
 		  ///For a complete example see the \ref arg_parser_demo.cc demo file.
 		  class ArgParser {
 		    static void _showHelp(void *p);
 		  protected:
 		    int _argc;
 		    const char **_argv;
 		    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };
 		    class ParData {
 		    public:
 		      union {
 			bool *bool_p;
 			int *int_p;
 			double *double_p;
 			std::string *string_p;
 			struct {
 			  void (*p)(void *);
 			  void *data;
 			} func_p;
 		      };
 		      std::string help;
 		      bool mandatory;
 		      OptType type;
 		      bool set;
 		      bool ingroup;
 		      bool has_syn;
 		      bool syn;
 		      bool self_delete;
 		      ParData() : mandatory(false), type(UNKNOWN), set(false), ingroup(false),
 				  has_syn(false), syn(false), self_delete(false) {}
 		    };

lemon/assert.h

Show inline comments

modified binary file

lemon/error.h

Show inline comments

@@ -48,97 +48,97 @@
 			ptr.reset(new Type());
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const Type& type) throw() {
 		      try {
 			ptr.reset(new Type());
 			if (ptr.get() == 0) return;
 			*ptr = type;
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const ExceptionMember& copy) throw() {
 		      try {
 			if (!copy.valid()) return;
 			ptr.reset(new Type());
 			if (ptr.get() == 0) return;
 			*ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    ExceptionMember& operator=(const ExceptionMember& copy) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 			if (!copy.valid()) return;
 		 	*ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    void set(const Type& type) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 			*ptr = type;
 		      } catch (...) {}
+		    }
 		    const Type& get() const {
 		      return *ptr;
+		    }
 		    bool valid() const throw() {
 		      return ptr.get() != 0;
+		    }
 		  private:
 		    std::auto_ptr<_Type> ptr;
 		  };
-		  /// Exception-safe convenient "error message" class.
+		  /// Exception-safe convenient error message builder class.
 		  /// Helper class which provides a convenient ostream-like (operator <<
 		  /// based) interface to create a string message. Mostly useful in
 		  /// exception classes (therefore the name).
 		  class ErrorMessage {
 		  protected:
 		    ///\e
 		    ///\todo The good solution is boost::shared_ptr...
 		    ///
 		    mutable std::auto_ptr<std::ostringstream> buf;
 		    ///\e
 		    bool init() throw() {
 		      try {
 			buf.reset(new std::ostringstream);
+		      }
 		      catch(...) {
 			buf.reset();
+		      }
 		      return buf.get();
+		    }
 		  public:
 		    ///\e
 		    ErrorMessage() throw() { init(); }
 		    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
 		    ///\e
 		    ErrorMessage(const char *msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    ErrorMessage(const std::string &msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    template <typename T>
 		    ErrorMessage& operator<<(const T &t) throw() {
 		      if( ! buf.get() ) return *this;
 		      try {
@@ -368,308 +368,53 @@
 		    ///\e
 		    explicit IoParameterError(const char *the_message)
 		      : _message(the_message) {}
 		    ///\e
 		    IoParameterError(const char *file_name, const char *the_message)
 		      : _message(the_message), _file(file_name) {}
 		     ///\e
 		    void message(const std::string& msg) { _message.set(msg); }
 		    ///\e
 		    void file(const std::string &fl) { _file.set(fl); }
 		     ///\e
 		    const char* message() const {
 		      if (_message.valid()) {
 			return _message.get().c_str();
 		      } else {
 			return 0;
+		      }
+		    }
 		    /// \brief Returns the filename.
 		    ///
 		    /// Returns \c 0 if the filename was not specified.
 		    const char* file() const {
 		      if (_file.valid()) {
 			return _file.get().c_str();
 		      } else {
 			return 0;
+		      }
+		    }
 		    ///\e
 		    virtual const char* what() const throw() {
 		      try {
 			std::ostringstream ostr;
 			if (message()) ostr << message();
 			if (file()) ostr << "(when reading file '" << file() << "')";
 			_message_holder.set(ostr.str());
+		      }
 		      catch (...) {}
 		      if( _message_holder.valid() ) return _message_holder.get().c_str();
 		      return "lemon:IoParameterError";
+		    }
 		    virtual ~IoParameterError() throw() {}
 		  };
 		  ///\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 *func,
 					 const char *msg, const char *_assertion = 0) :
 		      assertion(_assertion), file(_file), line(_line), function(func),
 		      message(msg) {}
 		    ///\e
 		    const char* get_assertion() const { return assertion; }
 		    ///\e
 		    const char* get_message() const { return message; }
 		    ///\e
 		    const char* get_file() const { return file; }
 		    ///\e
 		    const char* get_function() const { return function; }
 		    ///\e
 		    int get_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() {}
 		  };
 		  /****************  Macros  ****************/
 		  template <typename Exception>
 		  inline void assert_fail(const char *file, int line,
 		                          const char *func,
 		                          Exception exception,
 		                          const char *assertion = 0,
 		                          bool do_abort=true)
+		  {
 		    using namespace std;
 		    cerr << file << ":" << line << ": ";
 		    if (func)
 		      cerr << func << ": ";
 		    cerr << exception.what();
 		    if (assertion)
 		      cerr << " (assertion '" << assertion << "' failed)";
 		    cerr << endl;
 		    if (do_abort)
 		      abort();
+		  }
 		  template <>
 		  inline void assert_fail<const char *>(const char *file, int line,
 		                                        const char *func,
 		                                        const char *message,
 		                                        const char *assertion,
 		                                        bool do_abort)
+		  {
 		    using namespace std;
 		    cerr << file << ":" << line << ": ";
 		    if (func)
 		      cerr << func << ": ";
 		    cerr << message;
 		    if (assertion)
 		      cerr << " (assertion '" << assertion << "' failed)";
 		    cerr << endl;
 		    if (do_abort)
 		      abort();
+		  }
 		  template <>
 		  inline void assert_fail<std::string>(const char *file, int line,
 		                                       const char *func,
 		                                       std::string message,
 		                                       const char *assertion,
 		                                       bool do_abort)
+		  {
 		    assert_fail(file, line, func, message.c_str(), assertion, do_abort);
+		  }
 		  template <typename Exception>
 		  inline void assert_fail_failure(const char *file, int line, const char *func,
 					   Exception exception,
 					   const char *assertion = 0,
 					   bool = true)
+		  {
 		    throw AssertionFailedError(file, line, func, exception.what(), assertion);
+		  }
 		  template <>
 		  inline void assert_fail_failure<const char *>(const char *file, int line,
 		                                                const char *func,
 		                                                const char *message,
 		                                                const char *assertion,
 		                                                bool)
+		  {
 		    throw AssertionFailedError(file, line, func, message, assertion);
+		  }
 		  template <>
 		  inline void assert_fail_failure<std::string>(const char *file, int line,
 		                                               const char *func,
 		                                               std::string message,
 		                                               const char *assertion,
 		                                               bool)
+		  {
 		    assert_fail_failure(file, line, func, message.c_str(), assertion, true);
+		  }
 		  template <typename Exception>
 		  inline void assert_fail_exception(const char *file, int line, const char *func,
 					     Exception exception,
 					     const char *assertion = 0, bool = true)
+		  {
 		    throw exception;
+		  }
 		  template <>
 		  inline void assert_fail_exception<const char *>(const char *file, int line,
 							   const char *func,
 							   const char *message,
 							   const char *assertion,
 							   bool)
+		  {
 		    throw AssertionFailedError(file, line, func, message, assertion);
+		  }
 		  template <>
 		  inline void assert_fail_exception<std::string>(const char *file, int line,
 		                                                 const char *func,
 		                                                 std::string message,
 		                                                 const char *assertion,
 		                                                 bool)
+		  {
 		    assert_fail_exception(file, line, func, message.c_str(), assertion, true);
+		  }
 		/// @}
+		}
 		#endif // LEMON_ERROR_H
 		#undef LEMON_ASSERT
 		#undef LEMON_FIXME
 		#ifdef LEMON_ENABLE_ASSERTS
 		#  define LEMON_ASSERT_ABORT
 		#endif
 		#ifndef LEMON_ASSERT_DO_ABORT
 		#  define LEMON_ASSERT_DO_ABORT 1
 		#endif
 		#ifndef LEMON_ASSERT_HANDLER
 		#  if defined LEMON_ASSERT_EXCEPTION
 		#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception
 		#  elif defined LEMON_ASSERT_FAILURE
 		#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_failure
 		#  elif defined LEMON_ASSERT_ABORT
 		#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail
 		#  else
 		#    define LEMON_DISABLE_ASSERTS
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		/// \brief Macro for assertions with customizable message
 		///
 		/// Macro for assertions with customizable message.
 		///
 		/// The assertions are disabled in the default behaviour. You can
 		/// enable the assertions with the
 		/// \code
 		/// #define LEMON_ENABLE_ASSERTS
 		/// \endcode
 		/// Then an assert
 		/// provides a log on the standard error about the assertion and aborts
 		/// the program if LEMON_ASSERT_DO_ABORT is also defined (otherwise the
 		/// program keeps on running).
 		/// By defining LEMON_ASSERT_FAILURE or
 		/// LEMON_ASSERT_EXCEPTION, you can set other behaviour to the
 		/// assertions. In case LEMON_ASSERT_FAILURE is given, LEMON_ASSERT
 		/// will always throw an \c AssertionFailedError exception with
 		/// the \c msg error message. By using
 		/// LEMON_ASSERT_EXCEPTION, one can define an arbitrary exception to be thrown.
 		///
 		/// The LEMON_ASSERT macro should be called with the \c exp parameter
 		/// which should be an expression convertible to bool. If the given
 		/// parameter is false the assertion is raised and one of the assertion
 		/// behaviour will be activated. The \c msg should be either a const
 		/// char* message or an exception. When the \c msg is an exception the
 		/// \ref lemon::Exception::what() "what()" function is called to retrieve and
 		/// display the error message.
 		///
 		/// \todo We should provide some way to reset to the default behaviour,
 		/// shouldn't we?
 		///
 		/// \todo This whole 'assert' business should be placed in a separate
 		/// include file. The boost assert is not guarded by header sentries
 		/// which may help to change the behaviour of the assertions in
 		/// the files.
 		///
 		/// \todo __PRETTY_FUNCTION__ should be replaced by something
 		/// compiler-independent, like BOOST_CURRENT_FUNCTION
 		#  define LEMON_ASSERT(exp, msg)                 \
 		     (static_cast<void> (!!(exp) ? 0 : (         \
 		       LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
 		                            __PRETTY_FUNCTION__, \
 		                            msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))
 		#else
 		#  if defined LEMON_DISABLE_ASSERTS
 		#    define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
 		#  else
 		#    define LEMON_ASSERT(exp, msg)                 \
 		       (static_cast<void> (!!(exp) ? 0 : (         \
 		         LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
 		                              __PRETTY_FUNCTION__, \
 		                              msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))
 		#  endif
 		#endif
 		/**
 		 * \brief Macro for mark not yet implemented features.
+		 *
 		 * \todo Is this the right place for this? It should be used only in
 		 * modules under development.
+		 *
 		 * \todo __PRETTY_FUNCTION__ should be replaced by something
 		 * compiler-independent, like BOOST_CURRENT_FUNCTION
 		 */
 		#define LEMON_FIXME(msg) \
 		    (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
 					  "FIXME: " msg))

test/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			test/Makefile
 		noinst_HEADERS += \
 			test/digraph_test.h \
 			test/heap_test.h \
 			test/map_test.h \
 		        test/test_tools.h
 		check_PROGRAMS += \
 			test/bfs_test \
 			test/dfs_test \
 			test/digraph_test \
 		        test/dim_test \
 			test/error_test \
 			test/graph_test \
 			test/kruskal_test \
 		        test/maps_test \
 		        test/random_test \
 		        test/path_test \
 		        test/test_tools_fail \
 		        test/test_tools_pass \
 			test/unionfind_test
 		TESTS += $(check_PROGRAMS)
 		XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
 		test_bfs_test_SOURCES = test/bfs_test.cc
 		test_dfs_test_SOURCES = test/dfs_test.cc
 		test_digraph_test_SOURCES = test/digraph_test.cc
 		test_dim_test_SOURCES = test/dim_test.cc
-		#test_error_test_SOURCES = test/error_test.cc
 		test_error_test_SOURCES = test/error_test.cc
 		test_graph_test_SOURCES = test/graph_test.cc
 		# test_heap_test_SOURCES = test/heap_test.cc
 		test_kruskal_test_SOURCES = test/kruskal_test.cc
 		test_maps_test_SOURCES = test/maps_test.cc
 		test_path_test_SOURCES = test/path_test.cc
 		test_random_test_SOURCES = test/random_test.cc
 		test_test_tools_fail_SOURCES = test/test_tools_fail.cc
 		test_test_tools_pass_SOURCES = test/test_tools_pass.cc
 		test_unionfind_test_SOURCES = test/unionfind_test.cc

test/error_test.cc

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include <iostream>
 		#include <lemon/error.h>
 		#include "test_tools.h"
 		using namespace lemon;
 		using std::cout;
 		using std::endl;
 		void faulty_fn() {
 		  fault("This is a fault message");
 		#ifdef LEMON_ENABLE_ASSERTS
 		#undef LEMON_ENABLE_ASSERTS
 		#endif
 		#ifdef LEMON_DISABLE_ASSERTS
 		#undef LEMON_DISABLE_ASSERTS
 		#endif
 		//checking disabled asserts
 		#define LEMON_DISABLE_ASSERTS
 		#include <lemon/assert.h>
 		void no_assertion_text_disable() {
 		  LEMON_ASSERT(true, "This is a fault message");
+		}
 		void exception_fn() {
 		  throw Exception("This is a function throwing exception with some args: ")
-		    << 5 << ", " << 18;
+		void no_assertion_exception_disable() {
 		  LEMON_ASSERT(true, Exception());
+		}
 		void unfinished_fn() {
 		  LEMON_FIXME("unfinished_fn() is unfinished!");
 		void assertion_text_disable() {
 		  LEMON_ASSERT(false, "This is a fault message");
+		}
 		void assertion_exception_disable() {
 		  LEMON_ASSERT(false, Exception());
+		}
-		int main() {
+		void fixme_disable() {
 		  LEMON_FIXME("fixme_disable() is fixme!");
+		}
 		void check_assertion_disable() {
 		  no_assertion_text_disable();
 		  no_assertion_exception_disable();
 		  assertion_exception_disable();
 		  assertion_text_disable();
 		  fixme_disable();
+		}
 		#undef LEMON_DISABLE_ASSERTS
 		#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 {
 		    faulty_fn();
 		    check(false, "A faulty function did not fail.");
+		  }
 		  catch(const Exception &e) {
-		    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;
+		    assertion_exception_error();
 		    check(false, "Assertion error");
 		  } catch (const AssertionFailedError& e) {
+		  }
 		  try {
 		    exception_fn();
 		    check(false, "The function did not throw Exception.");
+		  }
 		  catch(const Exception &e) {
-		    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;
+		    assertion_text_error();
 		    check(false, "Assertion error");
 		  } catch (const AssertionFailedError& e) {
+		  }
 		  try {
 		    unfinished_fn();
 		    check(false, "FIXME macro does not work.");
 		    fixme_error();
 		    check(false, "Assertion error");
 		  } catch (const AssertionFailedError& e) {
+		  }
 		  catch(const Exception &e) {
 		    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;
+		  }
 		#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
 		#define LEMON_ASSERT_CUSTOM
 		static int cnt = 0;
 		void my_assert_handler(const char*, int, const char*,
 				       const char*, const char*) {
 		  ++cnt;
+		}
 		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;
+		}
 		#define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler
 		#include <lemon/assert.h>
 		void no_assertion_text_custom() {
 		  LEMON_ASSERT(true, "This is a fault message");
+		}
 		void no_assertion_exception_custom() {
 		  LEMON_ASSERT(true, Exception());
+		}
 		void assertion_text_custom() {
 		  LEMON_ASSERT(false, "This is a fault message");
+		}
 		void assertion_exception_custom() {
 		  LEMON_ASSERT(false, Exception());
+		}
 		void fixme_custom() {
 		  LEMON_FIXME("fixme_custom() is fixme!");
+		}
 		void check_assertion_custom() {
 		  no_assertion_text_custom();
 		  no_assertion_exception_custom();
 		  assertion_exception_custom();
 		  assertion_text_custom();
 		  fixme_custom();
 		  check(cnt == 3, "The custom assert handler does not work");
+		}
 		#undef LEMON_ASSERT_CUSTOM
 		int main() {
 		  check_assertion_disable();
 		  check_assertion_error();
 		  check_assertion_exception();
 		  check_assertion_log();
 		  check_assertion_custom();
 		  return 0;
+		}

0 comments (0 inline)

RhodeCode

Login to your account