Ichthyostega
cc9dbd8a40
These are generic vehicles to verify computation structures. Since they are in no way related to our models, they belong into »Vault« layer Furthermore this reorganisation of test support components is prerequisite to also move further generic facilities down into the Vault
268 lines
9.2 KiB
C++
268 lines
9.2 KiB
C++
/*
|
||
TestFrame(Test) - verify proper operation of dummy data frames
|
||
|
||
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 test-frame-test.cpp
|
||
** unit test \ref TestFrame_test
|
||
*/
|
||
|
||
|
||
#include "test/run.hpp"
|
||
#include "test/test-helper.hpp"
|
||
#include "test/test-frame.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include <climits>
|
||
#include <memory>
|
||
|
||
using test::Test;
|
||
using util::isSameObject;
|
||
using std::unique_ptr;
|
||
|
||
namespace test {
|
||
namespace test {
|
||
|
||
namespace { // used internally
|
||
|
||
const uint CHAN_COUNT = 30; // independent families of test frames to generate
|
||
const uint NUM_FRAMES = 1000; // number of test frames in each of these families
|
||
|
||
|
||
void
|
||
corruptMemory(void* base, uint offset, uint count)
|
||
{
|
||
char* accessor = reinterpret_cast<char*> (base);
|
||
while (count--)
|
||
accessor[offset+count] = rani(CHAR_MAX);
|
||
}
|
||
} // (End) internal defs
|
||
|
||
|
||
|
||
/***************************************************************//**
|
||
* @test verify test helper for engine tests: a dummy data frame.
|
||
* TestFrame instances can be created right away, without any
|
||
* external library dependencies. A test frame is automatically
|
||
* filled with random data; multiple frames are arranged in
|
||
* sequences and channels, causing the random data to be
|
||
* reproducible yet different in each frame.
|
||
*
|
||
* To ease writing unit tests, TestFrame provides comparison
|
||
* and assignment and tracks lifecycle automatically. As tests
|
||
* regarding the engine typically have to deal with buffer
|
||
* management, an arbitrary memory location can be interpreted
|
||
* as TestFrame and checked for corruption.
|
||
*/
|
||
class TestFrame_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand(); // ◁—————————————————————————— Note: TestFrame::reseed() automatically invoked here
|
||
|
||
simpleUsage();
|
||
verifyDataContent();
|
||
verifyFrameLifecycle();
|
||
verifyFrameSeries();
|
||
useFrameTable();
|
||
}
|
||
|
||
|
||
void
|
||
simpleUsage()
|
||
{
|
||
CHECK (1024 < sizeof(TestFrame));
|
||
|
||
TestFrame frame;
|
||
CHECK (frame.isValid());
|
||
|
||
++frame.data()[5];
|
||
CHECK (not frame.isValid());
|
||
|
||
frame.markChecksum();
|
||
CHECK (frame.isValid());
|
||
|
||
CHECK (isSameObject(frame, frame.data())); // payload data stored embedded
|
||
CHECK (sizeof(TestFrame) > frame.data().size()); // additional metadata placed behind
|
||
}
|
||
|
||
|
||
void
|
||
verifyDataContent()
|
||
{
|
||
TestFrame frameA;
|
||
TestFrame frameB;
|
||
TestFrame frameC(5);
|
||
|
||
CHECK (frameA == frameB);
|
||
CHECK (frameA != frameC);
|
||
CHECK (frameB != frameC);
|
||
|
||
CHECK (frameA.data() == frameB.data());
|
||
CHECK (frameA.data() != frameC.data());
|
||
for (uint i=0; i<frameA.data().size(); ++i)
|
||
CHECK (frameA.data()[i] == frameB.data()[i]);
|
||
|
||
// can access data as uint64_t
|
||
CHECK (frameA.data()[ 8] == char(frameA.data64()[1])); // assuming little-endian
|
||
CHECK (frameA.data()[16] == char(frameA.data64()[2]));
|
||
CHECK (frameA.data()[24] == char(frameA.data64()[3]));
|
||
CHECK (frameA.data()[32] == char(frameA.data64()[4]));
|
||
CHECK (frameA.data().size() == 8*frameA.data64().size());
|
||
|
||
CHECK (frameA.isAlive());
|
||
CHECK (frameB.isAlive());
|
||
CHECK (frameC.isAlive());
|
||
|
||
CHECK (frameA.isSane());
|
||
CHECK (frameB.isSane());
|
||
CHECK (frameC.isSane());
|
||
|
||
CHECK (frameA.isValid());
|
||
CHECK (frameB.isValid());
|
||
CHECK (frameC.isValid());
|
||
|
||
CHECK (frameA.isPristine());
|
||
CHECK (frameB.isPristine());
|
||
CHECK (frameC.isPristine());
|
||
|
||
void * frameMem = &frameB;
|
||
|
||
CHECK (frameA == frameMem);
|
||
corruptMemory (frameMem,20,5);
|
||
CHECK ( frameB.isSane()); // still has valid metadata header
|
||
CHECK (not frameB.isValid()); // data checksum does not match any more
|
||
CHECK (not frameB.isPristine()); // data does not match the original generation sequence
|
||
|
||
frameB.markChecksum();
|
||
CHECK ( frameB.isSane()); // still has valid metadata header
|
||
CHECK ( frameB.isValid()); // data matches the new recorded checksum
|
||
CHECK (not frameB.isPristine()); // but data still does not match the original generation sequence
|
||
|
||
frameB = frameC;
|
||
|
||
CHECK (frameB.isSane());
|
||
CHECK (frameA != frameB);
|
||
CHECK (frameA != frameC);
|
||
CHECK (frameB == frameC);
|
||
|
||
corruptMemory (frameMem, 0,sizeof(TestFrame));
|
||
CHECK (not frameB.isSane()); // now also the metadata was corrupted...
|
||
CHECK (not frameB.isValid());
|
||
VERIFY_FAIL ("corrupted metadata"
|
||
, frameB.markChecksum() ); // reject to store new checksum in the corrupted header
|
||
VERIFY_FAIL ("target TestFrame already dead or unaccessible"
|
||
, frameB = frameC); // reject to assign new content to a corrupted target
|
||
}
|
||
|
||
|
||
void
|
||
verifyFrameLifecycle()
|
||
{
|
||
CHECK (not TestFrame::isDead (this));
|
||
CHECK (not TestFrame::isAlive (this));
|
||
|
||
static char buffer[sizeof(TestFrame)];
|
||
TestFrame* frame = new(&buffer) TestFrame(23);
|
||
|
||
CHECK ( TestFrame::isAlive (frame));
|
||
CHECK (not frame->isDead());
|
||
CHECK ( frame->isAlive());
|
||
CHECK ( frame->isValid());
|
||
|
||
frame->~TestFrame();
|
||
CHECK ( TestFrame::isDead (frame));
|
||
CHECK (not TestFrame::isAlive (frame));
|
||
CHECK ( frame->isValid());
|
||
CHECK ( frame->isSane());
|
||
}
|
||
|
||
|
||
/** @test build sequences of test frames,
|
||
* organised into multiple families (channels).
|
||
* Verify that adjacent frames hold differing data
|
||
*/
|
||
void
|
||
verifyFrameSeries()
|
||
{
|
||
unique_ptr<TestFrame> thisFrames[CHAN_COUNT];
|
||
unique_ptr<TestFrame> prevFrames[CHAN_COUNT];
|
||
|
||
for (uint i=0; i<CHAN_COUNT; ++i)
|
||
thisFrames[i].reset (new TestFrame(0, i));
|
||
|
||
for (uint nr=1; nr<NUM_FRAMES; ++nr)
|
||
for (uint i=0; i<CHAN_COUNT; ++i)
|
||
{
|
||
thisFrames[i].swap (prevFrames[i]);
|
||
thisFrames[i].reset (new TestFrame(nr, i));
|
||
CHECK (thisFrames[i]->isPristine());
|
||
CHECK (prevFrames[i]->isPristine());
|
||
CHECK (prevFrames[i]->isAlive());
|
||
|
||
CHECK (*thisFrames[i] != *prevFrames[i]); // differs from predecessor within the same channel
|
||
|
||
for (uint j=0; j<i; ++j)
|
||
{
|
||
ENSURE (j!=i);
|
||
CHECK (*thisFrames[i] != *thisFrames[j]); // differs from frames in other channels at this point
|
||
CHECK (*thisFrames[i] != *prevFrames[j]); // differs cross wise from predecessors in other channels
|
||
} } }
|
||
|
||
|
||
|
||
/** @test the table of test frames computed on demand */
|
||
void
|
||
useFrameTable()
|
||
{
|
||
TestFrame& frX = testData(50,3);
|
||
TestFrame& frY = testData(50,2);
|
||
TestFrame& frZ = testData(50,3);
|
||
|
||
CHECK (frX.isPristine());
|
||
CHECK (frY.isPristine());
|
||
CHECK (frZ.isPristine());
|
||
|
||
CHECK (frX != frY);
|
||
CHECK (frX == frZ);
|
||
CHECK (frY != frZ);
|
||
|
||
CHECK (isSameObject (frX, frZ));
|
||
|
||
corruptMemory(&frZ,40,20);
|
||
CHECK (not frX.isPristine());
|
||
CHECK (not testData(50,3).isPristine());
|
||
CHECK ( testData(51,3).isPristine());
|
||
CHECK ( testData(49,3).isPristine());
|
||
|
||
char c = testData(49,3).data()[5]; // some arbitrary content
|
||
|
||
TestFrame::reseed();
|
||
|
||
CHECK ( testData(50,3).isPristine());
|
||
CHECK (c != testData(49,3).data()[5]); // content regenerated with different seed
|
||
|
||
TestFrame o{49,3}; // all data content is reproducible with the new seed
|
||
CHECK (not isSameObject(o, testData(49,3)));
|
||
CHECK (o == testData(49,3));
|
||
CHECK (o.data()[5] == testData(49,3).data()[5]);
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (TestFrame_test, "unit engine");
|
||
|
||
|
||
|
||
}} // namespace test::test
|