haiku.git

// StatableTest.h

#ifndef __sk_statable_test_h__
#define __sk_statable_test_h__

#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>

#include <list>
using std::list;

#include "BasicTest.h"

class BStatable;
class BEntry;
class BNode;

// TestEntries

template <typename C>
struct TestEntries
{
	~TestEntries()
	{
		delete_all();
	}

	void delete_all()
	{
		for (typename list<C*>::iterator it = entries.begin();
			 it != entries.end();
			 it++) {
			// Arghh, BStatable has no virtual destructor!
			// Workaround: try to cast to one of the subclasses
			if (BNode *node = dynamic_cast<BNode*>(*it))
				delete node;
			else if (BEntry *entry = dynamic_cast<BEntry*>(*it))
				delete entry;
			else
				delete *it;
		}
		clear();
	}

	void clear()
	{
		entries.clear();
		entryNames.clear();
		rewind();
	}

	void add(C *entry, string entryName)
	{
		entries.push_back(entry);
		entryNames.push_back(entryName);
	}

	bool getNext(C *&entry, string &entryName)
	{
		bool result = (entryIt != entries.end()
					   && entryNameIt != entryNames.end());
		if (result) {
			entry = *entryIt;
			entryName = *entryNameIt;
			entryIt++;
			entryNameIt++;
		}
		return result;
	}
	
	void rewind()
	{
		entryIt = entries.begin();
		entryNameIt = entryNames.begin();
	}

	list<C*>						entries;
	list<string>					entryNames;
	typename list<C*>::iterator		entryIt;
	typename list<string>::iterator	entryNameIt;
};

typedef TestEntries<BStatable> TestStatables;


// StatableTest

class StatableTest : public BasicTest
{
public:
	template<typename DerivedClass>
	static inline void AddBaseClassTests(const char *prefix,
										 CppUnit::TestSuite *suite);

	virtual void CreateROStatables(TestStatables& testEntries) = 0;
	virtual void CreateRWStatables(TestStatables& testEntries) = 0;
	virtual void CreateUninitializedStatables(TestStatables& testEntries) = 0;

	// This function called before *each* test added in Suite()
	void setUp();
	
	// This function called after *each* test added in Suite()
	void tearDown();

	void GetStatTest();
	void IsXYZTest();
	void GetXYZTest();
	void SetXYZTest();
};

// AddBaseClassTests
template<typename DerivedClass>
inline void
StatableTest::AddBaseClassTests(const char *prefix, CppUnit::TestSuite *suite)
{
	typedef CppUnit::TestCaller<DerivedClass> TC;
	string p(prefix);

	suite->addTest( new TC(p + "BStatable::GetStat Test",
						   &StatableTest::GetStatTest) );
	suite->addTest( new TC(p + "BStatable::IsXYZ Test",
						   &StatableTest::IsXYZTest) );
	suite->addTest( new TC(p + "BStatable::GetXYZ Test",
						   &StatableTest::GetXYZTest) );
	suite->addTest( new TC(p + "BStatable::SetXYZ Test",
						   &StatableTest::SetXYZTest) );
}

#endif	// __sk_statable_test_h__