no message
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@70 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
tslettebo
parent
52020f94e0
commit
08bd05c8c4
27 changed files with 2717 additions and 1276 deletions
|
|
@ -38,49 +38,49 @@ class BadSuperMonster : public SuperMonster {};
|
|||
typedef Loki::AbstractFactory<TYPELIST_3(Soldier, Monster, SuperMonster)> AbstractEnemyFactory;
|
||||
|
||||
typedef Loki::ConcreteFactory<AbstractEnemyFactory, Loki::OpNewFactoryUnit,
|
||||
TYPELIST_3(SillySoldier, SillyMonster, SillySuperMonster)> EasyLevelEnemyFactory;
|
||||
TYPELIST_3(SillySoldier, SillyMonster, SillySuperMonster)> EasyLevelEnemyFactory;
|
||||
|
||||
typedef Loki::ConcreteFactory<AbstractEnemyFactory, Loki::OpNewFactoryUnit,
|
||||
TYPELIST_3(BadSoldier, BadMonster, BadSuperMonster)> HardLevelEnemyFactory;
|
||||
TYPELIST_3(BadSoldier, BadMonster, BadSuperMonster)> HardLevelEnemyFactory;
|
||||
|
||||
class AbstractFactoryTest : public Test
|
||||
{
|
||||
public:
|
||||
AbstractFactoryTest() : Test("AbstractFactory.h") {}
|
||||
AbstractFactoryTest() : Test("AbstractFactory.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
std::auto_ptr<AbstractEnemyFactory> easyFactory(new EasyLevelEnemyFactory);
|
||||
std::auto_ptr<AbstractEnemyFactory> hardFactory(new HardLevelEnemyFactory);
|
||||
std::auto_ptr<AbstractEnemyFactory> easyFactory(new EasyLevelEnemyFactory);
|
||||
std::auto_ptr<AbstractEnemyFactory> hardFactory(new HardLevelEnemyFactory);
|
||||
|
||||
Soldier *s;
|
||||
Soldier *s;
|
||||
|
||||
s = easyFactory->Create<Soldier>();
|
||||
|
||||
r= !!(typeid(*s)==typeid(SillySoldier)); //SGB !! eliminates bool-to-int performance warning
|
||||
s = easyFactory->Create<Soldier>();
|
||||
|
||||
r= !!(typeid(*s)==typeid(SillySoldier)); //SGB !! eliminates bool-to-int performance warning
|
||||
|
||||
delete s;
|
||||
delete s;
|
||||
|
||||
#ifndef __BORLANDC__
|
||||
|
||||
s = hardFactory->Create<Soldier>(); //BCB bug!!! - always creates SillySoldier
|
||||
s = hardFactory->Create<Soldier>(); //BCB bug!!! - always creates SillySoldier
|
||||
|
||||
r=r && typeid(*s)==typeid(BadSoldier);
|
||||
r=r && typeid(*s)==typeid(BadSoldier);
|
||||
|
||||
delete s;
|
||||
delete s;
|
||||
|
||||
#endif
|
||||
|
||||
testAssert("AbstractFactory",r,result);
|
||||
testAssert("AbstractFactory",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
} abstractFactoryTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -20,6 +20,12 @@
|
|||
#include <loki/AssocVector.h>
|
||||
#include "UnitTest.h"
|
||||
|
||||
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
|
||||
#define C_Namespace
|
||||
#else
|
||||
#define C_Namespace std
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// AssocVectorTest
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -31,51 +37,57 @@
|
|||
template <class T> class TestAllocator : public std::allocator<T>
|
||||
{
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef value_type* pointer;
|
||||
typedef const value_type* const_pointer;
|
||||
typedef value_type& reference;
|
||||
typedef const value_type& const_reference;
|
||||
typedef std::size_t size_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef T value_type;
|
||||
typedef value_type* pointer;
|
||||
typedef const value_type* const_pointer;
|
||||
typedef value_type& reference;
|
||||
typedef const value_type& const_reference;
|
||||
typedef C_Namespace::size_t size_type;
|
||||
typedef C_Namespace::ptrdiff_t difference_type;
|
||||
|
||||
template <class U>
|
||||
struct rebind { typedef TestAllocator<U> other; };
|
||||
template <class U>
|
||||
struct rebind { typedef TestAllocator<U> other; };
|
||||
|
||||
TestAllocator() {}
|
||||
TestAllocator(const TestAllocator&) {}
|
||||
template <class U>
|
||||
TestAllocator(const TestAllocator<U>&) {}
|
||||
~TestAllocator() {}
|
||||
TestAllocator() {}
|
||||
TestAllocator(const TestAllocator&) {}
|
||||
|
||||
pointer address(reference x) const { return &x; }
|
||||
const_pointer address(const_reference x) const {
|
||||
return x;
|
||||
}
|
||||
#if !(defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__))
|
||||
|
||||
pointer allocate(size_type n, const_pointer = 0) {
|
||||
return static_cast<pointer>(::operator new(n * sizeof(T)));
|
||||
}
|
||||
template <class U>
|
||||
TestAllocator(const TestAllocator<U>&) {}
|
||||
|
||||
void deallocate(pointer p, size_type size) {
|
||||
::operator delete(p);
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return static_cast<size_type>(-1) / sizeof(T);
|
||||
}
|
||||
|
||||
void construct(pointer p, const value_type& x) {
|
||||
new(p) value_type(x);
|
||||
}
|
||||
void destroy(pointer p) {
|
||||
#ifndef _USE_OLD_RW_STL // ?? failed to compile when RogueWave is enabled !?!
|
||||
p->~value_type();
|
||||
#endif
|
||||
}
|
||||
|
||||
~TestAllocator() {}
|
||||
|
||||
pointer address(reference x) const { return &x; }
|
||||
const_pointer address(const_reference x) const {
|
||||
return x;
|
||||
}
|
||||
|
||||
pointer allocate(size_type n, const_pointer = 0) {
|
||||
return static_cast<pointer>(::operator new(n * sizeof(T)));
|
||||
}
|
||||
|
||||
void deallocate(pointer p, size_type size) {
|
||||
::operator delete(p);
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return static_cast<size_type>(-1) / sizeof(T);
|
||||
}
|
||||
|
||||
void construct(pointer p, const value_type& x) {
|
||||
new(p) value_type(x);
|
||||
}
|
||||
void destroy(pointer p) {
|
||||
#ifndef _USE_OLD_RW_STL // ?? failed to compile when RogueWave is enabled !?!
|
||||
p->~value_type();
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
void operator=(const TestAllocator&);
|
||||
void operator=(const TestAllocator&);
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -85,19 +97,19 @@ private:
|
|||
class AVTestClass
|
||||
{
|
||||
public:
|
||||
AVTestClass(int value) : value_(value) {}
|
||||
AVTestClass(const AVTestClass& other) : value_(other.value_) {}
|
||||
AVTestClass& operator=(const AVTestClass& other) {
|
||||
value_ = other.value_;
|
||||
return *this;
|
||||
}
|
||||
AVTestClass(int value) : value_(value) {}
|
||||
AVTestClass(const AVTestClass& other) : value_(other.value_) {}
|
||||
AVTestClass& operator=(const AVTestClass& other) {
|
||||
value_ = other.value_;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int value_;
|
||||
int value_;
|
||||
};
|
||||
|
||||
bool operator<(const AVTestClass& lhs, const AVTestClass& rhs)
|
||||
{
|
||||
return lhs.value_ < rhs.value_;
|
||||
return lhs.value_ < rhs.value_;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -105,9 +117,9 @@ bool operator<(const AVTestClass& lhs, const AVTestClass& rhs)
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct str_less : public std::binary_function<const char*, const char*, bool> {
|
||||
bool operator()(const char* x, const char* y) const {
|
||||
return strcmp(x, y) < 0;
|
||||
}
|
||||
bool operator()(const char* x, const char* y) const {
|
||||
return strcmp(x, y) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -117,10 +129,10 @@ struct str_less : public std::binary_function<const char*, const char*, bool> {
|
|||
unsigned int_test_count = 0; // to verify usage
|
||||
struct int_less : public std::less<int>
|
||||
{
|
||||
bool operator()(int x, int y) const {
|
||||
++int_test_count;
|
||||
return x < y;
|
||||
}
|
||||
bool operator()(int x, int y) const {
|
||||
++int_test_count;
|
||||
return x < y;
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -129,17 +141,17 @@ struct int_less : public std::less<int>
|
|||
|
||||
template<class Vect>
|
||||
bool is_sorted(const Vect& v) {
|
||||
if (v.size() < 2) return true;
|
||||
typename Vect::const_iterator it = v.begin();
|
||||
typename Vect::key_type previous = it->first;
|
||||
++it;
|
||||
while (it != v.end()) {
|
||||
typename Vect::key_type current = it->first;
|
||||
if (!(Vect::key_compare()(previous, current))) return false;
|
||||
previous = current;
|
||||
++it;
|
||||
}
|
||||
return true;
|
||||
if (v.size() < 2) return true;
|
||||
typename Vect::const_iterator it = v.begin();
|
||||
typename Vect::key_type previous = it->first;
|
||||
++it;
|
||||
while (it != v.end()) {
|
||||
typename Vect::key_type current = it->first;
|
||||
if (!(Vect::key_compare()(previous, current))) return false;
|
||||
previous = current;
|
||||
++it;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -154,13 +166,13 @@ typedef Loki::AssocVector<int, const char*> test_vect5_t;
|
|||
|
||||
void check_insert1(test_vect1_t& v)
|
||||
{
|
||||
std::srand(10);
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
int x = std::rand();
|
||||
v.insert(std::make_pair(x, x));
|
||||
assert(is_sorted(v));
|
||||
}
|
||||
assert(v.size() == 100);
|
||||
C_Namespace::srand(10);
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
int x = C_Namespace::rand();
|
||||
v.insert(std::make_pair(x, x));
|
||||
assert(is_sorted(v));
|
||||
}
|
||||
assert(v.size() == 100);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -170,11 +182,11 @@ void check_insert1(test_vect1_t& v)
|
|||
template <class Vect>
|
||||
void check_swap(Vect& v1, Vect& v2)
|
||||
{
|
||||
unsigned size1 = v1.size();
|
||||
unsigned size2 = v2.size();
|
||||
v1.swap(v2);
|
||||
assert(v1.size() == size2);
|
||||
assert(v2.size() == size1);
|
||||
unsigned size1 = v1.size();
|
||||
unsigned size2 = v2.size();
|
||||
v1.swap(v2);
|
||||
assert(v1.size() == size2);
|
||||
assert(v2.size() == size1);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -183,47 +195,47 @@ void check_swap(Vect& v1, Vect& v2)
|
|||
|
||||
void test_vect1()
|
||||
{
|
||||
test_vect1_t vec11;
|
||||
assert(vec11.size() == 0);
|
||||
test_vect1_t vec11;
|
||||
assert(vec11.size() == 0);
|
||||
|
||||
check_insert1(vec11);
|
||||
size_t size1 = vec11.size();
|
||||
assert(size1);
|
||||
check_insert1(vec11);
|
||||
size_t size1 = vec11.size();
|
||||
assert(size1);
|
||||
|
||||
test_vect1_t vec12(vec11.begin(), vec11.end());
|
||||
assert(vec12.size() == vec11.size());
|
||||
assert(vec11.size() == size1);
|
||||
test_vect1_t vec12(vec11.begin(), vec11.end());
|
||||
assert(vec12.size() == vec11.size());
|
||||
assert(vec11.size() == size1);
|
||||
|
||||
test_vect1_t vec13;
|
||||
vec13 = vec11;
|
||||
assert(vec13.size() == vec11.size());
|
||||
assert(vec11.size() == size1);
|
||||
test_vect1_t vec13;
|
||||
vec13 = vec11;
|
||||
assert(vec13.size() == vec11.size());
|
||||
assert(vec11.size() == size1);
|
||||
|
||||
// this doesn't compile on Borland C++ 6.0 !?!
|
||||
//test_vect1_t vec99(test_vect1_t::key_compare(), TestAllocator<test_vect1_t::value_type>());
|
||||
//assert(vec99.size() == 0); //- here ir cries
|
||||
// this doesn't compile on Borland C++ 6.0 !?!
|
||||
//test_vect1_t vec99(test_vect1_t::key_compare(), TestAllocator<test_vect1_t::value_type>());
|
||||
//assert(vec99.size() == 0); //- here ir cries
|
||||
|
||||
test_vect1_t::key_compare comp = test_vect1_t::key_compare();
|
||||
test_vect1_t vec14(comp, TestAllocator<test_vect1_t::value_type>());
|
||||
assert(vec14.size() == 0);
|
||||
test_vect1_t::key_compare comp = test_vect1_t::key_compare();
|
||||
test_vect1_t vec14(comp, TestAllocator<test_vect1_t::value_type>());
|
||||
assert(vec14.size() == 0);
|
||||
|
||||
check_swap(vec11, vec14);
|
||||
assert(vec14.size() == size1);
|
||||
assert(vec11.size() == 0);
|
||||
check_swap(vec11, vec14);
|
||||
assert(vec14.size() == size1);
|
||||
assert(vec11.size() == 0);
|
||||
|
||||
// this compiles, unlike object on stack
|
||||
test_vect1_t* vec15 = new test_vect1_t(test_vect1_t::key_compare(), TestAllocator<test_vect1_t::value_type>());
|
||||
assert(vec15->size() == 0);
|
||||
check_insert1(*vec15);
|
||||
delete vec15;
|
||||
// this compiles, unlike object on stack
|
||||
test_vect1_t* vec15 = new test_vect1_t(test_vect1_t::key_compare(), TestAllocator<test_vect1_t::value_type>());
|
||||
assert(vec15->size() == 0);
|
||||
check_insert1(*vec15);
|
||||
delete vec15;
|
||||
|
||||
// different comparator test - doesn't work for Loki
|
||||
//comp = int_less();
|
||||
//test_vect1_t vec16(comp);
|
||||
//assert(vec16.size() == 0);
|
||||
//assert(int_test_count == 0);
|
||||
//check_insert1(vec16);
|
||||
//assert(int_test_count != 0);
|
||||
// different comparator test - doesn't work for Loki
|
||||
//comp = int_less();
|
||||
//test_vect1_t vec16(comp);
|
||||
//assert(vec16.size() == 0);
|
||||
//assert(int_test_count == 0);
|
||||
//check_insert1(vec16);
|
||||
//assert(int_test_count != 0);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -232,32 +244,32 @@ void test_vect1()
|
|||
|
||||
void test_vect2()
|
||||
{
|
||||
test_vect2_t vec21;
|
||||
vec21.insert(std::make_pair("abc", 1));
|
||||
vec21.insert(std::make_pair("xyz", 3));
|
||||
vec21.insert(std::make_pair("def", 2));
|
||||
assert(vec21.size() == 3);
|
||||
assert(is_sorted(vec21));
|
||||
test_vect2_t vec21;
|
||||
vec21.insert(std::make_pair("abc", 1));
|
||||
vec21.insert(std::make_pair("xyz", 3));
|
||||
vec21.insert(std::make_pair("def", 2));
|
||||
assert(vec21.size() == 3);
|
||||
assert(is_sorted(vec21));
|
||||
|
||||
test_vect2_t::iterator it = vec21.find("xyz");
|
||||
assert(it != vec21.end());
|
||||
assert(it->second == 3);
|
||||
test_vect2_t::iterator it = vec21.find("xyz");
|
||||
assert(it != vec21.end());
|
||||
assert(it->second == 3);
|
||||
|
||||
std::pair<test_vect2_t::iterator, bool> aux = vec21.insert(std::make_pair("xyz", 99));
|
||||
assert(aux.first); //TODOSGB was second meant, not first? MSVC7 dies here (more errors follow)
|
||||
it = vec21.find("xyz");
|
||||
assert(it->second == 3);
|
||||
std::pair<test_vect2_t::iterator, bool> aux = vec21.insert(std::make_pair("xyz", 99));
|
||||
assert(aux.first); //TODOSGB was second meant, not first? MSVC7 dies here (more errors follow)
|
||||
it = vec21.find("xyz");
|
||||
assert(it->second == 3);
|
||||
|
||||
vec21.erase(it);
|
||||
assert(vec21.size() == 2);
|
||||
it = vec21.find("xyz");
|
||||
assert(it == vec21.end());
|
||||
vec21.erase("xyz");
|
||||
vec21.erase("abc");
|
||||
assert(vec21.size() == 1);
|
||||
vec21.erase(it);
|
||||
assert(vec21.size() == 2);
|
||||
it = vec21.find("xyz");
|
||||
assert(it == vec21.end());
|
||||
vec21.erase("xyz");
|
||||
vec21.erase("abc");
|
||||
assert(vec21.size() == 1);
|
||||
|
||||
vec21.clear();
|
||||
assert(vec21.size() == 0);
|
||||
vec21.clear();
|
||||
assert(vec21.size() == 0);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -266,20 +278,20 @@ void test_vect2()
|
|||
|
||||
void test_vect3()
|
||||
{
|
||||
// To use string, you need:
|
||||
// 1) enable _STLP_USE_NEWALLOC in include\stl\_site_config.h
|
||||
// 2) either disable use of any dynamic RTL (menu Project | Options | Linker)
|
||||
// 3) or recompile STLPort DLL.
|
||||
// This all is related to bug in STLPort allocator.
|
||||
test_vect3_t vec31;
|
||||
std::srand(111);
|
||||
// a stress test
|
||||
for (unsigned i = 0; i < 2 * 1000; ++i) {
|
||||
char buffer[16];
|
||||
std::sprintf(buffer, "string%d", std::rand());
|
||||
std::string s(buffer);
|
||||
vec31.insert(std::make_pair(s, s));
|
||||
}
|
||||
// To use string, you need:
|
||||
// 1) enable _STLP_USE_NEWALLOC in include\stl\_site_config.h
|
||||
// 2) either disable use of any dynamic RTL (menu Project | Options | Linker)
|
||||
// 3) or recompile STLPort DLL.
|
||||
// This all is related to bug in STLPort allocator.
|
||||
test_vect3_t vec31;
|
||||
C_Namespace::srand(111);
|
||||
// a stress test
|
||||
for (unsigned i = 0; i < 2 * 1000; ++i) {
|
||||
char buffer[16];
|
||||
C_Namespace::sprintf(buffer, "string%d", C_Namespace::rand());
|
||||
std::string s(buffer);
|
||||
vec31.insert(std::make_pair(s, s));
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -288,27 +300,27 @@ void test_vect3()
|
|||
|
||||
void test_vect4()
|
||||
{
|
||||
test_vect4_t vec41;
|
||||
for (int i = 0; i < 100; ++i) {
|
||||
vec41.insert(std::make_pair(AVTestClass(i), AVTestClass(i)));
|
||||
}
|
||||
assert(vec41.size() == 100);
|
||||
test_vect4_t vec41;
|
||||
for (int i = 0; i < 100; ++i) {
|
||||
vec41.insert(std::make_pair(AVTestClass(i), AVTestClass(i)));
|
||||
}
|
||||
assert(vec41.size() == 100);
|
||||
|
||||
vec41.insert(std::make_pair(AVTestClass(300), AVTestClass(300)));
|
||||
vec41.insert(std::make_pair(AVTestClass(200), AVTestClass(200)));
|
||||
assert(vec41.size() == 102);
|
||||
vec41.insert(std::make_pair(AVTestClass(300), AVTestClass(300)));
|
||||
vec41.insert(std::make_pair(AVTestClass(200), AVTestClass(200)));
|
||||
assert(vec41.size() == 102);
|
||||
|
||||
test_vect4_t::iterator it = vec41.find(AVTestClass(22));
|
||||
assert(it != vec41.end());
|
||||
assert(it->second.value_ == 22);
|
||||
test_vect4_t::iterator it = vec41.find(AVTestClass(22));
|
||||
assert(it != vec41.end());
|
||||
assert(it->second.value_ == 22);
|
||||
|
||||
test_vect4_t vec42;
|
||||
vec42.swap(vec41);
|
||||
assert(vec41.size() == 0);
|
||||
assert(vec42.size() == 102);
|
||||
test_vect4_t vec42;
|
||||
vec42.swap(vec41);
|
||||
assert(vec41.size() == 0);
|
||||
assert(vec42.size() == 102);
|
||||
|
||||
vec42.erase(vec42.begin(), vec42.end());
|
||||
assert(vec42.size() == 0);
|
||||
vec42.erase(vec42.begin(), vec42.end());
|
||||
assert(vec42.size() == 0);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -317,42 +329,42 @@ void test_vect4()
|
|||
|
||||
void test_vect5()
|
||||
{
|
||||
test_vect5_t vec51;
|
||||
vec51.insert(test_vect5_t::value_type(3, "XXX"));
|
||||
vec51.insert(std::make_pair(1, "X"));
|
||||
vec51.insert(std::make_pair(2, "XX"));
|
||||
test_vect5_t vec51;
|
||||
vec51.insert(test_vect5_t::value_type(3, "XXX"));
|
||||
vec51.insert(std::make_pair(1, "X"));
|
||||
vec51.insert(std::make_pair(2, "XX"));
|
||||
|
||||
test_vect5_t::const_iterator it = vec51.begin();
|
||||
int count=1;
|
||||
test_vect5_t::const_iterator it = vec51.begin();
|
||||
int count=1;
|
||||
|
||||
while (it != vec51.end()) {
|
||||
assert(std::string(it->second).length()==count);
|
||||
while (it != vec51.end()) {
|
||||
assert(std::string(it->second).length()==count);
|
||||
|
||||
++count;
|
||||
++count;
|
||||
|
||||
it++; // intentionally
|
||||
}
|
||||
it++; // intentionally
|
||||
}
|
||||
}
|
||||
|
||||
class AssocVectorTest : public Test
|
||||
{
|
||||
public:
|
||||
AssocVectorTest() : Test("AssocVector.h") {}
|
||||
AssocVectorTest() : Test("AssocVector.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
test_vect1();
|
||||
test_vect2();
|
||||
test_vect3();
|
||||
test_vect4();
|
||||
test_vect5();
|
||||
test_vect1();
|
||||
test_vect2();
|
||||
test_vect3();
|
||||
test_vect4();
|
||||
test_vect5();
|
||||
|
||||
testAssert("AssocVector",true,result),
|
||||
testAssert("AssocVector",true,result),
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
} assocVectorTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -8,55 +8,55 @@
|
|||
#include <Loki/DataGenerators.h>
|
||||
|
||||
struct DataGeneratorsTest : public Test
|
||||
{
|
||||
DataGeneratorsTest() : Test("DataGeneratorsTest.h")
|
||||
{}
|
||||
virtual void execute(TestResult& result)
|
||||
{
|
||||
this->printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki::TL;
|
||||
|
||||
bool b;
|
||||
typedef MakeTypelist<>::Result null_tl;
|
||||
typedef MakeTypelist<char,
|
||||
unsigned char,
|
||||
signed char,
|
||||
wchar_t>::Result char_types;
|
||||
int n = Length<char_types>::value;
|
||||
|
||||
std::vector<const char*> names;
|
||||
names.reserve(n);
|
||||
//Some fascist decided that all temporaries should be const.
|
||||
//The following line of code stupidity is a direct result of the half-baked idea
|
||||
iterate_types<char_types, nameof_type>(std::back_inserter(names));
|
||||
b = names.size() == n;
|
||||
testAssert("iterate_types - Check Length", b, result);
|
||||
|
||||
std::vector<size_t> sizes;
|
||||
sizes.reserve(n);
|
||||
typedef MakeTypelist<char,
|
||||
short,
|
||||
int,
|
||||
double>::Result some_types;
|
||||
iterate_types<some_types, sizeof_type>(std::back_inserter(sizes));
|
||||
size_t apriori_size[] = {sizeof(char), sizeof(short), sizeof(int), sizeof(double)};
|
||||
b = true;
|
||||
for(int i=0; i<n; ++i)
|
||||
b &= sizes[i] == apriori_size[i];
|
||||
testAssert("iterate_types - Check Elements", b, result);
|
||||
|
||||
sizes.resize(0);
|
||||
iterate_types<null_tl, sizeof_type>(sizes);
|
||||
b = sizes.size() == 0;
|
||||
testAssert("iterate_types - Degenerate Case 1 - Null List", b, result);
|
||||
{
|
||||
DataGeneratorsTest() : Test("DataGeneratorsTest.h")
|
||||
{}
|
||||
virtual void execute(TestResult& result)
|
||||
{
|
||||
this->printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki::TL;
|
||||
|
||||
bool b;
|
||||
typedef MakeTypelist<>::Result null_tl;
|
||||
typedef MakeTypelist<char,
|
||||
unsigned char,
|
||||
signed char,
|
||||
wchar_t>::Result char_types;
|
||||
int n = Length<char_types>::value;
|
||||
|
||||
std::vector<const char*> names;
|
||||
names.reserve(n);
|
||||
//Some fascist decided that all temporaries should be const.
|
||||
//The following line of code stupidity is a direct result of the half-baked idea
|
||||
iterate_types<char_types, nameof_type>(std::back_inserter(names));
|
||||
b = names.size() == n;
|
||||
testAssert("iterate_types - Check Length", b, result);
|
||||
|
||||
std::vector<size_t> sizes;
|
||||
sizes.reserve(n);
|
||||
typedef MakeTypelist<char,
|
||||
short,
|
||||
int,
|
||||
double>::Result some_types;
|
||||
iterate_types<some_types, sizeof_type>(std::back_inserter(sizes));
|
||||
size_t apriori_size[] = {sizeof(char), sizeof(short), sizeof(int), sizeof(double)};
|
||||
b = true;
|
||||
for(int i=0; i<n; ++i)
|
||||
b &= sizes[i] == apriori_size[i];
|
||||
testAssert("iterate_types - Check Elements", b, result);
|
||||
|
||||
sizes.resize(0);
|
||||
iterate_types<null_tl, sizeof_type>(sizes);
|
||||
b = sizes.size() == 0;
|
||||
testAssert("iterate_types - Degenerate Case 1 - Null List", b, result);
|
||||
|
||||
sizes.resize(0);
|
||||
iterate_types<Loki::NullType, sizeof_type>(sizes);
|
||||
b = sizes.size() == 0;
|
||||
testAssert("iterate_types - Degenerate Case 2 - NullType", b, result);
|
||||
}
|
||||
} datageneratorsTest;
|
||||
sizes.resize(0);
|
||||
iterate_types<Loki::NullType, sizeof_type>(sizes);
|
||||
b = sizes.size() == 0;
|
||||
testAssert("iterate_types - Degenerate Case 2 - NullType", b, result);
|
||||
}
|
||||
} datageneratorsTest;
|
||||
|
||||
#endif //DATAGENERATORSTEST_H
|
||||
|
|
|
|||
|
|
@ -23,124 +23,124 @@
|
|||
|
||||
namespace FactoryTestPrivate
|
||||
{
|
||||
class Shape
|
||||
{
|
||||
public:
|
||||
virtual ~Shape() = 0;
|
||||
};
|
||||
class Shape
|
||||
{
|
||||
public:
|
||||
virtual ~Shape() = 0;
|
||||
};
|
||||
|
||||
inline Shape::~Shape() {}
|
||||
inline Shape::~Shape() {}
|
||||
|
||||
class Polygon : public Shape
|
||||
{
|
||||
};
|
||||
class Polygon : public Shape
|
||||
{
|
||||
};
|
||||
|
||||
class Line : public Shape
|
||||
{
|
||||
};
|
||||
class Line : public Shape
|
||||
{
|
||||
};
|
||||
|
||||
class Circle : public Shape
|
||||
{
|
||||
};
|
||||
class Circle : public Shape
|
||||
{
|
||||
};
|
||||
|
||||
Polygon *createPolygon() { return new Polygon; }
|
||||
Line *createLine() { return new Line; }
|
||||
Circle *createCircle() { return new Circle; }
|
||||
Polygon *createPolygon() { return new Polygon; }
|
||||
Line *createLine() { return new Line; }
|
||||
Circle *createCircle() { return new Circle; }
|
||||
|
||||
Polygon *clonePolygon(Polygon *) { return new Polygon; }
|
||||
Line *cloneLine(Line *) { return new Line; }
|
||||
Circle *cloneCircle(Circle *) { return new Circle; }
|
||||
Polygon *clonePolygon(Polygon *) { return new Polygon; }
|
||||
Line *cloneLine(Line *) { return new Line; }
|
||||
Circle *cloneCircle(Circle *) { return new Circle; }
|
||||
|
||||
typedef Loki::Factory<Shape, int> FactoryType;
|
||||
typedef Loki::Factory<Shape, int> FactoryType;
|
||||
|
||||
bool testFactory()
|
||||
{
|
||||
FactoryType factory;
|
||||
bool testFactory()
|
||||
{
|
||||
FactoryType factory;
|
||||
|
||||
factory.Register(1, (Shape * (*)()) createPolygon);
|
||||
factory.Register(2, (Shape * (*)()) createCircle);
|
||||
factory.Register(3, (Shape * (*)()) createLine);
|
||||
factory.Register(1, (Shape * (*)()) createPolygon);
|
||||
factory.Register(2, (Shape * (*)()) createCircle);
|
||||
factory.Register(3, (Shape * (*)()) createLine);
|
||||
|
||||
Shape *s;
|
||||
Shape *s;
|
||||
|
||||
s = factory.CreateObject(1);
|
||||
delete s;
|
||||
bool test1=s!=NULL;
|
||||
s = factory.CreateObject(1);
|
||||
delete s;
|
||||
bool test1=s!=NULL;
|
||||
|
||||
s = factory.CreateObject(2);
|
||||
delete s;
|
||||
bool test2=s!=NULL;
|
||||
s = factory.CreateObject(2);
|
||||
delete s;
|
||||
bool test2=s!=NULL;
|
||||
|
||||
s = factory.CreateObject(3);
|
||||
delete s;
|
||||
bool test3=s!=NULL;
|
||||
s = factory.CreateObject(3);
|
||||
delete s;
|
||||
bool test3=s!=NULL;
|
||||
|
||||
bool test4=true;
|
||||
bool test4=true;
|
||||
|
||||
// try
|
||||
// {
|
||||
// factory.CreateObject(4);
|
||||
// try
|
||||
// {
|
||||
// factory.CreateObject(4);
|
||||
//
|
||||
// test4=false;
|
||||
// }
|
||||
// catch (std::exception&)
|
||||
// {
|
||||
// }
|
||||
// test4=false;
|
||||
// }
|
||||
// catch (std::exception&)
|
||||
// {
|
||||
// }
|
||||
|
||||
return test1 && test2 && test3 && test4;
|
||||
}
|
||||
return test1 && test2 && test3 && test4;
|
||||
}
|
||||
|
||||
typedef Loki::CloneFactory<Shape> CloneFactoryType;
|
||||
typedef Loki::CloneFactory<Shape> CloneFactoryType;
|
||||
|
||||
bool testCloneFactory()
|
||||
{
|
||||
CloneFactoryType factory;
|
||||
bool testCloneFactory()
|
||||
{
|
||||
CloneFactoryType factory;
|
||||
|
||||
factory.Register(Loki::TypeInfo(typeid(Polygon)), (Shape * (*)(const Shape *)) clonePolygon);
|
||||
factory.Register(Loki::TypeInfo(typeid(Circle)), (Shape * (*)(const Shape *)) cloneCircle);
|
||||
factory.Register(Loki::TypeInfo(typeid(Line)), (Shape * (*)(const Shape *)) cloneLine);
|
||||
factory.Register(Loki::TypeInfo(typeid(Polygon)), (Shape * (*)(const Shape *)) clonePolygon);
|
||||
factory.Register(Loki::TypeInfo(typeid(Circle)), (Shape * (*)(const Shape *)) cloneCircle);
|
||||
factory.Register(Loki::TypeInfo(typeid(Line)), (Shape * (*)(const Shape *)) cloneLine);
|
||||
|
||||
Polygon p;
|
||||
Circle c;
|
||||
Line l;
|
||||
Polygon p;
|
||||
Circle c;
|
||||
Line l;
|
||||
|
||||
Shape *s;
|
||||
Shape *s;
|
||||
|
||||
s = factory.CreateObject(&p);
|
||||
delete s;
|
||||
bool test1=s!=NULL;
|
||||
s = factory.CreateObject(&p);
|
||||
delete s;
|
||||
bool test1=s!=NULL;
|
||||
|
||||
s = factory.CreateObject(&c);
|
||||
delete s;
|
||||
bool test2=s!=NULL;
|
||||
s = factory.CreateObject(&c);
|
||||
delete s;
|
||||
bool test2=s!=NULL;
|
||||
|
||||
s = factory.CreateObject(&l);
|
||||
delete s;
|
||||
bool test3=s!=NULL;
|
||||
s = factory.CreateObject(&l);
|
||||
delete s;
|
||||
bool test3=s!=NULL;
|
||||
|
||||
return test1 && test2 && test3;
|
||||
}
|
||||
return test1 && test2 && test3;
|
||||
}
|
||||
}
|
||||
|
||||
class FactoryTest : public Test
|
||||
{
|
||||
public:
|
||||
FactoryTest() : Test("Factory.h") {}
|
||||
FactoryTest() : Test("Factory.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
bool test1=FactoryTestPrivate::testFactory();
|
||||
bool test1=FactoryTestPrivate::testFactory();
|
||||
|
||||
bool test2=FactoryTestPrivate::testCloneFactory();
|
||||
bool test2=FactoryTestPrivate::testCloneFactory();
|
||||
|
||||
bool r=test1 && test2;
|
||||
bool r=test1 && test2;
|
||||
|
||||
testAssert("Factory",r,result);
|
||||
testAssert("Factory",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
} factoryTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,89 +24,89 @@
|
|||
class FunctorTest : public Test
|
||||
{
|
||||
public:
|
||||
FunctorTest() : Test("Functor.h") {}
|
||||
FunctorTest() : Test("Functor.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
TestFunctor testFunctor;
|
||||
TestClass testClass;
|
||||
TestFunctor testFunctor;
|
||||
TestClass testClass;
|
||||
|
||||
Functor<void,TYPELIST_1(bool &)> function(testFunction);
|
||||
Functor<void,TYPELIST_1(bool &)> functor(testFunctor);
|
||||
Functor<void,TYPELIST_1(bool &)> classFunctor(&testClass,&TestClass::member);
|
||||
Functor<void,TYPELIST_1(bool &)> functorCopy(function);
|
||||
Functor<void,NullType> bindFunctor(BindFirst(function,testResult));
|
||||
Functor<void> chainFunctor(Chain(bindFunctor,bindFunctor));
|
||||
Functor<void,TYPELIST_1(bool &)> function(testFunction);
|
||||
Functor<void,TYPELIST_1(bool &)> functor(testFunctor);
|
||||
Functor<void,TYPELIST_1(bool &)> classFunctor(&testClass,&TestClass::member);
|
||||
Functor<void,TYPELIST_1(bool &)> functorCopy(function);
|
||||
Functor<void,NullType> bindFunctor(BindFirst(function,testResult));
|
||||
Functor<void> chainFunctor(Chain(bindFunctor,bindFunctor));
|
||||
|
||||
testResult=false;
|
||||
function(testResult);
|
||||
bool functionResult=testResult;
|
||||
testResult=false;
|
||||
function(testResult);
|
||||
bool functionResult=testResult;
|
||||
|
||||
testResult=false;
|
||||
functor(testResult);
|
||||
bool functorResult=testResult;
|
||||
testResult=false;
|
||||
functor(testResult);
|
||||
bool functorResult=testResult;
|
||||
|
||||
testResult=false;
|
||||
classFunctor(testResult);
|
||||
bool classFunctorResult=testResult;
|
||||
testResult=false;
|
||||
classFunctor(testResult);
|
||||
bool classFunctorResult=testResult;
|
||||
|
||||
testResult=false;
|
||||
functorCopy(testResult);
|
||||
bool functorCopyResult=testResult;
|
||||
testResult=false;
|
||||
functorCopy(testResult);
|
||||
bool functorCopyResult=testResult;
|
||||
|
||||
testResult=false;
|
||||
bindFunctor();
|
||||
bool bindFunctorResult=testResult;
|
||||
testResult=false;
|
||||
bindFunctor();
|
||||
bool bindFunctorResult=testResult;
|
||||
|
||||
testResult=false;
|
||||
chainFunctor();
|
||||
bool chainFunctorResult=testResult;
|
||||
testResult=false;
|
||||
chainFunctor();
|
||||
bool chainFunctorResult=testResult;
|
||||
|
||||
r=functionResult && functorResult && classFunctorResult && functorCopyResult && bindFunctorResult &&
|
||||
chainFunctorResult;
|
||||
r=functionResult && functorResult && classFunctorResult && functorCopyResult && bindFunctorResult &&
|
||||
chainFunctorResult;
|
||||
|
||||
testAssert("Functor",r,result);
|
||||
testAssert("Functor",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
static bool testResult;
|
||||
static bool testResult;
|
||||
|
||||
static void testFunction(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
static void testFunction(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
|
||||
class TestFunctor
|
||||
{
|
||||
public:
|
||||
void operator()(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
};
|
||||
class TestFunctor
|
||||
{
|
||||
public:
|
||||
void operator()(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
};
|
||||
|
||||
class TestClass
|
||||
{
|
||||
public:
|
||||
void member(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
};
|
||||
class TestClass
|
||||
{
|
||||
public:
|
||||
void member(bool &result)
|
||||
{
|
||||
result=true;
|
||||
}
|
||||
};
|
||||
} functorTest;
|
||||
|
||||
bool FunctorTest::testResult;
|
||||
|
||||
#ifndef SMALLOBJ_CPP
|
||||
# define SMALLOBJ_CPP
|
||||
# include "../../SmallObj.cpp"
|
||||
# define SMALLOBJ_CPP
|
||||
# include "../../SmallObj.cpp"
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,80 +0,0 @@
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Test for Loki
|
||||
//
|
||||
// Copyright Terje Slettebø and Pavel Vozenilek 2002.
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software for any
|
||||
// purpose is hereby granted without fee, provided that this copyright and
|
||||
// permissions notice appear in all copies and derivatives.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty.
|
||||
//
|
||||
// Last update: September 16, 2002
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef LOKITEST_H
|
||||
#define LOKITEST_H
|
||||
|
||||
#include "TypelistTest.h"
|
||||
//#include "TypeManipTest.h"
|
||||
//#include "TypeTraitsTest.h"
|
||||
//#include "SmallObjectTest.h"
|
||||
//#include "SingletonTest.h"
|
||||
//#include "SmartPtrTest.h"
|
||||
//#include "FactoryTest.h"
|
||||
//#include "AbstractFactoryTest.h"
|
||||
//#include "AssocVectorTest.h"
|
||||
//#include "FunctorTest.h"
|
||||
#include "DataGeneratorsTest.h"
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// LokiTest
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class LokiTest
|
||||
{
|
||||
public:
|
||||
LokiTest()
|
||||
{
|
||||
addTests();
|
||||
}
|
||||
|
||||
int result()
|
||||
{
|
||||
return unitTest.run("Unit Test",tests);
|
||||
}
|
||||
|
||||
private:
|
||||
void addTests()
|
||||
{
|
||||
tests.add(typelistTest);
|
||||
// tests.add(typeManipTest);
|
||||
// tests.add(typeTraitsTest);
|
||||
// tests.add(smallObjectTest);
|
||||
// tests.add(singletonTest);
|
||||
// tests.add(smartPtrTest);
|
||||
// tests.add(factoryTest);
|
||||
// tests.add(abstractFactoryTest);
|
||||
// tests.add(assocVectorTest);
|
||||
// tests.add(functorTest);
|
||||
tests.add(datageneratorTest);
|
||||
}
|
||||
|
||||
private:
|
||||
UnitTest unitTest;
|
||||
TestSuite tests;
|
||||
|
||||
TypelistTest typelistTest;
|
||||
// TypeManipTest typeManipTest;
|
||||
// TypeTraitsTest typeTraitsTest;
|
||||
// SmallObjectTest smallObjectTest;
|
||||
// SingletonTest singletonTest;
|
||||
// SmartPtrTest smartPtrTest;
|
||||
// FactoryTest factoryTest;
|
||||
// AbstractFactoryTest abstractFactoryTest;
|
||||
// AssocVectorTest assocVectorTest;
|
||||
// FunctorTest functorTest;
|
||||
DataGeneratorsTest datageneratorTest;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -20,11 +20,11 @@
|
|||
#include "UnitTest.h"
|
||||
|
||||
#define MAKE_TEST(name)\
|
||||
if(singletonTest && name::Instance().a != 99)\
|
||||
singletonTest=false;\
|
||||
++name::Instance().a;\
|
||||
if(singletonTest && name::Instance().a != 100)\
|
||||
singletonTest=false;
|
||||
if(singletonTest && name::Instance().a != 99)\
|
||||
singletonTest=false;\
|
||||
++name::Instance().a;\
|
||||
if(singletonTest && name::Instance().a != 100)\
|
||||
singletonTest=false;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// SingletonTest
|
||||
|
|
@ -34,18 +34,18 @@ template<int N>
|
|||
class MyClass
|
||||
{
|
||||
public:
|
||||
MyClass() : a(99), wasDestroyed(false) {}
|
||||
MyClass() : a(99), wasDestroyed(false) {}
|
||||
|
||||
virtual ~MyClass()
|
||||
{
|
||||
assert(!wasDestroyed);
|
||||
virtual ~MyClass()
|
||||
{
|
||||
assert(!wasDestroyed);
|
||||
|
||||
wasDestroyed = true;
|
||||
}
|
||||
wasDestroyed = true;
|
||||
}
|
||||
|
||||
public:
|
||||
int a;
|
||||
bool wasDestroyed;
|
||||
int a;
|
||||
bool wasDestroyed;
|
||||
};
|
||||
|
||||
inline unsigned GetLongevity(MyClass<3> *) { return 6; }
|
||||
|
|
@ -57,41 +57,41 @@ inline unsigned GetLongevity(MyClass<23> *) { return 3; }
|
|||
|
||||
namespace
|
||||
{
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
typedef SingletonHolder<MyClass<0> > t0;
|
||||
typedef SingletonHolder<MyClass<0> > t0;
|
||||
|
||||
typedef SingletonHolder<MyClass<1>, CreateUsingNew, DefaultLifetime, SingleThreaded> t1;
|
||||
typedef SingletonHolder<MyClass<2>, CreateUsingNew, PhoenixSingleton, SingleThreaded> t2;
|
||||
typedef SingletonHolder<MyClass<3>, CreateUsingNew, SingletonWithLongevity, SingleThreaded> t3;
|
||||
typedef SingletonHolder<MyClass<4>, CreateUsingNew, NoDestroy, SingleThreaded> t4;
|
||||
typedef SingletonHolder<MyClass<1>, CreateUsingNew, DefaultLifetime, SingleThreaded> t1;
|
||||
typedef SingletonHolder<MyClass<2>, CreateUsingNew, PhoenixSingleton, SingleThreaded> t2;
|
||||
typedef SingletonHolder<MyClass<3>, CreateUsingNew, SingletonWithLongevity, SingleThreaded> t3;
|
||||
typedef SingletonHolder<MyClass<4>, CreateUsingNew, NoDestroy, SingleThreaded> t4;
|
||||
|
||||
typedef SingletonHolder<MyClass<9>, CreateUsingMalloc, DefaultLifetime, SingleThreaded> t9;
|
||||
typedef SingletonHolder<MyClass<10>, CreateUsingMalloc, PhoenixSingleton, SingleThreaded> t10;
|
||||
typedef SingletonHolder<MyClass<11>, CreateUsingMalloc, SingletonWithLongevity, SingleThreaded> t11;
|
||||
typedef SingletonHolder<MyClass<12>, CreateUsingMalloc, NoDestroy, SingleThreaded> t12;
|
||||
typedef SingletonHolder<MyClass<9>, CreateUsingMalloc, DefaultLifetime, SingleThreaded> t9;
|
||||
typedef SingletonHolder<MyClass<10>, CreateUsingMalloc, PhoenixSingleton, SingleThreaded> t10;
|
||||
typedef SingletonHolder<MyClass<11>, CreateUsingMalloc, SingletonWithLongevity, SingleThreaded> t11;
|
||||
typedef SingletonHolder<MyClass<12>, CreateUsingMalloc, NoDestroy, SingleThreaded> t12;
|
||||
|
||||
typedef SingletonHolder<MyClass<17>, CreateStatic, DefaultLifetime, SingleThreaded> t17;
|
||||
typedef SingletonHolder<MyClass<18>, CreateStatic, PhoenixSingleton, SingleThreaded> t18;
|
||||
typedef SingletonHolder<MyClass<19>, CreateStatic, SingletonWithLongevity, SingleThreaded> t19;
|
||||
typedef SingletonHolder<MyClass<20>, CreateStatic, NoDestroy, SingleThreaded> t20;
|
||||
typedef SingletonHolder<MyClass<17>, CreateStatic, DefaultLifetime, SingleThreaded> t17;
|
||||
typedef SingletonHolder<MyClass<18>, CreateStatic, PhoenixSingleton, SingleThreaded> t18;
|
||||
typedef SingletonHolder<MyClass<19>, CreateStatic, SingletonWithLongevity, SingleThreaded> t19;
|
||||
typedef SingletonHolder<MyClass<20>, CreateStatic, NoDestroy, SingleThreaded> t20;
|
||||
|
||||
#if !__INTEL_COMPILER && !__GNUC__ && !_MSC_VER
|
||||
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
|
||||
|
||||
typedef SingletonHolder<MyClass<5>, CreateUsingNew, DefaultLifetime, ClassLevelLockable> t5;
|
||||
typedef SingletonHolder<MyClass<6>, CreateUsingNew, PhoenixSingleton, ClassLevelLockable> t6;
|
||||
typedef SingletonHolder<MyClass<7>, CreateUsingNew, SingletonWithLongevity, ClassLevelLockable> t7;
|
||||
typedef SingletonHolder<MyClass<8>, CreateUsingNew, NoDestroy, ClassLevelLockable> t8;
|
||||
typedef SingletonHolder<MyClass<5>, CreateUsingNew, DefaultLifetime, ClassLevelLockable> t5;
|
||||
typedef SingletonHolder<MyClass<6>, CreateUsingNew, PhoenixSingleton, ClassLevelLockable> t6;
|
||||
typedef SingletonHolder<MyClass<7>, CreateUsingNew, SingletonWithLongevity, ClassLevelLockable> t7;
|
||||
typedef SingletonHolder<MyClass<8>, CreateUsingNew, NoDestroy, ClassLevelLockable> t8;
|
||||
|
||||
typedef SingletonHolder<MyClass<13>, CreateUsingMalloc, DefaultLifetime, ClassLevelLockable> t13;
|
||||
typedef SingletonHolder<MyClass<14>, CreateUsingMalloc, PhoenixSingleton, ClassLevelLockable> t14;
|
||||
typedef SingletonHolder<MyClass<15>, CreateUsingMalloc, SingletonWithLongevity, ClassLevelLockable> t15;
|
||||
typedef SingletonHolder<MyClass<16>, CreateUsingMalloc, NoDestroy, ClassLevelLockable> t16;
|
||||
typedef SingletonHolder<MyClass<13>, CreateUsingMalloc, DefaultLifetime, ClassLevelLockable> t13;
|
||||
typedef SingletonHolder<MyClass<14>, CreateUsingMalloc, PhoenixSingleton, ClassLevelLockable> t14;
|
||||
typedef SingletonHolder<MyClass<15>, CreateUsingMalloc, SingletonWithLongevity, ClassLevelLockable> t15;
|
||||
typedef SingletonHolder<MyClass<16>, CreateUsingMalloc, NoDestroy, ClassLevelLockable> t16;
|
||||
|
||||
typedef SingletonHolder<MyClass<21>, CreateStatic, DefaultLifetime, ClassLevelLockable> t21;
|
||||
typedef SingletonHolder<MyClass<22>, CreateStatic, PhoenixSingleton, ClassLevelLockable> t22;
|
||||
typedef SingletonHolder<MyClass<23>, CreateStatic, SingletonWithLongevity, ClassLevelLockable> t23;
|
||||
typedef SingletonHolder<MyClass<24>, CreateStatic, NoDestroy, ClassLevelLockable> t24;
|
||||
typedef SingletonHolder<MyClass<21>, CreateStatic, DefaultLifetime, ClassLevelLockable> t21;
|
||||
typedef SingletonHolder<MyClass<22>, CreateStatic, PhoenixSingleton, ClassLevelLockable> t22;
|
||||
typedef SingletonHolder<MyClass<23>, CreateStatic, SingletonWithLongevity, ClassLevelLockable> t23;
|
||||
typedef SingletonHolder<MyClass<24>, CreateStatic, NoDestroy, ClassLevelLockable> t24;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
|
@ -99,59 +99,59 @@ namespace
|
|||
class SingletonTest : public Test
|
||||
{
|
||||
public:
|
||||
SingletonTest() : Test("Singleton.h") {}
|
||||
SingletonTest() : Test("Singleton.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
singletonTest=true;
|
||||
singletonTest=true;
|
||||
|
||||
MAKE_TEST(t0)
|
||||
MAKE_TEST(t0)
|
||||
|
||||
MAKE_TEST(t1)
|
||||
MAKE_TEST(t2)
|
||||
MAKE_TEST(t3)
|
||||
MAKE_TEST(t4)
|
||||
MAKE_TEST(t1)
|
||||
MAKE_TEST(t2)
|
||||
MAKE_TEST(t3)
|
||||
MAKE_TEST(t4)
|
||||
|
||||
MAKE_TEST(t9)
|
||||
MAKE_TEST(t10)
|
||||
MAKE_TEST(t11)
|
||||
MAKE_TEST(t12)
|
||||
MAKE_TEST(t9)
|
||||
MAKE_TEST(t10)
|
||||
MAKE_TEST(t11)
|
||||
MAKE_TEST(t12)
|
||||
|
||||
MAKE_TEST(t17)
|
||||
MAKE_TEST(t18)
|
||||
MAKE_TEST(t19)
|
||||
MAKE_TEST(t20)
|
||||
MAKE_TEST(t17)
|
||||
MAKE_TEST(t18)
|
||||
MAKE_TEST(t19)
|
||||
MAKE_TEST(t20)
|
||||
|
||||
#if !__INTEL_COMPILER && !__GNUC__ && !_MSC_VER
|
||||
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
|
||||
|
||||
MAKE_TEST(t5)
|
||||
MAKE_TEST(t6)
|
||||
MAKE_TEST(t7)
|
||||
MAKE_TEST(t8)
|
||||
MAKE_TEST(t5)
|
||||
MAKE_TEST(t6)
|
||||
MAKE_TEST(t7)
|
||||
MAKE_TEST(t8)
|
||||
|
||||
MAKE_TEST(t13)
|
||||
MAKE_TEST(t14)
|
||||
MAKE_TEST(t15)
|
||||
MAKE_TEST(t16)
|
||||
MAKE_TEST(t13)
|
||||
MAKE_TEST(t14)
|
||||
MAKE_TEST(t15)
|
||||
MAKE_TEST(t16)
|
||||
|
||||
MAKE_TEST(t21)
|
||||
MAKE_TEST(t22)
|
||||
MAKE_TEST(t23)
|
||||
MAKE_TEST(t24)
|
||||
MAKE_TEST(t21)
|
||||
MAKE_TEST(t22)
|
||||
MAKE_TEST(t23)
|
||||
MAKE_TEST(t24)
|
||||
|
||||
#endif
|
||||
|
||||
testAssert("Singleton",singletonTest,result);
|
||||
testAssert("Singleton",singletonTest,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
bool singletonTest;
|
||||
bool singletonTest;
|
||||
} singletonTest;
|
||||
|
||||
#include "../../Singleton.cpp"
|
||||
|
|
|
|||
|
|
@ -26,143 +26,143 @@
|
|||
class SmallObjectTest : public Test
|
||||
{
|
||||
public:
|
||||
SmallObjectTest() : Test("SmallObject.h") {}
|
||||
SmallObjectTest() : Test("SmallObject.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
SmallClass* a = new SmallClass;
|
||||
delete a;
|
||||
SmallClass* a = new SmallClass;
|
||||
delete a;
|
||||
|
||||
bool smallTest1=a!=NULL;
|
||||
bool smallTest1=a!=NULL;
|
||||
|
||||
a = new SmallClass2;
|
||||
delete a;
|
||||
a = new SmallClass2;
|
||||
delete a;
|
||||
|
||||
bool smallTest2=a!=NULL;
|
||||
bool smallTest2=a!=NULL;
|
||||
|
||||
BigClass* b = new BigClass;
|
||||
delete b;
|
||||
BigClass* b = new BigClass;
|
||||
delete b;
|
||||
|
||||
bool bigTest1=b!=NULL;
|
||||
bool bigTest1=b!=NULL;
|
||||
|
||||
b = new BigClass2;
|
||||
delete b;
|
||||
b = new BigClass2;
|
||||
delete b;
|
||||
|
||||
bool bigTest2=b!=NULL;
|
||||
bool bigTest2=b!=NULL;
|
||||
|
||||
char* buff = static_cast<char*>(Loki::SmallObject<>::operator new(10));
|
||||
Loki::SmallObject<>::operator delete(buff, 10);
|
||||
char* buff = static_cast<char*>(Loki::SmallObject<>::operator new(10));
|
||||
Loki::SmallObject<>::operator delete(buff, 10);
|
||||
|
||||
bool test=buff!=NULL;
|
||||
bool test=buff!=NULL;
|
||||
|
||||
// stress_test();
|
||||
// stress_test();
|
||||
|
||||
r=smallTest1 && smallTest2 && bigTest1 && bigTest2 && test;
|
||||
r=smallTest1 && smallTest2 && bigTest1 && bigTest2 && test;
|
||||
|
||||
testAssert("SmallObject",r,result);
|
||||
testAssert("SmallObject",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
class SmallClass : public Loki::SmallObject<>
|
||||
{
|
||||
int a;
|
||||
};
|
||||
class SmallClass : public Loki::SmallObject<>
|
||||
{
|
||||
int a;
|
||||
};
|
||||
|
||||
class SmallClass2 : public SmallClass
|
||||
{
|
||||
int b;
|
||||
};
|
||||
class SmallClass2 : public SmallClass
|
||||
{
|
||||
int b;
|
||||
};
|
||||
|
||||
class BigClass : public Loki::SmallObject<>
|
||||
{
|
||||
char a[200];
|
||||
};
|
||||
class BigClass : public Loki::SmallObject<>
|
||||
{
|
||||
char a[200];
|
||||
};
|
||||
|
||||
class BigClass2 : public BigClass
|
||||
{
|
||||
int b;
|
||||
};
|
||||
class BigClass2 : public BigClass
|
||||
{
|
||||
int b;
|
||||
};
|
||||
|
||||
class Base
|
||||
{
|
||||
public:
|
||||
virtual ~Base() {}
|
||||
};
|
||||
class Base
|
||||
{
|
||||
public:
|
||||
virtual ~Base() {}
|
||||
};
|
||||
|
||||
class A : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[1];
|
||||
};
|
||||
class A : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[1];
|
||||
};
|
||||
|
||||
class B : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[2];
|
||||
};
|
||||
class B : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[2];
|
||||
};
|
||||
|
||||
class C : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[3];
|
||||
};
|
||||
class C : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[3];
|
||||
};
|
||||
|
||||
class D : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[4];
|
||||
};
|
||||
class D : public Base, public Loki::SmallObject<>
|
||||
{
|
||||
int a[4];
|
||||
};
|
||||
|
||||
static void stress_test()
|
||||
{
|
||||
std::vector<Base*> vec;
|
||||
static void stress_test()
|
||||
{
|
||||
std::vector<Base*> vec;
|
||||
|
||||
vec.reserve(20 * 1024);
|
||||
vec.reserve(20 * 1024);
|
||||
|
||||
std::srand(1231);
|
||||
std::srand(1231);
|
||||
|
||||
for (int i = 0; i < 10; ++i)
|
||||
{
|
||||
for (int j = 0; j < 2 * 1024; ++j)
|
||||
{
|
||||
Base* p;
|
||||
for (int i = 0; i < 10; ++i)
|
||||
{
|
||||
for (int j = 0; j < 2 * 1024; ++j)
|
||||
{
|
||||
Base* p;
|
||||
|
||||
switch (std::rand() % 4)
|
||||
{
|
||||
case 0: p = new A; break;
|
||||
case 1: p = new B; break;
|
||||
case 2: p = new C; break;
|
||||
case 3: p = new D; break;
|
||||
}
|
||||
switch (std::rand() % 4)
|
||||
{
|
||||
case 0: p = new A; break;
|
||||
case 1: p = new B; break;
|
||||
case 2: p = new C; break;
|
||||
case 3: p = new D; break;
|
||||
}
|
||||
|
||||
vec.push_back(p);
|
||||
}
|
||||
vec.push_back(p);
|
||||
}
|
||||
|
||||
for (int j = 0; j < 1024; ++j)
|
||||
{
|
||||
size_t pos = std::rand() % vec.size();
|
||||
for (int j = 0; j < 1024; ++j)
|
||||
{
|
||||
size_t pos = std::rand() % vec.size();
|
||||
|
||||
delete vec[pos];
|
||||
delete vec[pos];
|
||||
|
||||
vec[pos] = 0;
|
||||
}
|
||||
}
|
||||
vec[pos] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
while (!vec.empty())
|
||||
{
|
||||
delete vec.back();
|
||||
while (!vec.empty())
|
||||
{
|
||||
delete vec.back();
|
||||
|
||||
vec.pop_back();
|
||||
}
|
||||
}
|
||||
vec.pop_back();
|
||||
}
|
||||
}
|
||||
} smallObjectTest;
|
||||
|
||||
#ifndef SMALLOBJ_CPP
|
||||
# define SMALLOBJ_CPP
|
||||
# include "../../SmallObj.cpp"
|
||||
# define SMALLOBJ_CPP
|
||||
# include "../../SmallObj.cpp"
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -25,33 +25,33 @@
|
|||
class TestClass
|
||||
{
|
||||
public:
|
||||
TestClass() : references(1)
|
||||
{
|
||||
++instances;
|
||||
}
|
||||
TestClass() : references(1)
|
||||
{
|
||||
++instances;
|
||||
}
|
||||
|
||||
~TestClass()
|
||||
{
|
||||
--instances;
|
||||
}
|
||||
~TestClass()
|
||||
{
|
||||
--instances;
|
||||
}
|
||||
|
||||
void AddRef()
|
||||
{
|
||||
++references;
|
||||
}
|
||||
void AddRef()
|
||||
{
|
||||
++references;
|
||||
}
|
||||
|
||||
void Release()
|
||||
{
|
||||
--references;
|
||||
void Release()
|
||||
{
|
||||
--references;
|
||||
|
||||
if (references <= 0)
|
||||
delete this;
|
||||
}
|
||||
if (references <= 0)
|
||||
delete this;
|
||||
}
|
||||
|
||||
public:
|
||||
static int instances;
|
||||
static int instances;
|
||||
|
||||
int references;
|
||||
int references;
|
||||
};
|
||||
|
||||
int TestClass::instances = 0;
|
||||
|
|
@ -59,232 +59,232 @@ int TestClass::instances = 0;
|
|||
class SmartPtrTest : public Test
|
||||
{
|
||||
public:
|
||||
SmartPtrTest() : Test("SmartPtr.h") {}
|
||||
SmartPtrTest() : Test("SmartPtr.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
{ SmartPtr<TestClass> p = new TestClass; }
|
||||
{ SmartPtr<TestClass> p = new TestClass; }
|
||||
|
||||
bool test1=TestClass::instances == 0;
|
||||
bool test1=TestClass::instances == 0;
|
||||
|
||||
{ p0 p = new TestClass(); }
|
||||
{ p1 p = new TestClass(); }
|
||||
// { p2 p = new TestClass(); }
|
||||
{ p3 p = new TestClass(); }
|
||||
{ p4 p = new TestClass(); }
|
||||
{ p5 p = new TestClass(); }
|
||||
{ p6 p = new TestClass(); }
|
||||
{ p7 p = new TestClass(); }
|
||||
{ p8 p = new TestClass(); }
|
||||
{ p9 p = new TestClass(); }
|
||||
// { p10 p = new TestClass(); }
|
||||
{ p11 p = new TestClass(); }
|
||||
{ p12 p = new TestClass(); }
|
||||
{ p13 p = new TestClass(); }
|
||||
{ p14 p = new TestClass(); }
|
||||
{ p15 p = new TestClass(); }
|
||||
{ p16 p = new TestClass(); }
|
||||
{ p17 p = new TestClass(); }
|
||||
// { p18 p = new TestClass(); }
|
||||
{ p19 p = new TestClass(); }
|
||||
{ p20 p = new TestClass(); }
|
||||
{ p21 p = new TestClass(); }
|
||||
{ p22 p = new TestClass(); }
|
||||
{ p23 p = new TestClass(); }
|
||||
{ p24 p = new TestClass(); }
|
||||
{ p25 p = new TestClass(); }
|
||||
// { p26 p = new TestClass(); }
|
||||
{ p27 p = new TestClass(); }
|
||||
{ p28 p = new TestClass(); }
|
||||
{ p29 p = new TestClass(); }
|
||||
{ p30 p = new TestClass(); }
|
||||
{ p31 p = new TestClass(); }
|
||||
{ p40 p = new TestClass(); }
|
||||
{ p41 p = new TestClass(); }
|
||||
// { p42 p = new TestClass(); }
|
||||
{ p43 p = new TestClass(); }
|
||||
{ p44 p = new TestClass(); }
|
||||
{ p45 p = new TestClass(); }
|
||||
{ p46 p = new TestClass(); }
|
||||
{ p47 p = new TestClass(); }
|
||||
{ p48 p = new TestClass(); }
|
||||
{ p49 p = new TestClass(); }
|
||||
// { p50 p = new TestClass(); }
|
||||
{ p51 p = new TestClass(); }
|
||||
{ p52 p = new TestClass(); }
|
||||
{ p53 p = new TestClass(); }
|
||||
{ p54 p = new TestClass(); }
|
||||
{ p55 p = new TestClass(); }
|
||||
{ p56 p = new TestClass(); }
|
||||
{ p57 p = new TestClass(); }
|
||||
// { p58 p = new TestClass(); }
|
||||
{ p59 p = new TestClass(); }
|
||||
{ p60 p = new TestClass(); }
|
||||
{ p61 p = new TestClass(); }
|
||||
{ p62 p = new TestClass(); }
|
||||
{ p63 p = new TestClass(); }
|
||||
{ p64 p = new TestClass(); }
|
||||
{ p65 p = new TestClass(); }
|
||||
// { p66 p = new TestClass(); }
|
||||
{ p67 p = new TestClass(); }
|
||||
{ p68 p = new TestClass(); }
|
||||
{ p69 p = new TestClass(); }
|
||||
{ p70 p = new TestClass(); }
|
||||
{ p71 p = new TestClass(); }
|
||||
{ p72 p = new TestClass(); }
|
||||
{ p73 p = new TestClass(); }
|
||||
// { p74 p = new TestClass(); }
|
||||
{ p75 p = new TestClass(); }
|
||||
{ p76 p = new TestClass(); }
|
||||
{ p77 p = new TestClass(); }
|
||||
{ p78 p = new TestClass(); }
|
||||
{ p79 p = new TestClass(); }
|
||||
{ p80 p = new TestClass(); }
|
||||
{ p81 p = new TestClass(); }
|
||||
// { p82 p = new TestClass(); }
|
||||
{ p83 p = new TestClass(); }
|
||||
{ p84 p = new TestClass(); }
|
||||
{ p85 p = new TestClass(); }
|
||||
{ p86 p = new TestClass(); }
|
||||
{ p87 p = new TestClass(); }
|
||||
{ p88 p = new TestClass(); }
|
||||
{ p89 p = new TestClass(); }
|
||||
// { p90 p = new TestClass(); }
|
||||
{ p91 p = new TestClass(); }
|
||||
{ p92 p = new TestClass(); }
|
||||
{ p93 p = new TestClass(); }
|
||||
{ p94 p = new TestClass(); }
|
||||
{ p95 p = new TestClass(); }
|
||||
{ p96 p = new TestClass(); }
|
||||
{ p97 p = new TestClass(); }
|
||||
// { p98 p = new TestClass(); }
|
||||
{ p99 p = new TestClass(); }
|
||||
{ p100 p = new TestClass(); }
|
||||
{ p101 p = new TestClass(); }
|
||||
{ p102 p = new TestClass(); }
|
||||
{ p103 p = new TestClass(); }
|
||||
{ p0 p = new TestClass(); }
|
||||
{ p1 p = new TestClass(); }
|
||||
// { p2 p = new TestClass(); }
|
||||
{ p3 p = new TestClass(); }
|
||||
{ p4 p = new TestClass(); }
|
||||
{ p5 p = new TestClass(); }
|
||||
{ p6 p = new TestClass(); }
|
||||
{ p7 p = new TestClass(); }
|
||||
{ p8 p = new TestClass(); }
|
||||
{ p9 p = new TestClass(); }
|
||||
// { p10 p = new TestClass(); }
|
||||
{ p11 p = new TestClass(); }
|
||||
{ p12 p = new TestClass(); }
|
||||
{ p13 p = new TestClass(); }
|
||||
{ p14 p = new TestClass(); }
|
||||
{ p15 p = new TestClass(); }
|
||||
{ p16 p = new TestClass(); }
|
||||
{ p17 p = new TestClass(); }
|
||||
// { p18 p = new TestClass(); }
|
||||
{ p19 p = new TestClass(); }
|
||||
{ p20 p = new TestClass(); }
|
||||
{ p21 p = new TestClass(); }
|
||||
{ p22 p = new TestClass(); }
|
||||
{ p23 p = new TestClass(); }
|
||||
{ p24 p = new TestClass(); }
|
||||
{ p25 p = new TestClass(); }
|
||||
// { p26 p = new TestClass(); }
|
||||
{ p27 p = new TestClass(); }
|
||||
{ p28 p = new TestClass(); }
|
||||
{ p29 p = new TestClass(); }
|
||||
{ p30 p = new TestClass(); }
|
||||
{ p31 p = new TestClass(); }
|
||||
{ p40 p = new TestClass(); }
|
||||
{ p41 p = new TestClass(); }
|
||||
// { p42 p = new TestClass(); }
|
||||
{ p43 p = new TestClass(); }
|
||||
{ p44 p = new TestClass(); }
|
||||
{ p45 p = new TestClass(); }
|
||||
{ p46 p = new TestClass(); }
|
||||
{ p47 p = new TestClass(); }
|
||||
{ p48 p = new TestClass(); }
|
||||
{ p49 p = new TestClass(); }
|
||||
// { p50 p = new TestClass(); }
|
||||
{ p51 p = new TestClass(); }
|
||||
{ p52 p = new TestClass(); }
|
||||
{ p53 p = new TestClass(); }
|
||||
{ p54 p = new TestClass(); }
|
||||
{ p55 p = new TestClass(); }
|
||||
{ p56 p = new TestClass(); }
|
||||
{ p57 p = new TestClass(); }
|
||||
// { p58 p = new TestClass(); }
|
||||
{ p59 p = new TestClass(); }
|
||||
{ p60 p = new TestClass(); }
|
||||
{ p61 p = new TestClass(); }
|
||||
{ p62 p = new TestClass(); }
|
||||
{ p63 p = new TestClass(); }
|
||||
{ p64 p = new TestClass(); }
|
||||
{ p65 p = new TestClass(); }
|
||||
// { p66 p = new TestClass(); }
|
||||
{ p67 p = new TestClass(); }
|
||||
{ p68 p = new TestClass(); }
|
||||
{ p69 p = new TestClass(); }
|
||||
{ p70 p = new TestClass(); }
|
||||
{ p71 p = new TestClass(); }
|
||||
{ p72 p = new TestClass(); }
|
||||
{ p73 p = new TestClass(); }
|
||||
// { p74 p = new TestClass(); }
|
||||
{ p75 p = new TestClass(); }
|
||||
{ p76 p = new TestClass(); }
|
||||
{ p77 p = new TestClass(); }
|
||||
{ p78 p = new TestClass(); }
|
||||
{ p79 p = new TestClass(); }
|
||||
{ p80 p = new TestClass(); }
|
||||
{ p81 p = new TestClass(); }
|
||||
// { p82 p = new TestClass(); }
|
||||
{ p83 p = new TestClass(); }
|
||||
{ p84 p = new TestClass(); }
|
||||
{ p85 p = new TestClass(); }
|
||||
{ p86 p = new TestClass(); }
|
||||
{ p87 p = new TestClass(); }
|
||||
{ p88 p = new TestClass(); }
|
||||
{ p89 p = new TestClass(); }
|
||||
// { p90 p = new TestClass(); }
|
||||
{ p91 p = new TestClass(); }
|
||||
{ p92 p = new TestClass(); }
|
||||
{ p93 p = new TestClass(); }
|
||||
{ p94 p = new TestClass(); }
|
||||
{ p95 p = new TestClass(); }
|
||||
{ p96 p = new TestClass(); }
|
||||
{ p97 p = new TestClass(); }
|
||||
// { p98 p = new TestClass(); }
|
||||
{ p99 p = new TestClass(); }
|
||||
{ p100 p = new TestClass(); }
|
||||
{ p101 p = new TestClass(); }
|
||||
{ p102 p = new TestClass(); }
|
||||
{ p103 p = new TestClass(); }
|
||||
|
||||
bool test2=TestClass::instances==0;
|
||||
bool test2=TestClass::instances==0;
|
||||
|
||||
bool r=test1 && test2;
|
||||
bool r=test1 && test2;
|
||||
|
||||
testAssert("SmartPtr",r,result);
|
||||
testAssert("SmartPtr",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p0;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage> p1;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, AssertCheck, DefaultSPStorage> p2;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, AssertCheck, DefaultSPStorage> p3;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, AssertCheck, DefaultSPStorage> p4;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p5;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p6;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p7;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p0;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, AssertCheck, DefaultSPStorage> p1;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, AssertCheck, DefaultSPStorage> p2;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, AssertCheck, DefaultSPStorage> p3;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, AssertCheck, DefaultSPStorage> p4;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p5;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p6;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheck, DefaultSPStorage> p7;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, AssertCheck, DefaultSPStorage> p8;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, AssertCheck, DefaultSPStorage> p9;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, AssertCheck, DefaultSPStorage> p10;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, AssertCheck, DefaultSPStorage> p11;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, AssertCheck, DefaultSPStorage> p12;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, AssertCheck, DefaultSPStorage> p13;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheck, DefaultSPStorage> p14;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheck, DefaultSPStorage> p15;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, AssertCheck, DefaultSPStorage> p8;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, AssertCheck, DefaultSPStorage> p9;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, AssertCheck, DefaultSPStorage> p10;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, AssertCheck, DefaultSPStorage> p11;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, AssertCheck, DefaultSPStorage> p12;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, AssertCheck, DefaultSPStorage> p13;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheck, DefaultSPStorage> p14;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheck, DefaultSPStorage> p15;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p16;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p17;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p18;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p19;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p20;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p21;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p22;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p23;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p16;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p17;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p18;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p19;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p20;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p21;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p22;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, AssertCheckStrict, DefaultSPStorage> p23;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p24;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, AssertCheckStrict, DefaultSPStorage> p25;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, AssertCheckStrict, DefaultSPStorage> p26;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, AssertCheckStrict, DefaultSPStorage> p27;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, AssertCheckStrict, DefaultSPStorage> p28;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p29;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p30;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p31;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p24;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, AssertCheckStrict, DefaultSPStorage> p25;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, AssertCheckStrict, DefaultSPStorage> p26;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, AssertCheckStrict, DefaultSPStorage> p27;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, AssertCheckStrict, DefaultSPStorage> p28;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p29;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p30;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, AssertCheckStrict, DefaultSPStorage> p31;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p40;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNullStatic, DefaultSPStorage> p41;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNullStatic, DefaultSPStorage> p42;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNullStatic, DefaultSPStorage> p43;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNullStatic, DefaultSPStorage> p44;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p45;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p46;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p47;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p40;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNullStatic, DefaultSPStorage> p41;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNullStatic, DefaultSPStorage> p42;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNullStatic, DefaultSPStorage> p43;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNullStatic, DefaultSPStorage> p44;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p45;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p46;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStatic, DefaultSPStorage> p47;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNullStatic, DefaultSPStorage> p48;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNullStatic, DefaultSPStorage> p49;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNullStatic, DefaultSPStorage> p50;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNullStatic, DefaultSPStorage> p51;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNullStatic, DefaultSPStorage> p52;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNullStatic, DefaultSPStorage> p53;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStatic,DefaultSPStorage> p54;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStatic,DefaultSPStorage> p55;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNullStatic, DefaultSPStorage> p48;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNullStatic, DefaultSPStorage> p49;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNullStatic, DefaultSPStorage> p50;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNullStatic, DefaultSPStorage> p51;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNullStatic, DefaultSPStorage> p52;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNullStatic, DefaultSPStorage> p53;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStatic,DefaultSPStorage> p54;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStatic,DefaultSPStorage> p55;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNull, DefaultSPStorage> p56;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNull, DefaultSPStorage> p57;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNull, DefaultSPStorage> p58;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNull, DefaultSPStorage> p59;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNull, DefaultSPStorage> p60;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNull, DefaultSPStorage> p61;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNull, DefaultSPStorage> p62;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNull, DefaultSPStorage> p63;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNull, DefaultSPStorage> p56;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNull, DefaultSPStorage> p57;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNull, DefaultSPStorage> p58;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNull, DefaultSPStorage> p59;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNull, DefaultSPStorage> p60;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNull, DefaultSPStorage> p61;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNull, DefaultSPStorage> p62;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNull, DefaultSPStorage> p63;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNull, DefaultSPStorage> p64;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNull, DefaultSPStorage> p65;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNull, DefaultSPStorage> p66;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNull, DefaultSPStorage> p67;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNull, DefaultSPStorage> p68;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNull, DefaultSPStorage> p69;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNull, DefaultSPStorage> p70;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNull, DefaultSPStorage> p71;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNull, DefaultSPStorage> p64;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNull, DefaultSPStorage> p65;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNull, DefaultSPStorage> p66;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNull, DefaultSPStorage> p67;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNull, DefaultSPStorage> p68;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNull, DefaultSPStorage> p69;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNull, DefaultSPStorage> p70;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNull, DefaultSPStorage> p71;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p72;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNullStrict, DefaultSPStorage> p73;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNullStrict, DefaultSPStorage> p74;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNullStrict, DefaultSPStorage> p75;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNullStrict, DefaultSPStorage> p76;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p77;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p78;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p79;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p72;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, RejectNullStrict, DefaultSPStorage> p73;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, RejectNullStrict, DefaultSPStorage> p74;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, RejectNullStrict, DefaultSPStorage> p75;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, RejectNullStrict, DefaultSPStorage> p76;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p77;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p78;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, RejectNullStrict, DefaultSPStorage> p79;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p80;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNullStrict, DefaultSPStorage> p81;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNullStrict, DefaultSPStorage> p82;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNullStrict, DefaultSPStorage> p83;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNullStrict, DefaultSPStorage> p84;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p85;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p86;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p87;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p80;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, RejectNullStrict, DefaultSPStorage> p81;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, RejectNullStrict, DefaultSPStorage> p82;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, RejectNullStrict, DefaultSPStorage> p83;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, RejectNullStrict, DefaultSPStorage> p84;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p85;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p86;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, RejectNullStrict, DefaultSPStorage> p87;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, NoCheck, DefaultSPStorage> p88;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, NoCheck, DefaultSPStorage> p89;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, NoCheck, DefaultSPStorage> p90;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, NoCheck, DefaultSPStorage> p91;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, NoCheck, DefaultSPStorage> p92;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, NoCheck, DefaultSPStorage> p93;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, NoCheck, DefaultSPStorage> p94;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, NoCheck, DefaultSPStorage> p95;
|
||||
typedef SmartPtr<TestClass, DeepCopy, AllowConversion, NoCheck, DefaultSPStorage> p88;
|
||||
typedef SmartPtr<TestClass, RefCounted, AllowConversion, NoCheck, DefaultSPStorage> p89;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, AllowConversion, NoCheck, DefaultSPStorage> p90;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, AllowConversion, NoCheck, DefaultSPStorage> p91;
|
||||
typedef SmartPtr<TestClass, RefLinked, AllowConversion, NoCheck, DefaultSPStorage> p92;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, AllowConversion, NoCheck, DefaultSPStorage> p93;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, NoCheck, DefaultSPStorage> p94;
|
||||
typedef SmartPtr<TestClass, NoCopy, AllowConversion, NoCheck, DefaultSPStorage> p95;
|
||||
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, NoCheck, DefaultSPStorage> p96;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, NoCheck, DefaultSPStorage> p97;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, NoCheck, DefaultSPStorage> p98;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, NoCheck, DefaultSPStorage> p99;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, NoCheck, DefaultSPStorage> p100;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, NoCheck, DefaultSPStorage> p101;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, NoCheck, DefaultSPStorage> p102;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, NoCheck, DefaultSPStorage> p103;
|
||||
typedef SmartPtr<TestClass, DeepCopy, DisallowConversion, NoCheck, DefaultSPStorage> p96;
|
||||
typedef SmartPtr<TestClass, RefCounted, DisallowConversion, NoCheck, DefaultSPStorage> p97;
|
||||
//typedef SmartPtr<TestClass, RefCountedMT, DisallowConversion, NoCheck, DefaultSPStorage> p98;
|
||||
typedef SmartPtr<TestClass, COMRefCounted, DisallowConversion, NoCheck, DefaultSPStorage> p99;
|
||||
typedef SmartPtr<TestClass, RefLinked, DisallowConversion, NoCheck, DefaultSPStorage> p100;
|
||||
typedef SmartPtr<TestClass, DestructiveCopy, DisallowConversion, NoCheck, DefaultSPStorage> p101;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, NoCheck, DefaultSPStorage> p102;
|
||||
typedef SmartPtr<TestClass, NoCopy, DisallowConversion, NoCheck, DefaultSPStorage> p103;
|
||||
} smartPtrTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -9,26 +9,29 @@
|
|||
//
|
||||
// This software is provided "as is" without express or implied warranty.
|
||||
//
|
||||
// Last update: October 10, 2002
|
||||
// Last update: October 12, 2002
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __INTEL_COMPILER
|
||||
# pragma warning(disable: 111 193 304 383 444 488 981 1418)
|
||||
#elif defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
# pragma warning(disable: 4018 4097 4100 4213 4290 4512 4514 4700 4702 4710 4786 4800)
|
||||
#endif
|
||||
|
||||
//Some platforms might have difficulty with this
|
||||
//Need to ifdef around those cases.
|
||||
//TODOSGB
|
||||
// Some platforms might have difficulty with this
|
||||
// Need to ifdef around those cases.
|
||||
// TODO SGB
|
||||
|
||||
#include "UnitTest.h"
|
||||
|
||||
//static variable defintion, do not remove
|
||||
// static variable defintion, do not remove
|
||||
|
||||
Test::tests_type Test::tests;
|
||||
|
||||
|
||||
//Merely comment out any of the following headers to
|
||||
// Merely comment out any of the following headers to
|
||||
// prevent thier execution during the test.
|
||||
//A pluggable-factory-like method is used to
|
||||
//
|
||||
// A pluggable-factory-like method is used to
|
||||
// auto-register the test, so all that is needed
|
||||
// is the header inclusion to execute the correspond
|
||||
// unit test.
|
||||
|
|
@ -45,37 +48,44 @@ Test::tests_type Test::tests;
|
|||
#include "FunctorTest.h"
|
||||
#include "DataGeneratorsTest.h"
|
||||
|
||||
|
||||
/*
|
||||
* AP - All Pass
|
||||
* FC - Fails to Compile
|
||||
* ? - Unknown/Not Tested/Not Recorded
|
||||
*
|
||||
* TypelistTest TypeManipTest TypeTraitsTest SmallObjectTest SingletonTest
|
||||
* gcc 2.95.3 ? ? ? ? ?
|
||||
* gcc 3.2 AP AP AP AP P #ifdef?
|
||||
* MSVC 6 ? ? ? ? ?
|
||||
* MSVC 7 AP Conversion FC AP P #ifdef?
|
||||
* Intel ? ? ? ? ? ?
|
||||
* BCB 5.5? ? ? ? ? ?
|
||||
* CW 6.0 ? ? ? ? ?
|
||||
* gcc 2.95.3 ? ? ? ? ?
|
||||
* gcc 3.2 AP AP AP AP P (Only SingleThreaded)
|
||||
* MSVC 6.0 P AP FC FC AP
|
||||
* MSVC 7.0 AP Conversion FC AP P (Only SingleThreaded) ?
|
||||
* Intel 5.0 AP AP AP FC FC
|
||||
* Intel 6.0 AP AP AP FC P (Only SingleThreaded)
|
||||
* Intel 7.0 AP AP AP FC P (Only SingleThreaded)
|
||||
* BCC 5.5 ? ? ? ? ?
|
||||
* BCC 5.6 ? ? ? ? ?
|
||||
* CW 6.0 ? ? ? ? ?
|
||||
*
|
||||
* SmartPtrTest FactoryTest AbstractFactoryTest AssocVectorTest FunctorTest
|
||||
* gcc 2.95.3 ? ? ? ? ?
|
||||
* gcc 3.2 FC AP AP FC AP
|
||||
* MSVC 6 ? ? ? ? ?
|
||||
* MSVC 7 FC AP AP FC AP
|
||||
* Intel ? ? ? ? ? ?
|
||||
* BCB 5.5? ? ? ? ? ?
|
||||
* CW 6.0 ? ? ? ? ?
|
||||
* gcc 2.95.3 ? ? ? ? ?
|
||||
* gcc 3.2 FC AP AP FC AP
|
||||
* MSVC 6.0 FC AP FC FC FC
|
||||
* MSVC 7.0 FC AP AP FC AP
|
||||
* Intel 5.0 FC FC FC FC FC
|
||||
* Intel 6.0 FC AP AP FC FC
|
||||
* Intel 7.0 FC AP AP FC FC
|
||||
* BCC 5.5 ? ? ? ? ?
|
||||
* CW 6.0 ? ? ? ? ?
|
||||
*
|
||||
* DataGeneratorsTest
|
||||
* gcc 2.95.3 ?
|
||||
* gcc 3.2 AP
|
||||
* MSVC 6 ?
|
||||
* MSVC 7 AP
|
||||
* Intel ? ?
|
||||
* BCB 5.5? ?
|
||||
* gcc 2.95.3 ?
|
||||
* gcc 3.2 AP
|
||||
* MSVC 6.0 FC
|
||||
* MSVC 7.0 AP
|
||||
* Intel 5.0 FC
|
||||
* Intel 6.0 AP
|
||||
* Intel 7.0 AP
|
||||
* BCC 5.5 ?
|
||||
* BCC 5.6 ?
|
||||
* CW 6.0 ?
|
||||
|
||||
*/
|
||||
|
|
@ -85,10 +95,8 @@ int main()
|
|||
|
||||
int result = Test::run("Loki Unit Test");
|
||||
|
||||
#if __BORLANDC__
|
||||
while(true); // Stop console window from closing if run from IDE.
|
||||
#elif _MSC_VER || __GNUC__
|
||||
system("pause");
|
||||
#if defined(__BORLANDC__) || defined(__GNUC__)
|
||||
system("pause"); // Stop console window from closing if run from IDE.
|
||||
#endif
|
||||
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -25,95 +25,95 @@
|
|||
class TypeManipTest : public Test
|
||||
{
|
||||
public:
|
||||
TypeManipTest() : Test("TypeManip.h") {}
|
||||
TypeManipTest() : Test("TypeManip.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
r=Int2Type<1>::value==1;
|
||||
r=Int2Type<1>::value==1;
|
||||
|
||||
testAssert("Int2Type",r,result);
|
||||
testAssert("Int2Type",r,result);
|
||||
|
||||
r=SameType<Type2Type<char>::OriginalType,char>::value;
|
||||
r=SameType<Type2Type<char>::OriginalType,char>::value;
|
||||
|
||||
testAssert("Type2Type",r,result);
|
||||
testAssert("Type2Type",r,result);
|
||||
|
||||
r=SameType<Select<true,char,int>::Result,char>::value &&
|
||||
SameType<Select<false,char,int>::Result,int>::value;
|
||||
r=SameType<Select<true,char,int>::Result,char>::value &&
|
||||
SameType<Select<false,char,int>::Result,int>::value;
|
||||
|
||||
testAssert("Select",r,result);
|
||||
testAssert("Select",r,result);
|
||||
|
||||
r=Conversion<char,int>::exists &&
|
||||
Conversion<char,int>::exists2Way &&
|
||||
!Conversion<char,int>::sameType &&
|
||||
Conversion<char,char>::exists &&
|
||||
Conversion<char,char>::exists2Way &&
|
||||
Conversion<char,char>::sameType &&
|
||||
Conversion<void,void>::exists &&
|
||||
!Conversion<void,char>::exists &&
|
||||
Conversion<char,void>::exists &&
|
||||
Conversion<Derived2,Base>::exists &&
|
||||
Conversion<Derived1,Base>::exists &&
|
||||
Conversion<Base,Base>::exists &&
|
||||
!Conversion<Base,Derived2>::exists &&
|
||||
!Conversion<Base,Derived1>::exists &&
|
||||
Conversion<Derived2 *,Base *>::exists &&
|
||||
Conversion<Derived1 *,Base *>::exists &&
|
||||
!Conversion<Base *,Derived2 *>::exists &&
|
||||
!Conversion<Base *,Derived1 *>::exists &&
|
||||
Conversion<Base *,void *>::exists &&
|
||||
!Conversion<void *,Base *>::exists;
|
||||
r=Conversion<char,int>::exists &&
|
||||
Conversion<char,int>::exists2Way &&
|
||||
!Conversion<char,int>::sameType &&
|
||||
Conversion<char,char>::exists &&
|
||||
Conversion<char,char>::exists2Way &&
|
||||
Conversion<char,char>::sameType &&
|
||||
Conversion<void,void>::exists &&
|
||||
!Conversion<void,char>::exists &&
|
||||
Conversion<char,void>::exists &&
|
||||
Conversion<Derived2,Base>::exists &&
|
||||
Conversion<Derived1,Base>::exists &&
|
||||
Conversion<Base,Base>::exists &&
|
||||
!Conversion<Base,Derived2>::exists &&
|
||||
!Conversion<Base,Derived1>::exists &&
|
||||
Conversion<Derived2 *,Base *>::exists &&
|
||||
Conversion<Derived1 *,Base *>::exists &&
|
||||
!Conversion<Base *,Derived2 *>::exists &&
|
||||
!Conversion<Base *,Derived1 *>::exists &&
|
||||
Conversion<Base *,void *>::exists &&
|
||||
!Conversion<void *,Base *>::exists;
|
||||
|
||||
testAssert("Conversion",r,result);
|
||||
testAssert("Conversion",r,result);
|
||||
|
||||
r=SuperSubclass<Base,Derived1>::value &&
|
||||
SuperSubclass<Base,Derived2>::value &&
|
||||
SuperSubclass<Base,Base>::value &&
|
||||
!SuperSubclass<Derived1,Base>::value &&
|
||||
!SuperSubclass<Derived2,Base>::value &&
|
||||
!SuperSubclass<void,Base>::value;
|
||||
|
||||
testAssert("SuperSubclass",r,result);
|
||||
r=SuperSubclass<Base,Derived1>::value &&
|
||||
SuperSubclass<Base,Derived2>::value &&
|
||||
SuperSubclass<Base,Base>::value &&
|
||||
!SuperSubclass<Derived1,Base>::value &&
|
||||
!SuperSubclass<Derived2,Base>::value &&
|
||||
!SuperSubclass<void,Base>::value;
|
||||
|
||||
testAssert("SuperSubclass",r,result);
|
||||
|
||||
r=SuperSubclassStrict<Base,Derived1>::value &&
|
||||
SuperSubclassStrict<Base,Derived2>::value &&
|
||||
!SuperSubclassStrict<Base,Base>::value &&
|
||||
!SuperSubclassStrict<Derived1,Base>::value &&
|
||||
!SuperSubclassStrict<Derived2,Base>::value &&
|
||||
!SuperSubclassStrict<void,Base>::value;
|
||||
r=SuperSubclassStrict<Base,Derived1>::value &&
|
||||
SuperSubclassStrict<Base,Derived2>::value &&
|
||||
!SuperSubclassStrict<Base,Base>::value &&
|
||||
!SuperSubclassStrict<Derived1,Base>::value &&
|
||||
!SuperSubclassStrict<Derived2,Base>::value &&
|
||||
!SuperSubclassStrict<void,Base>::value;
|
||||
|
||||
testAssert("SuperSubclassStrict",r,result);
|
||||
testAssert("SuperSubclassStrict",r,result);
|
||||
|
||||
r=SUPERSUBCLASS(Base,Derived1) &&
|
||||
SUPERSUBCLASS(Base,Derived2) &&
|
||||
SUPERSUBCLASS(Base,Base) &&
|
||||
!SUPERSUBCLASS(Derived1,Base) &&
|
||||
!SUPERSUBCLASS(Derived2,Base) &&
|
||||
!SUPERSUBCLASS(void,Base);
|
||||
r=SUPERSUBCLASS(Base,Derived1) &&
|
||||
SUPERSUBCLASS(Base,Derived2) &&
|
||||
SUPERSUBCLASS(Base,Base) &&
|
||||
!SUPERSUBCLASS(Derived1,Base) &&
|
||||
!SUPERSUBCLASS(Derived2,Base) &&
|
||||
!SUPERSUBCLASS(void,Base);
|
||||
|
||||
testAssert("SUPERSUBCLASS",r,result);
|
||||
testAssert("SUPERSUBCLASS",r,result);
|
||||
|
||||
r=SUPERSUBCLASS_STRICT(Base,Derived1) &&
|
||||
SUPERSUBCLASS_STRICT(Base,Derived2) &&
|
||||
!SUPERSUBCLASS_STRICT(Base,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(Derived1,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(Derived2,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(void,Base);
|
||||
r=SUPERSUBCLASS_STRICT(Base,Derived1) &&
|
||||
SUPERSUBCLASS_STRICT(Base,Derived2) &&
|
||||
!SUPERSUBCLASS_STRICT(Base,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(Derived1,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(Derived2,Base) &&
|
||||
!SUPERSUBCLASS_STRICT(void,Base);
|
||||
|
||||
testAssert("SUPERSUBCLASS_STRICT",r,result);
|
||||
testAssert("SUPERSUBCLASS_STRICT",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
struct Base { char c; };
|
||||
struct Derived1 : Base { char c; };
|
||||
struct Derived2 : Derived1 { char c; };
|
||||
struct Base { char c; };
|
||||
struct Derived1 : Base { char c; };
|
||||
struct Derived2 : Derived1 { char c; };
|
||||
} typeManipTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,92 +24,92 @@
|
|||
class TypeTraitsTest : public Test
|
||||
{
|
||||
public:
|
||||
TypeTraitsTest() : Test("TypeTraits.h") {}
|
||||
TypeTraitsTest() : Test("TypeTraits.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
r=TypeTraits<int *>::isPointer &&
|
||||
!TypeTraits<int>::isPointer &&
|
||||
SameType<TypeTraits<int *>::PointeeType,int>::value &&
|
||||
SameType<TypeTraits<int>::PointeeType,NullType>::value &&
|
||||
r=TypeTraits<int *>::isPointer &&
|
||||
!TypeTraits<int>::isPointer &&
|
||||
SameType<TypeTraits<int *>::PointeeType,int>::value &&
|
||||
SameType<TypeTraits<int>::PointeeType,NullType>::value &&
|
||||
|
||||
TypeTraits<int &>::isReference &&
|
||||
!TypeTraits<int>::isReference &&
|
||||
SameType<TypeTraits<int &>::ReferredType,int>::value &&
|
||||
SameType<TypeTraits<int>::ReferredType,int>::value &&
|
||||
TypeTraits<int &>::isReference &&
|
||||
!TypeTraits<int>::isReference &&
|
||||
SameType<TypeTraits<int &>::ReferredType,int>::value &&
|
||||
SameType<TypeTraits<int>::ReferredType,int>::value &&
|
||||
|
||||
TypeTraits<int Test::*>::isMemberPointer &&
|
||||
!TypeTraits<int>::isMemberPointer &&
|
||||
TypeTraits<int Test::*>::isMemberPointer &&
|
||||
!TypeTraits<int>::isMemberPointer &&
|
||||
|
||||
TypeTraits<unsigned int>::isStdUnsignedInt &&
|
||||
!TypeTraits<int>::isStdUnsignedInt &&
|
||||
TypeTraits<unsigned int>::isStdUnsignedInt &&
|
||||
!TypeTraits<int>::isStdUnsignedInt &&
|
||||
|
||||
TypeTraits<int>::isStdSignedInt &&
|
||||
!TypeTraits<unsigned int>::isStdSignedInt &&
|
||||
TypeTraits<int>::isStdSignedInt &&
|
||||
!TypeTraits<unsigned int>::isStdSignedInt &&
|
||||
|
||||
TypeTraits<int>::isStdIntegral &&
|
||||
!TypeTraits<double>::isStdIntegral &&
|
||||
TypeTraits<int>::isStdIntegral &&
|
||||
!TypeTraits<double>::isStdIntegral &&
|
||||
|
||||
TypeTraits<double>::isStdFloat &&
|
||||
!TypeTraits<int>::isStdFloat &&
|
||||
TypeTraits<double>::isStdFloat &&
|
||||
!TypeTraits<int>::isStdFloat &&
|
||||
|
||||
TypeTraits<int>::isStdArith &&
|
||||
!TypeTraits<void>::isStdArith &&
|
||||
TypeTraits<int>::isStdArith &&
|
||||
!TypeTraits<void>::isStdArith &&
|
||||
|
||||
TypeTraits<void>::isStdFundamental &&
|
||||
!TypeTraits<Test>::isStdFundamental &&
|
||||
TypeTraits<void>::isStdFundamental &&
|
||||
!TypeTraits<Test>::isStdFundamental &&
|
||||
|
||||
TypeTraits<unsigned int>::isUnsignedInt &&
|
||||
!TypeTraits<int>::isUnsignedInt &&
|
||||
TypeTraits<unsigned int>::isUnsignedInt &&
|
||||
!TypeTraits<int>::isUnsignedInt &&
|
||||
|
||||
TypeTraits<int>::isSignedInt &&
|
||||
!TypeTraits<unsigned int>::isSignedInt &&
|
||||
TypeTraits<int>::isSignedInt &&
|
||||
!TypeTraits<unsigned int>::isSignedInt &&
|
||||
|
||||
TypeTraits<int>::isIntegral &&
|
||||
!TypeTraits<double>::isIntegral &&
|
||||
TypeTraits<int>::isIntegral &&
|
||||
!TypeTraits<double>::isIntegral &&
|
||||
|
||||
TypeTraits<double>::isFloat &&
|
||||
!TypeTraits<int>::isFloat &&
|
||||
TypeTraits<double>::isFloat &&
|
||||
!TypeTraits<int>::isFloat &&
|
||||
|
||||
TypeTraits<char>::isArith &&
|
||||
TypeTraits<int>::isArith &&
|
||||
TypeTraits<double>::isArith &&
|
||||
!TypeTraits<void>::isArith &&
|
||||
TypeTraits<char>::isArith &&
|
||||
TypeTraits<int>::isArith &&
|
||||
TypeTraits<double>::isArith &&
|
||||
!TypeTraits<void>::isArith &&
|
||||
|
||||
TypeTraits<void>::isFundamental &&
|
||||
!TypeTraits<Test>::isFundamental &&
|
||||
TypeTraits<void>::isFundamental &&
|
||||
!TypeTraits<Test>::isFundamental &&
|
||||
|
||||
#ifndef __BORLANDC__
|
||||
|
||||
TypeTraits<const int>::isConst &&
|
||||
!TypeTraits<int>::isConst &&
|
||||
SameType<TypeTraits<const int>::NonConstType,int>::value &&
|
||||
SameType<TypeTraits<int>::NonConstType,int>::value &&
|
||||
TypeTraits<const int>::isConst &&
|
||||
!TypeTraits<int>::isConst &&
|
||||
SameType<TypeTraits<const int>::NonConstType,int>::value &&
|
||||
SameType<TypeTraits<int>::NonConstType,int>::value &&
|
||||
|
||||
TypeTraits<volatile int>::isVolatile &&
|
||||
!TypeTraits<int>::isVolatile &&
|
||||
SameType<TypeTraits<volatile int>::NonVolatileType,int>::value &&
|
||||
SameType<TypeTraits<int>::NonVolatileType,int>::value &&
|
||||
TypeTraits<volatile int>::isVolatile &&
|
||||
!TypeTraits<int>::isVolatile &&
|
||||
SameType<TypeTraits<volatile int>::NonVolatileType,int>::value &&
|
||||
SameType<TypeTraits<int>::NonVolatileType,int>::value &&
|
||||
|
||||
SameType<TypeTraits<const volatile int>::UnqualifiedType,int>::value &&
|
||||
SameType<TypeTraits<const volatile int>::UnqualifiedType,int>::value &&
|
||||
|
||||
#endif
|
||||
|
||||
SameType<TypeTraits<char>::ParameterType,char>::value &&
|
||||
SameType<TypeTraits<int>::ParameterType,int>::value &&
|
||||
SameType<TypeTraits<double>::ParameterType,double>::value &&
|
||||
SameType<TypeTraits<Test>::ParameterType,Test &>::value;
|
||||
SameType<TypeTraits<char>::ParameterType,char>::value &&
|
||||
SameType<TypeTraits<int>::ParameterType,int>::value &&
|
||||
SameType<TypeTraits<double>::ParameterType,double>::value &&
|
||||
SameType<TypeTraits<Test>::ParameterType,Test &>::value;
|
||||
|
||||
testAssert("TypeTraits",r,result);
|
||||
testAssert("TypeTraits",r,result);
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
} typeTraitsTest;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,165 +24,165 @@
|
|||
class TypelistTest : public Test
|
||||
{
|
||||
public:
|
||||
TypelistTest() : Test("Typelist.h") {}
|
||||
TypelistTest() : Test("Typelist.h") {}
|
||||
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
virtual void execute(TestResult &result)
|
||||
{
|
||||
printName(result);
|
||||
|
||||
using namespace Loki;
|
||||
using namespace Loki::TL;
|
||||
using namespace Loki;
|
||||
using namespace Loki::TL;
|
||||
|
||||
typedef TYPELIST_1(char) CharList;
|
||||
typedef TYPELIST_3(char,int,double) CharIntDoubleList;
|
||||
typedef TYPELIST_4(char,int,double,char) CharIntDoubleCharList;
|
||||
typedef TYPELIST_3(Base,Derived1,Derived2) BaseDerived1Derived2List;
|
||||
typedef TYPELIST_3(Derived2,Derived1,Base) Derived2Derived1BaseList;
|
||||
typedef TYPELIST_4(Base,Derived1,Base,Derived2) BaseDerived1BaseDerived2List;
|
||||
typedef TYPELIST_4(Derived1,Base,Derived1,Derived2) Derived1BaseDerived1Derived2List;
|
||||
typedef TYPELIST_1(char) CharList;
|
||||
typedef TYPELIST_3(char,int,double) CharIntDoubleList;
|
||||
typedef TYPELIST_4(char,int,double,char) CharIntDoubleCharList;
|
||||
typedef TYPELIST_3(Base,Derived1,Derived2) BaseDerived1Derived2List;
|
||||
typedef TYPELIST_3(Derived2,Derived1,Base) Derived2Derived1BaseList;
|
||||
typedef TYPELIST_4(Base,Derived1,Base,Derived2) BaseDerived1BaseDerived2List;
|
||||
typedef TYPELIST_4(Derived1,Base,Derived1,Derived2) Derived1BaseDerived1Derived2List;
|
||||
|
||||
bool r;
|
||||
bool r;
|
||||
|
||||
r=Length<NullType>::value==0 &&
|
||||
Length<CharList>::value==1 &&
|
||||
Length<CharIntDoubleList>::value==3;
|
||||
r=Length<NullType>::value==0 &&
|
||||
Length<CharList>::value==1 &&
|
||||
Length<CharIntDoubleList>::value==3;
|
||||
|
||||
testAssert("Length",r,result);
|
||||
testAssert("Length",r,result);
|
||||
|
||||
r=SameType<TypeAt<CharList,0>::Result,char>::value &&
|
||||
SameType<TypeAt<CharIntDoubleList,2>::Result,double>::value;
|
||||
r=SameType<TypeAt<CharList,0>::Result,char>::value &&
|
||||
SameType<TypeAt<CharIntDoubleList,2>::Result,double>::value;
|
||||
|
||||
testAssert("TypeAt",r,result);
|
||||
testAssert("TypeAt",r,result);
|
||||
|
||||
#if !(_MSC_VER && !__INTEL_COMPILER && !__MWERKS__ && _MSC_VER < 1300)
|
||||
#if !(_MSC_VER && !__INTEL_COMPILER && !__MWERKS__ && _MSC_VER < 1300)
|
||||
|
||||
// TypeAtNonStrict works like TypeAt on MSVC 6.0
|
||||
// TypeAtNonStrict works like TypeAt on MSVC 6.0
|
||||
|
||||
r=SameType<TypeAtNonStrict<NullType,0>::Result,NullType>::value &&
|
||||
SameType<TypeAtNonStrict<CharList,0>::Result,char>::value &&
|
||||
SameType<TypeAtNonStrict<CharIntDoubleList,2>::Result,double>::value &&
|
||||
SameType<TypeAtNonStrict<CharIntDoubleList,3>::Result,NullType>::value &&
|
||||
r=SameType<TypeAtNonStrict<NullType,0>::Result,NullType>::value &&
|
||||
SameType<TypeAtNonStrict<CharList,0>::Result,char>::value &&
|
||||
SameType<TypeAtNonStrict<CharIntDoubleList,2>::Result,double>::value &&
|
||||
SameType<TypeAtNonStrict<CharIntDoubleList,3>::Result,NullType>::value &&
|
||||
SameType<TypeAtNonStrict<CharList,1,long>::Result,long>::value;
|
||||
|
||||
testAssert("TypeAtNonStrict",r,result);
|
||||
testAssert("TypeAtNonStrict",r,result);
|
||||
|
||||
#else
|
||||
#else
|
||||
|
||||
testAssert("TypeAtNonStrict",false,result,false);
|
||||
testAssert("TypeAtNonStrict",false,result,false);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
r=IndexOf<NullType,char>::value==-1 &&
|
||||
IndexOf<CharList,char>::value==0 &&
|
||||
IndexOf<CharIntDoubleList,double>::value==2 &&
|
||||
IndexOf<CharIntDoubleList,long>::value==-1;
|
||||
r=IndexOf<NullType,char>::value==-1 &&
|
||||
IndexOf<CharList,char>::value==0 &&
|
||||
IndexOf<CharIntDoubleList,double>::value==2 &&
|
||||
IndexOf<CharIntDoubleList,long>::value==-1;
|
||||
|
||||
testAssert("IndexOf",r,result);
|
||||
testAssert("IndexOf",r,result);
|
||||
|
||||
#if !(_MSC_VER && !__INTEL_COMPILER && !__MWERKS__ && _MSC_VER < 1300)
|
||||
#if !(_MSC_VER && !__INTEL_COMPILER && !__MWERKS__ && _MSC_VER < 1300)
|
||||
|
||||
// Append, Erase, EraseAll, NoDuplicates, Replace, ReplaceAll, Reverse,
|
||||
// MostDerived and DerivedToFront doesn't work on MSVC 6.0
|
||||
// Append, Erase, EraseAll, NoDuplicates, Replace, ReplaceAll, Reverse,
|
||||
// MostDerived and DerivedToFront doesn't work on MSVC 6.0
|
||||
|
||||
r=SameType<Append<NullType,NullType>::Result,NullType>::value &&
|
||||
SameType<Append<NullType,char>::Result,TYPELIST_1(char)>::value &&
|
||||
SameType<Append<NullType,CharList>::Result,CharList>::value &&
|
||||
SameType<Append<CharList,NullType>::Result,CharList>::value &&
|
||||
SameType<Append<CharList,int>::Result,TYPELIST_2(char,int)>::value &&
|
||||
SameType<Append<CharList,CharIntDoubleList>::Result,TYPELIST_4(char,char,int,double)>::value;
|
||||
r=SameType<Append<NullType,NullType>::Result,NullType>::value &&
|
||||
SameType<Append<NullType,char>::Result,TYPELIST_1(char)>::value &&
|
||||
SameType<Append<NullType,CharList>::Result,CharList>::value &&
|
||||
SameType<Append<CharList,NullType>::Result,CharList>::value &&
|
||||
SameType<Append<CharList,int>::Result,TYPELIST_2(char,int)>::value &&
|
||||
SameType<Append<CharList,CharIntDoubleList>::Result,TYPELIST_4(char,char,int,double)>::value;
|
||||
|
||||
testAssert("Append",r,result);
|
||||
testAssert("Append",r,result);
|
||||
|
||||
r=SameType<Erase<NullType,char>::Result,NullType>::value &&
|
||||
SameType<Erase<CharList,char>::Result,NullType>::value &&
|
||||
SameType<Erase<CharList,long>::Result,CharList>::value &&
|
||||
SameType<Erase<CharIntDoubleList,int>::Result,TYPELIST_2(char,double)>::value &&
|
||||
SameType<Erase<CharIntDoubleList,double>::Result,TYPELIST_2(char,int)>::value;
|
||||
r=SameType<Erase<NullType,char>::Result,NullType>::value &&
|
||||
SameType<Erase<CharList,char>::Result,NullType>::value &&
|
||||
SameType<Erase<CharList,long>::Result,CharList>::value &&
|
||||
SameType<Erase<CharIntDoubleList,int>::Result,TYPELIST_2(char,double)>::value &&
|
||||
SameType<Erase<CharIntDoubleList,double>::Result,TYPELIST_2(char,int)>::value;
|
||||
|
||||
testAssert("Erase",r,result);
|
||||
testAssert("Erase",r,result);
|
||||
|
||||
r=SameType<EraseAll<NullType,char>::Result,NullType>::value &&
|
||||
SameType<EraseAll<CharList,char>::Result,NullType>::value &&
|
||||
SameType<EraseAll<CharList,long>::Result,CharList>::value &&
|
||||
SameType<EraseAll<CharIntDoubleList,int>::Result,TYPELIST_2(char,double)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleList,double>::Result,TYPELIST_2(char,int)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,char>::Result,TYPELIST_2(int,double)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,int>::Result,TYPELIST_3(char,double,char)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,double>::Result,TYPELIST_3(char,int,char)>::value;
|
||||
r=SameType<EraseAll<NullType,char>::Result,NullType>::value &&
|
||||
SameType<EraseAll<CharList,char>::Result,NullType>::value &&
|
||||
SameType<EraseAll<CharList,long>::Result,CharList>::value &&
|
||||
SameType<EraseAll<CharIntDoubleList,int>::Result,TYPELIST_2(char,double)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleList,double>::Result,TYPELIST_2(char,int)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,char>::Result,TYPELIST_2(int,double)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,int>::Result,TYPELIST_3(char,double,char)>::value &&
|
||||
SameType<EraseAll<CharIntDoubleCharList,double>::Result,TYPELIST_3(char,int,char)>::value;
|
||||
|
||||
testAssert("EraseAll",r,result);
|
||||
testAssert("EraseAll",r,result);
|
||||
|
||||
r=SameType<NoDuplicates<NullType>::Result,NullType>::value &&
|
||||
SameType<NoDuplicates<CharList>::Result,CharList>::value &&
|
||||
SameType<NoDuplicates<CharIntDoubleList>::Result,CharIntDoubleList>::value &&
|
||||
SameType<NoDuplicates<CharIntDoubleCharList>::Result,CharIntDoubleList>::value;
|
||||
r=SameType<NoDuplicates<NullType>::Result,NullType>::value &&
|
||||
SameType<NoDuplicates<CharList>::Result,CharList>::value &&
|
||||
SameType<NoDuplicates<CharIntDoubleList>::Result,CharIntDoubleList>::value &&
|
||||
SameType<NoDuplicates<CharIntDoubleCharList>::Result,CharIntDoubleList>::value;
|
||||
|
||||
testAssert("NoDuplicates",r,result);
|
||||
testAssert("NoDuplicates",r,result);
|
||||
|
||||
r=SameType<Replace<NullType,char,long>::Result,NullType>::value &&
|
||||
SameType<Replace<CharList,char,long>::Result,TYPELIST_1(long)>::value &&
|
||||
SameType<Replace<CharList,int,long>::Result,CharList>::value &&
|
||||
SameType<Replace<CharIntDoubleList,char,long>::Result,TYPELIST_3(long,int,double)>::value &&
|
||||
SameType<Replace<CharIntDoubleList,long,char[16]>::Result,CharIntDoubleList>::value &&
|
||||
SameType<Replace<CharIntDoubleCharList,char,long>::Result,TYPELIST_4(long,int,double,char)>::value;
|
||||
r=SameType<Replace<NullType,char,long>::Result,NullType>::value &&
|
||||
SameType<Replace<CharList,char,long>::Result,TYPELIST_1(long)>::value &&
|
||||
SameType<Replace<CharList,int,long>::Result,CharList>::value &&
|
||||
SameType<Replace<CharIntDoubleList,char,long>::Result,TYPELIST_3(long,int,double)>::value &&
|
||||
SameType<Replace<CharIntDoubleList,long,char[16]>::Result,CharIntDoubleList>::value &&
|
||||
SameType<Replace<CharIntDoubleCharList,char,long>::Result,TYPELIST_4(long,int,double,char)>::value;
|
||||
|
||||
testAssert("Replace",r,result);
|
||||
testAssert("Replace",r,result);
|
||||
|
||||
r=SameType<ReplaceAll<NullType,char,long>::Result,NullType>::value &&
|
||||
SameType<ReplaceAll<CharList,char,long>::Result,TYPELIST_1(long)>::value &&
|
||||
SameType<ReplaceAll<CharList,int,long>::Result,CharList>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleList,char,long>::Result,TYPELIST_3(long,int,double)>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleList,long,char[16]>::Result,CharIntDoubleList>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleCharList,char,long>::Result,TYPELIST_4(long,int,double,long)>::value;
|
||||
r=SameType<ReplaceAll<NullType,char,long>::Result,NullType>::value &&
|
||||
SameType<ReplaceAll<CharList,char,long>::Result,TYPELIST_1(long)>::value &&
|
||||
SameType<ReplaceAll<CharList,int,long>::Result,CharList>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleList,char,long>::Result,TYPELIST_3(long,int,double)>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleList,long,char[16]>::Result,CharIntDoubleList>::value &&
|
||||
SameType<ReplaceAll<CharIntDoubleCharList,char,long>::Result,TYPELIST_4(long,int,double,long)>::value;
|
||||
|
||||
testAssert("ReplaceAll",r,result);
|
||||
testAssert("ReplaceAll",r,result);
|
||||
|
||||
r=SameType<Reverse<NullType>::Result,NullType>::value &&
|
||||
SameType<Reverse<CharList>::Result,CharList>::value &&
|
||||
SameType<Reverse<CharIntDoubleList>::Result,TYPELIST_3(double,int,char)>::value;
|
||||
r=SameType<Reverse<NullType>::Result,NullType>::value &&
|
||||
SameType<Reverse<CharList>::Result,CharList>::value &&
|
||||
SameType<Reverse<CharIntDoubleList>::Result,TYPELIST_3(double,int,char)>::value;
|
||||
|
||||
testAssert("Reverse",r,result);
|
||||
testAssert("Reverse",r,result);
|
||||
|
||||
r=SameType<MostDerived<NullType,Base>::Result,Base>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Base>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Derived1>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Derived2>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Base>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Derived1>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Derived2>::Result,Derived2>::value;
|
||||
r=SameType<MostDerived<NullType,Base>::Result,Base>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Base>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Derived1>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<BaseDerived1Derived2List,Derived2>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Base>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Derived1>::Result,Derived2>::value &&
|
||||
SameType<MostDerived<Derived2Derived1BaseList,Derived2>::Result,Derived2>::value;
|
||||
|
||||
testAssert("MostDerived",r,result);
|
||||
testAssert("MostDerived",r,result);
|
||||
|
||||
r=SameType<DerivedToFront<NullType>::Result,NullType>::value &&
|
||||
SameType<DerivedToFront<CharList>::Result,CharList>::value &&
|
||||
SameType<DerivedToFront<CharIntDoubleList>::Result,CharIntDoubleList>::value &&
|
||||
SameType<DerivedToFront<CharIntDoubleCharList>::Result,CharIntDoubleCharList>::value &&
|
||||
SameType<DerivedToFront<BaseDerived1Derived2List>::Result,Derived2Derived1BaseList>::value &&
|
||||
SameType<DerivedToFront<Derived2Derived1BaseList>::Result,Derived2Derived1BaseList>::value &&
|
||||
SameType<DerivedToFront<BaseDerived1BaseDerived2List>::Result,TYPELIST_4(Derived2,Derived1,Base,Base)>::value &&
|
||||
SameType<DerivedToFront<Derived1BaseDerived1Derived2List>::Result,TYPELIST_4(Derived2,Derived1,Derived1,Base)>::value;
|
||||
r=SameType<DerivedToFront<NullType>::Result,NullType>::value &&
|
||||
SameType<DerivedToFront<CharList>::Result,CharList>::value &&
|
||||
SameType<DerivedToFront<CharIntDoubleList>::Result,CharIntDoubleList>::value &&
|
||||
SameType<DerivedToFront<CharIntDoubleCharList>::Result,CharIntDoubleCharList>::value &&
|
||||
SameType<DerivedToFront<BaseDerived1Derived2List>::Result,Derived2Derived1BaseList>::value &&
|
||||
SameType<DerivedToFront<Derived2Derived1BaseList>::Result,Derived2Derived1BaseList>::value &&
|
||||
SameType<DerivedToFront<BaseDerived1BaseDerived2List>::Result,TYPELIST_4(Derived2,Derived1,Base,Base)>::value &&
|
||||
SameType<DerivedToFront<Derived1BaseDerived1Derived2List>::Result,TYPELIST_4(Derived2,Derived1,Derived1,Base)>::value;
|
||||
|
||||
testAssert("DerivedToFront",r,result);
|
||||
testAssert("DerivedToFront",r,result);
|
||||
|
||||
#else
|
||||
#else
|
||||
|
||||
testAssert("Append",false,result,false);
|
||||
testAssert("Erase",false,result,false);
|
||||
testAssert("EraseAll",false,result,false);
|
||||
testAssert("NoDuplicates",false,result,false);
|
||||
testAssert("Replace",false,result,false);
|
||||
testAssert("Reverse",false,result,false);
|
||||
testAssert("MostDerived",false,result,false);
|
||||
testAssert("DerivedToFront",false,result,false);
|
||||
testAssert("Append",false,result,false);
|
||||
testAssert("Erase",false,result,false);
|
||||
testAssert("EraseAll",false,result,false);
|
||||
testAssert("NoDuplicates",false,result,false);
|
||||
testAssert("Replace",false,result,false);
|
||||
testAssert("Reverse",false,result,false);
|
||||
testAssert("MostDerived",false,result,false);
|
||||
testAssert("DerivedToFront",false,result,false);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
std::cout << '\n';
|
||||
}
|
||||
std::cout << '\n';
|
||||
}
|
||||
|
||||
private:
|
||||
struct Base { char c; };
|
||||
struct Derived1 : Base { char c; };
|
||||
struct Derived2 : Derived1 { char c; };
|
||||
struct Base { char c; };
|
||||
struct Derived1 : Base { char c; };
|
||||
struct Derived2 : Derived1 { char c; };
|
||||
} typelistTest;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -25,26 +25,26 @@
|
|||
// SameType
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if _MSC_VER && !__INTEL_COMPILER && !__MWERKS__
|
||||
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
|
||||
|
||||
// Rani Sharoni's SameType
|
||||
//
|
||||
// Non-conforming workaround for MSVC
|
||||
|
||||
//This is non-standard code, you are not allowed to
|
||||
// specialize a nested template
|
||||
template<class T1,class T2>
|
||||
struct SameType
|
||||
{
|
||||
private:
|
||||
template<class>
|
||||
struct In
|
||||
{ enum { value = false }; };
|
||||
template<class>
|
||||
struct In
|
||||
{ enum { value = false }; };
|
||||
|
||||
template<>
|
||||
struct In<T1>
|
||||
{ enum { value = true }; };
|
||||
template<>
|
||||
struct In<T1>
|
||||
{ enum { value = true }; };
|
||||
|
||||
public:
|
||||
enum { value = In<T2>::value };
|
||||
enum { value = In<T2>::value };
|
||||
};
|
||||
|
||||
#else
|
||||
|
|
@ -52,13 +52,13 @@ public:
|
|||
template<class T1,class T2>
|
||||
struct SameType
|
||||
{
|
||||
static const bool value=false;
|
||||
static const bool value=false;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct SameType<T,T>
|
||||
{
|
||||
static const bool value=true;
|
||||
static const bool value=true;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -70,12 +70,12 @@ struct SameType<T,T>
|
|||
class TestResult
|
||||
{
|
||||
public:
|
||||
TestResult() : pos(0),passed(0),failed(0),notSupported(0) {}
|
||||
TestResult() : pos(0),passed(0),failed(0),notSupported(0) {}
|
||||
|
||||
int pos;
|
||||
int passed;
|
||||
int failed;
|
||||
int notSupported;
|
||||
int pos;
|
||||
int passed;
|
||||
int failed;
|
||||
int notSupported;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -89,94 +89,94 @@ typedef std::vector<Test*> tests_type;
|
|||
static tests_type tests;
|
||||
|
||||
public:
|
||||
explicit Test(const std::string &n) : name(n)
|
||||
{
|
||||
Test::tests.push_back(this);
|
||||
}
|
||||
explicit Test(const std::string &n) : name(n)
|
||||
{
|
||||
Test::tests.push_back(this);
|
||||
}
|
||||
|
||||
virtual void execute(TestResult &) =0;
|
||||
|
||||
virtual void execute(TestResult &) =0;
|
||||
|
||||
protected:
|
||||
~Test() {}
|
||||
~Test() {}
|
||||
|
||||
void printName(const TestResult &result) const
|
||||
{
|
||||
if(name.length()!=0)
|
||||
std::cout << std::string(result.pos,' ') << name << '\n';
|
||||
}
|
||||
void printName(const TestResult &result) const
|
||||
{
|
||||
if(name.length()!=0)
|
||||
std::cout << std::string(result.pos,' ') << name << '\n';
|
||||
}
|
||||
|
||||
void testAssert(const std::string &s,bool assertion,TestResult &result,bool supported =true,
|
||||
const std::string &failStr =emptyStr())
|
||||
{
|
||||
std::string str=std::string(result.pos+2,' ')+s;
|
||||
void testAssert(const std::string &s,bool assertion,TestResult &result,bool supported =true,
|
||||
const std::string &failStr =emptyStr())
|
||||
{
|
||||
std::string str=std::string(result.pos+2,' ')+s;
|
||||
|
||||
str+=std::string(offset-str.length(),' ');
|
||||
str+=std::string(offset-str.length(),' ');
|
||||
|
||||
if(supported)
|
||||
{
|
||||
if(assertion)
|
||||
{
|
||||
std::cout << str << "Passed\n";
|
||||
if(supported)
|
||||
{
|
||||
if(assertion)
|
||||
{
|
||||
std::cout << str << "Passed\n";
|
||||
|
||||
++result.passed;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << str << (failStr==emptyStr() ? std::string("Failed") : "Failed - "+failStr) << '\n';
|
||||
++result.passed;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << str << (failStr==emptyStr() ? std::string("Failed") : "Failed - "+failStr) << '\n';
|
||||
|
||||
++result.failed;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << str << "Not Supported\n";
|
||||
++result.failed;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << str << "Not Supported\n";
|
||||
|
||||
++result.notSupported;
|
||||
}
|
||||
}
|
||||
++result.notSupported;
|
||||
}
|
||||
}
|
||||
|
||||
static std::string emptyStr()
|
||||
{
|
||||
return std::string();
|
||||
}
|
||||
static std::string emptyStr()
|
||||
{
|
||||
return std::string();
|
||||
}
|
||||
|
||||
public:
|
||||
enum { offset=63 };
|
||||
enum { offset=63 };
|
||||
|
||||
protected:
|
||||
const std::string name;
|
||||
|
||||
const std::string name;
|
||||
|
||||
public:
|
||||
static int run(const std::string &title)
|
||||
{
|
||||
std::cout << title << std::string(Test::offset-title.length(),' ') << "Result\n";
|
||||
std::cout << std::string(76,'-') << '\n';
|
||||
|
||||
TestResult testResult;
|
||||
|
||||
tests_type::iterator it;
|
||||
tests_type::const_iterator itEnd = Test::tests.end();
|
||||
for(it=Test::tests.begin(); it!=itEnd; ++it)
|
||||
{
|
||||
Test* test = *it;
|
||||
test->execute(testResult);
|
||||
}
|
||||
|
||||
std::cout << std::string(76,'-') << '\n';
|
||||
static int run(const std::string &title)
|
||||
{
|
||||
std::cout << title << std::string(Test::offset-title.length(),' ') << "Result\n";
|
||||
std::cout << std::string(76,'-') << '\n';
|
||||
|
||||
TestResult testResult;
|
||||
|
||||
tests_type::iterator it;
|
||||
tests_type::const_iterator itEnd = Test::tests.end();
|
||||
for(it=Test::tests.begin(); it!=itEnd; ++it)
|
||||
{
|
||||
Test* test = *it;
|
||||
test->execute(testResult);
|
||||
}
|
||||
|
||||
std::cout << std::string(76,'-') << '\n';
|
||||
|
||||
const int total=testResult.passed+testResult.failed;
|
||||
const int totalAll=total+testResult.notSupported;
|
||||
const int total=testResult.passed+testResult.failed;
|
||||
const int totalAll=total+testResult.notSupported;
|
||||
|
||||
if(total!=0)
|
||||
std::cout << "Total - " << testResult.passed << '/' << total << (total==1 ? " test, " : " tests, ")
|
||||
<< testResult.passed*100/total << "% Passed\n";
|
||||
if(total!=0)
|
||||
std::cout << "Total - " << testResult.passed << '/' << total << (total==1 ? " test, " : " tests, ")
|
||||
<< testResult.passed*100/total << "% Passed\n";
|
||||
|
||||
if(testResult.notSupported!=0)
|
||||
std::cout << "Not Supported - " << testResult.notSupported << '/' << totalAll << ", "
|
||||
<< testResult.notSupported*100/totalAll << "%\n";
|
||||
if(testResult.notSupported!=0)
|
||||
std::cout << "Not Supported - " << testResult.notSupported << '/' << totalAll << ", "
|
||||
<< testResult.notSupported*100/totalAll << "%\n";
|
||||
|
||||
return testResult.failed;
|
||||
}
|
||||
return testResult.failed;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue