Reusing tests in cppUnit

[Belebele]

Suppose I want to test several implementations of the same protocol
(interface with clearly defined semantics) using cppUnit. How to reuse
the test that checks the semantics?

Take, for example, the simple SetterGetter interface and the even
simpler implementations Impl1 and Impl2.

class SetterGetter {

SetterGetter& operator=(Sette rGetter const& ); // Not Implemented

public:
virtual ~SetterGetter() {}

virtual void set(int ) = 0;

virtual int get() const = 0;
};
class Impl1: public SetterGetter {

/* This class clearly fails to comply with
the intended semantics, thus the protocol
test should fail when passed an object of
this class */

public:
virtual void set(int ) {}

virtual int get() const {return 0;}
};
class Impl2: public SetterGetter {
int i_;

public:
virtual void set(int i) {i_ = i;}

virtual int get() const {return i_;}
};
I would like to write a single class that tests the semantics and that
can be reused for any implementation of the protocol. Any ideas?

I made an attempt, but it did not work. The output said that there was
a Segmentation fault. See below:

class TestSetterGette r: public CppUnit::TestCa se {

CPPUNIT_TEST_SU ITE( TestSetterGette r );

CPPUNIT_TEST( testSetGet );

CPPUNIT_TEST_SU ITE_END();

SetterGetter *psetterGetter_ ;

public:
TestSetterGette r(): psetterGetter_( 0) {}

void set(SetterGette r& sg) {psetterGetter_ = &sg;}

void testSetGet() {
psetterGetter_->set(0);
CPPUNIT_ASSERT_ EQUAL(0, psetterGetter_->get());
}
};
class TestImpl1: public TestSetterGette r {

Impl1 impl1_;

public:
TestImpl1() {set(impl1_);}
};
CPPUNIT_TEST_SU ITE_REGISTRATIO N( TestImpl1 );
class TestImpl2: public TestSetterGette r {

Impl2 impl2_;

public:
TestImpl2() {set(impl2_);}
};
CPPUNIT_TEST_SU ITE_REGISTRATIO N( TestImpl2 );

[Belebele]

Never mind, I got it ...

The solution that worked for me is:
1. Create the test base class, that derives from cppUnit::TestCa se, and
define the tests for the protocol in it. Two things to notice: the
termination macro for the declaration of the tests in the fixture must
be CPPUNIT_TEST_SU ITE_END_ABSTRAC T() and the class should not be
registered as a fixture. See below (the auto_ptr is to avoid having to
deallocate the memory explicitly):

#include <memory>
using namespace std;

class TestSetterGette r: public CppUnit::TestCa se {

CPPUNIT_TEST_SU ITE( TestSetterGette r );

CPPUNIT_TEST( testSetGet );

// Different termination macro for the test declarations.
CPPUNIT_TEST_SU ITE_END_ABSTRAC T();

auto_ptr<Setter GetterpsetterGe tter_;

virtual auto_ptr<Setter GettermakeSette rGetter() = 0;

public:
void setUp() {psetterGetter_ = makeSetterGette r();}

void tearDown() {}

protected:
void testSetGet() {
psetterGetter_->set(1);
CPPUNIT_ASSERT_ EQUAL(1, psetterGetter_->get());
}
};
// No test registration here.

2. Then, for the implementations of the tests of the different
implementations (sorry for the tongue twisting), one thing to notice is
that the initialization of the test declaration requires a different
macro which includes a declaration of the base test. See below:
class TestImpl1: public TestSetterGette r {

// A different macro for the initialization of the test
declarations.
CPPUNIT_TEST_SU B_SUITE( TestImpl1, TestSetterGette r );

CPPUNIT_TEST_SU ITE_END();

auto_ptr<Setter GettermakeSette rGetter() {
return auto_ptr<Setter Getter>(new Impl1());
}

public:

// In my example, no extra tests to add here

};
CPPUNIT_TEST_SU ITE_REGISTRATIO N( TestImpl1 ); // Just register your
fixture and you will be in business.
class TestImpl2: public TestSetterGette r {

CPPUNIT_TEST_SU B_SUITE( TestImpl2, TestSetterGette r );
CPPUNIT_TEST_SU ITE_END();

auto_ptr<Setter GettermakeSette rGetter() {return
auto_ptr<Setter Getter>(new Impl2());}

public:

// In my example, no extra tests to add here

};
CPPUNIT_TEST_SU ITE_REGISTRATIO N( TestImpl2 );

All of this complication only because reflection is nowhere to be seen
on C++.

[andrewmcdonagh]

On Jan 15, 8:19 pm, "Belebele" <beluc...@gmail .comwrote:

Never mind, I got it ...

snipped...

A similar (but IMHO cleaner) approach is the (google-able)
'Parametrised test case'

Andrew

[Belebele]

A similar (but IMHO cleaner) approach is the (google-able)

'Parametrised test case'

I looked it up. I don't feel I understood it very well. It got the
impression that can be used to run the same test on a set of input
data. It was not clear to me how to apply it to the example I posted.
Also, I could not even find the ParameterizedTe stCase.h file in my
cppUnit installation (1.10.2)

Could you please elaborate? Could you use the example from my previous
posts? Thanks.