[Libreoffice-commits] cppunit.git: examples/cppunittest include/cppunit src/cppunit
Markus Mohrhard
markus.mohrhard at googlemail.com
Sun Jul 13 02:33:29 PDT 2014
examples/cppunittest/TestAssertTest.cpp | 45 ++++++
examples/cppunittest/TestAssertTest.h | 8 +
include/cppunit/Asserter.h | 104 +++++++++++++++
include/cppunit/TestAssert.h | 213 +++++++++++++++++++++++++++++++-
src/cppunit/Asserter.cpp | 116 +++++++++++++++--
5 files changed, 472 insertions(+), 14 deletions(-)
New commits:
commit 0ef304e8b8cc517c6a1d8ddccfcaab49172c0535
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date: Sat May 5 21:52:20 2012 +0200
add new assertion macros for <, <=, > and >=
Now we support the following new macros:
- CPPUNIT_ASSERT_LESS
- CPPUNIT_ASSERT_GREATER
- CPPUNIT_ASSERT_LESSEQUAL
- CPPUNIT_ASSERT_GREATEREQUAL
diff --git a/examples/cppunittest/TestAssertTest.cpp b/examples/cppunittest/TestAssertTest.cpp
index 1a7a5de..1516117 100644
--- a/examples/cppunittest/TestAssertTest.cpp
+++ b/examples/cppunittest/TestAssertTest.cpp
@@ -141,6 +141,51 @@ TestAssertTest::testAssertEqual()
CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_EQUAL( 1, 2 ) );
}
+
+void
+TestAssertTest::testAssertLess()
+{
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_LESS( 2, 1 ) );
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_LESS( 12345679, 12345678 ) );
+
+ CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_LESS( 1, 2 ) );
+}
+
+
+void
+TestAssertTest::testAssertGreater()
+{
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATER( 1, 2 ) );
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATER( 12345678, 12345679 ));
+
+ CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_GREATER( 2, 1 ) );
+ CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_GREATER( 2, 2 ) );
+}
+
+
+void
+TestAssertTest::testAssertLessEqual()
+{
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_LESSEQUAL( 2, 1 ) );
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_LESSEQUAL( 12345679, 12345678 ));
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_LESSEQUAL( 2, 2 ) );
+
+ CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_LESSEQUAL( 1, 2 ) );
+}
+
+void
+TestAssertTest::testAssertGreaterEqual()
+{
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATEREQUAL( 1, 2 ) );
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATEREQUAL( 12345678, 12345679 ));
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATEREQUAL( 12345678, 12345678 ));
+ CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT_GREATEREQUAL( 2, 2 ) );
+
+ CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT_GREATEREQUAL( 2, 1 ) );
+}
+
+
+
void
TestAssertTest::testAssertMessageTrue()
{
diff --git a/examples/cppunittest/TestAssertTest.h b/examples/cppunittest/TestAssertTest.h
index a672d38..01d303e 100644
--- a/examples/cppunittest/TestAssertTest.h
+++ b/examples/cppunittest/TestAssertTest.h
@@ -13,6 +13,10 @@ class TestAssertTest : public CPPUNIT_NS::TestFixture
CPPUNIT_TEST( testAssertAssertionPass );
CPPUNIT_TEST( testAssert );
CPPUNIT_TEST( testAssertEqual );
+ CPPUNIT_TEST( testAssertLess );
+ CPPUNIT_TEST( testAssertGreater );
+ CPPUNIT_TEST( testAssertLessEqual );
+ CPPUNIT_TEST( testAssertGreaterEqual );
CPPUNIT_TEST( testAssertMessageTrue );
CPPUNIT_TEST( testAssertMessageFalse );
CPPUNIT_TEST( testAssertDoubleEquals );
@@ -39,6 +43,10 @@ public:
void testAssert();
void testAssertEqual();
+ void testAssertLess();
+ void testAssertGreater();
+ void testAssertLessEqual();
+ void testAssertGreaterEqual();
void testAssertMessageTrue();
void testAssertMessageFalse();
diff --git a/include/cppunit/Asserter.h b/include/cppunit/Asserter.h
index ad981b5..3321b87 100644
--- a/include/cppunit/Asserter.h
+++ b/include/cppunit/Asserter.h
@@ -83,16 +83,55 @@ struct Asserter
std::string message,
const SourceLine &sourceLine = SourceLine() );
- /*! \brief Returns a expected value string for a message.
+ /*! \brief Returns a expected value string for a message, case equal than
* Typically used to create 'not equal' message, or to check that a message
* contains the expected content when writing unit tests for your custom
* assertions.
*
* \param expectedValue String that represents the expected value.
* \return \a expectedValue prefixed with "Expected: ".
+ * \deprecated Use makeExpectedEqual instead
* \see makeActual().
*/
static std::string CPPUNIT_API makeExpected( const std::string &expectedValue );
+ /*! \brief Returns a expected value string for a message, case equal than
+ * Typically used to create 'not equal' message, or to check that a message
+ * contains the expected content when writing unit tests for your custom
+ * assertions.
+ *
+ * \param expectedValue String that represents the expected value.
+ * \return \a expectedValue prefixed with "Expected: ".
+ * \see makeActual().
+ */
+ static std::string CPPUNIT_API makeExpectedEqual( const std::string &expectedValue );
+ /*! \brief Returns a expected value string for a message, case less than.
+ *
+ * \param expectedValue String that represents the expected value.
+ * \return \a expectedValue prefixed with "Expected less than: ".
+ * \see makeExpectedEqual().
+ */
+ static std::string CPPUNIT_API makeExpectedLess( const std::string &expectedValue );
+ /*! \brief Returns a expected value string for a message, case less or equal than.
+ *
+ * \param expectedValue String that represents the expected value.
+ * \return \a expectedValue prefixed with "Expected: ".
+ * \see makeExpectedEqual().
+ */
+ static std::string CPPUNIT_API makeExpectedLessEqual( const std::string &expectedValue );
+ /*! \brief Returns a expected value string for a message, case greater than.
+ *
+ * \param expectedValue String that represents the expected value.
+ * \return \a expectedValue prefixed with "Expected: ".
+ * \see makeExpectedEqual().
+ */
+ static std::string CPPUNIT_API makeExpectedGreater( const std::string &expectedValue );
+ /*! \brief Returns a expected value string for a message, greater or equal than.
+ *
+ * \param expectedValue String that represents the expected value.
+ * \return \a expectedValue prefixed with "Expected: ".
+ * \see makeExpectedEqual().
+ */
+ static std::string CPPUNIT_API makeExpectedGreaterEqual( const std::string &expectedValue );
/*! \brief Returns an actual value string for a message.
* Typically used to create 'not equal' message, or to check that a message
@@ -105,11 +144,19 @@ struct Asserter
*/
static std::string CPPUNIT_API makeActual( const std::string &actualValue );
+ /*!
+ * \deprecated Use makeMessage instead
+ */
static Message CPPUNIT_API makeNotEqualMessage( const std::string &expectedValue,
const std::string &actualValue,
const AdditionalMessage &additionalMessage = AdditionalMessage(),
const std::string &shortDescription = "equality assertion failed");
+ static Message CPPUNIT_API makeMessage( const std::string &expectedValue,
+ const std::string &actualValue,
+ const std::string &shortDescription,
+ const AdditionalMessage &additionalMessage = AdditionalMessage());
+
/*! \brief Throws an Exception with the specified message and location.
* \param expected Text describing the expected value.
* \param actual Text describing the actual value.
@@ -125,6 +172,61 @@ struct Asserter
std::string shortDescription = "equality assertion failed" );
/*! \brief Throws an Exception with the specified message and location.
+ * \param expected Text describing the expected 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 expected and actual value.
+ * \param shortDescription Short description for the failure message.
+ */
+ static void CPPUNIT_API failNotLess( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage = AdditionalMessage(),
+ std::string shortDescription = "less assertion failed" );
+
+ /*! \brief Throws an Exception with the specified message and location.
+ * \param expected Text describing the expected 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 expected and actual value.
+ * \param shortDescription Short description for the failure message.
+ */
+ static void CPPUNIT_API failNotGreater( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage = AdditionalMessage(),
+ std::string shortDescription = "greater assertion failed" );
+
+ /*! \brief Throws an Exception with the specified message and location.
+ * \param expected Text describing the expected 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 expected and actual value.
+ * \param shortDescription Short description for the failure message.
+ */
+ static void CPPUNIT_API failNotLessEqual( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage = AdditionalMessage(),
+ std::string shortDescription = "less equal assertion failed" );
+
+ /*! \brief Throws an Exception with the specified message and location.
+ * \param expected Text describing the expected 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 expected and actual value.
+ * \param shortDescription Short description for the failure message.
+ */
+ static void CPPUNIT_API failNotGreaterEqual( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage = AdditionalMessage(),
+ std::string shortDescription = "greater equal 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.
diff --git a/include/cppunit/TestAssert.h b/include/cppunit/TestAssert.h
index 851a444..fa0bfa7 100644
--- a/include/cppunit/TestAssert.h
+++ b/include/cppunit/TestAssert.h
@@ -18,7 +18,7 @@
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:
*
@@ -30,7 +30,17 @@ CPPUNIT_NS_BEGIN
* {
* 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
@@ -49,6 +59,16 @@ struct assertion_traits
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;
@@ -83,6 +103,16 @@ struct assertion_traits<double>
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
@@ -133,6 +163,82 @@ void CPPUNIT_API assertDoubleEquals( double expected,
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
@@ -232,6 +338,109 @@ void CPPUNIT_API assertDoubleEquals( double expected,
(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
*
diff --git a/src/cppunit/Asserter.cpp b/src/cppunit/Asserter.cpp
index aeb0526..f3b6577 100644
--- a/src/cppunit/Asserter.cpp
+++ b/src/cppunit/Asserter.cpp
@@ -40,13 +40,41 @@ Asserter::failIf( bool shouldFail,
failIf( shouldFail, Message( "assertion failed", message ), sourceLine );
}
-
std::string
Asserter::makeExpected( const std::string &expectedValue )
{
return "Expected: " + expectedValue;
}
+std::string
+Asserter::makeExpectedEqual( const std::string &expectedValue )
+{
+ return "Expected: " + expectedValue;
+}
+
+std::string
+Asserter::makeExpectedLess( const std::string& expectedValue )
+{
+ return "Expected less than: " + expectedValue;
+}
+
+std::string
+Asserter::makeExpectedLessEqual( const std::string& expectedValue )
+{
+ return "Expected less or equal than: " + expectedValue;
+}
+
+std::string
+Asserter::makeExpectedGreater( const std::string& expectedValue )
+{
+ return "Expected greater than: " + expectedValue;
+}
+
+std::string
+Asserter::makeExpectedGreaterEqual( const std::string& expectedValue )
+{
+ return "Expected greater or equal than: " + expectedValue;
+}
std::string
Asserter::makeActual( const std::string &actualValue )
@@ -55,18 +83,28 @@ Asserter::makeActual( const std::string &actualValue )
}
+Message
+Asserter::makeMessage( const std::string& expectedMessage,
+ const std::string& actualMessage,
+ const std::string& shortDescription,
+ const AdditionalMessage& additionalMessage)
+{
+ Message message( shortDescription,
+ expectedMessage,
+ actualMessage );
+ message.addDetail( additionalMessage );
+
+ return message;
+}
+
+
Message
Asserter::makeNotEqualMessage( const std::string &expectedValue,
const std::string &actualValue,
const AdditionalMessage &additionalMessage,
const std::string &shortDescription )
{
- Message message( shortDescription,
- makeExpected( expectedValue ),
- makeActual( actualValue ) );
- message.addDetail( additionalMessage );
-
- return message;
+ return makeMessage(makeExpectedEqual(expectedValue), makeActual(actualValue), shortDescription, additionalMessage);
}
@@ -77,15 +115,71 @@ Asserter::failNotEqual( std::string expected,
const AdditionalMessage &additionalMessage,
std::string shortDescription )
{
- fail( makeNotEqualMessage( expected,
- actual,
- additionalMessage,
- shortDescription ),
+ fail( makeMessage( makeExpectedEqual(expected),
+ makeActual(actual),
+ shortDescription,
+ additionalMessage ),
sourceLine );
}
void
+Asserter::failNotLess( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage,
+ std::string shortDescription )
+{
+ fail( makeMessage( makeExpectedLess(expected),
+ makeActual(actual),
+ shortDescription,
+ additionalMessage),
+ sourceLine );
+}
+
+
+void
+Asserter::failNotGreater( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage,
+ std::string shortDescription )
+{
+ fail( makeMessage( makeExpectedGreater(expected),
+ makeActual(actual),
+ shortDescription,
+ additionalMessage),
+ sourceLine );
+}
+
+void
+Asserter::failNotLessEqual( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage,
+ std::string shortDescription )
+{
+ fail( makeMessage( makeExpectedLessEqual(expected),
+ makeActual(actual),
+ shortDescription,
+ additionalMessage ),
+ sourceLine );
+}
+
+void
+Asserter::failNotGreaterEqual( std::string expected,
+ std::string actual,
+ const SourceLine &sourceLine,
+ const AdditionalMessage &additionalMessage,
+ std::string shortDescription )
+{
+ fail( makeMessage( makeExpectedGreaterEqual(expected),
+ makeActual(actual),
+ shortDescription,
+ additionalMessage ),
+ sourceLine );
+}
+void
Asserter::failNotEqualIf( bool shouldFail,
std::string expected,
std::string actual,
More information about the Libreoffice-commits
mailing list