143 lines
3.8 KiB
C++
143 lines
3.8 KiB
C++
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <map>
|
|
|
|
#include <TestUtils.h>
|
|
#include <cppunit/Test.h>
|
|
#include <cppunit/TestCaller.h>
|
|
#include <cppunit/TestSuite.h>
|
|
|
|
#include <VectorMap.h>
|
|
|
|
#include "common.h"
|
|
#include "OrderedMapTest.h"
|
|
#include "VectorMapTest.h"
|
|
|
|
// That's how it should work, if we had a working compiler.
|
|
/*
|
|
template<typename Key, typename Value>
|
|
struct PairTestBase {
|
|
typedef SimpleValueStrategy<Key> KeyStrategy;
|
|
typedef SimpleValueStrategy<Value> ValueStrategy;
|
|
typedef PairEntryStrategy<KeyStrategy, ValueStrategy> EntryStrategy;
|
|
|
|
template<typename CompareStrategy>
|
|
struct MyMap
|
|
: public VectorMap<Key, Value, VectorMapEntryStrategy::Pair<Key, Value,
|
|
CompareStrategy> > {
|
|
};
|
|
|
|
template<class CompareStrategy>
|
|
struct Strategy : public TestStrategy<MyMap, EntryStrategy,
|
|
CompareStrategy> {
|
|
};
|
|
};
|
|
typedef typename PairTestBase<int, int>::Strategy IntIntTestStrategy;
|
|
// ...
|
|
*/
|
|
|
|
// ugly work-around:
|
|
|
|
template<typename Key, typename Value>
|
|
struct PairTestBase {
|
|
typedef SimpleValueStrategy<Key> KeyStrategy;
|
|
typedef SimpleValueStrategy<Value> ValueStrategy;
|
|
typedef PairEntryStrategy<KeyStrategy, ValueStrategy> EntryStrategy;
|
|
|
|
template<typename CompareStrategy>
|
|
struct MyMap
|
|
: public VectorMap<Key, Value, VectorMapEntryStrategy::Pair<Key, Value,
|
|
CompareStrategy> > {
|
|
};
|
|
};
|
|
|
|
#define DECLARE_TEST_STRATEGY(Key, Value, Map, Strategy, ClassName) \
|
|
template<typename CS> struct Map : PairTestBase<Key, Value>::MyMap<CS> {};\
|
|
template<typename CS> \
|
|
struct Strategy \
|
|
: public TestStrategy<Map, PairTestBase<Key, Value>::EntryStrategy, \
|
|
CS> { \
|
|
static const char *kClassName; \
|
|
}; \
|
|
template<typename CS> const char *Strategy<CS>::kClassName = ClassName;
|
|
|
|
DECLARE_TEST_STRATEGY(int, int, IntIntMap, IntIntTestStrategy,
|
|
"VectorMap<int, int, Pair>")
|
|
DECLARE_TEST_STRATEGY(int, string, IntStringMap, IntStringTestStrategy,
|
|
"VectorMap<int, string, Pair>")
|
|
DECLARE_TEST_STRATEGY(string, int, StringIntMap, StringIntTestStrategy,
|
|
"VectorMap<string, int, Pair>")
|
|
DECLARE_TEST_STRATEGY(string, string, StringStringMap,
|
|
StringStringTestStrategy,
|
|
"VectorMap<string, string, Pair>")
|
|
|
|
|
|
// TestStrategy for the ImplicitKey entry strategy
|
|
|
|
// string_hash (from the Dragon Book: a slightly modified hashpjw())
|
|
static inline
|
|
int
|
|
string_hash(const char *name)
|
|
{
|
|
uint32 h = 0;
|
|
for (; *name; name++) {
|
|
if (uint32 g = h & 0xf0000000)
|
|
h ^= g >> 24;
|
|
h = (h << 4) + *name;
|
|
}
|
|
return (int)h;
|
|
}
|
|
|
|
struct ImplicitKeyTestGetKey {
|
|
int operator()(string value) const
|
|
{
|
|
return string_hash(value.c_str());
|
|
}
|
|
};
|
|
|
|
template<typename CompareStrategy>
|
|
struct ImplicitKeyTestMap
|
|
: public VectorMap<int, string,
|
|
VectorMapEntryStrategy::ImplicitKey<int, string, ImplicitKeyTestGetKey,
|
|
CompareStrategy> > {
|
|
};
|
|
|
|
typedef ImplicitKeyStrategy<SimpleValueStrategy<int>,
|
|
SimpleValueStrategy<string>,
|
|
ImplicitKeyTestGetKey>
|
|
ImplicitKeyTestEntryStrategy;
|
|
|
|
template<class CompareStrategy>
|
|
struct ImplicitKeyTestStrategy : public TestStrategy<
|
|
ImplicitKeyTestMap, ImplicitKeyTestEntryStrategy, CompareStrategy> {
|
|
static const char *kClassName;
|
|
};
|
|
template<class CompareStrategy>
|
|
const char *ImplicitKeyTestStrategy<CompareStrategy>::kClassName
|
|
= "VectorMap<int, string, ImplicitKey>";
|
|
|
|
|
|
// constructor
|
|
VectorMapTest::VectorMapTest(std::string name)
|
|
: BTestCase(name)
|
|
{
|
|
}
|
|
|
|
// Suite
|
|
CppUnit::Test*
|
|
VectorMapTest::Suite()
|
|
{
|
|
CppUnit::TestSuite *suite = new CppUnit::TestSuite("VectorMap");
|
|
|
|
suite->addTest(OrderedMapTest<IntIntTestStrategy>::Suite());
|
|
suite->addTest(OrderedMapTest<IntStringTestStrategy>::Suite());
|
|
suite->addTest(OrderedMapTest<StringIntTestStrategy>::Suite());
|
|
suite->addTest(OrderedMapTest<StringStringTestStrategy>::Suite());
|
|
suite->addTest(OrderedMapTest<ImplicitKeyTestStrategy>::Suite());
|
|
|
|
return suite;
|
|
}
|
|
|