Ichthyostega
cd415c05aa
...just enough to be able to write the assertions in the first test case (..and the test case fails still, due to the pending work on sorting out the implementation APIs between `BufferStage` und `BufferStore`)
228 lines
8.6 KiB
C++
228 lines
8.6 KiB
C++
/*
|
||
DiagnosticBufferProvider(Test) - verify a support facility for diagnostic/test purposes
|
||
|
||
Copyright (C)
|
||
2011, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** is free software; you can redistribute it and/or modify it
|
||
under the terms of the GNU General Public License as published by the
|
||
Free Software Foundation; either version 2 of the License, or (at your
|
||
option) any later version. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file tracking-heap-block-provider-test.cpp
|
||
** unit test \ref DiagnosticBufferProvider_test
|
||
*/
|
||
|
||
|
||
#include "lib/error.hpp"
|
||
#include "lib/test/run.hpp"
|
||
#include "steam/engine/diagnostic-buffer-provider.hpp"
|
||
#include "steam/engine/buffhandle-attach.hpp" ///////////////////////////////////////////////////////////TICKET 1410 : remove unnecessary API
|
||
#include "steam/engine/testframe.hpp"
|
||
#include "lib/test/diagnostic-output.hpp"//////////////////TODO
|
||
|
||
#include <vector>
|
||
|
||
|
||
namespace steam {
|
||
namespace engine{
|
||
namespace test {
|
||
|
||
|
||
|
||
namespace { // Test fixture
|
||
|
||
const size_t TEST_ELM_SIZE = sizeof(uint);
|
||
const uint MAX_ELMS = 50;
|
||
|
||
std::vector<uint> testNumbers(MAX_ELMS);
|
||
|
||
|
||
bool
|
||
has_expectedContent (uint nr, diagn::Block& memoryBlock)
|
||
{
|
||
#if false //////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : disabled code to disentangle BufferProvider implementation
|
||
void* mem = memoryBlock.accessMemory();
|
||
uint data = *static_cast<uint*> (mem);
|
||
|
||
return data == testNumbers[nr];
|
||
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : (end) disabled code
|
||
}
|
||
|
||
bool
|
||
verifyUsedBlock (uint nr, diagn::Block& memoryBlock)
|
||
{
|
||
#if false //////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : disabled code to disentangle BufferProvider implementation
|
||
return memoryBlock.was_used()
|
||
and memoryBlock.was_closed()
|
||
and has_expectedContent (nr, memoryBlock);
|
||
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : (end) disabled code
|
||
}
|
||
}
|
||
|
||
|
||
/******************************************************************//**
|
||
* @test verify support to write mock components for buffer management.
|
||
* - HeapMemBufferStore is a „braindead“ implementation of the BufferProvider
|
||
* interface: it just claims new heap blocks and never de-allocates them.
|
||
* - adding a layer of instrumentation, the DiagnosticBufferProvider allows
|
||
* to count and verify allocated buffers and their content after the fact.
|
||
*/
|
||
class DiagnosticBufferProvider_test : public Test
|
||
{
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
|
||
simpleExample();
|
||
verifyStandardCase();
|
||
verifyTestProtocol();
|
||
}
|
||
|
||
|
||
void
|
||
simpleExample()
|
||
{
|
||
DiagnosticBufferProvider provider;
|
||
|
||
BuffHandle testBuff = provider.lockBufferFor<TestFrame>();
|
||
CHECK (testBuff);
|
||
CHECK (testBuff.accessAs<TestFrame>().isSane());
|
||
|
||
uint dataID = 1 + rani(29);
|
||
testBuff.accessAs<TestFrame>() = testData(dataID);
|
||
|
||
provider.emitBuffer (testBuff);
|
||
provider.releaseBuffer(testBuff);
|
||
|
||
SHOW_EXPR(watch(provider).created.cnt())
|
||
SHOW_EXPR(watch(provider).emitted.cnt())
|
||
SHOW_EXPR(watch(provider).released.cnt())
|
||
CHECK (1 == watch(provider).created.cnt());
|
||
CHECK (1 == watch(provider).emitted.cnt());
|
||
CHECK (1 == watch(provider).released.cnt());
|
||
diagn::Block block0 = watch(provider).emitted[0];
|
||
CHECK (testData(dataID) == block0.accessMemory());
|
||
}
|
||
|
||
|
||
void
|
||
verifyStandardCase()
|
||
{
|
||
DiagnosticBufferProvider provider;
|
||
|
||
BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE);
|
||
uint numElms = provider.announce(MAX_ELMS, buffType);
|
||
CHECK (0 < numElms);
|
||
CHECK (numElms <= MAX_ELMS);
|
||
|
||
for (uint i=0; i<numElms; ++i)
|
||
{
|
||
BuffHandle buff = provider.lockBuffer(buffType);
|
||
buff.accessAs<uint>() = testNumbers[i] = rani(100000);
|
||
provider.emitBuffer (buff);
|
||
provider.releaseBuffer(buff);
|
||
}
|
||
|
||
for (uint nr=0; nr<numElms; ++nr)
|
||
{
|
||
// CHECK (verifyUsedBlock (nr, provider.access_emitted(nr))); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
verifyTestProtocol()
|
||
{
|
||
DiagnosticBufferProvider provider;
|
||
|
||
BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE);
|
||
|
||
BuffHandle bu1 = provider.lockBuffer (buffType);
|
||
BuffHandle bu2 = provider.lockBuffer (buffType);
|
||
BuffHandle bu3 = provider.lockBuffer (buffType);
|
||
BuffHandle bu4 = provider.lockBuffer (buffType);
|
||
BuffHandle bu5 = provider.lockBuffer (buffType);
|
||
|
||
// buffers are locked,
|
||
// but still within the per-type allocation pool
|
||
// while the output sequence is still empty
|
||
// CHECK (!provider.access_emitted(0).was_used()); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
// CHECK (!provider.access_emitted(1).was_used());
|
||
// CHECK (!provider.access_emitted(2).was_used());
|
||
// CHECK (!provider.access_emitted(3).was_used());
|
||
// CHECK (!provider.access_emitted(4).was_used());
|
||
|
||
// can use the buffers for real
|
||
bu1.accessAs<uint>() = 1;
|
||
bu2.accessAs<uint>() = 2;
|
||
bu3.accessAs<uint>() = 3;
|
||
bu4.accessAs<uint>() = 4;
|
||
bu5.accessAs<uint>() = 5;
|
||
|
||
// CHECK (0 == provider.emittedCnt()); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
|
||
// now emit buffers in shuffled order
|
||
provider.emitBuffer (bu3);
|
||
provider.emitBuffer (bu1);
|
||
provider.emitBuffer (bu5);
|
||
provider.emitBuffer (bu4);
|
||
provider.emitBuffer (bu2);
|
||
|
||
// CHECK (5 == provider.emittedCnt()); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
|
||
// CHECK (3 == provider.accessAs<uint>(0)); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
// CHECK (1 == provider.accessAs<uint>(1));
|
||
// CHECK (5 == provider.accessAs<uint>(2));
|
||
// CHECK (4 == provider.accessAs<uint>(3));
|
||
// CHECK (2 == provider.accessAs<uint>(4));
|
||
|
||
// CHECK ( provider.access_emitted(0).was_used()); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
// CHECK ( provider.access_emitted(1).was_used());
|
||
// CHECK ( provider.access_emitted(2).was_used());
|
||
// CHECK ( provider.access_emitted(3).was_used());
|
||
// CHECK ( provider.access_emitted(4).was_used());
|
||
|
||
// CHECK (!provider.access_emitted(0).was_closed());
|
||
// CHECK (!provider.access_emitted(1).was_closed());
|
||
// CHECK (!provider.access_emitted(2).was_closed());
|
||
// CHECK (!provider.access_emitted(3).was_closed());
|
||
// CHECK (!provider.access_emitted(4).was_closed());
|
||
|
||
bu5.release();
|
||
// CHECK (!provider.access_emitted(0).was_closed());
|
||
// CHECK (!provider.access_emitted(1).was_closed());
|
||
// CHECK ( provider.access_emitted(2).was_closed());
|
||
// CHECK (!provider.access_emitted(3).was_closed());
|
||
// CHECK (!provider.access_emitted(4).was_closed());
|
||
|
||
bu2.release();
|
||
bu2.release();
|
||
bu5.release();
|
||
// CHECK (!provider.access_emitted(0).was_closed());
|
||
// CHECK (!provider.access_emitted(1).was_closed());
|
||
// CHECK ( provider.access_emitted(2).was_closed());
|
||
// CHECK (!provider.access_emitted(3).was_closed());
|
||
// CHECK ( provider.access_emitted(4).was_closed());
|
||
|
||
CHECK (!bu2);
|
||
CHECK (bu3);
|
||
|
||
bu1.release();
|
||
bu3.release();
|
||
bu4.release();
|
||
|
||
// CHECK (5 == provider.emittedCnt()); ///////////////////////////////OOO provide suitable diagnostic API!
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (DiagnosticBufferProvider_test, "unit player");
|
||
|
||
|
||
|
||
}}} // namespace steam::engine::test
|