King_DuckZ/Loki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

test program for lifetime policies FollowIntoDeath and DieOrder

Browse source 
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@339 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
syntheticpp 2005-11-01 11:15:22 +00:00
parent a7687a05a1
commit a17791f2c8
3 changed files with 450 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

8
test/Makefile
View file

@ -36,7 +36,8 @@ sub-SafeFormat: FORCE
sub-Singleton: FORCE sub-Singleton: FORCE
cd Singleton && \ cd Singleton && \
$(MAKE) -f $(MAKEFILE)-DeletableSingleton && \ $(MAKE) -f $(MAKEFILE)-DeletableSingleton && \
$(MAKE) -f $(MAKEFILE)-Phoenix $(MAKE) -f $(MAKEFILE)-Phoenix && \
$(MAKE) -f $(MAKEFILE)-Dependencies
@cd .. @cd ..
sub-SmallObj: FORCE sub-SmallObj: FORCE
@ -78,6 +79,11 @@ clean:
cd SmallObj && \ cd SmallObj && \
$(MAKE) -f $(MAKEFILE) clean $(MAKE) -f $(MAKEFILE) clean
@cd .. @cd ..
cd Singleton && \
$(MAKE) -f $(MAKEFILE)-DeletableSingleton clean&& \
$(MAKE) -f $(MAKEFILE)-Phoenix clean && \
$(MAKE) -f $(MAKEFILE)-Dependencies clean

411
test/Singleton/Dependencies.cpp Executable file
View file

@ -0,0 +1,411 @@
#include <iostream>
#include "loki/SmallObj.h"
#include "loki/Function.h"
using namespace Loki;
////////////////////////////////////////////////////////////////////////////////////
//
// How to use FollowIntoDeath with SmallObjects?
//
////////////////////////////////////////////////////////////////////////////////////
typedef Loki::SmallObject
<
LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL,
LOKI_DEFAULT_CHUNK_SIZE,
LOKI_MAX_SMALL_OBJECT_SIZE,
LOKI_DEFAULT_OBJECT_ALIGNMENT,
FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime
>
MySmallObjectBase;
struct MySmallObject : public MySmallObjectBase
{
};
typedef SingletonHolder
<
MySmallObject,
CreateUsingNew,
FollowIntoDeath::AfterMaster<MySmallObjectBase::ObjAllocatorSingleton>::IsDestroyed
>
Singleton_of_with_a_MySmallObject;
////////////////////////////////////////////////////////////////////////////////////
//
// How to use FollowIntoDeath with classes containing a Functor/Function?
//
////////////////////////////////////////////////////////////////////////////////////
struct MyFunctionObject
{
MyFunctionObject()
{
functor = Functor<void> (this, &MyFunctionObject::f);
function = Function< void()>(this, &MyFunctionObject::f);
}
void f(){}
Functor<void> functor;
Function<void()> function;
};
typedef SingletonHolder
<
MyFunctionObject,
CreateUsingNew,
FollowIntoDeath::AfterMaster<Function<>::Impl::ObjAllocatorSingleton
>::IsDestroyed
>
Singleton_MyFunctionObject1;
typedef SingletonHolder
<
MyFunctionObject,
CreateUsingNew,
FollowIntoDeath::AfterMaster<Functor<>::Impl::ObjAllocatorSingleton
>::IsDestroyed
>
Singleton_MyFunctionObject2;
////////////////////////////////////////////////////////////////////////////////////
//
// Data object for all singletons
//
////////////////////////////////////////////////////////////////////////////////////
template<template <class> class T, int Nr>
struct SingletonDataObject
{
SingletonDataObject() {std::cout<<"new SingletonDataObject"<<Nr<<"\n\n";}
~SingletonDataObject(){std::cout<<"delete SingletonDataObject"<<Nr<<"\n\n";}
int i[Nr];
};
////////////////////////////////////////////////////////////////////////////////////
//
// Test code for DieOrder Policy
//
////////////////////////////////////////////////////////////////////////////////////
template<template <class> class Lifetime>
struct Master_die_first
{
Master_die_first()
{
data = &Singleton::Instance();
}
virtual ~Master_die_first(){}
typedef Master_die_first<Lifetime> ThisType;
typedef SingletonDataObject<Lifetime,888> MasterSingleton;
typedef SingletonHolder<MasterSingleton,CreateUsingNew,Lifetime> Singleton;
MasterSingleton* data;
};
template<template <class> class Lifetime>
struct Master_die_last
{
Master_die_last()
{
data = &Singleton::Instance();
}
virtual ~Master_die_last(){}
typedef Master_die_last<Lifetime> ThisType;
typedef SingletonDataObject<Lifetime,555> MasterSingleton;
typedef SingletonHolder<MasterSingleton,CreateUsingNew,Lifetime> Singleton;
MasterSingleton* data;
};
typedef Master_die_first<DieOrder::First>
Master1_die_first;
typedef Master_die_last<DieOrder::Last>
Master1_die_last;
class B1_die_first;
class B1_die_last;
typedef SingletonHolder<B1_die_first,CreateUsingNew,
DieOrder::First
> Follower1_Singleton_B1_die_first;
typedef SingletonHolder<B1_die_last,CreateUsingNew,
DieOrder::Last
> Follower1_Singleton_B1_die_last;
class B1_die_first : public Master1_die_last
{
public:
B1_die_first(){std::cout<<"new B1_die_first, look for SingletonDataObject555\n\n";}
~B1_die_first(){std::cout<<"delete B1_die_first, look for SingletonDataObject555\n\n";}
};
class B1_die_last : public Master1_die_first
{
public:
B1_die_last(){std::cout<<"new B1_die_last, look for SingletonDataObject888\n\n";}
~B1_die_last(){std::cout<<"delete B1_die_last, look for SingletonDataObject888\n\n";}
};
////////////////////////////////////////////////////////////////////////////////////
//
// Test code for FollowIntoDeath policy
//
////////////////////////////////////////////////////////////////////////////////////
template<template <class> class Lifetime>
struct Master1
{
Master1()
{
data = &Singleton::Instance();
}
virtual ~Master1(){}
typedef Master1<Lifetime> ThisType;
typedef SingletonDataObject<Lifetime,1> MasterSingleton;
typedef SingletonHolder<MasterSingleton,CreateUsingNew,Lifetime> Singleton;
MasterSingleton* data;
};
typedef Master1<FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime>
Master1_DefaultLifetime;
typedef Master1<FollowIntoDeath::With<NoDestroy>::AsMasterLifetime>
Master1_NoDestroy;
typedef Master1<FollowIntoDeath::With<PhoenixSingleton>::AsMasterLifetime>
Master1_PhoenixSingleton;
typedef Master1<FollowIntoDeath::With<DeletableSingleton>::AsMasterLifetime>
Master1_DeletableSingleton;
class B1_DefaultLifetime : public Master1_DefaultLifetime
{
public:
B1_DefaultLifetime(){std::cout<<"new B1_DefaultLifetime\n";}
~B1_DefaultLifetime(){std::cout<<"delete B1_DefaultLifetime\n";}
};
class B1_NoDestroy : public Master1_NoDestroy
{
public:
B1_NoDestroy(){std::cout<<"new B1_NoDestroy. B1_NoDestroy must not be deleted\n";}
~B1_NoDestroy(){std::cout<<"delete B1_NoDestroy\n";};
};
class B1_PhoenixSingleton : public Master1_PhoenixSingleton
{
public:
B1_PhoenixSingleton(){std::cout<<"new B1_PhoenixSingleton\n";}
~B1_PhoenixSingleton(){std::cout<<"delete B1_PhoenixSingleton\n";}
};
class B1_DeletableSingleton : public Master1_DeletableSingleton
{
public:
B1_DeletableSingleton(){std::cout<<"new B1_DeletableSingleton\n";}
~B1_DeletableSingleton(){std::cout<<"delete B1_DeletableSingleton\n";}
};
typedef SingletonHolder<B1_DefaultLifetime,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master1_DefaultLifetime::MasterSingleton>::IsDestroyed
> Follower1_Singleton_DefaultLifetime;
typedef SingletonHolder<B1_NoDestroy,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master1_NoDestroy::MasterSingleton>::IsDestroyed
> Follower1_Singleton_NoDestroy;
typedef SingletonHolder<B1_PhoenixSingleton,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master1_PhoenixSingleton::MasterSingleton>::IsDestroyed
> Follower1_Singleton_PhoenixSingleton;
typedef SingletonHolder<B1_DeletableSingleton,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master1_DeletableSingleton::MasterSingleton>::IsDestroyed
> Follower1_Singleton_DeletableSingleton;
////////////////////////////////////////////////////////////////////////////////////
//
// Test code for FollowIntoDeath policy with reverse instantiation
//
////////////////////////////////////////////////////////////////////////////////////
template<template <class> class Lifetime>
struct Master2
{
Master2()
{
// don't create a MasterSingleton2 object!!
// to test the FollowIntoDeath policy
}
virtual ~Master2(){}
typedef Master2<Lifetime> ThisType;
typedef SingletonDataObject<Lifetime,2> MasterSingleton;
typedef SingletonHolder<MasterSingleton,CreateUsingNew,Lifetime> Singleton;
MasterSingleton* data;
};
typedef Master2<FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime>
Master2_DefaultLifetime;
typedef Master2<FollowIntoDeath::With<NoDestroy>::AsMasterLifetime>
Master2_NoDestroy;
typedef Master2<FollowIntoDeath::With<PhoenixSingleton>::AsMasterLifetime>
Master2_PhoenixSingleton;
typedef Master2<FollowIntoDeath::With<DeletableSingleton>::AsMasterLifetime>
Master2_DeletableSingleton;
class B2_DefaultLifetime : public Master2_DefaultLifetime
{
public:
B2_DefaultLifetime(){std::cout<<"new B2_DefaultLifetime\n";}
~B2_DefaultLifetime(){std::cout<<"delete B2_DefaultLifetime\n";}
};
class B2_NoDestroy : public Master2_NoDestroy
{
public:
B2_NoDestroy(){std::cout<<"new B2_NoDestroy. B2_NoDestroy must not be deleted\n";}
~B2_NoDestroy(){std::cout<<"delete B2_NoDestroy\n";};
};
class B2_PhoenixSingleton : public Master2_PhoenixSingleton
{
public:
B2_PhoenixSingleton(){std::cout<<"new B2_PhoenixSingleton\n";}
~B2_PhoenixSingleton(){std::cout<<"delete B2_PhoenixSingleton\n";}
};
class B2_DeletableSingleton : public Master2_DeletableSingleton
{
public:
B2_DeletableSingleton(){std::cout<<"new B2_DeletableSingleton\n";}
~B2_DeletableSingleton(){std::cout<<"delete B2_DeletableSingleton\n";}
};
typedef SingletonHolder<B2_DefaultLifetime,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master2_DefaultLifetime::MasterSingleton>::IsDestroyed
> Follower2_Singleton_DefaultLifetime;
typedef SingletonHolder<B2_NoDestroy,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master2_NoDestroy::MasterSingleton>::IsDestroyed
> Follower2_Singleton_NoDestroy;
typedef SingletonHolder<B2_PhoenixSingleton,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master2_PhoenixSingleton::MasterSingleton>::IsDestroyed
> Follower2_Singleton_PhoenixSingleton;
typedef SingletonHolder<B2_DeletableSingleton,CreateUsingNew,
FollowIntoDeath::AfterMaster<Master2_DeletableSingleton::MasterSingleton>::IsDestroyed
> Follower2_Singleton_DeletableSingleton;
////////////////////////////////////////////////////////////////////////////////////
//
// detect memory leaks on MSVC Ide
//
////////////////////////////////////////////////////////////////////////////////////
#ifdef _MSC_VER
#include <crtdbg.h>
#include <cassert>
void heap_debug()
{
int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
// Turn on leak-checking bit
tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
//tmpFlag |= _CRTDBG_CHECK_MasterLWMasterYS_DF;
// Turn off CRT block checking bit
tmpFlag &= ~_CRTDBG_CHECK_CRT_DF;
// Set flag to the new value
_CrtSetDbgFlag( tmpFlag );
}
#endif
////////////////////////////////////////////////////////////////////////////////////
//
// main
//
////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{
MyFunctionObject *f1 = &Singleton_MyFunctionObject1::Instance();
MyFunctionObject *f2 = &Singleton_MyFunctionObject2::Instance();
#ifdef _MSC_VER
heap_debug();
#endif
std::cout<<"\n";
B1_die_first *first= &Follower1_Singleton_B1_die_first::Instance();
B1_die_last *last = &Follower1_Singleton_B1_die_last::Instance();
std::cout << "\nMaster1:\n\n";
B1_DefaultLifetime *def = &Follower1_Singleton_DefaultLifetime::Instance();
B1_PhoenixSingleton *pho = &Follower1_Singleton_PhoenixSingleton::Instance();
B1_DeletableSingleton *del = &Follower1_Singleton_DeletableSingleton::Instance();
std::cout << "\n\nMaster2:\n\n";
B2_DefaultLifetime *def2 = &Follower2_Singleton_DefaultLifetime::Instance();
def2->data = &Master2_DefaultLifetime::Singleton::Instance();
B2_PhoenixSingleton *pho2 = &Follower2_Singleton_PhoenixSingleton::Instance();
pho2->data = &Master2_PhoenixSingleton::Singleton::Instance();
B2_DeletableSingleton *del2 = &Follower2_Singleton_DeletableSingleton::Instance();
del2->data = &Master2_DeletableSingleton::Singleton::Instance();
// memory leak when code is enabled
//#define ENMasterBLE_LEMasterK
#ifdef ENMasterBLE_LEMasterK
B1_NoDestroy *no = &Follower1_Singleton_NoDestroy::Instance();
B2_NoDestroy *no2 = &Follower2_Singleton_NoDestro0::Instance();
no2->data = &Master2_NoDestroy::Singleton::Instance();
#endif
std::cout << "\nnow leaving main \n";
std::cout << "________________________________\n\n";
return 0;
}

32
test/Singleton/Makefile-Dependencies Executable file
View file

@ -0,0 +1,32 @@
CPP = g++
CC = gcc
OBJ = Dependencies.o
LINKOBJ = Dependencies.o
CXXINCS = -I./../../include
LIBS = -L../../lib -lloki
CXXFLAGS = $(CXXINCS) -O2 -DNDEBUG
BIN = Dependencies-gcc.exe
RM = rm -f
CHK_DIR_EXISTS= if not exist
MKDIR = mkdir
.PHONY: all all-before all-after clean clean-custom
all: all-before $(BIN) all-after
clean: clean-custom
${RM} $(OBJ) $(BIN)
$(BIN): $(OBJ)
$(CPP) $(LINKOBJ) -o Dependencies-gcc.exe $(LIBS)
check_tmp:
@$(CHK_DIR_EXISTS) "" $(MKDIR) "tmp"
Factory.o: Factory.cpp
$(CPP) -c Dependencies.cpp -o Dependencies.o $(CXXFLAGS)