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

Back to revision 1109. Accidentally checked in more files than I intended.

Browse source 
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@1111 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
rich_sposato 2011-09-20 23:19:14 +00:00
parent 16094ffe39
commit ca6a94ac97
16 changed files with 344 additions and 450 deletions
Download patch file Download diff file Expand all files Collapse all files

50
test/LevelMutex/LevelMutex.cbp
View file

@ -6,24 +6,24 @@
<Option compiler="cygwin" />
<Build>
<Target title="Debug_GCC">
<Option output="obj/Debug_GCC/LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_GCC/" />
<Option output="obj\Debug_GCC\LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-W" />
<Add directory="../../include" />
<Add directory="../../include/loki" />
<Add option="-g" />
<Add directory="..\..\include" />
<Add directory="..\..\include\loki" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki_D.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="..\..\lib\GCC\Loki_D.a" />
<Add library="..\..\..\PThreads\lib\pthreadVC2.lib" />
</Linker>
</Target>
<Target title="Release_GCC">
<Option output="obj/Release_GCC/LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_GCC/" />
<Option output="obj\Release_GCC\LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
@ -31,33 +31,33 @@
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include" />
<Add directory="../../include/loki" />
<Add directory="..\..\include" />
<Add directory="..\..\include\loki" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="..\..\lib\GCC\Loki.a" />
<Add library="..\..\..\PThreads\lib\pthreadVC2.lib" />
</Linker>
</Target>
<Target title="Debug_Cygwin">
<Option output="obj/Debug_Cygwin/LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_Cygwin/" />
<Option output="obj\Debug_Cygwin\LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_Cygwin\" />
<Option type="1" />
<Option compiler="cygwin" />
<Compiler>
<Add option="-W" />
<Add option="-g" />
<Add directory="../../include" />
<Add directory="../../include/loki" />
<Add directory="..\..\include" />
<Add directory="..\..\include\loki" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki_D.a" />
<Add library="../../../PThreads/lib/pthreadVC2.lib" />
<Add library="..\..\lib\Cygwin\Loki_D.a" />
<Add library="..\..\..\PThreads\lib\pthreadVC2.lib" />
</Linker>
</Target>
<Target title="Release_Cygwin">
<Option output="obj/Release_Cygwin/LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_Cygwin/" />
<Option output="obj\Release_Cygwin\LevelMutex" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_Cygwin\" />
<Option type="1" />
<Option compiler="cygwin" />
<Compiler>
@ -65,12 +65,12 @@
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include" />
<Add directory="../../include/loki" />
<Add directory="..\..\include" />
<Add directory="..\..\include\loki" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki.a" />
<Add library="../../../PThreads/lib/pthreadVC2.lib" />
<Add library="..\..\lib\Cygwin\Loki.a" />
<Add library="..\..\..\PThreads\lib\pthreadVC2.lib" />
</Linker>
</Target>
</Build>

77
test/LevelMutex/MultiThreadTests.cpp
View file

@ -4,9 +4,9 @@
// Copyright (c) 2008, 2009 Richard Sposato
// The copyright on this file is protected under the terms of the MIT license.
//
// Permission to use, copy, modify, distribute and sell this software for any
// purpose is hereby granted without fee, provided that the above copyright
// notice appear in all copies and that both that copyright notice and this
// Permission to use, copy, modify, distribute and sell this software for any
// purpose is hereby granted without fee, provided that the above copyright
// notice appear in all copies and that both that copyright notice and this
// permission notice appear in supporting documentation.
//
// The author makes no representations about the suitability of this software
@ -22,7 +22,7 @@
#include "MultiThreadTests.hpp"
#include <assert.h>
//#include <process.h>
#include <process.h>
#include <stdlib.h>
#include <time.h>
@ -239,8 +239,6 @@ void * ValueUnsafeThread( void * p )
void MultiThreadSimpleTest( void )
{
cout << "Starting MultiThreadSimpleTest." << endl;
Thing::Init( 0 );
const unsigned int threadCount = 5;
ThreadPool pool( threadCount );
@ -264,8 +262,6 @@ void MultiThreadSimpleTest( void )
pool.JoinAll();
Thing::Destroy();
cout << "Finished MultiThreadSimpleTest." << endl;
}
// ----------------------------------------------------------------------------
@ -303,17 +299,13 @@ void * TryLockThread( void * p )
void MultiThreadTryLockTest( void )
{
cout << "Starting MultiThreadTryLockTest." << endl;
static const unsigned int threadCount = 3;
Thing::Init( 0 );
volatile Thing & thing = Thing::GetIt();
volatile SleepMutex & mutex = thing.GetMutex();
cout << endl << "Doing multi-threaded TryLock test. This test should not deadlock." << endl;
cout << "Press enter key to continue." << endl;
char theKey = 0;
cin.get( theKey );
::system( "pause" );
// First step is to lock the mutex in the main thread so no child thread
// can ever lock it, change the value, or anything like that.
MutexErrors::Type result = mutex.Lock();
@ -321,46 +313,36 @@ void MultiThreadTryLockTest( void )
bool okay = mutex.IsLockedByCurrentThread();
assert( okay );
thing.SetValue( threadCount );
ThreadPool pool( threadCount );
for ( unsigned int ii = 0; ii < threadCount; ++ii )
{
ThreadPool pool( threadCount );
for ( unsigned int ii = 0; ii < threadCount; ++ii )
{
void * p = reinterpret_cast< void * >( ii );
pool.Start( TryLockThread, p );
}
pool.JoinAll();
void * p = reinterpret_cast< void * >( ii );
pool.Start( TryLockThread, p );
}
const unsigned int value = thing.GetValue();
assert( value == threadCount );
result = mutex.Unlock();
assert( MutexErrors::Success == result );
okay = !mutex.IsLockedByCurrentThread();
assert( okay );
okay = !mutex.IsLocked();
assert( okay );
pool.JoinAll();
const unsigned int value = thing.GetValue();
assert( value == threadCount );
result = mutex.Unlock();
assert( MutexErrors::Success == result );
okay = !mutex.IsLockedByCurrentThread();
assert( okay );
okay = !mutex.IsLocked();
assert( okay );
Thing::Destroy();
cout << "Finished MultiThreadTryLockTest." << endl;
}
// ----------------------------------------------------------------------------
void MultiThreadReentrantTest( void )
{
cout << "Starting MultiThreadReentrantTest." << endl;
Thing::Init( 0 );
const unsigned int threadCount = 8;
TestResults::Create( threadCount );
ThreadPool pool( threadCount );
cout << endl << "Doing thread-safe value test. This test should pass and not deadlock." << endl;
cout << "Press enter key to continue." << endl;
char theKey = 0;
cin.get( theKey );
::system( "pause" );
for ( unsigned int ii = 0; ii < threadCount; ++ii )
{
void * p = reinterpret_cast< void * >( ii );
@ -370,8 +352,7 @@ void MultiThreadReentrantTest( void )
TestResults::GetIt()->OutputResults();
cout << endl << "Doing thread-unsafe value test. This test may fail." << endl;
cout << "Press enter key to continue." << endl;
cin.get( theKey );
::system( "pause" );
for ( unsigned int ii = 0; ii < threadCount; ++ii )
{
void * p = reinterpret_cast< void * >( ii );
@ -382,8 +363,6 @@ void MultiThreadReentrantTest( void )
TestResults::Destroy();
Thing::Destroy();
cout << "Finished MultiThreadReentrantTest." << endl;
}
// ----------------------------------------------------------------------------
@ -667,8 +646,6 @@ void * MultiLockUnsafeThread( void * p )
void MultiThreadMultiLockTest( void )
{
cout << "Starting MultiThreadMultiLockTest." << endl;
Thing::MakePool( thingCount );
const unsigned int threadCount = 8;
TestResults::Create( threadCount );
@ -697,8 +674,6 @@ void MultiThreadMultiLockTest( void )
TestResults::Destroy();
Thing::DestroyPool();
cout << "Finished MultiThreadMultiLockTest." << endl;
}
// ----------------------------------------------------------------------------
@ -833,8 +808,6 @@ void * MultiLockRandomUnsafeThread( void * p )
void MultiThreadRandomMultiLockTest( void )
{
cout << "Starting MultiThreadRandomMultiLockTest." << endl;
Thing::MakePool( thingCount );
const unsigned int threadCount = 8;
TestResults::Create( threadCount );
@ -863,8 +836,6 @@ void MultiThreadRandomMultiLockTest( void )
TestResults::Destroy();
Thing::DestroyPool();
cout << "Finished MultiThreadRandomMultiLockTest." << endl;
}
// ----------------------------------------------------------------------------
@ -965,8 +936,6 @@ void * UnsafeHierarchyTest( void * p )
void MultiThreadHierarchySingleLockTest( void )
{
cout << "Starting MultiThreadHierarchySingleLockTest." << endl;
LevelThing::MakePool( thingCount );
const unsigned int threadCount = 8;
TestResults::Create( threadCount );
@ -995,8 +964,6 @@ void MultiThreadHierarchySingleLockTest( void )
TestResults::Destroy();
LevelThing::DestroyPool();
cout << "Finished MultiThreadHierarchySingleLockTest." << endl;
}
// ----------------------------------------------------------------------------
@ -1098,8 +1065,6 @@ void * UnsafeHierarchyMultiLockTest( void * p )
void MultiThreadHierarchyMultiLockTest( void )
{
cout << "Starting MultiThreadHierarchyMultiLockTest." << endl;
MultiLevelPool::MakePool( 10, thingCount );
const unsigned int threadCount = 8;
TestResults::Create( threadCount );
@ -1128,8 +1093,6 @@ void MultiThreadHierarchyMultiLockTest( void )
TestResults::Destroy();
MultiLevelPool::DestroyPool();
cout << "Finished MultiThreadHierarchyMultiLockTest." << endl;
}
// ----------------------------------------------------------------------------

6
test/LevelMutex/ThreadPool.cpp
View file

@ -20,7 +20,7 @@
#include <assert.h>
//#include <process.h>
#include <process.h>
#if !defined( _MSC_VER )
#include <unistd.h> // needed for the usleep function.
#endif
@ -86,13 +86,11 @@ Thread::~Thread( void )
bool Thread::WaitForThread( void ) volatile
{
assert( IsValid( m_owner ) );
const volatile Thread * current = Thread::GetCurrentThread();
if ( this == current )
return false;
if ( m_status == Thread::Dead )
return false;
while ( this->m_status == Thread::Active )
{
// Call the wait policy.
@ -102,8 +100,6 @@ bool Thread::WaitForThread( void ) volatile
::usleep( 1000 );
#endif
}
m_status = Thread::Idle;
return true;
}

17
test/LevelMutex/main.cpp
View file

@ -48,8 +48,6 @@ typedef ::Loki::LevelMutex< ::Loki::SpinLevelMutex, 1,
void SingleThreadSimpleTest( void )
{
cout << "Starting SingleThreadSimpleTest." << endl;
const unsigned int priorLevel = GetCurrentThreadsLevel();
const unsigned int priorLockCount = CountLocksInCurrentThread();
const unsigned int priorMutexCount = CountMutexesInCurrentThread();
@ -173,8 +171,6 @@ void SingleThreadSimpleTest( void )
assert( okay );
okay = ( CountMutexesAtCurrentLevel() == priorLevelMutexCount );
assert( okay );
cout << "Finished SingleThreadSimpleTest." << endl;
}
// ----------------------------------------------------------------------------
@ -182,8 +178,6 @@ void SingleThreadSimpleTest( void )
void SingleThreadReentrantTest( void )
{
cout << "Starting SingleThreadReentrantTest." << endl;
const unsigned int priorLevel = GetCurrentThreadsLevel();
const unsigned int priorLockCount = CountLocksInCurrentThread();
const unsigned int priorMutexCount = CountMutexesInCurrentThread();
@ -289,8 +283,6 @@ void SingleThreadReentrantTest( void )
assert( okay );
okay = ( CountMutexesAtCurrentLevel() == priorLevelMutexCount );
assert( okay );
cout << "Finished SingleThreadReentrantTest." << endl;
}
// ----------------------------------------------------------------------------
@ -298,8 +290,6 @@ void SingleThreadReentrantTest( void )
void SingleThreadSimpleMultiLockTest( void )
{
cout << "Starting SingleThreadSimpleMultiLockTest." << endl;
const unsigned int priorLevel = GetCurrentThreadsLevel();
const unsigned int priorLockCount = CountLocksInCurrentThread();
const unsigned int priorMutexCount = CountMutexesInCurrentThread();
@ -491,8 +481,6 @@ void SingleThreadSimpleMultiLockTest( void )
assert( okay );
okay = ( CountMutexesAtCurrentLevel() == priorLevelMutexCount );
assert( okay );
cout << "Finished SingleThreadSimpleMultiLockTest." << endl;
}
// ----------------------------------------------------------------------------
@ -500,8 +488,6 @@ void SingleThreadSimpleMultiLockTest( void )
void SingleThreadExceptionTest( void )
{
cout << "Starting SingleThreadExceptionTest." << endl;
const unsigned int priorLevel = GetCurrentThreadsLevel();
const unsigned int priorLockCount = CountLocksInCurrentThread();
const unsigned int priorMutexCount = CountMutexesInCurrentThread();
@ -650,8 +636,6 @@ void SingleThreadExceptionTest( void )
assert( okay );
okay = ( CountMutexesAtCurrentLevel() == priorLevelMutexCount );
assert( okay );
cout << "Finished SingleThreadExceptionTest." << endl;
}
// ----------------------------------------------------------------------------
@ -676,7 +660,6 @@ int main( int argc, const char * const argv[] )
MultiThreadSimpleTest();
MultiThreadTryLockTest();
cout << "main 679" << endl;
MultiThreadReentrantTest();
MultiThreadMultiLockTest();
MultiThreadRandomMultiLockTest();

50
test/LockingPtr/LockingPtr.cbp
View file

@ -3,27 +3,26 @@
<FileVersion major="1" minor="6" />
<Project>
<Option title="LockingPtr" />
<Option compiler="gcc" />
<Option compiler="cygwin" />
<Build>
<Target title="Debug_GCC">
<Option output="obj/Debug_GCC/LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_GCC/" />
<Option output="obj\Debug_GCC\LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add option="-g" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki_D.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="..\..\lib\GCC\Loki_D.a" />
</Linker>
</Target>
<Target title="Release_GCC">
<Option output="obj/Release_GCC/LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_GCC/" />
<Option output="obj\Release_GCC\LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
@ -31,44 +30,43 @@
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="..\..\lib\GCC\Loki.a" />
</Linker>
</Target>
<Target title="Debug_Cygwin">
<Option output="obj/Debug_Cygwin/LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_Cygwin/" />
<Option output="obj\Debug_Cygwin\LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_Cygwin\" />
<Option type="1" />
<Option compiler="gcc" />
<Option compiler="cygwin" />
<Compiler>
<Add option="-W" />
<Add option="-g" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki_D.a" />
<Add library="..\..\lib\Cygwin\Loki_D.a" />
</Linker>
</Target>
<Target title="Release_Cygwin">
<Option output="obj/Release_Cygwin/LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_Cygwin/" />
<Option output="obj\Release_Cygwin\LockingPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_Cygwin\" />
<Option type="1" />
<Option compiler="gcc" />
<Option compiler="cygwin" />
<Compiler>
<Add option="-fexpensive-optimizations" />
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki.a" />
<Add library="..\..\lib\Cygwin\Loki.a" />
</Linker>
</Target>
</Build>

47
test/SmartPtr/SmartPtr.cbp
View file

@ -6,25 +6,23 @@
<Option compiler="gcc" />
<Build>
<Target title="Debug_GCC">
<Option output="bin/Debug_GCC/SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_GCC/" />
<Option output="bin\Debug_GCC\SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add option="-g" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki_D.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="/usr/lib/libc.so" />
<Add library="..\..\lib\GCC\Loki_D.a" />
</Linker>
</Target>
<Target title="Release_GCC">
<Option output="bin/Release_GCC/SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_GCC/" />
<Option output="bin\Release_GCC\SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
@ -32,33 +30,31 @@
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/GCC/Loki.a" />
<Add library="/usr/lib/libpthread.so" />
<Add library="/usr/lib/libc.so" />
<Add library="..\..\lib\GCC\Loki.a" />
</Linker>
</Target>
<Target title="Debug_Cygwin">
<Option output="bin/Debug_Cygwin/SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_Cygwin/" />
<Option output="bin\Debug_Cygwin\SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_Cygwin\" />
<Option type="1" />
<Option compiler="cygwin" />
<Compiler>
<Add option="-W" />
<Add option="-g" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki_D.a" />
<Add library="..\..\lib\Cygwin\Loki_D.a" />
</Linker>
</Target>
<Target title="Release_Cygwin">
<Option output="bin/Release_Cygwin/SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_Cygwin/" />
<Option output="bin\Release_Cygwin\SmartPtr" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_Cygwin\" />
<Option type="1" />
<Option compiler="cygwin" />
<Compiler>
@ -66,11 +62,11 @@
<Add option="-Os" />
<Add option="-O3" />
<Add option="-W" />
<Add directory="../../include/loki" />
<Add directory="../../include" />
<Add directory="..\..\include\loki" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="../../lib/Cygwin/Loki.a" />
<Add library="..\..\lib\Cygwin\Loki.a" />
</Linker>
</Target>
</Build>
@ -78,7 +74,6 @@
<Unit filename="base.h">
<Option target="&lt;{~None~}&gt;" />
</Unit>
<Unit filename="colvin_gibbons_trick.cpp" />
<Unit filename="main.cpp" />
<Unit filename="strong.cpp" />
<Extensions>

43
test/SmartPtr/base.h
View file

@ -73,10 +73,9 @@ public:
return s_destructions;
}
protected:
BaseClass( const BaseClass & that ) : m_refCount( that.m_refCount ) {}
private:
/// Not implemented.
BaseClass( const BaseClass & );
/// Not implemented.
BaseClass & operator = ( const BaseClass & );
@ -111,44 +110,6 @@ public:
}
};
// ----------------------------------------------------------------------------
/** @class Feline - The feline family of classes are to test dynamic_cast. Also used to test
pointers to arrays of objects.
*/
class Feline : public BaseClass
{
public:
virtual ~Feline() {}
virtual Feline * Clone( void ) const = 0;
};
class Lion : public Feline
{
public:
virtual ~Lion() {}
virtual Lion * Clone( void ) const { return new Lion( *this ); }
};
class Tiger : public Feline
{
public:
Tiger( void ) : m_stripes( 100 ) {}
virtual ~Tiger() {}
virtual Tiger * Clone( void ) const { return new Tiger( *this ); }
unsigned int GetStripes( void ) const { return m_stripes; }
void SetStripes( unsigned int s ) { m_stripes = s; }
private:
unsigned int m_stripes;
};
class Dog
{
public:
virtual ~Dog() {}
virtual Dog * Clone( void ) const { return new Dog( *this ); }
};
// ----------------------------------------------------------------------------

231
test/SmartPtr/main.cpp
View file

@ -1205,6 +1205,75 @@ void DoForwardReferenceTest( void )
// ----------------------------------------------------------------------------
namespace
{
class Feline
{
public:
static inline bool AllDestroyed( void )
{
return ( s_constructions == s_destructions );
}
static inline bool ExtraConstructions( void )
{
return ( s_constructions > s_destructions );
}
static inline bool ExtraDestructions( void )
{
return ( s_constructions < s_destructions );
}
static inline unsigned int GetCtorCount( void )
{
return s_constructions;
}
static inline unsigned int GetDtorCount( void )
{
return s_destructions;
}
Feline( void ) { s_constructions++; }
virtual ~Feline() { s_destructions++; }
virtual Feline * Clone( void ) const = 0;
private:
static unsigned int s_constructions;
static unsigned int s_destructions;
};
unsigned int Feline::s_constructions = 0;
unsigned int Feline::s_destructions = 0;
class Tiger : public Feline
{
public:
virtual ~Tiger() {}
virtual Tiger * Clone( void ) const { return new Tiger( *this ); }
};
class Lion : public Feline
{
public:
virtual ~Lion() {}
virtual Lion * Clone( void ) const { return new Lion( *this ); }
};
class Dog
{
public:
virtual ~Dog() {}
virtual Dog * Clone( void ) const { return new Dog( *this ); }
};
}
// ----------------------------------------------------------------------------
void DoSmartPtrDynamicCastTests( void )
{
cout << "Starting DoSmartPtrDynamicCastTests." << endl;
@ -1290,9 +1359,9 @@ void DoSmartPtrDynamicCastTests( void )
assert( !pDog );
}
assert( BaseClass::AllDestroyed() );
assert( !BaseClass::ExtraConstructions() );
assert( !BaseClass::ExtraDestructions() );
assert( Feline::AllDestroyed() );
assert( !Feline::ExtraConstructions() );
assert( !Feline::ExtraDestructions() );
cout << "Finished DoSmartPtrDynamicCastTests." << endl;
}
@ -1449,161 +1518,6 @@ void DoDestructiveCopyTest( void )
// ----------------------------------------------------------------------------
/// Use these typedefs to test DeleteArray policy.
typedef Loki::SmartPtr< Tiger, RefCounted, DisallowConversion,
AssertCheck, ArrayStorage, DontPropagateConst >
TigerArray_RefCounted_ptr;
typedef Loki::SmartPtr< Tiger, RefLinked, DisallowConversion,
AssertCheck, ArrayStorage, DontPropagateConst >
TigerArray_2RefLinks_ptr;
// ----------------------------------------------------------------------------
void DoSmartArrayTests( void )
{
cout << "Starting DoSmartArrayTests." << endl;
{
// test default construction.
TigerArray_RefCounted_ptr sp1;
assert( !sp1 );
assert( 0 == sp1.GetArrayCount() );
// test assignment.
sp1.Assign( new Tiger[ 8 ], 8 );
assert( sp1 );
assert( 8 == sp1.GetArrayCount() );
sp1[ 0 ].SetStripes( 8 );
sp1[ 1 ].SetStripes( 16 );
sp1[ 2 ].SetStripes( 24 );
sp1[ 3 ].SetStripes( 32 );
sp1[ 4 ].SetStripes( 40);
sp1[ 5 ].SetStripes( 48 );
sp1[ 6 ].SetStripes( 56 );
sp1[ 7 ].SetStripes( 64 );
// test initialization construction.
TigerArray_RefCounted_ptr sp2( new Tiger[ 4 ], 4 );
assert( sp2 );
assert( 4 == sp2.GetArrayCount() );
sp2[ 0 ].SetStripes( 5 );
sp2[ 1 ].SetStripes( 10 );
sp2[ 2 ].SetStripes( 15 );
sp2[ 3 ].SetStripes( 20 );
// test range checking.
try
{
Tiger & p4 = sp2[ 4 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
// test range checking.
try
{
Tiger & p8 = sp1[ 8 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
// test swap.
sp2.Swap( sp1 );
assert( sp1 );
assert( sp2 );
// test checking of item count.
assert( 4 == sp1.GetArrayCount() );
assert( 8 == sp2.GetArrayCount() );
// test that operator[] returns reference to
assert( 5 == sp1[ 0 ].GetStripes() );
assert( 10 == sp1[ 1 ].GetStripes() );
assert( 15 == sp1[ 2 ].GetStripes() );
assert( 20 == sp1[ 3 ].GetStripes() );
assert( 8 == sp2[ 0 ].GetStripes() );
assert( 16 == sp2[ 1 ].GetStripes() );
assert( 24 == sp2[ 2 ].GetStripes() );
assert( 32 == sp2[ 3 ].GetStripes() );
assert( 40 == sp2[ 4 ].GetStripes() );
assert( 48 == sp2[ 5 ].GetStripes() );
assert( 56 == sp2[ 6 ].GetStripes() );
assert( 64 == sp2[ 7 ].GetStripes() );
try
{
Tiger & p4 = sp1[ 4 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
try
{
Tiger & p8 = sp2[ 8 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
const TigerArray_RefCounted_ptr sp3( sp1 );
assert( sp3 == sp1 );
assert( sp3.GetArrayCount() == sp1.GetArrayCount() );
try
{
const Tiger & p4 = sp3[ 4 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
const TigerArray_RefCounted_ptr sp5( sp2 );
assert( sp5 == sp2 );
assert( sp5.GetArrayCount() == sp2.GetArrayCount() );
try
{
const Tiger & p8 = sp5[ 8 ];
assert( false );
}
catch ( const ::std::out_of_range & ex )
{
assert( true );
}
sp2 = sp1;
assert( sp1 == sp2 );
assert( sp3 == sp2 );
assert( sp2.GetArrayCount() == sp1.GetArrayCount() );
assert( sp2.GetArrayCount() == sp1.GetArrayCount() );
assert( sp1 != sp5 );
assert( sp2 != sp5 );
assert( sp3 != sp5 );
assert( sp1.GetArrayCount() != sp5.GetArrayCount() );
assert( sp2.GetArrayCount() != sp5.GetArrayCount() );
assert( sp3.GetArrayCount() != sp5.GetArrayCount() );
}
assert( BaseClass::AllDestroyed() );
assert( !BaseClass::ExtraConstructions() );
assert( !BaseClass::ExtraDestructions() );
cout << "Finished DoSmartArrayTests." << endl;
}
// ----------------------------------------------------------------------------
int main( int argc, const char * argv[] )
{
bool doThreadTest = false;
@ -1642,7 +1556,6 @@ int main( int argc, const char * argv[] )
DoSmartPtrDynamicCastTests();
DoStrongPtrDynamicCastTests();
DoStrongArrayTests();
DoSmartArrayTests();
#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
if ( doThreadTest )

36
test/SmartPtr/strong.cpp
View file

@ -1778,6 +1778,42 @@ void DoStrongCompareTests( void )
// ----------------------------------------------------------------------------
namespace
{
class Feline : public BaseClass
{
public:
virtual ~Feline() {}
};
class Lion : public Feline
{
public:
virtual ~Lion() {}
};
class Tiger : public Feline
{
public:
Tiger( void ) : m_stripes( 100 ) {}
virtual ~Tiger() {}
unsigned int GetStripes( void ) const { return m_stripes; }
void SetStripes( unsigned int s ) { m_stripes = s; }
private:
unsigned int m_stripes;
};
class Dog
{
public:
virtual ~Dog() {}
};
}
// ----------------------------------------------------------------------------
void DoStrongPtrDynamicCastTests( void )
{
typedef ::Loki::StrongPtr< Feline, true, ::Loki::TwoRefCounts > FelineCountPtr;

22
test/ThreadLocal/ThreadLocal.cbp
View file

@ -7,37 +7,28 @@
<Option compiler="gcc" />
<Build>
<Target title="Debug_GCC">
<Option output="obj/Debug_GCC/ThreadLocal" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug_GCC/" />
<Option output="obj\Debug_GCC\ThreadLocal" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Debug_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-Wmain" />
<Add option="-pedantic" />
<Add option="-g" />
<Add option="-W" />
<Add directory="../../include" />
<Add option="-g" />
<Add directory="..\..\include" />
</Compiler>
<Linker>
<Add library="/usr/lib/libpthread.so" />
<Add library="/usr/lib/libc.so" />
</Linker>
</Target>
<Target title="Release_GCC">
<Option output="obj/Release_GCC/ThreadLocal" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release_GCC/" />
<Option output="obj\Release_GCC\ThreadLocal" prefix_auto="1" extension_auto="1" />
<Option object_output="obj\Release_GCC\" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
<Add option="-Wmain" />
<Add option="-pedantic" />
<Add option="-W" />
<Add directory="../../include" />
</Compiler>
<Linker>
<Add option="-s" />
<Add library="/usr/lib/libpthread.so" />
</Linker>
</Target>
</Build>
@ -50,7 +41,6 @@
<code_completion />
<debugger />
<lib_finder disable_auto="1" />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>

33
test/ThreadLocal/main.cpp
View file

@ -26,7 +26,18 @@
#include <sstream>
#include <iostream>
#include <stdlib.h>
using namespace ::std;
#if !defined( NULL )
#define NULL 0
#endif
// define nullptr even though new compilers will have this keyword just so we
// have a consistent and easy way of identifying which uses of 0 mean null.
#if !defined( nullptr )
#define nullptr NULL
#endif
#if defined(_WIN32)
@ -45,8 +56,6 @@
#else
#include <pthread.h>
#define LOKI_pthread_t \
pthread_t
#define LOKI_pthread_create(handle,attr,func,arg) \
@ -56,19 +65,6 @@
#endif
using namespace ::std;
#if !defined( NULL )
#define NULL 0
#endif
// define nullptr even though new compilers will have this keyword just so we
// have a consistent and easy way of identifying which uses of 0 mean null.
#if !defined( nullptr )
#define nullptr NULL
#endif
// ----------------------------------------------------------------------------
class Thread
@ -368,10 +364,7 @@ bool TestThreadLocalClassStaticValue( void )
// ----------------------------------------------------------------------------
int main( int argc, const char * const argv[] )
{
(void)argc;
(void)argv;
{
bool okay = true;
cout << "Starting ThreadLocal tests." << endl;
cout << "If any tests fail, or any assertions fail," << endl