From ae050862b81357c427cc2a0a631899339269965e Mon Sep 17 00:00:00 2001 From: tslettebo Date: Mon, 7 Oct 2002 13:01:49 +0000 Subject: [PATCH] *** empty log message *** git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@62 7ec92016-0320-0410-acc4-a06ded1c099a --- tools/RegressionTest2/AbstractFactoryTest.h | 87 ----- tools/RegressionTest2/AssocVectorTest.h | 358 -------------------- tools/RegressionTest2/FactoryTest.h | 147 -------- tools/RegressionTest2/FunctorTest.h | 109 ------ tools/RegressionTest2/LokiTest.h | 77 ----- tools/RegressionTest2/SingletonTest.h | 157 --------- tools/RegressionTest2/SmallObjectTest.h | 164 --------- tools/RegressionTest2/SmartPtrTest.h | 290 ---------------- tools/RegressionTest2/Test.cpp | 32 -- tools/RegressionTest2/TypeManipTest.h | 119 ------- tools/RegressionTest2/TypeTraitsTest.h | 116 ------- tools/RegressionTest2/TypelistTest.h | 186 ---------- tools/RegressionTest2/UnitTest.h | 208 ------------ 13 files changed, 2050 deletions(-) delete mode 100644 tools/RegressionTest2/AbstractFactoryTest.h delete mode 100644 tools/RegressionTest2/AssocVectorTest.h delete mode 100644 tools/RegressionTest2/FactoryTest.h delete mode 100644 tools/RegressionTest2/FunctorTest.h delete mode 100644 tools/RegressionTest2/LokiTest.h delete mode 100644 tools/RegressionTest2/SingletonTest.h delete mode 100644 tools/RegressionTest2/SmallObjectTest.h delete mode 100644 tools/RegressionTest2/SmartPtrTest.h delete mode 100644 tools/RegressionTest2/Test.cpp delete mode 100644 tools/RegressionTest2/TypeManipTest.h delete mode 100644 tools/RegressionTest2/TypeTraitsTest.h delete mode 100644 tools/RegressionTest2/TypelistTest.h delete mode 100644 tools/RegressionTest2/UnitTest.h diff --git a/tools/RegressionTest2/AbstractFactoryTest.h b/tools/RegressionTest2/AbstractFactoryTest.h deleted file mode 100644 index 930aa66..0000000 --- a/tools/RegressionTest2/AbstractFactoryTest.h +++ /dev/null @@ -1,87 +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 ABSTRACTFACTORYTEST_H -#define ABSTRACTFACTORYTEST_H - -#include -#include -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// AbstractFactoryTest -/////////////////////////////////////////////////////////////////////////////// - -class Soldier { public: virtual ~Soldier() {} }; -class Monster { public: virtual ~Monster() {} }; -class SuperMonster { public: virtual ~SuperMonster() {} }; - -class SillySoldier : public Soldier {}; -class SillyMonster : public Monster {}; -class SillySuperMonster : public SuperMonster {}; - -class BadSoldier : public Soldier {}; -class BadMonster : public Monster {}; -class BadSuperMonster : public SuperMonster {}; - -typedef Loki::AbstractFactory AbstractEnemyFactory; - -typedef Loki::ConcreteFactory EasyLevelEnemyFactory; - -typedef Loki::ConcreteFactory HardLevelEnemyFactory; - -class AbstractFactoryTest : public Test -{ -public: - AbstractFactoryTest() : Test("AbstractFactory.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - bool r; - - std::auto_ptr easyFactory(new EasyLevelEnemyFactory); - std::auto_ptr hardFactory(new HardLevelEnemyFactory); - - Soldier *s; - - s = easyFactory->Create(); - - r=typeid(*s)==typeid(SillySoldier); - - delete s; - -#ifndef __BORLANDC__ - - s = hardFactory->Create(); //BCB bug!!! - always creates SillySoldier - - r=r && typeid(*s)==typeid(BadSoldier); - - delete s; - -#endif - - testAssert("AbstractFactory",r,result); - - std::cout << '\n'; - } -}; - -#endif diff --git a/tools/RegressionTest2/AssocVectorTest.h b/tools/RegressionTest2/AssocVectorTest.h deleted file mode 100644 index 43eea62..0000000 --- a/tools/RegressionTest2/AssocVectorTest.h +++ /dev/null @@ -1,358 +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 ASSOCVECTORTEST_H -#define ASSOCVECTORTEST_H - -#include -#include -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// AssocVectorTest -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// STL compatible allocator -/////////////////////////////////////////////////////////////////////////////// - -template class TestAllocator : public std::allocator -{ -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; - - template - struct rebind { typedef TestAllocator other; }; - - TestAllocator() {} - TestAllocator(const TestAllocator&) {} - template - TestAllocator(const TestAllocator&) {} - ~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(::operator new(n * sizeof(T))); - } - - void deallocate(pointer p, size_type size) { - ::operator delete(p); - } - - size_type max_size() const { - return static_cast(-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&); -}; - -/////////////////////////////////////////////////////////////////////////////// -// AVTestClass -/////////////////////////////////////////////////////////////////////////////// - -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; - } - - int value_; -}; - -bool operator<(const AVTestClass& lhs, const AVTestClass& rhs) -{ - return lhs.value_ < rhs.value_; -} - -/////////////////////////////////////////////////////////////////////////////// -// str_less -/////////////////////////////////////////////////////////////////////////////// - -struct str_less : public std::binary_function { - bool operator()(const char* x, const char* y) const { - return strcmp(x, y) < 0; - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// int_less -/////////////////////////////////////////////////////////////////////////////// - -unsigned int_test_count = 0; // to verify usage -struct int_less : public std::less -{ - bool operator()(int x, int y) const { - ++int_test_count; - return x < y; - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// is_sorted -/////////////////////////////////////////////////////////////////////////////// - -template -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; -} - -/////////////////////////////////////////////////////////////////////////////// - -typedef Loki::AssocVector, TestAllocator > > test_vect1_t; -typedef Loki::AssocVector > > test_vect2_t; -typedef Loki::AssocVector test_vect3_t; -typedef Loki::AssocVector, TestAllocator > > test_vect4_t; -typedef Loki::AssocVector 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); -} - -/////////////////////////////////////////////////////////////////////////////// -// check_swap -/////////////////////////////////////////////////////////////////////////////// - -template -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); -} - -/////////////////////////////////////////////////////////////////////////////// -// test_vect1 -/////////////////////////////////////////////////////////////////////////////// - -void test_vect1() -{ - test_vect1_t vec11; - assert(vec11.size() == 0); - - check_insert1(vec11); - unsigned 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 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()); - //assert(vec99.size() == 0); //- here ir cries - - test_vect1_t::key_compare comp = test_vect1_t::key_compare(); - test_vect1_t vec14(comp, TestAllocator()); - assert(vec14.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()); - 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); -} - -/////////////////////////////////////////////////////////////////////////////// -// test_vect2 -/////////////////////////////////////////////////////////////////////////////// - -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::iterator it = vec21.find("xyz"); - assert(it != vec21.end()); - assert(it->second == 3); - - std::pair aux = vec21.insert(std::make_pair("xyz", 99)); - assert(aux.first); - 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.clear(); - assert(vec21.size() == 0); -} - -/////////////////////////////////////////////////////////////////////////////// -// test_vect3 -/////////////////////////////////////////////////////////////////////////////// - -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)); - } -} - -/////////////////////////////////////////////////////////////////////////////// -// test_vect4 -/////////////////////////////////////////////////////////////////////////////// - -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); - - 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 vec42; - vec42.swap(vec41); - assert(vec41.size() == 0); - assert(vec42.size() == 102); - - vec42.erase(vec42.begin(), vec42.end()); - assert(vec42.size() == 0); -} - -/////////////////////////////////////////////////////////////////////////////// -// test_vect5 -/////////////////////////////////////////////////////////////////////////////// - -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::const_iterator it = vec51.begin(); - int count=1; - - while (it != vec51.end()) { - assert(std::string(it->second).length()==count); - - ++count; - - it++; // intentionally - } -} - -class AssocVectorTest : public Test -{ -public: - AssocVectorTest() : Test("AssocVector.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - test_vect1(); - test_vect2(); - test_vect3(); - test_vect4(); - test_vect5(); - - testAssert("AssocVector",true,result), - - std::cout << '\n'; - } -}; - -#endif diff --git a/tools/RegressionTest2/FactoryTest.h b/tools/RegressionTest2/FactoryTest.h deleted file mode 100644 index 1051ba9..0000000 --- a/tools/RegressionTest2/FactoryTest.h +++ /dev/null @@ -1,147 +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 FACTORYTEST_H -#define FACTORYTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// FactoryTest -/////////////////////////////////////////////////////////////////////////////// - -namespace FactoryTestPrivate -{ - class Shape - { - public: - virtual ~Shape() = 0; - }; - - inline Shape::~Shape() {} - - class Polygon : public Shape - { - }; - - class Line : public Shape - { - }; - - class Circle : public Shape - { - }; - - 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; } - - typedef Loki::Factory FactoryType; - - bool testFactory() - { - FactoryType factory; - - factory.Register(1, (Shape * (*)()) createPolygon); - factory.Register(2, (Shape * (*)()) createCircle); - factory.Register(3, (Shape * (*)()) createLine); - - Shape *s; - - s = factory.CreateObject(1); - delete s; - bool test1=s!=NULL; - - s = factory.CreateObject(2); - delete s; - bool test2=s!=NULL; - - s = factory.CreateObject(3); - delete s; - bool test3=s!=NULL; - - bool test4=true; - -// try -// { -// factory.CreateObject(4); -// -// test4=false; -// } -// catch (std::exception&) -// { -// } - - return test1 && test2 && test3 && test4; - } - - typedef Loki::CloneFactory CloneFactoryType; - - 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); - - Polygon p; - Circle c; - Line l; - - Shape *s; - - s = factory.CreateObject(&p); - delete s; - bool test1=s!=NULL; - - s = factory.CreateObject(&c); - delete s; - bool test2=s!=NULL; - - s = factory.CreateObject(&l); - delete s; - bool test3=s!=NULL; - - return test1 && test2 && test3; - } -} - -class FactoryTest : public Test -{ -public: - FactoryTest() : Test("Factory.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - bool test1=FactoryTestPrivate::testFactory(); - - bool test2=FactoryTestPrivate::testCloneFactory(); - - bool r=test1 && test2; - - testAssert("Factory",r,result); - - std::cout << '\n'; - } -}; - -#endif diff --git a/tools/RegressionTest2/FunctorTest.h b/tools/RegressionTest2/FunctorTest.h deleted file mode 100644 index 89f8c6e..0000000 --- a/tools/RegressionTest2/FunctorTest.h +++ /dev/null @@ -1,109 +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 FUNCTORTEST_H -#define FUNCTORTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// FunctorTest -/////////////////////////////////////////////////////////////////////////////// - -class FunctorTest : public Test -{ -public: - FunctorTest() : Test("Functor.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - bool r; - - TestFunctor testFunctor; - TestClass testClass; - - Functor function(testFunction); - Functor functor(testFunctor); - Functor classFunctor(&testClass,&TestClass::member); - Functor functorCopy(function); - Functor bindFunctor(BindFirst(function,testResult)); - Functor chainFunctor(Chain(bindFunctor,bindFunctor)); - - testResult=false; - function(testResult); - bool functionResult=testResult; - - testResult=false; - functor(testResult); - bool functorResult=testResult; - - testResult=false; - classFunctor(testResult); - bool classFunctorResult=testResult; - - testResult=false; - functorCopy(testResult); - bool functorCopyResult=testResult; - - testResult=false; - bindFunctor(); - bool bindFunctorResult=testResult; - - testResult=false; - chainFunctor(); - bool chainFunctorResult=testResult; - - r=functionResult && functorResult && classFunctorResult && functorCopyResult && bindFunctorResult && - chainFunctorResult; - - testAssert("Functor",r,result); - - std::cout << '\n'; - } - -private: - static bool testResult; - - static void testFunction(bool &result) - { - result=true; - } - - class TestFunctor - { - public: - void operator()(bool &result) - { - result=true; - } - }; - - class TestClass - { - public: - void member(bool &result) - { - result=true; - } - }; -}; - -bool FunctorTest::testResult; - -#endif diff --git a/tools/RegressionTest2/LokiTest.h b/tools/RegressionTest2/LokiTest.h deleted file mode 100644 index 1fc9be5..0000000 --- a/tools/RegressionTest2/LokiTest.h +++ /dev/null @@ -1,77 +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" - -/////////////////////////////////////////////////////////////////////////////// -// 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); - } - -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; -}; - -#endif diff --git a/tools/RegressionTest2/SingletonTest.h b/tools/RegressionTest2/SingletonTest.h deleted file mode 100644 index 9572e39..0000000 --- a/tools/RegressionTest2/SingletonTest.h +++ /dev/null @@ -1,157 +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 SINGLETONTEST_H -#define SINGLETONTEST_H - -#include -#include -#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; - -/////////////////////////////////////////////////////////////////////////////// -// SingletonTest -/////////////////////////////////////////////////////////////////////////////// - -template -class MyClass -{ -public: - MyClass() : a(99), wasDestroyed(false) {} - - virtual ~MyClass() - { - assert(!wasDestroyed); - - wasDestroyed = true; - } - -public: - int a; - bool wasDestroyed; -}; - -inline unsigned GetLongevity(MyClass<3> *) { return 6; } -inline unsigned GetLongevity(MyClass<7> *) { return 5; } -inline unsigned GetLongevity(MyClass<11> *) { return 4; } -inline unsigned GetLongevity(MyClass<15> *) { return 1; } -inline unsigned GetLongevity(MyClass<19> *) { return 2; } -inline unsigned GetLongevity(MyClass<23> *) { return 3; } - -namespace -{ - using namespace Loki; - - typedef SingletonHolder > t0; - - typedef SingletonHolder, CreateUsingNew, DefaultLifetime, SingleThreaded> t1; - typedef SingletonHolder, CreateUsingNew, PhoenixSingleton, SingleThreaded> t2; - typedef SingletonHolder, CreateUsingNew, SingletonWithLongevity, SingleThreaded> t3; - typedef SingletonHolder, CreateUsingNew, NoDestroy, SingleThreaded> t4; - - typedef SingletonHolder, CreateUsingMalloc, DefaultLifetime, SingleThreaded> t9; - typedef SingletonHolder, CreateUsingMalloc, PhoenixSingleton, SingleThreaded> t10; - typedef SingletonHolder, CreateUsingMalloc, SingletonWithLongevity, SingleThreaded> t11; - typedef SingletonHolder, CreateUsingMalloc, NoDestroy, SingleThreaded> t12; - - typedef SingletonHolder, CreateStatic, DefaultLifetime, SingleThreaded> t17; - typedef SingletonHolder, CreateStatic, PhoenixSingleton, SingleThreaded> t18; - typedef SingletonHolder, CreateStatic, SingletonWithLongevity, SingleThreaded> t19; - typedef SingletonHolder, CreateStatic, NoDestroy, SingleThreaded> t20; - -#if !__INTEL_COMPILER && !__GNUC__ - - typedef SingletonHolder, CreateUsingNew, DefaultLifetime, ClassLevelLockable> t5; - typedef SingletonHolder, CreateUsingNew, PhoenixSingleton, ClassLevelLockable> t6; - typedef SingletonHolder, CreateUsingNew, SingletonWithLongevity, ClassLevelLockable> t7; - typedef SingletonHolder, CreateUsingNew, NoDestroy, ClassLevelLockable> t8; - - typedef SingletonHolder, CreateUsingMalloc, DefaultLifetime, ClassLevelLockable> t13; - typedef SingletonHolder, CreateUsingMalloc, PhoenixSingleton, ClassLevelLockable> t14; - typedef SingletonHolder, CreateUsingMalloc, SingletonWithLongevity, ClassLevelLockable> t15; - typedef SingletonHolder, CreateUsingMalloc, NoDestroy, ClassLevelLockable> t16; - - typedef SingletonHolder, CreateStatic, DefaultLifetime, ClassLevelLockable> t21; - typedef SingletonHolder, CreateStatic, PhoenixSingleton, ClassLevelLockable> t22; - typedef SingletonHolder, CreateStatic, SingletonWithLongevity, ClassLevelLockable> t23; - typedef SingletonHolder, CreateStatic, NoDestroy, ClassLevelLockable> t24; - -#endif -} - -class SingletonTest : public Test -{ -public: - SingletonTest() : Test("Singleton.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - singletonTest=true; - - MAKE_TEST(t0) - - 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(t17) - MAKE_TEST(t18) - MAKE_TEST(t19) - MAKE_TEST(t20) - -#if !__INTEL_COMPILER && !__GNUC__ - - 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(t21) - MAKE_TEST(t22) - MAKE_TEST(t23) - MAKE_TEST(t24) - -#endif - - testAssert("Singleton",singletonTest,result); - - std::cout << '\n'; - } - -private: - bool singletonTest; -}; - -#endif diff --git a/tools/RegressionTest2/SmallObjectTest.h b/tools/RegressionTest2/SmallObjectTest.h deleted file mode 100644 index 3f6770e..0000000 --- a/tools/RegressionTest2/SmallObjectTest.h +++ /dev/null @@ -1,164 +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 SMALLOBJECTTEST_H -#define SMALLOBJECTTEST_H - -#include -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// SmallObjectTest -/////////////////////////////////////////////////////////////////////////////// - -class SmallObjectTest : public Test -{ -public: - SmallObjectTest() : Test("SmallObject.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - bool r; - - SmallClass* a = new SmallClass; - delete a; - - bool smallTest1=a!=NULL; - - a = new SmallClass2; - delete a; - - bool smallTest2=a!=NULL; - - BigClass* b = new BigClass; - delete b; - - bool bigTest1=b!=NULL; - - b = new BigClass2; - delete b; - - bool bigTest2=b!=NULL; - - char* buff = static_cast(Loki::SmallObject<>::operator new(10)); - Loki::SmallObject<>::operator delete(buff, 10); - - bool test=buff!=NULL; - -// stress_test(); - - r=smallTest1 && smallTest2 && bigTest1 && bigTest2 && test; - - testAssert("SmallObject",r,result); - - std::cout << '\n'; - } - -private: - class SmallClass : public Loki::SmallObject<> - { - int a; - }; - - class SmallClass2 : public SmallClass - { - int b; - }; - - class BigClass : public Loki::SmallObject<> - { - char a[200]; - }; - - class BigClass2 : public BigClass - { - int b; - }; - - class Base - { - public: - virtual ~Base() {} - }; - - class A : public Base, public Loki::SmallObject<> - { - int a[1]; - }; - - class B : public Base, public Loki::SmallObject<> - { - int a[2]; - }; - - class C : public Base, public Loki::SmallObject<> - { - int a[3]; - }; - - class D : public Base, public Loki::SmallObject<> - { - int a[4]; - }; - - static void stress_test() - { - std::vector vec; - - vec.reserve(20 * 1024); - - std::srand(1231); - - 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; - } - - vec.push_back(p); - } - - for (int j = 0; j < 1024; ++j) - { - int pos = std::rand() % vec.size(); - - delete vec[pos]; - - vec[pos] = 0; - } - } - - while (!vec.empty()) - { - delete vec.back(); - - vec.pop_back(); - } - } -}; - -#endif diff --git a/tools/RegressionTest2/SmartPtrTest.h b/tools/RegressionTest2/SmartPtrTest.h deleted file mode 100644 index 84d317d..0000000 --- a/tools/RegressionTest2/SmartPtrTest.h +++ /dev/null @@ -1,290 +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 SMARTPTRTEST_H -#define SMARTPTRTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// SmartPtrTest -/////////////////////////////////////////////////////////////////////////////// - -class TestClass -{ -public: - TestClass() : references(1) - { - ++instances; - } - - ~TestClass() - { - --instances; - } - - void AddRef() - { - ++references; - } - - void Release() - { - --references; - - if (references <= 0) - delete this; - } - -public: - static int instances; - - int references; -}; - -int TestClass::instances = 0; - -class SmartPtrTest : public Test -{ -public: - SmartPtrTest() : Test("SmartPtr.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - { SmartPtr p = new TestClass; } - - 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(); } - - bool test2=TestClass::instances==0; - - bool r=test1 && test2; - - testAssert("SmartPtr",r,result); - - std::cout << '\n'; - } - -private: - typedef SmartPtr p0; - typedef SmartPtr p1; - //typedef SmartPtr p2; - typedef SmartPtr p3; - typedef SmartPtr p4; - typedef SmartPtr p5; - typedef SmartPtr p6; - typedef SmartPtr p7; - - typedef SmartPtr p8; - typedef SmartPtr p9; - //typedef SmartPtr p10; - typedef SmartPtr p11; - typedef SmartPtr p12; - typedef SmartPtr p13; - typedef SmartPtr p14; - typedef SmartPtr p15; - - typedef SmartPtr p16; - typedef SmartPtr p17; - //typedef SmartPtr p18; - typedef SmartPtr p19; - typedef SmartPtr p20; - typedef SmartPtr p21; - typedef SmartPtr p22; - typedef SmartPtr p23; - - typedef SmartPtr p24; - typedef SmartPtr p25; - //typedef SmartPtr p26; - typedef SmartPtr p27; - typedef SmartPtr p28; - typedef SmartPtr p29; - typedef SmartPtr p30; - typedef SmartPtr p31; - - typedef SmartPtr p40; - typedef SmartPtr p41; - //typedef SmartPtr p42; - typedef SmartPtr p43; - typedef SmartPtr p44; - typedef SmartPtr p45; - typedef SmartPtr p46; - typedef SmartPtr p47; - - typedef SmartPtr p48; - typedef SmartPtr p49; - //typedef SmartPtr p50; - typedef SmartPtr p51; - typedef SmartPtr p52; - typedef SmartPtr p53; - typedef SmartPtr p54; - typedef SmartPtr p55; - - typedef SmartPtr p56; - typedef SmartPtr p57; - //typedef SmartPtr p58; - typedef SmartPtr p59; - typedef SmartPtr p60; - typedef SmartPtr p61; - typedef SmartPtr p62; - typedef SmartPtr p63; - - typedef SmartPtr p64; - typedef SmartPtr p65; - //typedef SmartPtr p66; - typedef SmartPtr p67; - typedef SmartPtr p68; - typedef SmartPtr p69; - typedef SmartPtr p70; - typedef SmartPtr p71; - - typedef SmartPtr p72; - typedef SmartPtr p73; - //typedef SmartPtr p74; - typedef SmartPtr p75; - typedef SmartPtr p76; - typedef SmartPtr p77; - typedef SmartPtr p78; - typedef SmartPtr p79; - - typedef SmartPtr p80; - typedef SmartPtr p81; - //typedef SmartPtr p82; - typedef SmartPtr p83; - typedef SmartPtr p84; - typedef SmartPtr p85; - typedef SmartPtr p86; - typedef SmartPtr p87; - - typedef SmartPtr p88; - typedef SmartPtr p89; - //typedef SmartPtr p90; - typedef SmartPtr p91; - typedef SmartPtr p92; - typedef SmartPtr p93; - typedef SmartPtr p94; - typedef SmartPtr p95; - - typedef SmartPtr p96; - typedef SmartPtr p97; - //typedef SmartPtr p98; - typedef SmartPtr p99; - typedef SmartPtr p100; - typedef SmartPtr p101; - typedef SmartPtr p102; - typedef SmartPtr p103; -}; - -#endif diff --git a/tools/RegressionTest2/Test.cpp b/tools/RegressionTest2/Test.cpp deleted file mode 100644 index 71f3fc9..0000000 --- a/tools/RegressionTest2/Test.cpp +++ /dev/null @@ -1,32 +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 -/////////////////////////////////////////////////////////////////////////////// - -#ifdef __INTEL_COMPILER -# pragma warning(disable: 111 193 304 383 444 488 981 1418) -#endif - -#include "LokiTest.h" - -int main() -{ -LokiTest test; - -const int result=test.result(); - -#if __BORLANDC__ || __GNUC__ - while(true); // Stop console window from closing if run from IDE. -#endif - -return result; -} diff --git a/tools/RegressionTest2/TypeManipTest.h b/tools/RegressionTest2/TypeManipTest.h deleted file mode 100644 index 3ae16fd..0000000 --- a/tools/RegressionTest2/TypeManipTest.h +++ /dev/null @@ -1,119 +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 TYPEMANIPTEST_H -#define TYPEMANIPTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// TypeManipTest -/////////////////////////////////////////////////////////////////////////////// - -class TypeManipTest : public Test -{ -public: - TypeManipTest() : Test("TypeManip.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - bool r; - - r=Int2Type<1>::value==1; - - testAssert("Int2Type",r,result); - - r=SameType::OriginalType,char>::value; - - testAssert("Type2Type",r,result); - - r=SameType::Result,char>::value && - SameType::Result,int>::value; - - testAssert("Select",r,result); - - r=Conversion::exists && - Conversion::exists2Way && - !Conversion::sameType && - Conversion::exists && - Conversion::exists2Way && - Conversion::sameType && - Conversion::exists && - !Conversion::exists && - Conversion::exists && - Conversion::exists && - Conversion::exists && - Conversion::exists && - !Conversion::exists && - !Conversion::exists && - Conversion::exists && - Conversion::exists && - !Conversion::exists && - !Conversion::exists && - Conversion::exists && - !Conversion::exists; - - testAssert("Conversion",r,result); - - r=SuperSubclass::value && - SuperSubclass::value && - SuperSubclass::value && - !SuperSubclass::value && - !SuperSubclass::value && - !SuperSubclass::value; - - testAssert("SuperSubclass",r,result); - - r=SuperSubclassStrict::value && - SuperSubclassStrict::value && - !SuperSubclassStrict::value && - !SuperSubclassStrict::value && - !SuperSubclassStrict::value && - !SuperSubclassStrict::value; - - testAssert("SuperSubclassStrict",r,result); - - r=SUPERSUBCLASS(Base,Derived1) && - SUPERSUBCLASS(Base,Derived2) && - SUPERSUBCLASS(Base,Base) && - !SUPERSUBCLASS(Derived1,Base) && - !SUPERSUBCLASS(Derived2,Base) && - !SUPERSUBCLASS(void,Base); - - 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); - - testAssert("SUPERSUBCLASS_STRICT",r,result); - - std::cout << '\n'; - } - -private: - struct Base { char c; }; - struct Derived1 : Base { char c; }; - struct Derived2 : Derived1 { char c; }; -}; - -#endif diff --git a/tools/RegressionTest2/TypeTraitsTest.h b/tools/RegressionTest2/TypeTraitsTest.h deleted file mode 100644 index a78496f..0000000 --- a/tools/RegressionTest2/TypeTraitsTest.h +++ /dev/null @@ -1,116 +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 TYPETRAITSTEST_H -#define TYPETRAITSTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// TypeTraitsTest -/////////////////////////////////////////////////////////////////////////////// - -class TypeTraitsTest : public Test -{ -public: - TypeTraitsTest() : Test("TypeTraits.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - using namespace Loki; - - bool r; - - r=TypeTraits::isPointer && - !TypeTraits::isPointer && - SameType::PointeeType,int>::value && - SameType::PointeeType,NullType>::value && - - TypeTraits::isReference && - !TypeTraits::isReference && - SameType::ReferredType,int>::value && - SameType::ReferredType,int>::value && - - TypeTraits::isMemberPointer && - !TypeTraits::isMemberPointer && - - TypeTraits::isStdUnsignedInt && - !TypeTraits::isStdUnsignedInt && - - TypeTraits::isStdSignedInt && - !TypeTraits::isStdSignedInt && - - TypeTraits::isStdIntegral && - !TypeTraits::isStdIntegral && - - TypeTraits::isStdFloat && - !TypeTraits::isStdFloat && - - TypeTraits::isStdArith && - !TypeTraits::isStdArith && - - TypeTraits::isStdFundamental && - !TypeTraits::isStdFundamental && - - TypeTraits::isUnsignedInt && - !TypeTraits::isUnsignedInt && - - TypeTraits::isSignedInt && - !TypeTraits::isSignedInt && - - TypeTraits::isIntegral && - !TypeTraits::isIntegral && - - TypeTraits::isFloat && - !TypeTraits::isFloat && - - TypeTraits::isArith && - TypeTraits::isArith && - TypeTraits::isArith && - !TypeTraits::isArith && - - TypeTraits::isFundamental && - !TypeTraits::isFundamental && - -#ifndef __BORLANDC__ - - TypeTraits::isConst && - !TypeTraits::isConst && - SameType::NonConstType,int>::value && - SameType::NonConstType,int>::value && - - TypeTraits::isVolatile && - !TypeTraits::isVolatile && - SameType::NonVolatileType,int>::value && - SameType::NonVolatileType,int>::value && - - SameType::UnqualifiedType,int>::value && - -#endif - - SameType::ParameterType,char>::value && - SameType::ParameterType,int>::value && - SameType::ParameterType,double>::value && - SameType::ParameterType,Test &>::value; - - testAssert("TypeTraits",r,result); - - std::cout << '\n'; - } -}; - -#endif diff --git a/tools/RegressionTest2/TypelistTest.h b/tools/RegressionTest2/TypelistTest.h deleted file mode 100644 index e8c545f..0000000 --- a/tools/RegressionTest2/TypelistTest.h +++ /dev/null @@ -1,186 +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 TYPELISTTEST_H -#define TYPELISTTEST_H - -#include -#include "UnitTest.h" - -/////////////////////////////////////////////////////////////////////////////// -// TypelistTest -/////////////////////////////////////////////////////////////////////////////// - -class TypelistTest : public Test -{ -public: - TypelistTest() : Test("Typelist.h") {} - - virtual void execute(TestResult &result) - { - printName(result); - - 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; - - bool r; - - r=Length::value==0 && - Length::value==1 && - Length::value==3; - - testAssert("Length",r,result); - - r=SameType::Result,char>::value && - SameType::Result,double>::value; - - testAssert("TypeAt",r,result); - - #if !(_MSC_VER && !__INTEL_COMPILER && !__MWERKS__ && _MSC_VER < 1300) - - // TypeAtNonStrict works like TypeAt on MSVC 6.0 - - r=SameType::Result,NullType>::value && - SameType::Result,char>::value && - SameType::Result,double>::value && - SameType::Result,NullType>::value && - SameType::Result,long>::value; - - testAssert("TypeAtNonStrict",r,result); - - #else - - testAssert("TypeAtNonStrict",false,result,false); - - #endif - - r=IndexOf::value==-1 && - IndexOf::value==0 && - IndexOf::value==2 && - IndexOf::value==-1; - - testAssert("IndexOf",r,result); - - #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 - - r=SameType::Result,NullType>::value && - SameType::Result,TYPELIST_1(char)>::value && - SameType::Result,CharList>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_2(char,int)>::value && - SameType::Result,TYPELIST_4(char,char,int,double)>::value; - - testAssert("Append",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,NullType>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_2(char,double)>::value && - SameType::Result,TYPELIST_2(char,int)>::value; - - testAssert("Erase",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,NullType>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_2(char,double)>::value && - SameType::Result,TYPELIST_2(char,int)>::value && - SameType::Result,TYPELIST_2(int,double)>::value && - SameType::Result,TYPELIST_3(char,double,char)>::value && - SameType::Result,TYPELIST_3(char,int,char)>::value; - - testAssert("EraseAll",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,CharList>::value && - SameType::Result,CharIntDoubleList>::value && - SameType::Result,CharIntDoubleList>::value; - - testAssert("NoDuplicates",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,TYPELIST_1(long)>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_3(long,int,double)>::value && - SameType::Result,CharIntDoubleList>::value && - SameType::Result,TYPELIST_4(long,int,double,char)>::value; - - testAssert("Replace",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,TYPELIST_1(long)>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_3(long,int,double)>::value && - SameType::Result,CharIntDoubleList>::value && - SameType::Result,TYPELIST_4(long,int,double,long)>::value; - - testAssert("ReplaceAll",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,CharList>::value && - SameType::Result,TYPELIST_3(double,int,char)>::value; - - testAssert("Reverse",r,result); - - r=SameType::Result,Base>::value && - SameType::Result,Derived2>::value && - SameType::Result,Derived2>::value && - SameType::Result,Derived2>::value && - SameType::Result,Derived2>::value && - SameType::Result,Derived2>::value && - SameType::Result,Derived2>::value; - - testAssert("MostDerived",r,result); - - r=SameType::Result,NullType>::value && - SameType::Result,CharList>::value && - SameType::Result,CharIntDoubleList>::value && - SameType::Result,CharIntDoubleCharList>::value && - SameType::Result,Derived2Derived1BaseList>::value && - SameType::Result,Derived2Derived1BaseList>::value; - - testAssert("DerivedToFront",r,result); - - #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); - - #endif - - std::cout << '\n'; - } - -private: - struct Base { char c; }; - struct Derived1 : Base { char c; }; - struct Derived2 : Derived1 { char c; }; -}; - -#endif diff --git a/tools/RegressionTest2/UnitTest.h b/tools/RegressionTest2/UnitTest.h deleted file mode 100644 index c2eb303..0000000 --- a/tools/RegressionTest2/UnitTest.h +++ /dev/null @@ -1,208 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// Unit Test framework -// -// 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 UNITTEST_H -#define UNITTEST_H - -#include -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -// SameType -/////////////////////////////////////////////////////////////////////////////// - -#if _MSC_VER && !__INTEL_COMPILER && !__MWERKS__ - -// Rani Sharoni's SameType - -template -struct SameType -{ -private: - template - struct In - { enum { value = false }; }; - - template<> - struct In - { enum { value = true }; }; - -public: - enum { value = In::value }; -}; - -#else - -template -struct SameType -{ - static const bool value=false; -}; - -template -struct SameType -{ - static const bool value=true; -}; - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// TestResult -/////////////////////////////////////////////////////////////////////////////// - -class TestResult -{ -public: - TestResult() : pos(0),passed(0),failed(0),notSupported(0) {} - - int pos; - int passed; - int failed; - int notSupported; -}; - -/////////////////////////////////////////////////////////////////////////////// -// Test -/////////////////////////////////////////////////////////////////////////////// - -class Test -{ -public: - explicit Test(const std::string &n) : name(n) {} - - virtual void execute(TestResult &) =0; - -protected: - ~Test() {} - - 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; - - str+=std::string(offset-str.length(),' '); - - if(supported) - { - if(assertion) - { - std::cout << str << "Passed\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.notSupported; - } - } - - static std::string emptyStr() - { - return std::string(); - } - -public: - enum { offset=63 }; - -protected: - const std::string name; -}; - -/////////////////////////////////////////////////////////////////////////////// -// TestSuite -/////////////////////////////////////////////////////////////////////////////// - -class TestSuite : public Test -{ -private: - typedef std::vector TestList; - -public: - explicit TestSuite(const std::string &name =emptyStr()) : Test(name) {} - - void add(Test &test) - { - tests.push_back(&test); - } - - virtual void execute(TestResult &result) - { - printName(result); - - if(name.length()!=0) - result.pos+=2; - - for(TestList::iterator i=tests.begin();i!=tests.end();++i) - (*i)->execute(result); - - if(name.length()!=0) - result.pos-=2; - } - -private: - TestList tests; -}; - -/////////////////////////////////////////////////////////////////////////////// -// UnitTest -/////////////////////////////////////////////////////////////////////////////// - -class UnitTest -{ -public: - int run(const std::string &title,TestSuite &tests) const - { - std::cout << title << std::string(Test::offset-title.length(),' ') << "Result\n"; - std::cout << std::string(76,'-') << '\n'; - - TestResult testResult; - - tests.execute(testResult); - - std::cout << std::string(76,'-') << '\n'; - - 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(testResult.notSupported!=0) - std::cout << "Not Supported - " << testResult.notSupported << '/' << totalAll << ", " - << testResult.notSupported*100/totalAll << "%\n"; - - return testResult.failed; - } -}; - -#endif