AnotherFoxGuy/polyvox
1
0
Fork 0
Code Issues Pull Requests Activity

TestVolume unit test now tests PagedVolume rather than SimpleVolume and LargeVolume.

Browse Source
This commit is contained in:
David Williams 2014-09-20 14:49:12 +02:00
parent 6f08184fcb
commit 4779f91787
2 changed files with 34 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
tests/testvolume.cpp
View File

@ -24,9 +24,8 @@ freely, subject to the following restrictions:
#include "testvolume.h"
#include "PolyVoxCore/FilePager.h"
#include "PolyVoxCore/LargeVolume.h"
#include "PolyVoxCore/PagedVolume.h"
#include "PolyVoxCore/RawVolume.h"
#include "PolyVoxCore/SimpleVolume.h"
#include <QtGlobal>
#include <QtTest>
@ -274,10 +273,9 @@ TestVolume::TestVolume()
//Create the volumes
m_pRawVolume = new RawVolume<int32_t>(region);
m_pSimpleVolume = new SimpleVolume<int32_t>(region);
m_pLargeVolume = new LargeVolume<int32_t>(region, m_pFilePager, 32);
m_pPagedVolume = new LargeVolume<int32_t>(region, m_pFilePager, 32);
m_pLargeVolume->setMemoryUsageLimit(1 * 1024 * 1024);
m_pPagedVolume->setMemoryUsageLimit(1 * 1024 * 1024);
//Fill the volume with some data
for(int z = region.getLowerZ(); z <= region.getUpperZ(); z++)
@ -288,8 +286,7 @@ TestVolume::TestVolume()
{
int32_t value = x + y + z;
m_pRawVolume->setVoxelAt(x, y, z, value);
m_pSimpleVolume->setVoxelAt(x, y, z, value);
m_pLargeVolume->setVoxelAt(x, y, z, value);
m_pPagedVolume->setVoxelAt(x, y, z, value);
}
}
}
@ -298,18 +295,16 @@ TestVolume::TestVolume()
TestVolume::~TestVolume()
{
delete m_pRawVolume;
delete m_pSimpleVolume;
delete m_pLargeVolume;
delete m_pPagedVolume;
delete m_pFilePager;
delete m_pBlockCompressor;
}
/*
* RawVolume Tests
*/
/*void TestVolume::testRawVolumeDirectAccessAllInternalForwards()
void TestVolume::testRawVolumeDirectAccessAllInternalForwards()
{
int32_t result = 0;
@ -395,176 +390,88 @@ void TestVolume::testRawVolumeSamplersWithExternalBackwards()
result = testSamplersWithWrappingBackwards(m_pRawVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-769775893));
}*/
}
/*
* SimpleVolume Tests
* PagedVolume Tests
*/
/*void TestVolume::testSimpleVolumeDirectAccessAllInternalForwards()
void TestVolume::testPagedVolumeDirectAccessAllInternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingForwards(m_pSimpleVolume, 4, 2, 2, -3, -1, -2);
result = testDirectAccessWithWrappingForwards(m_pPagedVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(1004598054));
}
void TestVolume::testSimpleVolumeSamplersAllInternalForwards()
void TestVolume::testPagedVolumeSamplersAllInternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingForwards(m_pSimpleVolume, 4, 2, 2, -3, -1, -2);
result = testSamplersWithWrappingForwards(m_pPagedVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(1004598054));
}
void TestVolume::testSimpleVolumeDirectAccessWithExternalForwards()
void TestVolume::testPagedVolumeDirectAccessWithExternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingForwards(m_pSimpleVolume, -1, -3, -2, 2, 5, 4);
result = testDirectAccessWithWrappingForwards(m_pPagedVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-928601007));
}
void TestVolume::testSimpleVolumeSamplersWithExternalForwards()
void TestVolume::testPagedVolumeSamplersWithExternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingForwards(m_pSimpleVolume, -1, -3, -2, 2, 5, 4);
result = testSamplersWithWrappingForwards(m_pPagedVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-928601007));
}
void TestVolume::testSimpleVolumeDirectAccessAllInternalBackwards()
void TestVolume::testPagedVolumeDirectAccessAllInternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingBackwards(m_pSimpleVolume, 4, 2, 2, -3, -1, -2);
result = testDirectAccessWithWrappingBackwards(m_pPagedVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(-269366578));
}
void TestVolume::testSimpleVolumeSamplersAllInternalBackwards()
void TestVolume::testPagedVolumeSamplersAllInternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingBackwards(m_pSimpleVolume, 4, 2, 2, -3, -1, -2);
result = testSamplersWithWrappingBackwards(m_pPagedVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(-269366578));
}
void TestVolume::testSimpleVolumeDirectAccessWithExternalBackwards()
void TestVolume::testPagedVolumeDirectAccessWithExternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingBackwards(m_pSimpleVolume, -1, -3, -2, 2, 5, 4);
result = testDirectAccessWithWrappingBackwards(m_pPagedVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-769775893));
}
void TestVolume::testSimpleVolumeSamplersWithExternalBackwards()
void TestVolume::testPagedVolumeSamplersWithExternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingBackwards(m_pSimpleVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-769775893));
}*/
/*
* LargeVolume Tests
*/
void TestVolume::testLargeVolumeDirectAccessAllInternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingForwards(m_pLargeVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(1004598054));
}
void TestVolume::testLargeVolumeSamplersAllInternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingForwards(m_pLargeVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(1004598054));
}
void TestVolume::testLargeVolumeDirectAccessWithExternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingForwards(m_pLargeVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-928601007));
}
void TestVolume::testLargeVolumeSamplersWithExternalForwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingForwards(m_pLargeVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-928601007));
}
void TestVolume::testLargeVolumeDirectAccessAllInternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingBackwards(m_pLargeVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(-269366578));
}
void TestVolume::testLargeVolumeSamplersAllInternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingBackwards(m_pLargeVolume, 4, 2, 2, -3, -1, -2);
}
QCOMPARE(result, static_cast<int32_t>(-269366578));
}
void TestVolume::testLargeVolumeDirectAccessWithExternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testDirectAccessWithWrappingBackwards(m_pLargeVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-769775893));
}
void TestVolume::testLargeVolumeSamplersWithExternalBackwards()
{
int32_t result = 0;
QBENCHMARK
{
result = testSamplersWithWrappingBackwards(m_pLargeVolume, -1, -3, -2, 2, 5, 4);
result = testSamplersWithWrappingBackwards(m_pPagedVolume, -1, -3, -2, 2, 5, 4);
}
QCOMPARE(result, static_cast<int32_t>(-769775893));
}

31
tests/testvolume.h
View File

@ -37,7 +37,7 @@ public:
~TestVolume();
private slots:
/*void testRawVolumeDirectAccessAllInternalForwards();
void testRawVolumeDirectAccessAllInternalForwards();
void testRawVolumeSamplersAllInternalForwards();
void testRawVolumeDirectAccessWithExternalForwards();
void testRawVolumeSamplersWithExternalForwards();
@ -46,31 +46,20 @@ private slots:
void testRawVolumeDirectAccessWithExternalBackwards();
void testRawVolumeSamplersWithExternalBackwards();
void testSimpleVolumeDirectAccessAllInternalForwards();
void testSimpleVolumeSamplersAllInternalForwards();
void testSimpleVolumeDirectAccessWithExternalForwards();
void testSimpleVolumeSamplersWithExternalForwards();
void testSimpleVolumeDirectAccessAllInternalBackwards();
void testSimpleVolumeSamplersAllInternalBackwards();
void testSimpleVolumeDirectAccessWithExternalBackwards();
void testSimpleVolumeSamplersWithExternalBackwards();*/
void testLargeVolumeDirectAccessAllInternalForwards();
void testLargeVolumeSamplersAllInternalForwards();
void testLargeVolumeDirectAccessWithExternalForwards();
void testLargeVolumeSamplersWithExternalForwards();
void testLargeVolumeDirectAccessAllInternalBackwards();
void testLargeVolumeSamplersAllInternalBackwards();
void testLargeVolumeDirectAccessWithExternalBackwards();
void testLargeVolumeSamplersWithExternalBackwards();
void testPagedVolumeDirectAccessAllInternalForwards();
void testPagedVolumeSamplersAllInternalForwards();
void testPagedVolumeDirectAccessWithExternalForwards();
void testPagedVolumeSamplersWithExternalForwards();
void testPagedVolumeDirectAccessAllInternalBackwards();
void testPagedVolumeSamplersAllInternalBackwards();
void testPagedVolumeDirectAccessWithExternalBackwards();
void testPagedVolumeSamplersWithExternalBackwards();
private:
PolyVox::BlockCompressor<int32_t>* m_pBlockCompressor;
PolyVox::FilePager<int32_t>* m_pFilePager;
PolyVox::RawVolume<int32_t>* m_pRawVolume;
PolyVox::SimpleVolume<int32_t>* m_pSimpleVolume;
PolyVox::LargeVolume<int32_t>* m_pLargeVolume;
PolyVox::PagedVolume<int32_t>* m_pPagedVolume;
};
#endif