mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
New unit_test framework:
* Header-only! * No external dependencies or other beast modules * Compilation options allow for: - Stand-alone application to run a single test suite - Stand-alone application to run a set of test suites - Global suite of tests inline with the host application - Disable test suite generation completely * Existing tests reworked to use the new classes
This commit is contained in:
Vinnie Falco
@@ -1,133 +0,0 @@
|
||||
//------------------------------------------------------------------------------
|
||||
/*
|
||||
This file is part of Beast: https://github.com/vinniefalco/Beast
|
||||
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
|
||||
|
||||
Portions of this file are from JUCE.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
Please visit http://www.juce.com
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
//==============================================================================
|
||||
|
||||
#include "../../../modules/beast_core/beast_core.h" // for UnitTest
|
||||
|
||||
namespace beast {
|
||||
|
||||
class AtomicTests : public UnitTest
|
||||
{
|
||||
public:
|
||||
AtomicTests() : UnitTest ("Atomic", "beast") {}
|
||||
|
||||
template <typename Type>
|
||||
void testFloat ()
|
||||
{
|
||||
Atomic<Type> a, b;
|
||||
a = (Type) 21;
|
||||
memoryBarrier();
|
||||
|
||||
/* These are some simple test cases to check the atomics - let me know
|
||||
if any of these assertions fail on your system!
|
||||
*/
|
||||
expect (a.get() == (Type) 21);
|
||||
expect (a.compareAndSetValue ((Type) 100, (Type) 50) == (Type) 21);
|
||||
expect (a.get() == (Type) 21);
|
||||
expect (a.compareAndSetValue ((Type) 101, a.get()) == (Type) 21);
|
||||
expect (a.get() == (Type) 101);
|
||||
expect (! a.compareAndSetBool ((Type) 300, (Type) 200));
|
||||
expect (a.get() == (Type) 101);
|
||||
expect (a.compareAndSetBool ((Type) 200, a.get()));
|
||||
expect (a.get() == (Type) 200);
|
||||
|
||||
expect (a.exchange ((Type) 300) == (Type) 200);
|
||||
expect (a.get() == (Type) 300);
|
||||
|
||||
b = a;
|
||||
expect (b.get() == a.get());
|
||||
}
|
||||
|
||||
template <typename Type>
|
||||
void testInteger ()
|
||||
{
|
||||
Atomic<Type> a, b;
|
||||
a.set ((Type) 10);
|
||||
expect (a.value == (Type) 10);
|
||||
expect (a.get() == (Type) 10);
|
||||
a += (Type) 15;
|
||||
expect (a.get() == (Type) 25);
|
||||
memoryBarrier();
|
||||
a -= (Type) 5;
|
||||
expect (a.get() == (Type) 20);
|
||||
expect (++a == (Type) 21);
|
||||
++a;
|
||||
expect (--a == (Type) 21);
|
||||
expect (a.get() == (Type) 21);
|
||||
memoryBarrier();
|
||||
|
||||
testFloat <Type> ();
|
||||
}
|
||||
|
||||
void runTest()
|
||||
{
|
||||
beginTestCase ("Misc");
|
||||
|
||||
char a1[7];
|
||||
expect (numElementsInArray(a1) == 7);
|
||||
int a2[3];
|
||||
expect (numElementsInArray(a2) == 3);
|
||||
|
||||
expect (ByteOrder::swap ((uint16) 0x1122) == 0x2211);
|
||||
expect (ByteOrder::swap ((uint32) 0x11223344) == 0x44332211);
|
||||
expect (ByteOrder::swap ((uint64) literal64bit (0x1122334455667788)) == literal64bit (0x8877665544332211));
|
||||
|
||||
beginTestCase ("int");
|
||||
testInteger <int> ();
|
||||
|
||||
beginTestCase ("unsigned int");
|
||||
testInteger <unsigned int> ();
|
||||
|
||||
beginTestCase ("int32");
|
||||
testInteger <int32> ();
|
||||
|
||||
beginTestCase ("uint32");
|
||||
testInteger <uint32> ();
|
||||
|
||||
beginTestCase ("long");
|
||||
testInteger <long> ();
|
||||
|
||||
beginTestCase ("void*");
|
||||
testInteger <void*> ();
|
||||
|
||||
beginTestCase ("int*");
|
||||
testInteger <int*> ();
|
||||
|
||||
beginTestCase ("float");
|
||||
testFloat <float> ();
|
||||
|
||||
#if ! BEAST_64BIT_ATOMICS_UNAVAILABLE // 64-bit intrinsics aren't available on some old platforms
|
||||
beginTestCase ("int64");
|
||||
testInteger <int64> ();
|
||||
|
||||
beginTestCase ("uint64");
|
||||
testInteger <uint64> ();
|
||||
|
||||
beginTestCase ("double");
|
||||
testFloat <double> ();
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
static AtomicTests atomicTests;
|
||||
|
||||
}
|
||||
@@ -19,8 +19,6 @@
|
||||
|
||||
#include "../ServiceQueue.h"
|
||||
|
||||
#include "../../../modules/beast_core/beast_core.h" // for UnitTest
|
||||
|
||||
namespace beast {
|
||||
|
||||
class ServiceQueueBase::ScopedServiceThread : public List <ScopedServiceThread>::Node
|
||||
@@ -185,275 +183,4 @@ bool ServiceQueueBase::empty()
|
||||
//
|
||||
ThreadLocalValue <ServiceQueueBase*> ServiceQueueBase::s_service;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
namespace detail {
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class ServiceQueueTimingTests
|
||||
: public UnitTest
|
||||
{
|
||||
public:
|
||||
class Stopwatch
|
||||
{
|
||||
public:
|
||||
Stopwatch () { start(); }
|
||||
void start () { m_startTime = Time::getHighResolutionTicks (); }
|
||||
double getElapsed ()
|
||||
{
|
||||
int64 const now = Time::getHighResolutionTicks();
|
||||
return Time::highResolutionTicksToSeconds (now - m_startTime);
|
||||
}
|
||||
private:
|
||||
int64 m_startTime;
|
||||
};
|
||||
|
||||
static int const callsPerThread = 50000;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
template <typename ServiceType>
|
||||
struct Consumer : Thread
|
||||
{
|
||||
ServiceType& m_service;
|
||||
Random m_random;
|
||||
String m_string;
|
||||
|
||||
Consumer (int id, int64 seedValue, ServiceType& service)
|
||||
: Thread ("C#" + String::fromNumber (id))
|
||||
, m_service (service)
|
||||
, m_random (seedValue)
|
||||
{ startThread(); }
|
||||
|
||||
~Consumer ()
|
||||
{ stopThread(); }
|
||||
|
||||
static Consumer*& thread()
|
||||
{
|
||||
static ThreadLocalValue <Consumer*> local;
|
||||
return local.get();
|
||||
}
|
||||
|
||||
static void stop_one ()
|
||||
{ thread()->signalThreadShouldExit(); }
|
||||
|
||||
static void handler ()
|
||||
{ thread()->do_handler(); }
|
||||
|
||||
void do_handler()
|
||||
{
|
||||
String const s (String::fromNumber (m_random.nextInt()));
|
||||
m_string += s;
|
||||
if (m_string.length() > 100)
|
||||
m_string = String::empty;
|
||||
}
|
||||
|
||||
void run ()
|
||||
{
|
||||
thread() = this;
|
||||
while (! threadShouldExit())
|
||||
m_service.run_one();
|
||||
}
|
||||
};
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
template <typename ServiceType>
|
||||
struct Producer : Thread
|
||||
{
|
||||
ServiceType& m_service;
|
||||
Random m_random;
|
||||
String m_string;
|
||||
|
||||
Producer (int id, int64 seedValue, ServiceType& service)
|
||||
: Thread ("P#" + String::fromNumber (id))
|
||||
, m_service (service)
|
||||
, m_random (seedValue)
|
||||
{ }
|
||||
|
||||
~Producer ()
|
||||
{ stopThread(); }
|
||||
|
||||
void run ()
|
||||
{
|
||||
for (std::size_t i = 0; i < callsPerThread; ++i)
|
||||
{
|
||||
String const s (String::fromNumber (m_random.nextInt()));
|
||||
m_string += s;
|
||||
if (m_string.length() > 100)
|
||||
m_string = String::empty;
|
||||
m_service.dispatch (bind (&Consumer<ServiceType>::handler));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
template <typename Allocator>
|
||||
void testThreads (std::size_t nConsumers, std::size_t nProducers)
|
||||
{
|
||||
beginTestCase (String::fromNumber (nConsumers) + " consumers, " +
|
||||
String::fromNumber (nProducers) + " producers, " +
|
||||
"Allocator = " + std::string(typeid(Allocator).name()));
|
||||
|
||||
typedef ServiceQueueType <Allocator> ServiceType;
|
||||
|
||||
ServiceType service (nConsumers);
|
||||
std::vector <ScopedPointer <Consumer <ServiceType> > > consumers;
|
||||
std::vector <ScopedPointer <Producer <ServiceType> > > producers;
|
||||
consumers.reserve (nConsumers);
|
||||
producers.reserve (nProducers);
|
||||
|
||||
for (std::size_t i = 0; i < nConsumers; ++i)
|
||||
consumers.push_back (new Consumer <ServiceType> (i + 1,
|
||||
random().nextInt64(), service));
|
||||
|
||||
for (std::size_t i = 0; i < nProducers; ++i)
|
||||
producers.push_back (new Producer <ServiceType> (i + 1,
|
||||
random().nextInt64(), service));
|
||||
|
||||
Stopwatch t;
|
||||
|
||||
for (std::size_t i = 0; i < producers.size(); ++i)
|
||||
producers[i]->startThread();
|
||||
|
||||
for (std::size_t i = 0; i < producers.size(); ++i)
|
||||
producers[i]->waitForThreadToExit();
|
||||
|
||||
for (std::size_t i = 0; i < consumers.size(); ++i)
|
||||
service.dispatch (bind (&Consumer <ServiceType>::stop_one));
|
||||
|
||||
for (std::size_t i = 0; i < consumers.size(); ++i)
|
||||
consumers[i]->waitForThreadToExit();
|
||||
|
||||
double const seconds (t.getElapsed());
|
||||
logMessage (String (seconds, 2) + " seconds");
|
||||
|
||||
pass();
|
||||
}
|
||||
|
||||
void runTest()
|
||||
{
|
||||
#if 1
|
||||
testThreads <std::allocator<char> > (1, 1);
|
||||
testThreads <std::allocator<char> > (1, 4);
|
||||
testThreads <std::allocator<char> > (1, 16);
|
||||
testThreads <std::allocator<char> > (4, 1);
|
||||
testThreads <std::allocator<char> > (8, 16);
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
testThreads <detail::ServiceQueueAllocator<char> > (1, 1);
|
||||
testThreads <detail::ServiceQueueAllocator<char> > (1, 4);
|
||||
testThreads <detail::ServiceQueueAllocator<char> > (1, 16);
|
||||
testThreads <detail::ServiceQueueAllocator<char> > (4, 1);
|
||||
testThreads <detail::ServiceQueueAllocator<char> > (8, 16);
|
||||
#endif
|
||||
}
|
||||
|
||||
ServiceQueueTimingTests () : UnitTest ("ServiceQueueTiming", "beast", runManual)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
static ServiceQueueTimingTests serviceQueueTimingTests;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class ServiceQueueTests
|
||||
: public UnitTest
|
||||
{
|
||||
public:
|
||||
struct ServiceThread : Thread
|
||||
{
|
||||
Random m_random;
|
||||
ServiceQueue& m_service;
|
||||
String m_string;
|
||||
|
||||
ServiceThread (int id, int64 seedValue,
|
||||
ServiceQueue& service)
|
||||
: Thread ("#" + String::fromNumber (id))
|
||||
, m_random (seedValue)
|
||||
, m_service (service)
|
||||
{
|
||||
startThread();
|
||||
}
|
||||
|
||||
~ServiceThread ()
|
||||
{
|
||||
stopThread();
|
||||
}
|
||||
|
||||
static ServiceThread*& thread()
|
||||
{
|
||||
static ThreadLocalValue <ServiceThread*> local;
|
||||
return local.get();
|
||||
}
|
||||
|
||||
static void stop_one ()
|
||||
{
|
||||
thread()->signalThreadShouldExit();
|
||||
}
|
||||
|
||||
static void handler ()
|
||||
{
|
||||
thread()->do_handler();
|
||||
}
|
||||
|
||||
void do_handler()
|
||||
{
|
||||
#if 1
|
||||
String const s (String::fromNumber (m_random.nextInt()));
|
||||
m_string += s;
|
||||
if (m_string.length() > 100)
|
||||
m_string = String::empty;
|
||||
#endif
|
||||
}
|
||||
|
||||
void run ()
|
||||
{
|
||||
thread() = this;
|
||||
while (! threadShouldExit())
|
||||
m_service.run_one();
|
||||
}
|
||||
};
|
||||
|
||||
static std::size_t const totalCalls = 10000;
|
||||
|
||||
void testThreads (std::size_t n)
|
||||
{
|
||||
std::size_t const callsPerThread (totalCalls / n);
|
||||
beginTestCase (String::fromNumber (n) + " threads");
|
||||
ServiceQueue service (n);
|
||||
std::vector <ScopedPointer <ServiceThread> > threads;
|
||||
threads.reserve (n);
|
||||
for (std::size_t i = 0; i < n; ++i)
|
||||
threads.push_back (new ServiceThread (i + 1,
|
||||
random().nextInt64(), service));
|
||||
for (std::size_t i = n * callsPerThread; i; --i)
|
||||
service.dispatch (bind (&ServiceThread::handler));
|
||||
for (std::size_t i = 0; i < threads.size(); ++i)
|
||||
service.dispatch (bind (&ServiceThread::stop_one));
|
||||
for (std::size_t i = 0; i < threads.size(); ++i)
|
||||
threads[i]->waitForThreadToExit();
|
||||
pass();
|
||||
}
|
||||
|
||||
void runTest()
|
||||
{
|
||||
testThreads (1);
|
||||
testThreads (4);
|
||||
testThreads (16);
|
||||
}
|
||||
|
||||
ServiceQueueTests () : UnitTest ("ServiceQueue", "beast")
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
static ServiceQueueTests serviceQueueTests;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -22,6 +22,11 @@
|
||||
//==============================================================================
|
||||
|
||||
#include "../Thread.h"
|
||||
#include "../../smart_ptr/SharedObject.h"
|
||||
#include "../../smart_ptr/SharedPtr.h"
|
||||
#include "../../../modules/beast_core/time/Time.h"
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace beast {
|
||||
|
||||
@@ -44,7 +49,7 @@ Thread::~Thread()
|
||||
To avoid this type of nastiness, always make sure you call stopThread() before or during
|
||||
your subclass's destructor.
|
||||
*/
|
||||
check_precondition (! isThreadRunning());
|
||||
assert (! isThreadRunning());
|
||||
|
||||
stopThread ();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user