1 files changed, 220 insertions, 8 deletions
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestAssert.h b/3rdParty/CppUnit/src/include/cppunit/TestAssert.h
index f74797b..bb29ac0 100644
--- a/3rdParty/CppUnit/src/include/cppunit/TestAssert.h
+++ b/3rdParty/CppUnit/src/include/cppunit/TestAssert.h
@@ -2,32 +2,48 @@
 #define CPPUNIT_TESTASSERT_H
 
 #include <cppunit/Portability.h>
 #include <cppunit/Exception.h>
 #include <cppunit/Asserter.h>
 #include <cppunit/portability/Stream.h>
+#include <cppunit/tools/StringHelper.h>
 #include <stdio.h>
 #include <float.h> // For struct assertion_traits<double>
 
+// Work around "passing 'T' chooses 'int' over 'unsigned int'" warnings when T
+// is an enum type:
+#if defined __GNUC__ && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6))
+#pragma GCC system_header
+#endif
 
-CPPUNIT_NS_BEGIN
 
+CPPUNIT_NS_BEGIN
 
-/*! \brief Traits used by CPPUNIT_ASSERT_EQUAL().
+/*! \brief Traits used by CPPUNIT_ASSERT* macros.
  *
  * Here is an example of specialising these traits: 
  *
  * \code
  * template<>
  * struct assertion_traits<std::string>   // specialization for the std::string type
  * {
  *   static bool equal( const std::string& x, const std::string& y )
  *   {
  *     return x == y;
  *   }
- * 
+ *
+ *   static bool less( const std::string& x, const std::string& y )
+ *   {
+ *      return x < y;
+ *   }
+ *
+ *   static bool lessEqual( const std::string& x, const std::string& y )
+ *   {
+ *      return x <= y;
+ *   }
+ *
  *   static std::string toString( const std::string& x )
  *   {
  *     std::string text = '"' + x + '"';    // adds quote around the string to see whitespace
  *     OStringStream ost;
  *     ost << text;
  *     return ost.str();
@@ -40,21 +56,28 @@ struct assertion_traits
 {  
     static bool equal( const T& x, const T& y )
     {
         return x == y;
     }
 
+    static bool less( const T& x, const T& y )
+    {
+        return x < y;
+    }
+
+    static bool lessEqual( const T& x, const T& y )
+    {
+        return x <= y;
+    }
+
     static std::string toString( const T& x )
     {
-        OStringStream ost;
-        ost << x;
-        return ost.str();
+        return CPPUNIT_NS::StringHelper::toString(x);
     }
 };
 
-
 /*! \brief Traits used by CPPUNIT_ASSERT_DOUBLES_EQUAL(). 
  * 
  * This specialisation from @c struct @c assertion_traits<> ensures that 
  * doubles are converted in full, instead of being rounded to the default 
  * 6 digits of precision. Use the system defined ISO C99 macro DBL_DIG 
  * within float.h is available to define the maximum precision, otherwise
@@ -65,12 +88,22 @@ struct assertion_traits<double>
 {  
     static bool equal( double x, double y )
     {
         return x == y;
     }
 
+    static bool less( double x, double y )
+    {
+        return x < y;
+    }
+
+    static bool lessEqual( double x, double y )
+    {
+        return x <= y;
+    }
+
     static std::string toString( double x )
     {
 #ifdef DBL_DIG
        const int precision = DBL_DIG;
 #else
        const int precision = 15;
@@ -115,12 +148,88 @@ void CPPUNIT_API assertDoubleEquals( double expected,
                                      double actual,
                                      double delta,
                                      SourceLine sourceLine, 
                                      const std::string &message );
 
 
+/*! \brief (Implementation) Asserts that an object is less than another one of the same type
+ * Use CPPUNIT_ASSERT_LESS, CPPUNIT_ASSERT_GREATER instead of this function.
+ * \sa assertion_traits, Asserter::failNotLess().
+ */
+template <class T>
+void assertLess( const T& expected,
+                 const T& actual,
+                 SourceLine sourceLine,
+                 const std::string& message )
+{
+    if ( !assertion_traits<T>::less(actual,expected) )
+    {
+        Asserter::failNotLess( assertion_traits<T>::toString(expected),
+                               assertion_traits<T>::toString(actual),
+                               sourceLine,
+                               message );
+    }
+}
+
+
+/*! \brief (Implementation) Asserts that an object is less than another one of the same type
+ * Use CPPUNIT_ASSERT_LESS, CPPUNIT_ASSERT_GREATER instead of this function.
+ * \sa assertion_traits, Asserter::failNotLess().
+ */
+template <class T>
+void assertGreater( const T& expected,
+                 const T& actual,
+                 SourceLine sourceLine,
+                 const std::string& message )
+{
+    if ( !assertion_traits<T>::less(expected,actual) )
+    {
+        Asserter::failNotGreater( assertion_traits<T>::toString(expected),
+                               assertion_traits<T>::toString(actual),
+                               sourceLine,
+                               message );
+    }
+}
+
+/*! \brief (Implementation) Asserts that two objects of the same type are equals.
+ * Use CPPUNIT_ASSERT_LESSEQUAL, CPPUNIT_ASSERT_GREATEREQUAL instead of this function.
+ * \sa assertion_traits, Asserter::failNotLessEqual().
+ */
+template <class T>
+void assertLessEqual( const T& expected,
+                      const T& actual,
+                      SourceLine sourceLine,
+                      const std::string& message )
+{
+    if ( !assertion_traits<T>::lessEqual(actual,expected) )
+    {
+        Asserter::failNotLessEqual( assertion_traits<T>::toString(expected),
+                               assertion_traits<T>::toString(actual),
+                               sourceLine,
+                               message );
+    }
+}
+
+/*! \brief (Implementation) Asserts that two objects of the same type are equals.
+ * Use CPPUNIT_ASSERT_LESSEQUAL, CPPUNIT_ASSERT_GREATEREQUAL instead of this function.
+ * \sa assertion_traits, Asserter::failNotLessEqual().
+ */
+template <class T>
+void assertGreaterEqual( const T& expected,
+                      const T& actual,
+                      SourceLine sourceLine,
+                      const std::string& message )
+{
+    if ( !assertion_traits<T>::lessEqual(expected,actual) )
+    {
+        Asserter::failNotGreaterEqual( assertion_traits<T>::toString(expected),
+                               assertion_traits<T>::toString(actual),
+                               sourceLine,
+                               message );
+    }
+}
 /* A set of macros which allow us to get the line number
  * and file name at the point of an error.
  * Just goes to show that preprocessors do have some
  * redeeming qualities.
  */
 #if CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION
@@ -214,12 +323,115 @@ void CPPUNIT_API assertDoubleEquals( double expected,
   ( CPPUNIT_NS::assertEquals( (expected),              \
                               (actual),                \
                               CPPUNIT_SOURCELINE(),    \
                               (message) ) )
 #endif
 
+/** Asserts that actual is less than expected, provides additional message on failure.
+ * \ingroup Assertions
+ *
+ * Less and string representation can be defined with
+ * an appropriate assertion_traits class.
+ *
+ * A diagnostic is printed if actual is less than expected.
+ * The message is printed in addition to the expected and actual value
+ * to provide additional information.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator <. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ *
+ * \sa CPPUNIT_ASSERT_GREATER
+ */
+#define CPPUNIT_ASSERT_LESS(expected, actual)          \
+    ( CPPUNIT_NS::assertLess( (expected),              \
+                              (actual),                \
+                              CPPUNIT_SOURCELINE(),    \
+                              "" ) )
+
+/** Asserts that actual is greater than expected, provides additional message on failure.
+ * \ingroup Assertions
+ *
+ * String representation can be defined with
+ * an appropriate assertion_traits class. For comparison assertLess is used.
+ *
+ * A diagnostic is printed if actual is less than expected.
+ * The message is printed in addition to the expected and actual value
+ * to provide additional information.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator<. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ *
+ * \sa CPPUNIT_ASSERT_LESS
+ */
+#define CPPUNIT_ASSERT_GREATER(expected, actual)       \
+    ( CPPUNIT_NS::assertGreater( (expected),           \
+                                 (actual),             \
+                                 CPPUNIT_SOURCELINE(), \
+                                 "" ) )
+
+/** Asserts that actual is less or equal than expected, provides additional message on failure.
+ * \ingroup Assertions
+ *
+ * LessEqual and string representation can be defined with
+ * an appropriate assertion_traits class.
+ *
+ * A diagnostic is printed if actual is greater than expected.
+ * The message is printed in addition to the expected and actual value
+ * to provide additional information.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator <=. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ *
+ * \sa CPPUNIT_ASSERT_GREATEREQUAL
+ */
+#define CPPUNIT_ASSERT_LESSEQUAL(expected, actual)               \
+    ( CPPUNIT_NS::assertLessEqual( (expected),              \
+                                   (actual),                \
+                                   CPPUNIT_SOURCELINE(),    \
+                                   "" ) )
+
+/** Asserts that actual is greater than expected, provides additional message on failure.
+ * \ingroup Assertions
+ *
+ * String representation can be defined with
+ * an appropriate assertion_traits class. For comparison assertLess is used.
+ *
+ * A diagnostic is printed if actual is less than expected.
+ * The message is printed in addition to the expected and actual value
+ * to provide additional information.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator<=. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ *
+ * \sa CPPUNIT_ASSERT_LESSEQUAL
+ */
+#define CPPUNIT_ASSERT_GREATEREQUAL(expected, actual)            \
+    ( CPPUNIT_NS::assertGreaterEqual( (expected),                \
+                                      (actual),              \
+                                      CPPUNIT_SOURCELINE(),    \
+                                      "" ) )
 /*! \brief Macro for primitive double value comparisons. 
  * \ingroup Assertions
  *
  * The assertion pass if both expected and actual are finite and
  * \c fabs( \c expected - \c actual ) <= \c delta.
  * If either \c expected or actual are infinite (+/- inf), the 
@@ -260,13 +472,13 @@ void CPPUNIT_API assertDoubleEquals( double expected,
    CPPUNIT_ASSERT_THROW_MESSAGE( CPPUNIT_NS::AdditionalMessage(),       \
                                  expression,                            \
                                  ExceptionType )
 
 
 // implementation detail
-#if CPPUNIT_USE_TYPEINFO_NAME
+#if defined(CPPUNIT_USE_TYPEINFO_NAME)
 #define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
    CPPUNIT_NS::TypeInfoHelper::getClassName( typeid(exception) )
 #else
 #define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
    std::string( no_rtti_message )
 #endif // CPPUNIT_USE_TYPEINFO_NAME