diff options
35 files changed, 2071 insertions, 61 deletions
diff --git a/examples/cppunittest/BaseTestCase.cpp b/examples/cppunittest/BaseTestCase.cpp new file mode 100644 index 0000000..c1cde16 --- /dev/null +++ b/examples/cppunittest/BaseTestCase.cpp @@ -0,0 +1,36 @@ +#include "BaseTestCase.h" + + +BaseTestCase::BaseTestCase() +{ +} + + +BaseTestCase::~BaseTestCase() +{ +} + + +void +BaseTestCase::setUp() +{ +} + + +void +BaseTestCase::tearDown() +{ +} + + +void +BaseTestCase::testUsingCheckIt() +{ + checkIt(); +} + + +void +BaseTestCase::checkIt() +{ +} diff --git a/examples/cppunittest/BaseTestCase.h b/examples/cppunittest/BaseTestCase.h new file mode 100644 index 0000000..86f069f --- /dev/null +++ b/examples/cppunittest/BaseTestCase.h @@ -0,0 +1,32 @@ +#ifndef BASETESTCASE_H +#define BASETESTCASE_H + +#include <cppunit/extensions/HelperMacros.h> + + +class BaseTestCase : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( BaseTestCase ); + CPPUNIT_TEST( testUsingCheckIt ); + CPPUNIT_TEST_SUITE_END(); + +public: + BaseTestCase(); + virtual ~BaseTestCase(); + + virtual void setUp(); + virtual void tearDown(); + + void testUsingCheckIt(); + +protected: + virtual void checkIt(); + +private: + BaseTestCase( const BaseTestCase © ); + void operator =( const BaseTestCase © ); +}; + + + +#endif // BASETESTCASE_H diff --git a/examples/cppunittest/CppUnitTestMain.dsp b/examples/cppunittest/CppUnitTestMain.dsp index a7c82bf..ac7466a 100644 --- a/examples/cppunittest/CppUnitTestMain.dsp +++ b/examples/cppunittest/CppUnitTestMain.dsp @@ -115,10 +115,46 @@ LINK32=link.exe # Name "CppUnitTestMain - Win32 Debug Crossplatform Setting" # Begin Source File +SOURCE=.\BaseTestCase.cpp +# End Source File +# Begin Source File + +SOURCE=.\BaseTestCase.h +# End Source File +# Begin Source File + SOURCE=.\CppUnitTestMain.cpp # End Source File # Begin Source File +SOURCE=.\ExceptionTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\ExceptionTest.h +# End Source File +# Begin Source File + +SOURCE=.\FailingTestCase.cpp +# End Source File +# Begin Source File + +SOURCE=.\FailingTestCase.h +# End Source File +# Begin Source File + +SOURCE=.\FailureException.h +# End Source File +# Begin Source File + +SOURCE=.\HelperMacrosTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\HelperMacrosTest.h +# End Source File +# Begin Source File + SOURCE=.\MockTestListener.cpp # End Source File # Begin Source File @@ -127,6 +163,42 @@ SOURCE=.\MockTestListener.h # End Source File # Begin Source File +SOURCE=.\OrthodoxTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\OrthodoxTest.h +# End Source File +# Begin Source File + +SOURCE=.\RepeatedTestTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\RepeatedTestTest.h +# End Source File +# Begin Source File + +SOURCE=.\SubclassedTestCase.cpp +# End Source File +# Begin Source File + +SOURCE=.\SubclassedTestCase.h +# End Source File +# Begin Source File + +SOURCE=.\SynchronizedTestResult.h +# End Source File +# Begin Source File + +SOURCE=.\TestAssertTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestAssertTest.h +# End Source File +# Begin Source File + SOURCE=.\TestCallerTest.cpp # End Source File # Begin Source File @@ -135,6 +207,38 @@ SOURCE=.\TestCallerTest.h # End Source File # Begin Source File +SOURCE=.\TestCaseTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestCaseTest.h +# End Source File +# Begin Source File + +SOURCE=.\TestDecoratorTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestDecoratorTest.h +# End Source File +# Begin Source File + +SOURCE=.\TestFailureTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestFailureTest.h +# End Source File +# Begin Source File + +SOURCE=.\TestListenerTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestListenerTest.h +# End Source File +# Begin Source File + SOURCE=.\TestResultTest.cpp # End Source File # Begin Source File @@ -143,6 +247,22 @@ SOURCE=.\TestResultTest.h # End Source File # Begin Source File +SOURCE=.\TestSetupTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestSetupTest.h +# End Source File +# Begin Source File + +SOURCE=.\TestSuiteTest.cpp +# End Source File +# Begin Source File + +SOURCE=.\TestSuiteTest.h +# End Source File +# Begin Source File + SOURCE=.\TrackedTestCase.cpp # End Source File # Begin Source File diff --git a/examples/cppunittest/ExceptionTest.cpp b/examples/cppunittest/ExceptionTest.cpp new file mode 100644 index 0000000..c56082e --- /dev/null +++ b/examples/cppunittest/ExceptionTest.cpp @@ -0,0 +1,106 @@ +#include "ExceptionTest.h" +#include <cppunit/Exception.h> +#include <cppunit/NotEqualException.h> +#include <memory> + + +CPPUNIT_TEST_SUITE_REGISTRATION( ExceptionTest ); + + +ExceptionTest::ExceptionTest() +{ +} + + +ExceptionTest::~ExceptionTest() +{ +} + + +void +ExceptionTest::setUp() +{ +} + + +void +ExceptionTest::tearDown() +{ +} + + +void +ExceptionTest::testConstructor() +{ + const std::string message( "a message" ); + const int lineNumber = 17; + const std::string fileName( "dir/afile.cpp" ); + + CppUnit::Exception e( message, lineNumber, fileName ); + + CPPUNIT_ASSERT_EQUAL( message, std::string( e.what() ) ); + CPPUNIT_ASSERT_EQUAL( lineNumber, int(e.lineNumber()) ); + CPPUNIT_ASSERT_EQUAL( fileName, e.fileName() ); +} + + +void +ExceptionTest::testDefaultConstructor() +{ + CppUnit::Exception e; + + CPPUNIT_ASSERT_EQUAL( std::string(""), std::string( e.what() ) ); + CPPUNIT_ASSERT_EQUAL( CppUnit::Exception::UNKNOWNLINENUMBER, + e.lineNumber() ); + CPPUNIT_ASSERT_EQUAL( CppUnit::Exception::UNKNOWNFILENAME, + e.fileName() ); +} + + +void +ExceptionTest::testCopyConstructor() +{ + CppUnit::Exception e( "message", 17, "fileName.cpp" ); + CppUnit::Exception other( e ); + checkIsSame( e, other ); +} + + +void +ExceptionTest::testAssignment() +{ + CppUnit::Exception e( "message", 17, "fileName.cpp" ); + CppUnit::Exception other; + other = e; + checkIsSame( e, other ); +} + + +void +ExceptionTest::testClone() +{ + CppUnit::Exception e( "message", 17, "fileName.cpp" ); + std::auto_ptr<CppUnit::Exception> other( e.clone() ); + checkIsSame( e, *other.get() ); +} + + +void +ExceptionTest::testIsInstanceOf() +{ + CppUnit::Exception e( "message", 17, "fileName.cpp" ); + CPPUNIT_ASSERT( e.isInstanceOf( CppUnit::Exception::type() ) ); + CPPUNIT_ASSERT( !e.isInstanceOf( CppUnit::NotEqualException::type() ) ); +} + + +void +ExceptionTest::checkIsSame( CppUnit::Exception &e, + CppUnit::Exception &other ) +{ + std::string eWhat( e.what() ); + std::string otherWhat( other.what() ); + CPPUNIT_ASSERT_EQUAL( eWhat, otherWhat ); + CPPUNIT_ASSERT_EQUAL( e.lineNumber(), other.lineNumber() ); + CPPUNIT_ASSERT_EQUAL( e.fileName(), other.fileName() ); +} diff --git a/examples/cppunittest/ExceptionTest.h b/examples/cppunittest/ExceptionTest.h new file mode 100644 index 0000000..bc177e1 --- /dev/null +++ b/examples/cppunittest/ExceptionTest.h @@ -0,0 +1,43 @@ +#ifndef EXCEPTIONTEST_H +#define EXCEPTIONTEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class ExceptionTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( ExceptionTest ); + CPPUNIT_TEST( testConstructor ); + CPPUNIT_TEST( testDefaultConstructor ); + CPPUNIT_TEST( testCopyConstructor ); + CPPUNIT_TEST( testAssignment ); + CPPUNIT_TEST( testClone ); + CPPUNIT_TEST( testIsInstanceOf ); + CPPUNIT_TEST_SUITE_END(); + +public: + ExceptionTest(); + virtual ~ExceptionTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testConstructor(); + void testDefaultConstructor(); + void testCopyConstructor(); + void testAssignment(); + void testClone(); + void testIsInstanceOf(); + +private: + ExceptionTest( const ExceptionTest © ); + void operator =( const ExceptionTest © ); + void checkIsSame( CppUnit::Exception &e, + CppUnit::Exception &other ); + +private: +}; + + + +#endif // EXCEPTIONTEST_H diff --git a/examples/cppunittest/FailingTestCase.cpp b/examples/cppunittest/FailingTestCase.cpp new file mode 100644 index 0000000..f519438 --- /dev/null +++ b/examples/cppunittest/FailingTestCase.cpp @@ -0,0 +1,62 @@ +#include "FailingTestCase.h" + + +FailingTestCase::FailingTestCase( bool failSetUp, + bool failRunTest, + bool failTearDown ) : + CppUnit::TestCase( "FailingTestCase" ), + m_failSetUp( failSetUp ), + m_failRunTest( failRunTest ), + m_failTearDown( failTearDown ), + m_setUpCalled( false ), + m_runTestCalled( false ), + m_tearDownCalled( false ) +{ +} + + +FailingTestCase::~FailingTestCase() +{ +} + + +void +FailingTestCase::setUp() +{ + m_setUpCalled = true; + doFailure( m_failSetUp ); +} + + +void +FailingTestCase::tearDown() +{ + m_tearDownCalled = true; + doFailure( m_failTearDown ); +} + + +void +FailingTestCase::runTest() +{ + m_runTestCalled = true; + doFailure( m_failRunTest ); +} + + +void +FailingTestCase::doFailure( bool shouldFail ) +{ + if ( shouldFail ) + throw FailureException(); +} + + +void +FailingTestCase::verify( bool runTestCalled, + bool tearDownCalled ) +{ + CPPUNIT_ASSERT( m_setUpCalled ); + CPPUNIT_ASSERT_EQUAL( runTestCalled, m_runTestCalled ); + CPPUNIT_ASSERT_EQUAL( tearDownCalled, m_tearDownCalled ); +} diff --git a/examples/cppunittest/FailingTestCase.h b/examples/cppunittest/FailingTestCase.h new file mode 100644 index 0000000..2ac52b5 --- /dev/null +++ b/examples/cppunittest/FailingTestCase.h @@ -0,0 +1,42 @@ +#ifndef FAILINGTESTCASE_H +#define FAILINGTESTCASE_H + +#include <cppunit/TestCase.h> +#include "FailureException.h" + + +class FailingTestCase : public CppUnit::TestCase +{ +public: + FailingTestCase( bool failSetUp =false, + bool failRunTest =false, + bool failTearDown =false ); + + virtual ~FailingTestCase(); + + virtual void setUp(); + virtual void tearDown(); + + virtual void runTest(); + + void verify( bool runTestCalled =true, + bool tearDownCalled =true); + +private: + FailingTestCase( const FailingTestCase © ); + void operator =( const FailingTestCase © ); + + void doFailure( bool shouldFail ); + +private: + bool m_failSetUp; + bool m_failRunTest; + bool m_failTearDown; + + bool m_setUpCalled; + bool m_runTestCalled; + bool m_tearDownCalled; +}; + + +#endif // FAILINGTESTCASE_H diff --git a/examples/cppunittest/FailureException.h b/examples/cppunittest/FailureException.h new file mode 100644 index 0000000..0a4be47 --- /dev/null +++ b/examples/cppunittest/FailureException.h @@ -0,0 +1,10 @@ +#ifndef FAILUREEXCEPTION_H +#define FAILUREEXCEPTION_H + + +class FailureException +{ +}; + + +#endif // FAILUREEXCEPTION_H diff --git a/examples/cppunittest/HelperMacrosTest.cpp b/examples/cppunittest/HelperMacrosTest.cpp new file mode 100644 index 0000000..a7b0ddc --- /dev/null +++ b/examples/cppunittest/HelperMacrosTest.cpp @@ -0,0 +1,69 @@ +#include "HelperMacrosTest.h" +#include "SubclassedTestCase.h" +#include <cppunit/TestResult.h> +#include <memory> + +/* Note: + - no unit test for CPPUNIT_TEST_SUITE_REGISTRATION... + */ + + +CPPUNIT_TEST_SUITE_REGISTRATION( HelperMacrosTest ); + + +HelperMacrosTest::HelperMacrosTest() : + CppUnit::TestCase() +{ +} + + +HelperMacrosTest::~HelperMacrosTest() +{ +} + + +void +HelperMacrosTest::setUp() +{ + m_result = new CppUnit::TestResult(); +} + + +void +HelperMacrosTest::tearDown() +{ + delete m_result; +} + + +void +HelperMacrosTest::testNoSubclassing() +{ + std::auto_ptr<CppUnit::TestSuite> suite( BaseTestCase::suite() ); + CPPUNIT_ASSERT_EQUAL( 1, suite->countTestCases() ); + + suite->run( m_result ); + checkTestResult( 0,0,1 ); +} + + +void +HelperMacrosTest::testSubclassing() +{ + std::auto_ptr<CppUnit::TestSuite> suite( SubclassedTestCase::suite() ); + CPPUNIT_ASSERT_EQUAL( 2, suite->countTestCases() ); + + suite->run( m_result ); + checkTestResult( 1,0,2 ); +} + + +void +HelperMacrosTest::checkTestResult( int expectedFailures, + int expectedErrors, + int expectedTestsRun ) +{ + CPPUNIT_ASSERT_EQUAL( expectedFailures, m_result->testFailures() ); + CPPUNIT_ASSERT_EQUAL( expectedErrors, m_result->testErrors() ); + CPPUNIT_ASSERT_EQUAL( expectedTestsRun, m_result->runTests() ); +} diff --git a/examples/cppunittest/HelperMacrosTest.h b/examples/cppunittest/HelperMacrosTest.h new file mode 100644 index 0000000..c9d33a7 --- /dev/null +++ b/examples/cppunittest/HelperMacrosTest.h @@ -0,0 +1,39 @@ +#ifndef HELPERMACROSTEST_H +#define HELPERMACROSTEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class HelperMacrosTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( HelperMacrosTest ); + CPPUNIT_TEST( testNoSubclassing ); + CPPUNIT_TEST( testSubclassing ); + CPPUNIT_TEST_SUITE_END(); + +public: + HelperMacrosTest(); + virtual ~HelperMacrosTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testNoSubclassing(); + + void testSubclassing(); + +private: + HelperMacrosTest( const HelperMacrosTest © ); + void operator =( const HelperMacrosTest © ); + + void checkTestResult( int expectedFailures, + int expectedErrors, + int expectedTestsRun ); + +private: + CppUnit::TestResult *m_result; +}; + + + +#endif // HELPERMACROSTEST_H diff --git a/examples/cppunittest/Makefile.am b/examples/cppunittest/Makefile.am index 8631228..f129602 100644 --- a/examples/cppunittest/Makefile.am +++ b/examples/cppunittest/Makefile.am @@ -6,13 +6,41 @@ check_PROGRAMS = $(TESTS) INCLUDES = -I$(top_srcdir)/include cppunittestmain_SOURCES = \ + BaseTestCase.cpp \ + BaseTestCase.h \ CppUnitTestMain.cpp \ + ExceptionTest.cpp \ + ExceptionTest.h \ + FailingTestCase.cpp \ + FailingTestCase.h \ + FailureException.h \ + HelperMacrosTest.cpp \ + HelperMacrosTest.h \ MockTestListener.cpp \ MockTestListener.h \ + OrthodoxTest.cpp \ + OrthodoxTest.h \ + RepeatedTestTest.cpp \ + RepeatedTestTest.h \ + SubclassedTestCase.cpp \ + SubclassedTestCase.h \ + SynchronizedTestResult.h \ + TestAssertTest.cpp \ + TestAssertTest.h \ TestCallerTest.cpp \ TestCallerTest.h \ + TestCaseTest.cpp \ + TestCaseTest.h \ + TestDecoratorTest.cpp \ + TestDecoratorTest.h \ + TestListenerTest.cpp \ + TestListenerTest.h \ + TestFailureTest.cpp \ + TestFailureTest.h \ TestResultTest.cpp \ TestResultTest.h \ + TestSuiteTest.cpp \ + TestSuiteTest.h \ TrackedTestCase.cpp \ TrackedTestCase.h diff --git a/examples/cppunittest/OrthodoxTest.cpp b/examples/cppunittest/OrthodoxTest.cpp new file mode 100644 index 0000000..5e472df --- /dev/null +++ b/examples/cppunittest/OrthodoxTest.cpp @@ -0,0 +1,109 @@ +#include "OrthodoxTest.h" +#include <cppunit/extensions/Orthodox.h> +#include <cppunit/TestResult.h> + +CPPUNIT_TEST_SUITE_REGISTRATION( OrthodoxTest ); + +OrthodoxTest::OrthodoxTest() +{ +} + + +OrthodoxTest::~OrthodoxTest() +{ +} + + +void +OrthodoxTest::setUp() +{ + m_result = new CppUnit::TestResult(); +} + + +void +OrthodoxTest::tearDown() +{ + delete m_result; +} + + +void +OrthodoxTest::testValue() +{ + CppUnit::Orthodox<Value> test; + test.run( m_result ); + checkSuccess(); +} + + +void +OrthodoxTest::testValueBadConstructor() +{ + CppUnit::Orthodox<ValueBadConstructor> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::testValueBadInvert() +{ + CppUnit::Orthodox<ValueBadInvert> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::testValueBadEqual() +{ + CppUnit::Orthodox<ValueBadEqual> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::testValueBadNotEqual() +{ + CppUnit::Orthodox<ValueBadNotEqual> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::testValueBadCall() +{ + CppUnit::Orthodox<ValueBadCall> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::testValueBadAssignment() +{ + CppUnit::Orthodox<ValueBadAssignment> test; + test.run( m_result ); + checkFailure(); +} + + +void +OrthodoxTest::checkSuccess() +{ + CPPUNIT_ASSERT_EQUAL( 0, m_result->testErrors() ); + CPPUNIT_ASSERT_EQUAL( 0, m_result->testFailures() ); + CPPUNIT_ASSERT( m_result->runTests() > 0 ); +} + + +void +OrthodoxTest::checkFailure() +{ + CPPUNIT_ASSERT( m_result->testErrors() > 0 || + m_result->testFailures() > 0 ); +} + diff --git a/examples/cppunittest/OrthodoxTest.h b/examples/cppunittest/OrthodoxTest.h new file mode 100644 index 0000000..02d9ee8 --- /dev/null +++ b/examples/cppunittest/OrthodoxTest.h @@ -0,0 +1,173 @@ +#ifndef ORTHODOXTEST_H +#define ORTHODOXTEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class OrthodoxTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( OrthodoxTest ); + CPPUNIT_TEST( testValue ); + CPPUNIT_TEST( testValueBadConstructor ); + CPPUNIT_TEST( testValueBadInvert ); + CPPUNIT_TEST( testValueBadEqual ); + CPPUNIT_TEST( testValueBadNotEqual ); + CPPUNIT_TEST( testValueBadCall ); + CPPUNIT_TEST( testValueBadAssignment ); + CPPUNIT_TEST_SUITE_END(); + +public: + OrthodoxTest(); + virtual ~OrthodoxTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testValue(); + void testValueBadConstructor(); + void testValueBadInvert(); + void testValueBadEqual(); + void testValueBadNotEqual(); + void testValueBadCall(); + void testValueBadAssignment(); + +private: + class Value + { + public: + Value( int value =0 ) : m_value( value ) {} + + bool operator ==( const Value &other ) + { + return m_value == other.m_value; + } + + bool operator !=( const Value &other ) + { + return !( *this == other ); + } + + Value operator !() + { + return -1 - m_value; + } + + protected: + int m_value; + }; + + + class ValueBadConstructor : public Value + { + public: + ValueBadConstructor() + { + static int serialNumber = 0; + m_value = ++serialNumber; + } + + ValueBadConstructor( int value ) : Value( value ) {} + + ValueBadConstructor operator !() + { + return -1 - m_value; + } + }; + + + class ValueBadInvert : public Value + { + public: + ValueBadInvert( int value =0 ) : Value( value ) {} + + ValueBadInvert operator !() + { + return 1; + } + }; + + + class ValueBadEqual : public Value + { + public: + ValueBadEqual( int value =0 ) : Value( value ) {} + + ValueBadEqual operator !() + { + return -1 - m_value; + } + + bool operator ==( const ValueBadEqual &other ) + { + return m_value != other.m_value; + } + }; + + + class ValueBadNotEqual : public Value + { + public: + ValueBadNotEqual( int value =0 ) : Value( value ) {} + + ValueBadNotEqual operator !() + { + return -1 - m_value; + } + + bool operator !=( const ValueBadNotEqual &other ) + { + return m_value == other.m_value; + } + }; + + + class ValueBadCall : public Value + { + public: + ValueBadCall( int value =0 ) : Value( value ) {} + + ValueBadCall( const ValueBadCall &other ) + { + static int serialNumber = 0; + m_value = ++serialNumber; + } + + ValueBadCall operator !() + { + return -1 - m_value; + } + }; + + + class ValueBadAssignment: public Value + { + public: + ValueBadAssignment( int value =0 ) : Value( value ) {} + + ValueBadAssignment operator !() + { + return -1 - m_value; + } + + ValueBadAssignment &operator =( const ValueBadAssignment &other ) + { + ++m_value; + return *this; + } + }; + + + + OrthodoxTest( const OrthodoxTest © ); + void operator =( const OrthodoxTest © ); + + void checkSuccess(); + void checkFailure(); + +private: + CppUnit::TestResult *m_result; +}; + + + +#endif // ORTHODOXTEST_H diff --git a/examples/cppunittest/RepeatedTestTest.cpp b/examples/cppunittest/RepeatedTestTest.cpp new file mode 100644 index 0000000..883575d --- /dev/null +++ b/examples/cppunittest/RepeatedTestTest.cpp @@ -0,0 +1,42 @@ +#include "RepeatedTestTest.h" +#include <cppunit/extensions/RepeatedTest.h> +#include <cppunit/TestResult.h> + +CPPUNIT_TEST_SUITE_REGISTRATION( RepeatedTestTest ); + + +RepeatedTestTest::RepeatedTestTest() : + m_repeatCount( 17 ) +{ +} + + +RepeatedTestTest::~RepeatedTestTest() +{ +} + + +void +RepeatedTestTest::setUp() +{ + m_test = new RunCountTest(); + m_repeatedTest = new CppUnit::RepeatedTest( m_test, m_repeatCount ); +} + + +void +RepeatedTestTest::tearDown() +{ + delete m_repeatedTest; + delete m_test; +} + + +void +RepeatedTestTest::testRun() +{ + CppUnit::TestResult result; + m_repeatedTest->run( &result ); + + CPPUNIT_ASSERT_EQUAL( 17, m_test->m_runCount ); +} diff --git a/examples/cppunittest/RepeatedTestTest.h b/examples/cppunittest/RepeatedTestTest.h new file mode 100644 index 0000000..712fc26 --- /dev/null +++ b/examples/cppunittest/RepeatedTestTest.h @@ -0,0 +1,47 @@ +#ifndef REPEATEDTESTTEST_H +#define REPEATEDTESTTEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class RepeatedTestTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( RepeatedTestTest ); + CPPUNIT_TEST( testRun ); + CPPUNIT_TEST_SUITE_END(); + +public: + RepeatedTestTest(); + virtual ~RepeatedTestTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testRun(); + +private: + class RunCountTest : public CppUnit::TestCase + { + public: + RunCountTest() : m_runCount( 0 ) {} + + void runTest() + { + ++m_runCount; + } + + int m_runCount; + }; + + RepeatedTestTest( const RepeatedTestTest © ); + void operator =( const RepeatedTestTest © ); + +private: + RunCountTest *m_test; + CppUnit::Test *m_repeatedTest; + const int m_repeatCount; +}; + + + +#endif // REPEATEDTESTTEST_H diff --git a/examples/cppunittest/SubclassedTestCase.cpp b/examples/cppunittest/SubclassedTestCase.cpp new file mode 100644 index 0000000..ac39697 --- /dev/null +++ b/examples/cppunittest/SubclassedTestCase.cpp @@ -0,0 +1,36 @@ +#include "SubclassedTestCase.h" + + +SubclassedTestCase::SubclassedTestCase() +{ +} + + +SubclassedTestCase::~SubclassedTestCase() +{ +} + + +void +SubclassedTestCase::setUp() +{ +} + + +void +SubclassedTestCase::tearDown() +{ +} + + +void +SubclassedTestCase::checkIt() +{ + CPPUNIT_ASSERT( false ); +} + + +void +SubclassedTestCase::testSubclassing() +{ +} diff --git a/examples/cppunittest/SubclassedTestCase.h b/examples/cppunittest/SubclassedTestCase.h new file mode 100644 index 0000000..84e6e7f --- /dev/null +++ b/examples/cppunittest/SubclassedTestCase.h @@ -0,0 +1,35 @@ +#ifndef SUBCLASSEDTESTCASE_H +#define SUBCLASSEDTESTCASE_H + +#include "BaseTestCase.h" + + +class SubclassedTestCase : public BaseTestCase +{ + CPPUNIT_TEST_SUB_SUITE( SubclassedTestCase, BaseTestCase ); + CPPUNIT_TEST( testSubclassing ); + CPPUNIT_TEST_SUITE_END(); + +public: + SubclassedTestCase(); + virtual ~SubclassedTestCase(); + + virtual void setUp(); + virtual void tearDown(); + + // Another test to ensure the subclassed test case are in the suite . + void testSubclassing(); + +protected: + // We overload this method to ensure that the testUsingCheckIt in the + // parent class will fail. + virtual void checkIt(); + +private: + SubclassedTestCase( const SubclassedTestCase © ); + void operator =( const SubclassedTestCase © ); +}; + + + +#endif // SUBCLASSEDTESTCASE_H diff --git a/examples/cppunittest/SynchronizedTestResult.h b/examples/cppunittest/SynchronizedTestResult.h new file mode 100644 index 0000000..78ce2bb --- /dev/null +++ b/examples/cppunittest/SynchronizedTestResult.h @@ -0,0 +1,55 @@ +#ifndef SYNCHRONIZEDTESTRESULT_H +#define SYNCHRONIZEDTESTRESULT_H + +#include <cppunit/TestResult.h> + + +class SynchronizedTestResult : public CppUnit::TestResult +{ +public: + + class SynchronizationObjectListener + { + public: + virtual ~SynchronizationObjectListener() {} + virtual void locked() {} + virtual void unlocked() {} + }; + + class ObservedSynchronizationObject : public CppUnit::TestResult::SynchronizationObject + { + public: + ObservedSynchronizationObject( SynchronizationObjectListener *listener ) : + m_listener( listener ) + { + } + + virtual ~ObservedSynchronizationObject() + { + } + + virtual void lock() + { + m_listener->locked(); + } + + virtual void unlock() + { + m_listener->unlocked(); + } + + private: + SynchronizationObjectListener *m_listener; + }; + + + SynchronizedTestResult( SynchronizationObjectListener *listener ) + { + setSynchronizationObject( new ObservedSynchronizationObject( listener ) ); + } + + virtual ~SynchronizedTestResult() {} + +}; + +#endif // SYNCHRONIZEDTESTRESULT_H diff --git a/examples/cppunittest/TestAssertTest.cpp b/examples/cppunittest/TestAssertTest.cpp new file mode 100644 index 0000000..c6eb73c --- /dev/null +++ b/examples/cppunittest/TestAssertTest.cpp @@ -0,0 +1,143 @@ +#include "TestAssertTest.h" + +/* + Note: + - tests need to be added to test asserEquals() template function and + use of assertion traits. Some check may need to be added to check + the message content in Exception. + - code need to be refactored with the use of a test caller that expect + an exception. + */ + + +CPPUNIT_TEST_SUITE_REGISTRATION( TestAssertTest ); + + +TestAssertTest::TestAssertTest() +{ +} + + +TestAssertTest::~TestAssertTest() +{ +} + + +void +TestAssertTest::setUp() +{ +} + + +void +TestAssertTest::tearDown() +{ +} + +void +TestAssertTest::testAssertTrue() +{ + CPPUNIT_ASSERT( true ); +} + + +void +TestAssertTest::testAssertFalse() +{ + bool exceptionCatched = false; + try + { + CPPUNIT_ASSERT( false ); + } + catch( CppUnit::Exception & ) + { + exceptionCatched = true; // ok, we were expecting an exception. + } + + CPPUNIT_ASSERT( exceptionCatched ); +} + + +void +TestAssertTest::testAssertMessageTrue() +{ + CPPUNIT_ASSERT_MESSAGE( "This test should not failed", true ); +} + + +void +TestAssertTest::testAssertMessageFalse() +{ + bool exceptionCatched = false; + std::string message( "This test message should not be seen" ); + try + { + CPPUNIT_ASSERT_MESSAGE( message, false ); + } + catch( CppUnit::Exception &e ) + { + CPPUNIT_ASSERT_EQUAL( message, std::string( e.what() ) ); + exceptionCatched = true; // ok, we were expecting an exception. + } + + CPPUNIT_ASSERT( exceptionCatched ); +} + + +void +TestAssertTest::testAssertDoubleEquals() +{ + CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.1, 1.2, 0.101 ); + CPPUNIT_ASSERT_DOUBLES_EQUAL( 1.2, 1.1, 0.101 ); +} + + +void +TestAssertTest::testAssertDoubleNotEquals() +{ + checkDoubleNotEquals( 1.1, 1.2, 0.09 ); + checkDoubleNotEquals( 1.2, 1.1, 0.09 ); +} + + +void +TestAssertTest::checkDoubleNotEquals( double expected, + double actual, + double delta ) +{ + bool exceptionCatched = false; + try + { + CPPUNIT_ASSERT_DOUBLES_EQUAL( expected, actual, delta ); + } + catch( CppUnit::Exception & ) + { + exceptionCatched = true; // ok, we were expecting an exception. + } + + CPPUNIT_ASSERT( exceptionCatched ); +} + + +void +TestAssertTest::testAssertLongEquals() +{ + CPPUNIT_ASSERT_EQUAL( 12345678, 12345678 ); +} + + +void +TestAssertTest::testAssertLongNotEquals() +{ + bool exceptionCatched = false; + try + { + CPPUNIT_ASSERT_EQUAL( 1, 2 ); + } + catch( CppUnit::Exception & ) + { + exceptionCatched = true; // ok, we were expecting an exception. + } + + CPPUNIT_ASSERT( exceptionCatched ); +} diff --git a/examples/cppunittest/TestAssertTest.h b/examples/cppunittest/TestAssertTest.h new file mode 100644 index 0000000..718366c --- /dev/null +++ b/examples/cppunittest/TestAssertTest.h @@ -0,0 +1,51 @@ +#ifndef TESTASSERTTEST_H +#define TESTASSERTTEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class TestAssertTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestAssertTest ); + CPPUNIT_TEST( testAssertTrue ); + CPPUNIT_TEST( testAssertFalse ); + CPPUNIT_TEST( testAssertMessageTrue ); + CPPUNIT_TEST( testAssertMessageFalse ); + CPPUNIT_TEST( testAssertDoubleEquals ); + CPPUNIT_TEST( testAssertDoubleNotEquals ); + CPPUNIT_TEST( testAssertLongEquals ); + CPPUNIT_TEST( testAssertLongNotEquals ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestAssertTest(); + + virtual ~TestAssertTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testAssertTrue(); + void testAssertFalse(); + + void testAssertMessageTrue(); + void testAssertMessageFalse(); + + void testAssertDoubleEquals(); + void testAssertDoubleNotEquals(); + + void testAssertLongEquals(); + void testAssertLongNotEquals(); + +private: + TestAssertTest( const TestAssertTest © ); + void operator =( const TestAssertTest © ); + + void checkDoubleNotEquals( double expected, + double actual, + double delta ); + +private: +}; + +#endif // TESTASSERTTEST_H diff --git a/examples/cppunittest/TestCallerTest.cpp b/examples/cppunittest/TestCallerTest.cpp index d9cab55..9aafd8f 100644 --- a/examples/cppunittest/TestCallerTest.cpp +++ b/examples/cppunittest/TestCallerTest.cpp @@ -1,10 +1,26 @@ #include "TestCallerTest.h" +#include "FailureException.h" #include <cppunit/extensions/TestSuiteBuilder.h> #include <cppunit/extensions/HelperMacros.h> CPPUNIT_TEST_SUITE_REGISTRATION( TestCallerTest ); +void +TestCallerTest::ExceptionThrower::testThrowFailureException() +{ + throw FailureException(); +} + + +void +TestCallerTest::ExceptionThrower::testThrowException() +{ + throw CppUnit::Exception( "expected Exception" ); +} + + + TestCallerTest::TestCallerTest() : m_testName( "TrackedTestCaseCaller" ) { @@ -24,6 +40,8 @@ TestCallerTest::suite() suite.addTestCaller( "testBasicConstructor", &TestCallerTest::testBasicConstructor ); suite.addTestCaller( "testReferenceConstructor", &TestCallerTest::testReferenceConstructor ); suite.addTestCaller( "testPointerConstructor", &TestCallerTest::testPointerConstructor ); + suite.addTestCaller( "testExpectFailureException", &TestCallerTest::testExpectFailureException ); + suite.addTestCaller( "testExpectException", &TestCallerTest::testExpectException ); return suite.takeSuite(); } @@ -139,6 +157,26 @@ TestCallerTest::testPointerConstructor() void +TestCallerTest::testExpectFailureException() +{ + CppUnit::TestCaller<ExceptionThrower,FailureException> caller( + m_testName, + &ExceptionThrower::testThrowFailureException ); + caller.run(); +} + + +void +TestCallerTest::testExpectException() +{ + CppUnit::TestCaller<ExceptionThrower,CppUnit::Exception> caller( + m_testName, + &ExceptionThrower::testThrowException ); + caller.run(); +} + + +void TestCallerTest::checkNothingButConstructorCalled() { CPPUNIT_ASSERT_EQUAL( 1, m_constructorCount ); diff --git a/examples/cppunittest/TestCallerTest.h b/examples/cppunittest/TestCallerTest.h index 6579d42..e317716 100644 --- a/examples/cppunittest/TestCallerTest.h +++ b/examples/cppunittest/TestCallerTest.h @@ -10,12 +10,7 @@ class TestCallerTest : public CppUnit::TestCase, Tracker { public: - /*! Constructs a TestCallerTest object. - */ TestCallerTest(); - - /*! Destructor. - */ virtual ~TestCallerTest(); static CppUnit::TestSuite *suite(); @@ -27,7 +22,17 @@ public: void testReferenceConstructor(); void testPointerConstructor(); + void testExpectFailureException(); + void testExpectException(); + private: + class ExceptionThrower : public CppUnit::TestCase + { + public: + void testThrowFailureException(); + void testThrowException(); + }; + virtual void onConstructor(); virtual void onDestructor(); virtual void onSetUp(); @@ -38,10 +43,7 @@ private: void checkRunningSequenceCalled(); void checkTestName( std::string testName ); - /// Prevents the use of the copy constructor. TestCallerTest( const TestCallerTest © ); - - /// Prevents the use of the copy operator. void operator =( const TestCallerTest © ); private: diff --git a/examples/cppunittest/TestCaseTest.cpp b/examples/cppunittest/TestCaseTest.cpp new file mode 100644 index 0000000..d749938 --- /dev/null +++ b/examples/cppunittest/TestCaseTest.cpp @@ -0,0 +1,148 @@ +#include "TestCaseTest.h" +#include "FailingTestCase.h" +#include <cppunit/TestResult.h> + +/* + - test have been done to check exception management in run(). other + tests need to be added to check the other aspect of TestCase. + */ + +CPPUNIT_TEST_SUITE_REGISTRATION( TestCaseTest ); + + +TestCaseTest::TestCaseTest() +{ +} + + +TestCaseTest::~TestCaseTest() +{ +} + + +void +TestCaseTest::setUp() +{ + m_result = new CppUnit::TestResult(); +} + + +void +TestCaseTest::tearDown() +{ + delete m_result; +} + + +void +TestCaseTest::testSetUpFailure() +{ + checkFailure( true, false, false ); +} + + +void +TestCaseTest::testRunTestFailure() +{ + checkFailure( false, true, false ); +} + + +void +TestCaseTest::testTearDownFailure() +{ + checkFailure( false, false, true ); +} + + +void +TestCaseTest::testFailAll() +{ + checkFailure( true, true, true ); +} + + +void +TestCaseTest::testNoFailure() +{ + checkFailure( false, false, false ); +} + + +void +TestCaseTest::checkFailure( bool failSetUp, + bool failRunTest, + bool failTearDown ) +{ + try + { + FailingTestCase test( failSetUp, failRunTest, failTearDown ); + test.run( m_result ); + test.verify( !failSetUp, !failSetUp ); + } + catch ( FailureException & ) + { + CPPUNIT_ASSERT_MESSAGE( "exception should have been catched", false ); + } +} + + +void +TestCaseTest::testCountTestCases() +{ + CppUnit::TestCase test; + CPPUNIT_ASSERT_EQUAL( 1, test.countTestCases() ); +} + + +void +TestCaseTest::testDefaultConstructor() +{ + CppUnit::TestCase test; + CPPUNIT_ASSERT_EQUAL( std::string(""), test.getName() ); +} + + +void +TestCaseTest::testConstructorWithName() +{ + std::string testName( "TestName" ); + CppUnit::TestCase test( testName ); + CPPUNIT_ASSERT_EQUAL( testName, test.getName() ); +} + + +void +TestCaseTest::testDefaultRun() +{ + CppUnit::TestCase test; + std::auto_ptr<CppUnit::TestResult> result( test.run() ); + + checkResult( 0, 0, 1, result.get() ); +} + + +void +TestCaseTest::testTwoRun() +{ + FailingTestCase test1( false, true, false ); + test1.run( m_result ); + test1.run( m_result ); + + FailingTestCase test2( false, false, false ); + test2.run( m_result ); + + checkResult( 2, 0, 1, m_result ); +} + + +void +TestCaseTest::checkResult( int failures, + int errors, + int testsRun, + CppUnit::TestResult *result ) +{ + CPPUNIT_ASSERT_EQUAL( testsRun, result->runTests() ); + CPPUNIT_ASSERT_EQUAL( errors, result->testErrors() ); + CPPUNIT_ASSERT_EQUAL( failures, result->testFailures() ); +} diff --git a/examples/cppunittest/TestCaseTest.h b/examples/cppunittest/TestCaseTest.h new file mode 100644 index 0000000..16a6e37 --- /dev/null +++ b/examples/cppunittest/TestCaseTest.h @@ -0,0 +1,66 @@ +// ////////////////////////////////////////////////////////////////////////// +// Header file TestCaseTest.h for class TestCaseTest +// (c)Copyright 2000, Baptiste Lepilleur. +// Created: 2000/06/09 +// ////////////////////////////////////////////////////////////////////////// +#ifndef TESTCASETEST_H +#define TESTCASETEST_H + +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/TestResult.h> + + +class TestCaseTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestCaseTest ); + CPPUNIT_TEST( testSetUpFailure ); + CPPUNIT_TEST( testRunTestFailure ); + CPPUNIT_TEST( testTearDownFailure ); + CPPUNIT_TEST( testFailAll ); + CPPUNIT_TEST( testNoFailure ); + CPPUNIT_TEST( testDefaultRun ); + CPPUNIT_TEST( testCountTestCases ); + CPPUNIT_TEST( testDefaultConstructor ); + CPPUNIT_TEST( testConstructorWithName ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestCaseTest(); + + virtual ~TestCaseTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testSetUpFailure(); + void testRunTestFailure(); + void testTearDownFailure(); + void testFailAll(); + void testNoFailure(); + void testDefaultRun(); + void testTwoRun(); + + void testCountTestCases(); + + void testDefaultConstructor(); + void testConstructorWithName(); + + +private: + TestCaseTest( const TestCaseTest © ); + void operator =( const TestCaseTest © ); + + void checkFailure( bool failSetUp, + bool failRunTest, + bool failTearDown ); + + void checkResult( int failures, + int errors, + int testsRun, + CppUnit::TestResult *result ); +private: + CppUnit::TestResult *m_result; +}; + + +#endif // TESTCASETEST_H diff --git a/examples/cppunittest/TestDecoratorTest.cpp b/examples/cppunittest/TestDecoratorTest.cpp new file mode 100644 index 0000000..f05fce5 --- /dev/null +++ b/examples/cppunittest/TestDecoratorTest.cpp @@ -0,0 +1,55 @@ +#include "TestDecoratorTest.h" +#include "FailingTestCase.h" +#include <cppunit/TestResult.h> + + +CPPUNIT_TEST_SUITE_REGISTRATION( TestDecoratorTest ); + + +TestDecoratorTest::TestDecoratorTest() +{ +} + + +TestDecoratorTest::~TestDecoratorTest() +{ +} + + +void +TestDecoratorTest::setUp() +{ + m_test = new FailingTestCase(); + m_decorator = new CppUnit::TestDecorator( m_test ); +} + + +void +TestDecoratorTest::tearDown() +{ + delete m_decorator; + delete m_test; +} + + +void +TestDecoratorTest::testCountTestCases() +{ + CPPUNIT_ASSERT_EQUAL( 1, m_decorator->countTestCases() ); +} + + +void +TestDecoratorTest::testRun() +{ + CppUnit::TestResult result; + m_decorator->run( &result ); + m_test->verify(); +} + + +void +TestDecoratorTest::testGetName() +{ + CPPUNIT_ASSERT_EQUAL( m_test->getName(), m_decorator->getName() ); +} diff --git a/examples/cppunittest/TestDecoratorTest.h b/examples/cppunittest/TestDecoratorTest.h new file mode 100644 index 0000000..b795afd --- /dev/null +++ b/examples/cppunittest/TestDecoratorTest.h @@ -0,0 +1,39 @@ +#ifndef TESTDECORATORTEST_H +#define TESTDECORATORTEST_H + +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/extensions/TestDecorator.h> +class FailingTestCase; + + +class TestDecoratorTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestDecoratorTest ); + CPPUNIT_TEST( testCountTestCases ); + CPPUNIT_TEST( testRun ); + CPPUNIT_TEST( testGetName ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestDecoratorTest(); + virtual ~TestDecoratorTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testCountTestCases(); + void testRun(); + void testGetName(); + +private: + TestDecoratorTest( const TestDecoratorTest © ); + void operator =( const TestDecoratorTest © ); + +private: + CppUnit::Test *m_decorator; + FailingTestCase *m_test; +}; + + + +#endif // TESTDECORATORTEST_H diff --git a/examples/cppunittest/TestFailureTest.cpp b/examples/cppunittest/TestFailureTest.cpp new file mode 100644 index 0000000..c6b5736 --- /dev/null +++ b/examples/cppunittest/TestFailureTest.cpp @@ -0,0 +1,56 @@ +#include "TestFailureTest.h" +#include <cppunit/TestFailure.h> +#include <cppunit/Exception.h> + + +CPPUNIT_TEST_SUITE_REGISTRATION( TestFailureTest ); + + +TestFailureTest::TestFailureTest() +{ +} + + +TestFailureTest::~TestFailureTest() +{ +} + + +void +TestFailureTest::setUp() +{ + m_exceptionDestroyed = false; +} + + +void +TestFailureTest::tearDown() +{ +} + + +void +TestFailureTest::testConstructorAndGetters() +{ + CppUnit::TestCase test; + CppUnit::Exception *error = new ObservedException( this ); + checkTestFailure( &test, error ); + CPPUNIT_ASSERT( m_exceptionDestroyed ); +} + + +void +TestFailureTest::exceptionDestroyed() +{ + m_exceptionDestroyed = true; +} + + +void +TestFailureTest::checkTestFailure( CppUnit::Test *test, + CppUnit::Exception *error ) +{ + CppUnit::TestFailure failure( test, error ); + CPPUNIT_ASSERT_EQUAL( test, failure.failedTest() ); + CPPUNIT_ASSERT_EQUAL( error, failure.thrownException() ); +} diff --git a/examples/cppunittest/TestFailureTest.h b/examples/cppunittest/TestFailureTest.h new file mode 100644 index 0000000..9e5e297 --- /dev/null +++ b/examples/cppunittest/TestFailureTest.h @@ -0,0 +1,54 @@ +#ifndef TESTFAILURETEST_H +#define TESTFAILURETEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class TestFailureTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestFailureTest ); + CPPUNIT_TEST( testConstructorAndGetters ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestFailureTest(); + virtual ~TestFailureTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testConstructorAndGetters(); + + void exceptionDestroyed(); + +private: + class ObservedException : public CppUnit::Exception + { + public: + ObservedException( TestFailureTest *listener ) : + CppUnit::Exception( "ObservedException" ), + m_listener( listener ) + { + } + + virtual ~ObservedException() + { + m_listener->exceptionDestroyed(); + } + private: + TestFailureTest *m_listener; + }; + + + TestFailureTest( const TestFailureTest © ); + void operator =( const TestFailureTest © ); + void checkTestFailure( CppUnit::Test *test, + CppUnit::Exception *error ); + +private: + bool m_exceptionDestroyed; +}; + + + +#endif // TESTFAILURETEST_H diff --git a/examples/cppunittest/TestResultTest.cpp b/examples/cppunittest/TestListenerTest.cpp index 22695b6..a45b0e3 100644 --- a/examples/cppunittest/TestResultTest.cpp +++ b/examples/cppunittest/TestListenerTest.cpp @@ -1,48 +1,48 @@ -#include "TestResultTest.h" +#include "TestListenerTest.h" #include <cppunit/extensions/TestSuiteBuilder.h> #include <cppunit/extensions/HelperMacros.h> #include <cppunit/TestResult.h> #include "MockTestListener.h" -CPPUNIT_TEST_SUITE_REGISTRATION( TestResultTest ); +CPPUNIT_TEST_SUITE_REGISTRATION( TestListenerTest ); -TestResultTest::TestResultTest() : +TestListenerTest::TestListenerTest() : CppUnit::TestCase() { } -TestResultTest::~TestResultTest() +TestListenerTest::~TestListenerTest() { } CppUnit::TestSuite * -TestResultTest::suite() +TestListenerTest::suite() { - CppUnit::TestSuiteBuilder<TestResultTest> suite("TestResultTest"); + CppUnit::TestSuiteBuilder<TestListenerTest> suite("TestListenerTest"); - suite.addTestCaller( "testNoListener", &TestResultTest::testNoListener ); + suite.addTestCaller( "testNoListener", &TestListenerTest::testNoListener ); suite.addTestCaller( "testAddErrorListener", - &TestResultTest::testAddErrorListener ); + &TestListenerTest::testAddErrorListener ); suite.addTestCaller( "testAddFailureListener", - &TestResultTest::testAddFailureListener ); + &TestListenerTest::testAddFailureListener ); suite.addTestCaller( "testStartTestListener", - &TestResultTest::testStartTestListener ); + &TestListenerTest::testStartTestListener ); suite.addTestCaller( "testEndTestListener", - &TestResultTest::testEndTestListener ); + &TestListenerTest::testEndTestListener ); suite.addTestCaller( "testRemoveFrontListener", - &TestResultTest::testRemoveFrontListener ); + &TestListenerTest::testRemoveFrontListener ); suite.addTestCaller( "testRemoveLastListener", - &TestResultTest::testRemoveLastListener ); + &TestListenerTest::testRemoveLastListener ); return suite.takeSuite(); } void -TestResultTest::setUp() +TestListenerTest::setUp() { m_listenerTest = NULL; m_listenerError = NULL; @@ -55,7 +55,7 @@ TestResultTest::setUp() void -TestResultTest::tearDown() +TestListenerTest::tearDown() { m_result->removeListener( this ); delete m_result; @@ -64,7 +64,7 @@ TestResultTest::tearDown() void -TestResultTest::addError( CppUnit::Test *test, CppUnit::Exception *e ) +TestListenerTest::addError( CppUnit::Test *test, CppUnit::Exception *e ) { m_listenerTest = test; m_listenerError = e; @@ -73,7 +73,7 @@ TestResultTest::addError( CppUnit::Test *test, CppUnit::Exception *e ) void -TestResultTest::addFailure( CppUnit::Test *test, CppUnit::Exception *e ) +TestListenerTest::addFailure( CppUnit::Test *test, CppUnit::Exception *e ) { m_listenerTest = test; m_listenerError = e; @@ -81,7 +81,7 @@ TestResultTest::addFailure( CppUnit::Test *test, CppUnit::Exception *e ) } void -TestResultTest::startTest( CppUnit::Test *test ) +TestListenerTest::startTest( CppUnit::Test *test ) { m_listenerTest = test; m_listenerCallbackType = onStartTest; @@ -89,7 +89,7 @@ TestResultTest::startTest( CppUnit::Test *test ) void -TestResultTest::endTest( CppUnit::Test *test ) +TestListenerTest::endTest( CppUnit::Test *test ) { m_listenerTest = test; m_listenerCallbackType = onEndTest; @@ -97,7 +97,7 @@ TestResultTest::endTest( CppUnit::Test *test ) void -TestResultTest::testAddErrorListener() +TestListenerTest::testAddErrorListener() { m_result->addError( m_dummyTest, makeDummyError() ); CPPUNIT_ASSERT( m_listenerCallbackType == onAddError ); @@ -107,7 +107,7 @@ TestResultTest::testAddErrorListener() void -TestResultTest::testAddFailureListener() +TestListenerTest::testAddFailureListener() { m_result->addFailure( m_dummyTest, makeDummyError() ); CPPUNIT_ASSERT( m_listenerCallbackType == onAddFailure ); @@ -117,7 +117,7 @@ TestResultTest::testAddFailureListener() void -TestResultTest::testStartTestListener() +TestListenerTest::testStartTestListener() { m_result->startTest( m_dummyTest ); CPPUNIT_ASSERT( m_listenerCallbackType == onStartTest ); @@ -126,7 +126,7 @@ TestResultTest::testStartTestListener() void -TestResultTest::testEndTestListener() +TestListenerTest::testEndTestListener() { m_result->endTest( m_dummyTest ); CPPUNIT_ASSERT( m_listenerCallbackType == onEndTest ); @@ -135,7 +135,7 @@ TestResultTest::testEndTestListener() CppUnit::Exception * -TestResultTest::makeDummyError() +TestListenerTest::makeDummyError() { m_dummyError = new CppUnit::Exception( "dummy exception" ); return m_dummyError; @@ -143,7 +143,7 @@ TestResultTest::makeDummyError() void -TestResultTest::testNoListener() +TestListenerTest::testNoListener() { CppUnit::TestResult result; result.addError( m_dummyTest, makeDummyError() ); @@ -154,7 +154,7 @@ TestResultTest::testNoListener() void -TestResultTest::testTwoListener() +TestListenerTest::testTwoListener() { MockTestListener listener; m_result->addListener( &listener ); @@ -165,7 +165,7 @@ TestResultTest::testTwoListener() void -TestResultTest::testRemoveFrontListener() +TestListenerTest::testRemoveFrontListener() { MockTestListener listener; m_result->addListener( &listener ); @@ -177,7 +177,7 @@ TestResultTest::testRemoveFrontListener() void -TestResultTest::testRemoveLastListener() +TestListenerTest::testRemoveLastListener() { MockTestListener listener; m_result->addListener( &listener ); diff --git a/examples/cppunittest/TestResultTest.h b/examples/cppunittest/TestListenerTest.h index e3ab3f8..96a2e25 100644 --- a/examples/cppunittest/TestResultTest.h +++ b/examples/cppunittest/TestListenerTest.h @@ -1,22 +1,18 @@ -#ifndef TESTRESULTTEST_H -#define TESTRESULTTEST_H +#ifndef TESTLISTENERTEST_H +#define TESTLISTENERTEST_H #include <cppunit/TestCase.h> #include <cppunit/TestSuite.h> #include <cppunit/TestListener.h> -class TestResultTest : public CppUnit::TestCase, - public CppUnit::TestListener +class TestListenerTest : public CppUnit::TestCase, + public CppUnit::TestListener { public: - /*! Constructs a TestResultTest object. - */ - TestResultTest(); + TestListenerTest(); - /*! Destructor. - */ - virtual ~TestResultTest(); + virtual ~TestListenerTest(); static CppUnit::TestSuite *suite(); @@ -50,8 +46,8 @@ private: CppUnit::Exception *makeDummyError(); - TestResultTest( const TestResultTest © ); - void operator =( const TestResultTest © ); + TestListenerTest( const TestListenerTest © ); + void operator =( const TestListenerTest © ); private: CppUnit::Test *m_listenerTest; @@ -63,10 +59,4 @@ private: }; - -// Inlines methods for TestResultTest: -// ----------------------------------- - - - -#endif // TESTRESULTTEST_H +#endif // TESTLISTENERTEST_H diff --git a/examples/cppunittest/TestSetUpTest.cpp b/examples/cppunittest/TestSetUpTest.cpp new file mode 100644 index 0000000..b16933b --- /dev/null +++ b/examples/cppunittest/TestSetUpTest.cpp @@ -0,0 +1,40 @@ +#include "TestSetUpTest.h" +#include <cppunit/TestResult.h> + +CPPUNIT_TEST_SUITE_REGISTRATION( TestSetUpTest ); + + +TestSetUpTest::TestSetUpTest() +{ +} + + +TestSetUpTest::~TestSetUpTest() +{ +} + + +void +TestSetUpTest::setUp() +{ + m_test = new FailingTestCase(); + m_setUp = new SetUp( m_test ); +} + + +void +TestSetUpTest::tearDown() +{ + delete m_setUp; + delete m_test; +} + + +void +TestSetUpTest::testRun() +{ + CppUnit::TestResult result; + m_setUp->run( &result ); + CPPUNIT_ASSERT( m_setUp->m_setUpCalled ); + CPPUNIT_ASSERT( m_setUp->m_tearDownCalled ); +} diff --git a/examples/cppunittest/TestSetUpTest.h b/examples/cppunittest/TestSetUpTest.h new file mode 100644 index 0000000..854be0a --- /dev/null +++ b/examples/cppunittest/TestSetUpTest.h @@ -0,0 +1,59 @@ +#ifndef TESTSETUPTEST_H +#define TESTSETUPTEST_H + +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/extensions/TestSetUp.h> +#include "FailingTestCase.h" + + +class TestSetUpTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestSetUpTest ); + CPPUNIT_TEST( testRun ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestSetUpTest(); + virtual ~TestSetUpTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testRun(); + +private: + class SetUp : public CppUnit::TestSetUp + { + public: + SetUp( CppUnit::Test *test ) : + TestSetUp( test ), + m_setUpCalled( false ), + m_tearDownCalled( false ) + { + } + + void setUp() + { + m_setUpCalled = true; + } + + void tearDown() + { + m_tearDownCalled = true; + } + + bool m_setUpCalled; + bool m_tearDownCalled; + }; + + TestSetUpTest( const TestSetUpTest © ); + void operator =( const TestSetUpTest © ); + +private: + SetUp *m_setUp; + FailingTestCase *m_test; +}; + + + +#endif // TESTSETUPTEST_H diff --git a/examples/cppunittest/TestSuiteTest.cpp b/examples/cppunittest/TestSuiteTest.cpp new file mode 100644 index 0000000..b13c7ac --- /dev/null +++ b/examples/cppunittest/TestSuiteTest.cpp @@ -0,0 +1,136 @@ +#include "TestSuiteTest.h" +#include "FailingTestCase.h" +#include <cppunit/TestResult.h> + + +CPPUNIT_TEST_SUITE_REGISTRATION( TestSuiteTest ); + + +TestSuiteTest::TestSuiteTest() +{ +} + + +TestSuiteTest::~TestSuiteTest() +{ +} + + +void +TestSuiteTest::setUp() +{ + m_suite = new CppUnit::TestSuite(); + m_result = new CppUnit::TestResult(); +} + + +void +TestSuiteTest::tearDown() +{ + delete m_result; + delete m_suite; +} + + +void +TestSuiteTest::testConstructor() +{ + std::string name( "MySuite" ); + CppUnit::TestSuite suite( name ); + CPPUNIT_ASSERT_EQUAL( name, suite.getName() ); +} + + +void +TestSuiteTest::testCountTestCasesWithNoTest() +{ + CPPUNIT_ASSERT_EQUAL( 0, m_suite->countTestCases() ); +} + + +void +TestSuiteTest::testCountTestCasesWithTwoTests() +{ + m_suite->addTest( new CppUnit::TestCase( "test1" ) ); + m_suite->addTest( new CppUnit::TestCase( "test2" ) ); + + CPPUNIT_ASSERT_EQUAL( 2, m_suite->countTestCases() ); +} + + +void +TestSuiteTest::testCountTestCasesWithSubSuite() +{ + CppUnit::TestSuite *subSuite = new CppUnit::TestSuite( "SubSuite"); + subSuite->addTest( new CppUnit::TestCase( "test1" ) ); + subSuite->addTest( new CppUnit::TestCase( "test2" ) ); + + m_suite->addTest( new CppUnit::TestCase( "test3" ) ); + m_suite->addTest( subSuite ); + + CPPUNIT_ASSERT_EQUAL( 3, m_suite->countTestCases() ); +} + + +void +TestSuiteTest::testRunWithOneTest() +{ + FailingTestCase *test = new FailingTestCase(); + m_suite->addTest( test ); + + m_suite->run( m_result ); + test->verify(); + checkResult( 0, 0, 1 ); +} + + +void +TestSuiteTest::testRunWithOneTestAndSubSuite() +{ + CppUnit::TestSuite *subSuite = new CppUnit::TestSuite( "SubSuite"); + + FailingTestCase *test2 = new FailingTestCase(); + subSuite->addTest( test2 ); + + FailingTestCase *test3 = new FailingTestCase(); + subSuite->addTest( test3 ); + + FailingTestCase *test = new FailingTestCase(); + m_suite->addTest( test ); + m_suite->addTest( subSuite ); + + m_suite->run( m_result ); + checkResult( 0, 0, 3 ); + test->verify(); + test2->verify(); + test3->verify(); +} + + +void +TestSuiteTest::testGetTests() +{ + m_suite->addTest( new CppUnit::TestCase( "test1" ) ); + m_suite->addTest( new CppUnit::TestCase( "test2" ) ); + CPPUNIT_ASSERT_EQUAL( 2, int(m_suite->getTests().size()) ); +} + + +void +TestSuiteTest::testDeleteContents() +{ + m_suite->addTest( new CppUnit::TestCase( "test2" ) ); + m_suite->deleteContents(); + CPPUNIT_ASSERT_EQUAL( 0, int(m_suite->getTests().size()) ); +} + + +void +TestSuiteTest::checkResult( int failures, + int errors, + int testsRun ) +{ + CPPUNIT_ASSERT_EQUAL( testsRun, m_result->runTests() ); + CPPUNIT_ASSERT_EQUAL( errors, m_result->testErrors() ); + CPPUNIT_ASSERT_EQUAL( failures, m_result->testFailures() ); +} diff --git a/examples/cppunittest/TestSuiteTest.h b/examples/cppunittest/TestSuiteTest.h new file mode 100644 index 0000000..f39a652 --- /dev/null +++ b/examples/cppunittest/TestSuiteTest.h @@ -0,0 +1,55 @@ +#ifndef TESTSUITETEST_H +#define TESTSUITETEST_H + +#include <cppunit/extensions/HelperMacros.h> + + +class TestSuiteTest : public CppUnit::TestCase +{ + CPPUNIT_TEST_SUITE( TestSuiteTest ); + CPPUNIT_TEST( testConstructor ); + CPPUNIT_TEST( testCountTestCasesWithNoTest ); + CPPUNIT_TEST( testCountTestCasesWithTwoTests ); + CPPUNIT_TEST( testCountTestCasesWithSubSuite ); + CPPUNIT_TEST( testRunWithOneTest ); + CPPUNIT_TEST( testRunWithOneTestAndSubSuite ); + CPPUNIT_TEST( testGetTests ); + CPPUNIT_TEST( testDeleteContents ); + CPPUNIT_TEST_SUITE_END(); + +public: + TestSuiteTest(); + virtual ~TestSuiteTest(); + + virtual void setUp(); + virtual void tearDown(); + + void testConstructor(); + + void testCountTestCasesWithNoTest(); + void testCountTestCasesWithTwoTests(); + void testCountTestCasesWithSubSuite(); + + void testRunWithOneTest(); + void testRunWithOneTestAndSubSuite(); + + void testGetTests(); + + void testDeleteContents(); + +private: + TestSuiteTest( const TestSuiteTest © ); + void operator =( const TestSuiteTest © ); + + void checkResult( int failures, + int errors, + int testsRun ); + +private: + CppUnit::TestSuite *m_suite; + CppUnit::TestResult *m_result; +}; + + + +#endif // TESTSUITETEST_H diff --git a/examples/cppunittest/TrackedTestCase.h b/examples/cppunittest/TrackedTestCase.h index fb11bbf..b437033 100644 --- a/examples/cppunittest/TrackedTestCase.h +++ b/examples/cppunittest/TrackedTestCase.h @@ -42,10 +42,4 @@ private: }; - -// Inlines methods for TrackedTestCase: -// ------------------------------------ - - - #endif // TRACKEDTESTCASE_H |