Ichthyostega
c0e2d3b70e
These were defined in a confusing and implementation-oriented way. Since we have now mostly abstracted away the metadata handling from the `BufferProvider` front-end, a more succinct definition was chosen * a ''Descriptor'' is valid when the lookup succeeds * a ''Handle'' is likewise valid when the underlying state-Key can be resolved, and the memory address is given Some aspects regarding the state remain unresolved though. Ideally we'd want a `BuffHandle` to be valid preciselc when it ''is in valid state to be accessed''
228 lines
8.5 KiB
C++
228 lines
8.5 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/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);
|
||
|
||
CHECK (not 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
|