diff -rC 5 cppunit/examples/cppunittest/TestAssertTest.cpp cppunit_mod/examples/cppunittest/TestAssertTest.cpp
*** cppunit/examples/cppunittest/TestAssertTest.cpp	Mon Jun 26 18:03:11 2006
--- cppunit_mod/examples/cppunittest/TestAssertTest.cpp	Tue Jun 27 14:30:34 2006
***************
*** 126,140 ****
--- 126,163 ----
  {
    CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_EQUAL( 1, 1 ) );
    CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_EQUAL( 1, foo() ) );
    CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_EQUAL( 12345678, 12345678 ) );
  
+   std::string s("a string");
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_EQ( "a string", s ) );
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_EQ( s, "a string") );
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_EQ( s, "another string" ) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_EQ( "another string", s ) );
+ 
    CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_EQUAL( 1, 2 ) );
  }
  
  
  void 
+ TestAssertTest::testAssertNotEqual()
+ {
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_EQUAL( 1, 1 ) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_EQUAL( 1, foo() ) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_EQUAL(12345678,12345678));
+ 
+   std::string s("a string");
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_EQ( "a string", s ) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_EQ( s, "a string") );
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_NOT_EQ( s, "another string"));
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_NOT_EQ( "another string", s));
+ 
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_NOT_EQUAL( 1, 2 ) );
+ }
+ 
+ 
+ void 
  TestAssertTest::testAssertMessageTrue()
  {
    CPPUNIT_ASSERT_ASSERTION_PASS( 
       CPPUNIT_ASSERT_MESSAGE( "This test should not failed", true ) );
  }
***************
*** 165,174 ****
--- 188,258 ----
    CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.1, 1.2, 0.101 ) );
    CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.2, 1.1, 0.101 ) );
  
    CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.1, 1.2, 0.09 ) );
    CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.2, 1.1, 0.09 ) );
+ }
+ 
+ 
+ void 
+ TestAssertTest::testAssertDoubleNotEquals()
+ {
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL( 1.1, 1.2, 0.101 ) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL( 1.2, 1.1, 0.101 ) );
+   
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL( 1.1, 1.2, 0.09 ) );
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL( 1.2, 1.1, 0.09 ) );
+ }
+ 
+ 
+ void 
+ TestAssertTest::testAssertPointerEquals()
+ {
+   int dummy;
+   int *dummyptr = &dummy;
+   char dummy2;
+   void *dummyptrptr = &dummyptr;
+   void *nullptr = NULL;
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_POINTERS_EQUAL( &dummy, dummyptr) );
+   
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_POINTERS_EQUAL( dummyptrptr, dummyptr) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_POINTERS_EQUAL( &dummy, &dummy2) );
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_POINTERS_EQUAL( NULL, dummyptr) );
+   
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_NULL( nullptr));
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NULL( dummyptr));
+ }
+ 
+ 
+ void 
+ TestAssertTest::testAssertPointerNotEquals()
+ {
+   int dummy;
+   int *dummyptr = &dummy;
+   char dummy2;
+   void *dummyptrptr = &dummyptr;
+   void *nullptr = NULL;
+   CPPUNIT_ASSERT_ASSERTION_FAIL(
+       CPPUNIT_ASSERT_POINTERS_NOT_EQUAL( &dummy, dummyptr) );
+   
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_POINTERS_NOT_EQUAL( dummyptrptr, dummyptr) );
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_POINTERS_NOT_EQUAL( &dummy, &dummy2) );
+   CPPUNIT_ASSERT_ASSERTION_PASS(
+       CPPUNIT_ASSERT_POINTERS_NOT_EQUAL( NULL, dummyptr) );
+   
+   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_NOT_NULL( nullptr));
+   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_NOT_NULL( dummyptr));
  }
  
  
  void 
  TestAssertTest::testFail()
diff -rC 5 cppunit/examples/cppunittest/TestAssertTest.h cppunit_mod/examples/cppunittest/TestAssertTest.h
*** cppunit/examples/cppunittest/TestAssertTest.h	Mon Jun 26 18:03:11 2006
--- cppunit_mod/examples/cppunittest/TestAssertTest.h	Mon Jun 26 18:35:40 2006
***************
*** 11,23 ****
--- 11,27 ----
    CPPUNIT_TEST( testAssertNoThrow );
    CPPUNIT_TEST( testAssertAssertionFail );
    CPPUNIT_TEST( testAssertAssertionPass );
    CPPUNIT_TEST( testAssert );
    CPPUNIT_TEST( testAssertEqual );
+   CPPUNIT_TEST( testAssertNotEqual );
    CPPUNIT_TEST( testAssertMessageTrue );
    CPPUNIT_TEST( testAssertMessageFalse );
    CPPUNIT_TEST( testAssertDoubleEquals );
+   CPPUNIT_TEST( testAssertDoubleNotEquals );
+   CPPUNIT_TEST( testAssertPointerEquals );
+   CPPUNIT_TEST( testAssertPointerNotEquals );
    CPPUNIT_TEST( testFail );
    CPPUNIT_TEST_SUITE_END();
  
  public:
    TestAssertTest();
***************
*** 35,51 ****
--- 39,60 ----
    void testBasicAssertions();
  
    void testAssert();
    
    void testAssertEqual();
+   void testAssertNotEqual();
  
    void testAssertMessageTrue();
    void testAssertMessageFalse();
  
    void testAssertDoubleEquals();
    void testAssertDoubleNotEquals1();
    void testAssertDoubleNotEquals2();
+   void testAssertDoubleNotEquals();
+ 
+   void testAssertPointerEquals();
+   void testAssertPointerNotEquals();
  
    void testAssertLongEquals();
    void testAssertLongNotEquals();
  
    void testFail();
diff -rC 5 cppunit/include/cppunit/Asserter.h cppunit_mod/include/cppunit/Asserter.h
*** cppunit/include/cppunit/Asserter.h	Mon Jun 26 18:02:35 2006
--- cppunit_mod/include/cppunit/Asserter.h	Tue Jun 27 12:23:09 2006
***************
*** 116,125 ****
--- 116,141 ----
                                          const SourceLine &sourceLine,
                                          const AdditionalMessage &additionalMessage = AdditionalMessage(),
                                          std::string shortDescription = "equality assertion failed" );
  
    /*! \brief Throws an Exception with the specified message and location.
+    * \param unexpected Text describing the unexpected value.
+    * \param actual Text describing the actual value.
+    * \param sourceLine Location of the assertion.
+    * \param additionalMessage Additional message. Usually used to report
+    *                          what are the differences between the unexpected
+    *                          and actual value.
+    * \param shortDescription Short description for the failure message.
+    */
+   static void CPPUNIT_API failEqual(
+       std::string unexpected,
+       std::string actual,
+       const SourceLine &sourceLine,
+       const AdditionalMessage &additionalMessage = AdditionalMessage(),
+       std::string shortDescription = "inequality assertion failed" );
+ 
+   /*! \brief Throws an Exception with the specified message and location.
     * \param shouldFail if \c true then the exception is thrown. Otherwise
     *                   nothing happen.
     * \param expected Text describing the expected value.
     * \param actual Text describing the actual value.
     * \param sourceLine Location of the assertion.
***************
*** 131,140 ****
--- 147,174 ----
                                            std::string expected, 
                                            std::string actual, 
                                            const SourceLine &sourceLine,
                                            const AdditionalMessage &additionalMessage = AdditionalMessage(),
                                            std::string shortDescription = "equality assertion failed" );
+ 
+   /*! \brief Throws an Exception with the specified message and location.
+    * \param shouldFail if \c true then the exception is thrown. Otherwise
+    *                   nothing happen.
+    * \param unexpected Text describing the unexpected value.
+    * \param actual Text describing the actual value.
+    * \param sourceLine Location of the assertion.
+    * \param additionalMessage Additional message. Usually used to report
+    *                          where the "difference" is located.
+    * \param shortDescription Short description for the failure message.
+    */
+   static void CPPUNIT_API failEqualIf(
+       bool shouldFail,
+       std::string unexpected,
+       std::string actual,
+       const SourceLine &sourceLine,
+       const AdditionalMessage &additionalMessage = AdditionalMessage(),
+       std::string shortDescription = "inequality assertion failed" );
  
  };
  
  
  CPPUNIT_NS_END
diff -rC 5 cppunit/include/cppunit/TestAssert.h cppunit_mod/include/cppunit/TestAssert.h
*** cppunit/include/cppunit/TestAssert.h	Mon Jun 26 18:02:36 2006
--- cppunit_mod/include/cppunit/TestAssert.h	Tue Jun 27 14:09:58 2006
***************
*** 4,26 ****
  #include <cppunit/Portability.h>
  #include <cppunit/Exception.h>
  #include <cppunit/Asserter.h>
  #include <cppunit/portability/Stream.h>
  #include <stdio.h>
! #include <float.h> // For struct assertion_traits<double>
  
  
  CPPUNIT_NS_BEGIN
  
  
! /*! \brief Traits used by CPPUNIT_ASSERT_EQUAL().
   *
   * 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;
   *   }
--- 4,27 ----
  #include <cppunit/Portability.h>
  #include <cppunit/Exception.h>
  #include <cppunit/Asserter.h>
  #include <cppunit/portability/Stream.h>
  #include <stdio.h>
! #include <float.h> // For struct assertion_traits<double,double>
  
  
  CPPUNIT_NS_BEGIN
  
  
! /*! \brief Traits used by CPPUNIT_ASSERT_EQUAL(), CPPUNIT_ASSERT_EQ(),
!  * CPPUNIT_ASSERT_NOT_EQUAL(), and CPPUNIT_ASSERT_NOT_EQ().
   *
   * Here is an example of specialising these traits: 
   *
   * \code
   * template<>
!  * struct assertion_traits<std::string,std::string>   // specialization for the std::string type
   * {
   *   static bool equal( const std::string& x, const std::string& y )
   *   {
   *     return x == y;
   *   }
***************
*** 33,75 ****
   *     return ost.str();
   *   }
   * };
   * \endcode
   */
! template <class T>
! struct assertion_traits 
! {  
!     static bool equal( const T& x, const T& y )
      {
          return x == y;
      }
  
!     static std::string toString( const T& x )
      {
          OStringStream ost;
          ost << x;
          return ost.str();
      }
  };
  
! 
! /*! \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
   * use the hard-coded maximum precision of 15.
   */
  template <>
! struct assertion_traits<double>
  {  
      static bool equal( double x, double y )
      {
          return x == y;
      }
  
      static std::string toString( double x )
      {
  #ifdef DBL_DIG
         const int precision = DBL_DIG;
  #else
--- 34,92 ----
   *     return ost.str();
   *   }
   * };
   * \endcode
   */
! template <class T1, class T2 = T1>
! struct assertion_traits
! {
!     typedef T1 typeone;
!     typedef T2 typetwo;
! 
!     static bool equal( const T1& x, const T2& y )
      {
          return x == y;
      }
  
!     static bool notEqual( const T1& x, const T2& y )
!     {
!         return !(equal( x, y));
!     }
! 
!     static std::string toString( const T1& x )
      {
          OStringStream ost;
          ost << x;
          return ost.str();
      }
  };
  
! /*! \brief Traits used by CPPUNIT_ASSERT_DOUBLES_EQUAL()
!  * and CPPUNIT_ASSERT_DOUBLES_NOT_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
   * use the hard-coded maximum precision of 15.
   */
  template <>
! struct assertion_traits<double, double>
  {  
+     typedef double typeone;
+     typedef double typetwo;
+ 
      static bool equal( double x, double y )
      {
          return x == y;
      }
  
+     static bool notEqual( double x, double y )
+     {
+         return !(equal( x, y));
+     }
+ 
      static std::string toString( double x )
      {
  #ifdef DBL_DIG
         const int precision = DBL_DIG;
  #else
***************
*** 84,109 ****
         return buffer;
      }
  };
  
  
  /*! \brief (Implementation) Asserts that two objects of the same type are equals.
   * Use CPPUNIT_ASSERT_EQUAL instead of this function.
   * \sa assertion_traits, Asserter::failNotEqual().
   */
  template <class T>
! void assertEquals( const T& expected,
!                    const T& actual,
!                    SourceLine sourceLine,
!                    const std::string &message )
  {
!   if ( !assertion_traits<T>::equal(expected,actual) ) // lazy toString conversion...
    {
      Asserter::failNotEqual( assertion_traits<T>::toString(expected),
                              assertion_traits<T>::toString(actual),
                              sourceLine,
!                             message );
    }
  }
  
  
  /*! \brief (Implementation) Asserts that two double are equals given a tolerance.
--- 101,240 ----
         return buffer;
      }
  };
  
  
+ /*! \brief Traits used by CPPUNIT_ASSERT_NULL() and CPPUNIT_ASSERT_NOT_NULL().
+  * 
+  * This specialisation from @c struct @c assertion_traits<> ensures
+  * pointer comparison is handled properly.
+  */
+ template <>
+ struct assertion_traits< void *, void *>
+ {
+     typedef void *typeone;
+     typedef void *typetwo;
+ 
+     static bool equal( void *x, void *y )
+     {
+         return x == y;
+     }
+ 
+     static bool notEqual( void *x, void *y )
+     {
+         return !(equal( x, y));
+     }
+ 
+     static std::string toString( void *x )
+     {
+        char buffer[128];
+        if( x) {
+ #ifdef __STDC_SECURE_LIB__ // Use secure version with VS2005 to avoid warning.
+ 	 sprintf_s(buffer, sizeof(buffer), "0x%0*X", 2 * sizeof(void*), x);
+ #else	
+ 	 sprintf(buffer, "0x%0*X", 2 * sizeof(void*), x);
+ #endif
+        }
+        else {
+ 	 buffer[0] = 'N';
+ 	 buffer[1] = 'U';
+ 	 buffer[2] = buffer[3] = 'L';
+ 	 buffer[4] = '\0';
+        }
+        return buffer;
+     }
+ };
+ 
+ 
+ /*! \brief (Implementation) Asserts that two objects comparable
+  * using equality operator are equals.
+  * Use CPPUNIT_ASSERT_EQ instead of this function.
+  * \sa assertion_traits, Asserter::failNotEqual().
+  */
+ template <class T1, class T2>
+ void assertEqualsNonStrict( const T1& expected,
+                    const T2& actual,
+                    SourceLine sourceLine,
+                    const std::string &message )
+ {
+   if ( !assertion_traits<T2,T1>::equal(actual,expected) )
+     // lazy toString conversion...
+   {
+     Asserter::failNotEqual( assertion_traits<T1>::toString(expected),
+                             assertion_traits<T2>::toString(actual),
+                             sourceLine,
+                             message );
+   }
+ }
+ 
+ 
+ /*! \brief (Implementation) Asserts that two objects comparable
+  * using equality operator are not equals.
+  * Use CPPUNIT_ASSERT_NOT_EQ instead of this function.
+  * \sa assertion_traits, Asserter::failEqual().
+  */
+ template <class T1, class T2>
+ void assertNotEqualsNonStrict(	const T1& expected,
+ 				const T2& actual,
+ 				SourceLine sourceLine,
+ 				const std::string &message )
+ {
+   if ( !assertion_traits<T2,T1>::notEqual(actual,expected) )
+     // lazy toString conversion...
+   {
+     Asserter::failEqual(  assertion_traits<T1>::toString(expected),
+                           assertion_traits<T2>::toString(actual),
+                           sourceLine,
+                           message );
+   }
+ }
+ 
+ 
+ 
  /*! \brief (Implementation) Asserts that two objects of the same type are equals.
   * Use CPPUNIT_ASSERT_EQUAL instead of this function.
   * \sa assertion_traits, Asserter::failNotEqual().
   */
  template <class T>
! void assertEquals(  const T& expected,
! 		    const T& actual,
! 		    SourceLine sourceLine,
! 		    const std::string &message,
! 		    const std::string shortDescription
! 		      = "equality assertion failed" )
  {
!   if ( !assertion_traits<T>::equal(actual,expected) ) // lazy toString conversion...
    {
      Asserter::failNotEqual( assertion_traits<T>::toString(expected),
                              assertion_traits<T>::toString(actual),
                              sourceLine,
!                             message,
! 			    shortDescription );
!   }
! }
! 
! 
! /*! \brief (Implementation) Asserts that two objects of the same type are
!  * not equals.
!  * Use CPPUNIT_ASSERT_NOT_EQUAL instead of this function.
!  * \sa assertion_traits, Asserter::failEqual().
!  */
! template <class T>
! void assertNotEquals( const T& expected,
! 		      const T& actual,
! 		      SourceLine sourceLine,
! 		      const std::string &message,
! 		      const std::string shortDescription
! 			= "equality assertion failed" )
! {
!   if ( !assertion_traits<T>::notEqual(actual,expected) ) // lazy toString conversion...
!   {
!     Asserter::failEqual(  assertion_traits<T>::toString(expected),
!                           assertion_traits<T>::toString(actual),
!                           sourceLine,
!                           message,
! 			  shortDescription );
    }
  }
  
  
  /*! \brief (Implementation) Asserts that two double are equals given a tolerance.
***************
*** 115,124 ****
--- 246,267 ----
                                       double delta,
                                       SourceLine sourceLine, 
                                       const std::string &message );
  
  
+ /*! \brief (Implementation) Asserts that two double are not equal
+  * given a tolerance.
+  * Use CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL instead of this function.
+  * \sa Asserter::failEqual().
+  */
+ void CPPUNIT_API assertDoubleNotEquals( double expected,
+ 					double actual,
+ 					double delta,
+ 					SourceLine sourceLine, 
+ 					const std::string &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.
   */
***************
*** 161,175 ****
    ( CPPUNIT_NS::Asserter::fail( CPPUNIT_NS::Message( "forced failure",  \
                                                       message ),         \
                                  CPPUNIT_SOURCELINE() ) )
  
  #ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
! /// Generalized macro for primitive value comparisons
  #define CPPUNIT_ASSERT_EQUAL(expected,actual)                     \
    ( CPPUNIT_NS::assertEquals( (expected),             \
                                (actual),               \
                                __LINE__, __FILE__ ) )
  #else
  /** Asserts that two values are equals.
   * \ingroup Assertions
   *
   * Equality and string representation can be defined with
--- 304,330 ----
    ( CPPUNIT_NS::Asserter::fail( CPPUNIT_NS::Message( "forced failure",  \
                                                       message ),         \
                                  CPPUNIT_SOURCELINE() ) )
  
  #ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
! /// Generalized macros for primitive value comparisons
  #define CPPUNIT_ASSERT_EQUAL(expected,actual)                     \
    ( CPPUNIT_NS::assertEquals( (expected),             \
                                (actual),               \
                                __LINE__, __FILE__ ) )
+ #define CPPUNIT_ASSERT_NOT_EQUAL(unexpected,actual)                   \
+   ( CPPUNIT_NS::assertNotEquals(  (unexpected),		    \
+ 				  (actual),		    \
+ 				  __LINE__, __FILE__ ) )
+ #define CPPUNIT_ASSERT_EQ(expected,actual)			\
+   ( CPPUNIT_NS::assertEqualsNonStrict(	(expected),             \
+ 					(actual),               \
+ 					__LINE__, __FILE__ ) )
+ #define CPPUNIT_ASSERT_NOT_EQ(unexpected,actual)                    \
+   ( CPPUNIT_NS::assertNotEqualsNonStrict( (unexpected),             \
+ 					  (actual),		    \
+ 					  __LINE__, __FILE__ ) )
  #else
  /** Asserts that two values are equals.
   * \ingroup Assertions
   *
   * Equality and string representation can be defined with
***************
*** 189,198 ****
--- 344,417 ----
    ( CPPUNIT_NS::assertEquals( (expected),              \
                                (actual),                \
                                CPPUNIT_SOURCELINE(),    \
                                "" ) )
  
+ /** Asserts that two values are not equal.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate CppUnit::assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values agree.
+  *
+  * 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.
+  */
+ #define CPPUNIT_ASSERT_NOT_EQUAL(unexpected,actual)         \
+   ( CPPUNIT_NS::assertNotEquals(  (unexpected),             \
+ 				  (actual),		    \
+ 				  CPPUNIT_SOURCELINE(),	    \
+ 				  "" ) )
+ 
+ /** Asserts that two values are equals.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate CppUnit::assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values disagree.
+  *
+  * Requirement for \a expected and \a actual parameters:
+  * - 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.
+  */
+ #define CPPUNIT_ASSERT_EQ(expected,actual)                    \
+   ( CPPUNIT_NS::assertEqualsNonStrict( (expected),            \
+ 				       (actual),              \
+ 				       CPPUNIT_SOURCELINE(),  \
+ 				       "" ) )
+ 
+ /** Asserts that two values are not equal.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate CppUnit::assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values agree.
+  *
+  * Requirement for \a expected and \a actual parameters:
+  * - 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.
+  */
+ #define CPPUNIT_ASSERT_NOT_EQ(unexpected,actual)                    \
+   ( CPPUNIT_NS::assertNotEqualsNonStrict( (unexpected),            \
+ 					  (actual),              \
+ 					  CPPUNIT_SOURCELINE(),  \
+ 					  "" ) )
+ 
  /** Asserts that two values are equals, provides additional message on failure.
   * \ingroup Assertions
   *
   * Equality and string representation can be defined with
   * an appropriate assertion_traits class.
***************
*** 212,221 ****
--- 431,512 ----
  #define CPPUNIT_ASSERT_EQUAL_MESSAGE(message,expected,actual)      \
    ( CPPUNIT_NS::assertEquals( (expected),              \
                                (actual),                \
                                CPPUNIT_SOURCELINE(),    \
                                (message) ) )
+ 
+ /** Asserts that two values are not equal,
+  *  provides additional message on failure.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values disagree.
+  * 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.
+  */
+ #define CPPUNIT_ASSERT_NOT_EQUAL_MESSAGE(message,unexpected,actual)      \
+   ( CPPUNIT_NS::assertNotEquals(  (unexpected),		    \
+ 				  (actual),		    \
+ 				  CPPUNIT_SOURCELINE(),	    \
+ 				  (message) ) )
+ 
+ /** Asserts that two values are equals, provides additional message on failure.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values disagree.
+  * 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 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.
+  */
+ #define CPPUNIT_ASSERT_EQ_MESSAGE(message,expected,actual)      \
+   ( CPPUNIT_NS::assertEqualsNonStrict( (expected),              \
+ 				       (actual),                \
+ 				       CPPUNIT_SOURCELINE(),    \
+ 				       (message) ) )
+ 
+ /** Asserts that two values are not equal,
+  * provides additional message on failure.
+  * \ingroup Assertions
+  *
+  * Equality and string representation can be defined with
+  * an appropriate assertion_traits class.
+  *
+  * A diagnostic is printed if actual and expected values disagree.
+  * 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 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.
+  */
+ #define CPPUNIT_ASSERT_NOT_EQ_MESSAGE(message,unexpected,actual)      \
+   ( CPPUNIT_NS::assertNotEqualsNonStrict( (unexpected),             \
+ 					  (actual),		    \
+ 					  CPPUNIT_SOURCELINE(),	    \
+ 					  (message) ) )
  #endif
  
  /*! \brief Macro for primitive double value comparisons. 
   * \ingroup Assertions
   */
***************
*** 225,244 ****
--- 516,629 ----
                                      (delta),               \
                                      CPPUNIT_SOURCELINE(),  \
                                      "" ) )
  
  
+ /*! \brief Macro for primitive double value comparisons. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL(unexpected,actual,delta)        \
+   ( CPPUNIT_NS::assertDoubleNotEquals(	(unexpected),           \
+ 					(actual),		\
+ 					(delta),		\
+ 					CPPUNIT_SOURCELINE(),	\
+ 					"" ) )
+ 
+ 
  /*! \brief Macro for primitive double value comparisons, setting a 
   * user-supplied message in case of failure. 
   * \ingroup Assertions
   */
  #define CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(message,expected,actual,delta)  \
    ( CPPUNIT_NS::assertDoubleEquals( (expected),            \
                                      (actual),              \
                                      (delta),               \
                                      CPPUNIT_SOURCELINE(),  \
                                      (message) ) )
+ 
+ 
+ /*! \brief Macro for primitive double value comparisons, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_DOUBLES_NOT_EQUAL_MESSAGE(msg,unexpected,actual,delta)\
+   ( CPPUNIT_NS::assertDoubleNotEquals(	(unexpected),		\
+ 					(actual),		\
+ 					(delta),		\
+ 					CPPUNIT_SOURCELINE(),	\
+ 					(msg) ) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value comparisons, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_POINTERS_EQUAL_MESSAGE(message,exp,actual)   \
+   ( CPPUNIT_NS::assertEquals< void *>(  (exp),			\
+ 					(actual),		\
+ 					CPPUNIT_SOURCELINE(),   \
+ 					(message),		\
+ 					"pointer equality assertion failed"))
+ 
+ 
+ /*! \brief Macro for primitive pointer value comparisons, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_POINTERS_NOT_EQUAL_MESSAGE(msg,unexp,actual) \
+   ( CPPUNIT_NS::assertNotEquals< void *>(			\
+ 				      (unexp),			\
+ 				      (actual),			\
+ 				      CPPUNIT_SOURCELINE(),	\
+ 				      (msg),			\
+ 				      "pointer inequality assertion failed"))
+ 
+ 
+ /*! \brief Macro for primitive pointer value comparisons.
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_POINTERS_EQUAL(exp,actual)		\
+   ( CPPUNIT_ASSERT_POINTERS_EQUAL_MESSAGE( "", (exp), (actual)) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value comparisons.
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_POINTERS_NOT_EQUAL(unexp,actual)		\
+   ( CPPUNIT_ASSERT_POINTERS_NOT_EQUAL_MESSAGE( "", (unexp), (actual)) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value NULL test, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_NULL(actual)				\
+   ( CPPUNIT_ASSERT_POINTERS_EQUAL( (void *) 0, (actual)) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value NULL test, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_NOT_NULL(actual)				\
+   ( CPPUNIT_ASSERT_POINTERS_NOT_EQUAL( (void *) 0, (actual)) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value NULL test, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_NULL_MESSAGE(message,actual)		\
+   ( CPPUNIT_ASSERT_POINTERS_EQUAL_MESSAGE( (message), (void *) 0, (actual)) )
+ 
+ 
+ /*! \brief Macro for primitive pointer value NULL test, setting a 
+  * user-supplied message in case of failure. 
+  * \ingroup Assertions
+  */
+ #define CPPUNIT_ASSERT_NOT_NULL_MESSAGE(msg,actual) \
+   ( CPPUNIT_ASSERT_POINTERS_NOT_EQUAL_MESSAGE( (msg), (void *) 0, (actual)) )
  
  
  /** Asserts that the given expression throws an exception of the specified type. 
   * \ingroup Assertions
   * Example of usage:
diff -rC 5 cppunit/src/cppunit/Asserter.cpp cppunit_mod/src/cppunit/Asserter.cpp
*** cppunit/src/cppunit/Asserter.cpp	Mon Jun 26 18:03:47 2006
--- cppunit_mod/src/cppunit/Asserter.cpp	Mon Jun 26 17:59:19 2006
***************
*** 84,101 ****
--- 84,133 ----
          sourceLine );
  }
  
  
  void 
+ Asserter::failEqual(
+     std::string unexpected,
+     std::string actual,
+     const SourceLine &sourceLine,
+     const AdditionalMessage &additionalMessage,
+     std::string shortDescription )
+ {
+   fail( makeNotEqualMessage(
+ 	unexpected,
+ 	actual,
+ 	additionalMessage,
+ 	shortDescription ),
+       sourceLine );
+ }
+ 
+ 
+ void 
  Asserter::failNotEqualIf( bool shouldFail,
                            std::string expected, 
                            std::string actual, 
                            const SourceLine &sourceLine,
                            const AdditionalMessage &additionalMessage,
                            std::string shortDescription )
  {
    if ( shouldFail )
      failNotEqual( expected, actual, sourceLine, additionalMessage, shortDescription );
+ }
+ 
+ 
+ void 
+ Asserter::failEqualIf(
+     bool shouldFail,
+     std::string unexpected,
+     std::string actual,
+     const SourceLine &sourceLine,
+     const AdditionalMessage &additionalMessage,
+     std::string shortDescription )
+ {
+   if ( shouldFail )
+     failEqual(
+ 	unexpected, actual, sourceLine, additionalMessage, shortDescription );
  }
  
  
  CPPUNIT_NS_END
diff -rC 5 cppunit/src/cppunit/TestAssert.cpp cppunit_mod/src/cppunit/TestAssert.cpp
*** cppunit/src/cppunit/TestAssert.cpp	Mon Jun 26 18:03:47 2006
--- cppunit_mod/src/cppunit/TestAssert.cpp	Tue Jun 27 11:42:45 2006
***************
*** 28,33 ****
--- 28,53 ----
                              msg, 
                              "double equality assertion failed" );
  }
  
  
+ void 
+ assertDoubleNotEquals(	double unexpected,
+ 			double actual,
+ 			double delta,
+ 			SourceLine sourceLine,
+ 			const std::string &message )
+ {
+   AdditionalMessage msg( "Delta   : " + 
+                          assertion_traits<double>::toString(delta) );
+   msg.addDetail( AdditionalMessage(message) );
+ 
+   Asserter::failEqualIf(  fabs( unexpected - actual ) <= delta,
+                           assertion_traits<double>::toString(unexpected),
+                           assertion_traits<double>::toString(actual),
+                           sourceLine, 
+                           msg, 
+                           "double inequality assertion failed" );
+ }
+ 
+ 
  CPPUNIT_NS_END
