v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor: Use LF for end of line

pull/566/head
Richard 2015-05-18 22:24:07 -06:00
parent 0af1f0d32f
commit 4b0f9f3e89
26 changed files with 2377 additions and 2377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
test/unit/CCompilerTest.c
View File

@ -1,9 +1,9 @@
/* This is just a small test to check whether Assimp's API compiles from C */
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/version.h>
#include <assimp/config.h>
#include <assimp/cimport.h>
#include <assimp/cexport.h>
/* This is just a small test to check whether Assimp's API compiles from C */
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/version.h>
#include <assimp/config.h>
#include <assimp/cimport.h>
#include <assimp/cexport.h>

62
test/unit/Main.cpp
View File

@ -1,33 +1,33 @@
#include "UnitTestPCH.h"
#include "../../include/assimp/DefaultLogger.hpp"
#include <math.h>
#include <time.h>
int main(int argc, char* argv[])
{
::testing::InitGoogleTest(&argc, argv);
// seed the randomizer with the current system time
time_t t;time(&t);
srand((unsigned int)t);
// ............................................................................
// create a logger from both CPP
Assimp::DefaultLogger::create("AssimpLog_Cpp.txt",Assimp::Logger::VERBOSE,
aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE);
// .. and C. They should smoothly work together
aiEnableVerboseLogging(AI_TRUE);
aiLogStream logstream= aiGetPredefinedLogStream(aiDefaultLogStream_FILE, "AssimpLog_C.txt");
aiAttachLogStream(&logstream);
int result = RUN_ALL_TESTS();
// ............................................................................
// but shutdown must be done from C to ensure proper deallocation
aiDetachAllLogStreams();
return result;
}
#include <math.h>
#include <time.h>
int main(int argc, char* argv[])
{
::testing::InitGoogleTest(&argc, argv);
// seed the randomizer with the current system time
time_t t;time(&t);
srand((unsigned int)t);
// ............................................................................
// create a logger from both CPP
Assimp::DefaultLogger::create("AssimpLog_Cpp.txt",Assimp::Logger::VERBOSE,
aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE);
// .. and C. They should smoothly work together
aiEnableVerboseLogging(AI_TRUE);
aiLogStream logstream= aiGetPredefinedLogStream(aiDefaultLogStream_FILE, "AssimpLog_C.txt");
aiAttachLogStream(&logstream);
int result = RUN_ALL_TESTS();
// ............................................................................
// but shutdown must be done from C to ensure proper deallocation
aiDetachAllLogStreams();
return result;
}

32
test/unit/UnitTestPCH.h
View File

@ -1,16 +1,16 @@
// #ifndef ASSIMP_BUILD_SINGLETHREADED
// # include <boost/thread.hpp>
// #endif
// We need to be sure to have the same STL settings as Assimp
#include <assimp/cimport.h>
#include <gtest/gtest.h>
#include <math.h>
#undef min
#undef max
// #ifndef ASSIMP_BUILD_SINGLETHREADED
// # include <boost/thread.hpp>
// #endif
// We need to be sure to have the same STL settings as Assimp
#include <assimp/cimport.h>
#include <gtest/gtest.h>
#include <math.h>
#undef min
#undef max

168
test/unit/utExport.cpp
View File

@ -1,84 +1,84 @@
#include "UnitTestPCH.h"
#include <assimp/cexport.h>
#include <assimp/Exporter.hpp>
#ifndef ASSIMP_BUILD_NO_EXPORT
class ExporterTest : public ::testing::Test {
public:
virtual void SetUp()
{
ex = new Assimp::Exporter();
im = new Assimp::Importer();
pTest = im->ReadFile("../../test/models/X/test.x",0);
}
virtual void TearDown()
{
delete ex;
delete im;
}
protected:
const aiScene* pTest;
Assimp::Exporter* ex;
Assimp::Importer* im;
};
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testExportToFile)
{
const char* file = "unittest_output.dae";
EXPECT_EQ(AI_SUCCESS,ex->Export(pTest,"collada",file));
// check if we can read it again
EXPECT_TRUE(im->ReadFile(file,0));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testExportToBlob)
{
const aiExportDataBlob* blob = ex->ExportToBlob(pTest,"collada");
ASSERT_TRUE(blob);
EXPECT_TRUE(blob->data);
EXPECT_GT(blob->size, 0U);
EXPECT_EQ(0U, blob->name.length);
// XXX test chained blobs (i.e. obj file with accompanying mtl script)
// check if we can read it again
EXPECT_TRUE(im->ReadFileFromMemory(blob->data,blob->size,0,"dae"));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testCppExportInterface)
{
EXPECT_TRUE(ex->GetExportFormatCount() > 0);
for(size_t i = 0; i < ex->GetExportFormatCount(); ++i) {
const aiExportFormatDesc* const desc = ex->GetExportFormatDescription(i);
ASSERT_TRUE(desc);
EXPECT_TRUE(desc->description && strlen(desc->description));
EXPECT_TRUE(desc->fileExtension && strlen(desc->fileExtension));
EXPECT_TRUE(desc->id && strlen(desc->id));
}
EXPECT_TRUE(ex->IsDefaultIOHandler());
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testCExportInterface)
{
EXPECT_TRUE(aiGetExportFormatCount() > 0);
for(size_t i = 0; i < aiGetExportFormatCount(); ++i) {
const aiExportFormatDesc* const desc = aiGetExportFormatDescription(i);
EXPECT_TRUE(desc);
// rest has aleady been validated by testCppExportInterface
}
}
#endif
#include "UnitTestPCH.h"
#include <assimp/cexport.h>
#include <assimp/Exporter.hpp>
#ifndef ASSIMP_BUILD_NO_EXPORT
class ExporterTest : public ::testing::Test {
public:
virtual void SetUp()
{
ex = new Assimp::Exporter();
im = new Assimp::Importer();
pTest = im->ReadFile("../../test/models/X/test.x",0);
}
virtual void TearDown()
{
delete ex;
delete im;
}
protected:
const aiScene* pTest;
Assimp::Exporter* ex;
Assimp::Importer* im;
};
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testExportToFile)
{
const char* file = "unittest_output.dae";
EXPECT_EQ(AI_SUCCESS,ex->Export(pTest,"collada",file));
// check if we can read it again
EXPECT_TRUE(im->ReadFile(file,0));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testExportToBlob)
{
const aiExportDataBlob* blob = ex->ExportToBlob(pTest,"collada");
ASSERT_TRUE(blob);
EXPECT_TRUE(blob->data);
EXPECT_GT(blob->size, 0U);
EXPECT_EQ(0U, blob->name.length);
// XXX test chained blobs (i.e. obj file with accompanying mtl script)
// check if we can read it again
EXPECT_TRUE(im->ReadFileFromMemory(blob->data,blob->size,0,"dae"));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testCppExportInterface)
{
EXPECT_TRUE(ex->GetExportFormatCount() > 0);
for(size_t i = 0; i < ex->GetExportFormatCount(); ++i) {
const aiExportFormatDesc* const desc = ex->GetExportFormatDescription(i);
ASSERT_TRUE(desc);
EXPECT_TRUE(desc->description && strlen(desc->description));
EXPECT_TRUE(desc->fileExtension && strlen(desc->fileExtension));
EXPECT_TRUE(desc->id && strlen(desc->id));
}
EXPECT_TRUE(ex->IsDefaultIOHandler());
}
// ------------------------------------------------------------------------------------------------
TEST_F(ExporterTest, testCExportInterface)
{
EXPECT_TRUE(aiGetExportFormatCount() > 0);
for(size_t i = 0; i < aiGetExportFormatCount(); ++i) {
const aiExportFormatDesc* const desc = aiGetExportFormatDescription(i);
EXPECT_TRUE(desc);
// rest has aleady been validated by testCppExportInterface
}
}
#endif

216
test/unit/utFindDegenerates.cpp
View File

@ -1,108 +1,108 @@
#include "UnitTestPCH.h"
#include <FindDegenerates.h>
using namespace std;
using namespace Assimp;
class FindDegeneratesProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* mesh;
FindDegeneratesProcess* process;
};
// ------------------------------------------------------------------------------------------------
void FindDegeneratesProcessTest::SetUp()
{
mesh = new aiMesh();
process = new FindDegeneratesProcess();
mesh->mNumFaces = 1000;
mesh->mFaces = new aiFace[1000];
mesh->mNumVertices = 5000*2;
mesh->mVertices = new aiVector3D[5000*2];
for (unsigned int i = 0; i < 5000; ++i) {
mesh->mVertices[i] = mesh->mVertices[i+5000] = aiVector3D((float)i);
}
mesh->mPrimitiveTypes = aiPrimitiveType_LINE | aiPrimitiveType_POINT |
aiPrimitiveType_POLYGON | aiPrimitiveType_TRIANGLE;
unsigned int numOut = 0, numFaces = 0;
for (unsigned int i = 0; i < 1000; ++i) {
aiFace& f = mesh->mFaces[i];
f.mNumIndices = (i % 5)+1; // between 1 and 5
f.mIndices = new unsigned int[f.mNumIndices];
bool had = false;
for (unsigned int n = 0; n < f.mNumIndices;++n) {
// FIXME
#if 0
// some duplicate indices
if ( n && n == (i / 200)+1) {
f.mIndices[n] = f.mIndices[n-1];
had = true;
}
// and some duplicate vertices
#endif
if (n && i % 2 && 0 == n % 2) {
f.mIndices[n] = f.mIndices[n-1]+5000;
had = true;
}
else {
f.mIndices[n] = numOut++;
}
}
if (!had)
++numFaces;
}
mesh->mNumUVComponents[0] = numOut;
mesh->mNumUVComponents[1] = numFaces;
}
// ------------------------------------------------------------------------------------------------
void FindDegeneratesProcessTest::TearDown()
{
delete mesh;
delete process;
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindDegeneratesProcessTest, testDegeneratesDetection)
{
process->EnableInstantRemoval(false);
process->ExecuteOnMesh(mesh);
unsigned int out = 0;
for (unsigned int i = 0; i < 1000; ++i) {
aiFace& f = mesh->mFaces[i];
out += f.mNumIndices;
}
EXPECT_EQ(1000U, mesh->mNumFaces);
EXPECT_EQ(10000U, mesh->mNumVertices);
EXPECT_EQ(out, mesh->mNumUVComponents[0]);
EXPECT_EQ(static_cast<unsigned int>(
aiPrimitiveType_LINE | aiPrimitiveType_POINT |
aiPrimitiveType_POLYGON | aiPrimitiveType_TRIANGLE),
mesh->mPrimitiveTypes);
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindDegeneratesProcessTest, testDegeneratesRemoval)
{
process->EnableInstantRemoval(true);
process->ExecuteOnMesh(mesh);
EXPECT_EQ(mesh->mNumUVComponents[1], mesh->mNumFaces);
}
#include "UnitTestPCH.h"
#include <FindDegenerates.h>
using namespace std;
using namespace Assimp;
class FindDegeneratesProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* mesh;
FindDegeneratesProcess* process;
};
// ------------------------------------------------------------------------------------------------
void FindDegeneratesProcessTest::SetUp()
{
mesh = new aiMesh();
process = new FindDegeneratesProcess();
mesh->mNumFaces = 1000;
mesh->mFaces = new aiFace[1000];
mesh->mNumVertices = 5000*2;
mesh->mVertices = new aiVector3D[5000*2];
for (unsigned int i = 0; i < 5000; ++i) {
mesh->mVertices[i] = mesh->mVertices[i+5000] = aiVector3D((float)i);
}
mesh->mPrimitiveTypes = aiPrimitiveType_LINE | aiPrimitiveType_POINT |
aiPrimitiveType_POLYGON | aiPrimitiveType_TRIANGLE;
unsigned int numOut = 0, numFaces = 0;
for (unsigned int i = 0; i < 1000; ++i) {
aiFace& f = mesh->mFaces[i];
f.mNumIndices = (i % 5)+1; // between 1 and 5
f.mIndices = new unsigned int[f.mNumIndices];
bool had = false;
for (unsigned int n = 0; n < f.mNumIndices;++n) {
// FIXME
#if 0
// some duplicate indices
if ( n && n == (i / 200)+1) {
f.mIndices[n] = f.mIndices[n-1];
had = true;
}
// and some duplicate vertices
#endif
if (n && i % 2 && 0 == n % 2) {
f.mIndices[n] = f.mIndices[n-1]+5000;
had = true;
}
else {
f.mIndices[n] = numOut++;
}
}
if (!had)
++numFaces;
}
mesh->mNumUVComponents[0] = numOut;
mesh->mNumUVComponents[1] = numFaces;
}
// ------------------------------------------------------------------------------------------------
void FindDegeneratesProcessTest::TearDown()
{
delete mesh;
delete process;
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindDegeneratesProcessTest, testDegeneratesDetection)
{
process->EnableInstantRemoval(false);
process->ExecuteOnMesh(mesh);
unsigned int out = 0;
for (unsigned int i = 0; i < 1000; ++i) {
aiFace& f = mesh->mFaces[i];
out += f.mNumIndices;
}
EXPECT_EQ(1000U, mesh->mNumFaces);
EXPECT_EQ(10000U, mesh->mNumVertices);
EXPECT_EQ(out, mesh->mNumUVComponents[0]);
EXPECT_EQ(static_cast<unsigned int>(
aiPrimitiveType_LINE | aiPrimitiveType_POINT |
aiPrimitiveType_POLYGON | aiPrimitiveType_TRIANGLE),
mesh->mPrimitiveTypes);
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindDegeneratesProcessTest, testDegeneratesRemoval)
{
process->EnableInstantRemoval(true);
process->ExecuteOnMesh(mesh);
EXPECT_EQ(mesh->mNumUVComponents[1], mesh->mNumFaces);
}

194
test/unit/utFindInvalidData.cpp
View File

@ -1,98 +1,98 @@
#include "UnitTestPCH.h"
#include "UnitTestPCH.h"
#include <FindInvalidDataProcess.h>
#include "../../include/assimp/mesh.h"
using namespace std;
using namespace Assimp;
class FindInvalidDataProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
FindInvalidDataProcess* piProcess;
};
// ------------------------------------------------------------------------------------------------
void FindInvalidDataProcessTest::SetUp()
{
ASSERT_TRUE( AI_MAX_NUMBER_OF_TEXTURECOORDS >= 3);
piProcess = new FindInvalidDataProcess();
pcMesh = new aiMesh();
pcMesh->mNumVertices = 1000;
pcMesh->mVertices = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mVertices[i] = aiVector3D((float)i);
pcMesh->mNormals = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mNormals[i] = aiVector3D((float)i+1);
pcMesh->mTangents = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mTangents[i] = aiVector3D((float)i);
pcMesh->mBitangents = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mBitangents[i] = aiVector3D((float)i);
for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a)
{
pcMesh->mTextureCoords[a] = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mTextureCoords[a][i] = aiVector3D((float)i);
}
}
// ------------------------------------------------------------------------------------------------
void FindInvalidDataProcessTest::TearDown()
{
delete piProcess;
delete pcMesh;
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindInvalidDataProcessTest, testStepNegativeResult)
{
::memset(pcMesh->mNormals,0,pcMesh->mNumVertices*sizeof(aiVector3D));
::memset(pcMesh->mBitangents,0,pcMesh->mNumVertices*sizeof(aiVector3D));
pcMesh->mTextureCoords[2][455] = aiVector3D( std::numeric_limits<float>::quiet_NaN() );
piProcess->ProcessMesh(pcMesh);
EXPECT_TRUE(NULL != pcMesh->mVertices);
EXPECT_TRUE(NULL == pcMesh->mNormals);
EXPECT_TRUE(NULL == pcMesh->mTangents);
EXPECT_TRUE(NULL == pcMesh->mBitangents);
for (unsigned int i = 0; i < 2;++i)
EXPECT_TRUE(NULL != pcMesh->mTextureCoords[i]);
for (unsigned int i = 2; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
EXPECT_TRUE(NULL == pcMesh->mTextureCoords[i]);
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindInvalidDataProcessTest, testStepPositiveResult)
{
piProcess->ProcessMesh(pcMesh);
EXPECT_TRUE(NULL != pcMesh->mVertices);
EXPECT_TRUE(NULL != pcMesh->mNormals);
EXPECT_TRUE(NULL != pcMesh->mTangents);
EXPECT_TRUE(NULL != pcMesh->mBitangents);
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
EXPECT_TRUE(NULL != pcMesh->mTextureCoords[i]);
}
#include "../../include/assimp/mesh.h"
using namespace std;
using namespace Assimp;
class FindInvalidDataProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
FindInvalidDataProcess* piProcess;
};
// ------------------------------------------------------------------------------------------------
void FindInvalidDataProcessTest::SetUp()
{
ASSERT_TRUE( AI_MAX_NUMBER_OF_TEXTURECOORDS >= 3);
piProcess = new FindInvalidDataProcess();
pcMesh = new aiMesh();
pcMesh->mNumVertices = 1000;
pcMesh->mVertices = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mVertices[i] = aiVector3D((float)i);
pcMesh->mNormals = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mNormals[i] = aiVector3D((float)i+1);
pcMesh->mTangents = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mTangents[i] = aiVector3D((float)i);
pcMesh->mBitangents = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mBitangents[i] = aiVector3D((float)i);
for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a)
{
pcMesh->mTextureCoords[a] = new aiVector3D[1000];
for (unsigned int i = 0; i < 1000;++i)
pcMesh->mTextureCoords[a][i] = aiVector3D((float)i);
}
}
// ------------------------------------------------------------------------------------------------
void FindInvalidDataProcessTest::TearDown()
{
delete piProcess;
delete pcMesh;
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindInvalidDataProcessTest, testStepNegativeResult)
{
::memset(pcMesh->mNormals,0,pcMesh->mNumVertices*sizeof(aiVector3D));
::memset(pcMesh->mBitangents,0,pcMesh->mNumVertices*sizeof(aiVector3D));
pcMesh->mTextureCoords[2][455] = aiVector3D( std::numeric_limits<float>::quiet_NaN() );
piProcess->ProcessMesh(pcMesh);
EXPECT_TRUE(NULL != pcMesh->mVertices);
EXPECT_TRUE(NULL == pcMesh->mNormals);
EXPECT_TRUE(NULL == pcMesh->mTangents);
EXPECT_TRUE(NULL == pcMesh->mBitangents);
for (unsigned int i = 0; i < 2;++i)
EXPECT_TRUE(NULL != pcMesh->mTextureCoords[i]);
for (unsigned int i = 2; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
EXPECT_TRUE(NULL == pcMesh->mTextureCoords[i]);
}
// ------------------------------------------------------------------------------------------------
TEST_F(FindInvalidDataProcessTest, testStepPositiveResult)
{
piProcess->ProcessMesh(pcMesh);
EXPECT_TRUE(NULL != pcMesh->mVertices);
EXPECT_TRUE(NULL != pcMesh->mNormals);
EXPECT_TRUE(NULL != pcMesh->mTangents);
EXPECT_TRUE(NULL != pcMesh->mBitangents);
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
EXPECT_TRUE(NULL != pcMesh->mTextureCoords[i]);
}

2
test/unit/utFixInfacingNormals.cpp
View File

@ -1 +1 @@
#include "UnitTestPCH.h"
#include "UnitTestPCH.h"

104
test/unit/utGenNormals.cpp
View File

@ -1,52 +1,52 @@
#include "UnitTestPCH.h"
#include <GenVertexNormalsProcess.h>
using namespace std;
using namespace Assimp;
class GenNormalsTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
GenVertexNormalsProcess* piProcess;
};
// ------------------------------------------------------------------------------------------------
void GenNormalsTest::SetUp()
{
piProcess = new GenVertexNormalsProcess();
pcMesh = new aiMesh();
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
pcMesh->mNumFaces = 1;
pcMesh->mFaces = new aiFace[1];
pcMesh->mFaces[0].mIndices = new unsigned int[pcMesh->mFaces[0].mNumIndices = 3];
pcMesh->mFaces[0].mIndices[0] = 0;
pcMesh->mFaces[0].mIndices[1] = 1;
pcMesh->mFaces[0].mIndices[2] = 1;
pcMesh->mNumVertices = 3;
pcMesh->mVertices = new aiVector3D[3];
pcMesh->mVertices[0] = aiVector3D(0.0f,1.0f,6.0f);
pcMesh->mVertices[1] = aiVector3D(2.0f,3.0f,1.0f);
pcMesh->mVertices[2] = aiVector3D(3.0f,2.0f,4.0f);
}
// ------------------------------------------------------------------------------------------------
void GenNormalsTest::TearDown()
{
delete this->pcMesh;
delete this->piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(GenNormalsTest, testSimpleTriangle)
{
piProcess->GenMeshVertexNormals(pcMesh, 0);
EXPECT_TRUE(pcMesh->mNormals != NULL);
}
#include "UnitTestPCH.h"
#include <GenVertexNormalsProcess.h>
using namespace std;
using namespace Assimp;
class GenNormalsTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
GenVertexNormalsProcess* piProcess;
};
// ------------------------------------------------------------------------------------------------
void GenNormalsTest::SetUp()
{
piProcess = new GenVertexNormalsProcess();
pcMesh = new aiMesh();
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
pcMesh->mNumFaces = 1;
pcMesh->mFaces = new aiFace[1];
pcMesh->mFaces[0].mIndices = new unsigned int[pcMesh->mFaces[0].mNumIndices = 3];
pcMesh->mFaces[0].mIndices[0] = 0;
pcMesh->mFaces[0].mIndices[1] = 1;
pcMesh->mFaces[0].mIndices[2] = 1;
pcMesh->mNumVertices = 3;
pcMesh->mVertices = new aiVector3D[3];
pcMesh->mVertices[0] = aiVector3D(0.0f,1.0f,6.0f);
pcMesh->mVertices[1] = aiVector3D(2.0f,3.0f,1.0f);
pcMesh->mVertices[2] = aiVector3D(3.0f,2.0f,4.0f);
}
// ------------------------------------------------------------------------------------------------
void GenNormalsTest::TearDown()
{
delete this->pcMesh;
delete this->piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(GenNormalsTest, testSimpleTriangle)
{
piProcess->GenMeshVertexNormals(pcMesh, 0);
EXPECT_TRUE(pcMesh->mNormals != NULL);
}

462
test/unit/utImporter.cpp
View File

@ -1,231 +1,231 @@
#include "UnitTestPCH.h"
#include "../../include/assimp/postprocess.h"
#include "../../include/assimp/scene.h"
#include <assimp/Importer.hpp>
#include <BaseImporter.h>
using namespace std;
using namespace Assimp;
class ImporterTest : public ::testing::Test
{
public:
virtual void SetUp() { pImp = new Importer(); }
virtual void TearDown() { delete pImp; }
protected:
Importer* pImp;
};
#define InputData_BLOCK_SIZE 1310
// test data for Importer::ReadFileFromMemory() - ./test/3DS/CameraRollAnim.3ds
static unsigned char InputData_abRawBlock[1310] = {
77,77,30,5,0,0,2,0,10,0,0,0,3,0,0,0,61,61,91,3,0,0,62,61,10,0,0,0,3,0,0,0,
0,1,10,0,0,0,0,0,128,63,0,64,254,2,0,0,66,111,120,48,49,0,0,65,242,2,0,0,16,65,64,1,
0,0,26,0,102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,102,74,198,193,0,0,0,0,102,74,198,193,
138,157,184,65,0,0,0,0,205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,102,74,198,193,90,252,26,66,
205,121,55,66,102,74,198,193,90,252,26,66,102,74,198,193,138,157,184,65,90,252,26,66,205,121,55,66,138,157,184,65,
90,252,26,66,102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,102,74,198,193,0,0,0,0,205,121,55,66,
102,74,198,193,90,252,26,66,205,121,55,66,102,74,198,193,90,252,26,66,102,74,198,193,102,74,198,193,90,252,26,66,
102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,138,157,184,65,0,0,0,0,205,121,55,66,102,74,198,193,
90,252,26,66,205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,138,157,184,65,0,0,0,0,102,74,198,193,
138,157,184,65,90,252,26,66,102,74,198,193,138,157,184,65,90,252,26,66,205,121,55,66,138,157,184,65,90,252,26,66,
205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,138,157,184,65,0,0,0,0,102,74,198,193,102,74,198,193,
90,252,26,66,102,74,198,193,102,74,198,193,90,252,26,66,102,74,198,193,138,157,184,65,0,0,0,0,64,65,216,0,
0,0,26,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,128,63,0,0,0,0,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,128,63,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,128,63,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,
0,0,128,63,0,0,128,63,0,0,128,63,0,0,0,0,0,0,0,0,96,65,54,0,0,0,0,0,128,63,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,53,169,
40,65,176,205,90,191,0,0,0,0,32,65,158,0,0,0,12,0,0,0,2,0,3,0,6,0,3,0,1,0,0,0,
6,0,4,0,5,0,7,0,6,0,7,0,6,0,4,0,6,0,8,0,9,0,10,0,6,0,11,0,12,0,13,0,
6,0,1,0,14,0,7,0,6,0,7,0,15,0,1,0,6,0,16,0,17,0,18,0,6,0,19,0,20,0,21,0,
6,0,22,0,0,0,23,0,6,0,24,0,6,0,25,0,6,0,80,65,54,0,0,0,2,0,0,0,2,0,0,0,
4,0,0,0,4,0,0,0,8,0,0,0,8,0,0,0,16,0,0,0,16,0,0,0,32,0,0,0,32,0,0,0,
64,0,0,0,64,0,0,0,0,64,67,0,0,0,67,97,109,101,114,97,48,49,0,0,71,52,0,0,0,189,19,25,
195,136,104,81,64,147,56,182,65,96,233,20,194,67,196,97,190,147,56,182,65,0,0,0,0,85,85,85,66,32,71,14,
0,0,0,0,0,0,0,0,0,122,68,0,176,179,1,0,0,10,176,21,0,0,0,5,0,77,65,88,83,67,69,78,
69,0,44,1,0,0,8,176,14,0,0,0,0,0,0,0,44,1,0,0,9,176,10,0,0,0,128,2,0,0,2,176,
168,0,0,0,48,176,8,0,0,0,0,0,16,176,18,0,0,0,66,111,120,48,49,0,0,64,0,0,255,255,19,176,
18,0,0,0,0,0,0,128,0,0,0,128,0,0,0,128,32,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,53,169,40,65,176,205,90,191,0,0,0,0,33,176,42,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
34,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,
128,63,0,0,128,63,3,176,143,0,0,0,48,176,8,0,0,0,1,0,16,176,21,0,0,0,67,97,109,101,114,97,
48,49,0,0,64,0,0,255,255,32,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
0,0,0,189,19,25,195,136,104,81,64,147,56,182,65,35,176,30,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
0,0,0,0,0,0,0,0,0,0,0,52,66,36,176,40,0,0,0,0,0,0,0,0,0,120,0,0,0,2,0,0,
0,0,0,0,0,0,0,120,13,90,189,120,0,0,0,0,0,99,156,154,194,4,176,73,0,0,0,48,176,8,0,0,
0,2,0,16,176,21,0,0,0,67,97,109,101,114,97,48,49,0,0,64,0,0,255,255,32,176,38,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,96,233,20,194,67,196,97,190,147,56,182,65,
};
#define AIUT_DEF_ERROR_TEXT "sorry, this is a test"
static const aiImporterDesc desc = {
"UNIT TEST - IMPORTER",
"",
"",
"",
0,
0,
0,
0,
0,
"apple mac linux windows"
};
class TestPlugin : public BaseImporter
{
public:
virtual bool CanRead(
const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*test*/) const
{
std::string::size_type pos = pFile.find_last_of('.');
// no file extension - can't read
if( pos == std::string::npos)
return false;
std::string extension = pFile.substr( pos);
// todo ... make case-insensitive
return (extension == ".apple" || extension == ".mac" ||
extension == ".linux" || extension == ".windows" );
}
virtual const aiImporterDesc* GetInfo () const
{
return & desc;
}
virtual void InternReadFile(
const std::string& /*pFile*/, aiScene* /*pScene*/, IOSystem* /*pIOHandler*/)
{
throw DeadlyImportError(AIUT_DEF_ERROR_TEXT);
}
};
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testMemoryRead)
{
const aiScene* sc = pImp->ReadFileFromMemory(InputData_abRawBlock,InputData_BLOCK_SIZE,
aiProcessPreset_TargetRealtime_Quality,"3ds");
ASSERT_TRUE(sc != NULL);
EXPECT_EQ(aiString("<3DSRoot>"), sc->mRootNode->mName);
EXPECT_EQ(1U, sc->mNumMeshes);
EXPECT_EQ(24U, sc->mMeshes[0]->mNumVertices);
EXPECT_EQ(12U, sc->mMeshes[0]->mNumFaces);
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testIntProperty)
{
bool b = pImp->SetPropertyInteger("quakquak",1503);
EXPECT_FALSE(b);
EXPECT_EQ(1503, pImp->GetPropertyInteger("quakquak",0));
EXPECT_EQ(314159, pImp->GetPropertyInteger("not_there",314159));
b = pImp->SetPropertyInteger("quakquak",1504);
EXPECT_TRUE(b);
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testFloatProperty)
{
bool b = pImp->SetPropertyFloat("quakquak",1503.f);
EXPECT_TRUE(!b);
EXPECT_EQ(1503.f, pImp->GetPropertyFloat("quakquak",0.f));
EXPECT_EQ(314159.f, pImp->GetPropertyFloat("not_there",314159.f));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testStringProperty)
{
bool b = pImp->SetPropertyString("quakquak","test");
EXPECT_TRUE(!b);
EXPECT_EQ("test", pImp->GetPropertyString("quakquak","weghwekg"));
EXPECT_EQ("ILoveYou", pImp->GetPropertyString("not_there","ILoveYou"));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testPluginInterface)
{
pImp->RegisterLoader(new TestPlugin());
EXPECT_TRUE(pImp->IsExtensionSupported(".apple"));
EXPECT_TRUE(pImp->IsExtensionSupported(".mac"));
EXPECT_TRUE(pImp->IsExtensionSupported("*.linux"));
EXPECT_TRUE(pImp->IsExtensionSupported("windows"));
EXPECT_TRUE(pImp->IsExtensionSupported(".x")); /* x and 3ds must be available in this Assimp build, of course! */
EXPECT_TRUE(pImp->IsExtensionSupported(".3ds"));
EXPECT_FALSE(pImp->IsExtensionSupported("."));
TestPlugin* p = (TestPlugin*) pImp->GetImporter(".windows");
ASSERT_TRUE(NULL != p);
try {
p->InternReadFile("",0,NULL);
}
catch ( const DeadlyImportError& dead)
{
EXPECT_TRUE(!strcmp(dead.what(),AIUT_DEF_ERROR_TEXT));
// unregister the plugin and delete it
pImp->UnregisterLoader(p);
delete p;
return;
}
EXPECT_TRUE(false); // control shouldn't reach this point
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testExtensionCheck)
{
std::string s;
pImp->GetExtensionList(s);
// TODO
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testMultipleReads)
{
// see http://sourceforge.net/projects/assimp/forums/forum/817654/topic/3591099
// Check whether reading and post-processing multiple times using
// the same objects is *generally* fine. This test doesn't target
// importers. Testing post-processing stability is the main point.
const unsigned int flags =
aiProcess_Triangulate |
aiProcess_JoinIdenticalVertices |
aiProcess_GenSmoothNormals |
aiProcess_ValidateDataStructure |
aiProcess_RemoveRedundantMaterials |
aiProcess_SortByPType |
aiProcess_FindDegenerates |
aiProcess_FindInvalidData |
aiProcess_GenUVCoords |
aiProcess_OptimizeMeshes |
aiProcess_OptimizeGraph;
EXPECT_TRUE(pImp->ReadFile("../test/models/X/test.x",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
EXPECT_TRUE(pImp->ReadFile("../test/models/X/Testwuson.X",flags));
EXPECT_TRUE(pImp->ReadFile("../test/models/X/anim_test.x",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
EXPECT_TRUE(pImp->ReadFile("../test/models/X/anim_test.x",flags));
EXPECT_TRUE(pImp->ReadFile("../test/models/X/BCN_Epileptic.X",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
}
#include "UnitTestPCH.h"
#include "../../include/assimp/postprocess.h"
#include "../../include/assimp/scene.h"
#include <assimp/Importer.hpp>
#include <BaseImporter.h>
using namespace std;
using namespace Assimp;
class ImporterTest : public ::testing::Test
{
public:
virtual void SetUp() { pImp = new Importer(); }
virtual void TearDown() { delete pImp; }
protected:
Importer* pImp;
};
#define InputData_BLOCK_SIZE 1310
// test data for Importer::ReadFileFromMemory() - ./test/3DS/CameraRollAnim.3ds
static unsigned char InputData_abRawBlock[1310] = {
77,77,30,5,0,0,2,0,10,0,0,0,3,0,0,0,61,61,91,3,0,0,62,61,10,0,0,0,3,0,0,0,
0,1,10,0,0,0,0,0,128,63,0,64,254,2,0,0,66,111,120,48,49,0,0,65,242,2,0,0,16,65,64,1,
0,0,26,0,102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,102,74,198,193,0,0,0,0,102,74,198,193,
138,157,184,65,0,0,0,0,205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,102,74,198,193,90,252,26,66,
205,121,55,66,102,74,198,193,90,252,26,66,102,74,198,193,138,157,184,65,90,252,26,66,205,121,55,66,138,157,184,65,
90,252,26,66,102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,102,74,198,193,0,0,0,0,205,121,55,66,
102,74,198,193,90,252,26,66,205,121,55,66,102,74,198,193,90,252,26,66,102,74,198,193,102,74,198,193,90,252,26,66,
102,74,198,193,102,74,198,193,0,0,0,0,205,121,55,66,138,157,184,65,0,0,0,0,205,121,55,66,102,74,198,193,
90,252,26,66,205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,138,157,184,65,0,0,0,0,102,74,198,193,
138,157,184,65,90,252,26,66,102,74,198,193,138,157,184,65,90,252,26,66,205,121,55,66,138,157,184,65,90,252,26,66,
205,121,55,66,138,157,184,65,0,0,0,0,102,74,198,193,138,157,184,65,0,0,0,0,102,74,198,193,102,74,198,193,
90,252,26,66,102,74,198,193,102,74,198,193,90,252,26,66,102,74,198,193,138,157,184,65,0,0,0,0,64,65,216,0,
0,0,26,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,128,63,0,0,0,0,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,128,63,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,
0,0,128,63,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,128,63,0,0,128,63,0,0,128,63,
0,0,128,63,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,
0,0,128,63,0,0,128,63,0,0,128,63,0,0,0,0,0,0,0,0,96,65,54,0,0,0,0,0,128,63,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,63,53,169,
40,65,176,205,90,191,0,0,0,0,32,65,158,0,0,0,12,0,0,0,2,0,3,0,6,0,3,0,1,0,0,0,
6,0,4,0,5,0,7,0,6,0,7,0,6,0,4,0,6,0,8,0,9,0,10,0,6,0,11,0,12,0,13,0,
6,0,1,0,14,0,7,0,6,0,7,0,15,0,1,0,6,0,16,0,17,0,18,0,6,0,19,0,20,0,21,0,
6,0,22,0,0,0,23,0,6,0,24,0,6,0,25,0,6,0,80,65,54,0,0,0,2,0,0,0,2,0,0,0,
4,0,0,0,4,0,0,0,8,0,0,0,8,0,0,0,16,0,0,0,16,0,0,0,32,0,0,0,32,0,0,0,
64,0,0,0,64,0,0,0,0,64,67,0,0,0,67,97,109,101,114,97,48,49,0,0,71,52,0,0,0,189,19,25,
195,136,104,81,64,147,56,182,65,96,233,20,194,67,196,97,190,147,56,182,65,0,0,0,0,85,85,85,66,32,71,14,
0,0,0,0,0,0,0,0,0,122,68,0,176,179,1,0,0,10,176,21,0,0,0,5,0,77,65,88,83,67,69,78,
69,0,44,1,0,0,8,176,14,0,0,0,0,0,0,0,44,1,0,0,9,176,10,0,0,0,128,2,0,0,2,176,
168,0,0,0,48,176,8,0,0,0,0,0,16,176,18,0,0,0,66,111,120,48,49,0,0,64,0,0,255,255,19,176,
18,0,0,0,0,0,0,128,0,0,0,128,0,0,0,128,32,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,53,169,40,65,176,205,90,191,0,0,0,0,33,176,42,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
34,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,128,63,0,0,
128,63,0,0,128,63,3,176,143,0,0,0,48,176,8,0,0,0,1,0,16,176,21,0,0,0,67,97,109,101,114,97,
48,49,0,0,64,0,0,255,255,32,176,38,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
0,0,0,189,19,25,195,136,104,81,64,147,56,182,65,35,176,30,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
0,0,0,0,0,0,0,0,0,0,0,52,66,36,176,40,0,0,0,0,0,0,0,0,0,120,0,0,0,2,0,0,
0,0,0,0,0,0,0,120,13,90,189,120,0,0,0,0,0,99,156,154,194,4,176,73,0,0,0,48,176,8,0,0,
0,2,0,16,176,21,0,0,0,67,97,109,101,114,97,48,49,0,0,64,0,0,255,255,32,176,38,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,96,233,20,194,67,196,97,190,147,56,182,65,
};
#define AIUT_DEF_ERROR_TEXT "sorry, this is a test"
static const aiImporterDesc desc = {
"UNIT TEST - IMPORTER",
"",
"",
"",
0,
0,
0,
0,
0,
"apple mac linux windows"
};
class TestPlugin : public BaseImporter
{
public:
virtual bool CanRead(
const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*test*/) const
{
std::string::size_type pos = pFile.find_last_of('.');
// no file extension - can't read
if( pos == std::string::npos)
return false;
std::string extension = pFile.substr( pos);
// todo ... make case-insensitive
return (extension == ".apple" || extension == ".mac" ||
extension == ".linux" || extension == ".windows" );
}
virtual const aiImporterDesc* GetInfo () const
{
return & desc;
}
virtual void InternReadFile(
const std::string& /*pFile*/, aiScene* /*pScene*/, IOSystem* /*pIOHandler*/)
{
throw DeadlyImportError(AIUT_DEF_ERROR_TEXT);
}
};
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testMemoryRead)
{
const aiScene* sc = pImp->ReadFileFromMemory(InputData_abRawBlock,InputData_BLOCK_SIZE,
aiProcessPreset_TargetRealtime_Quality,"3ds");
ASSERT_TRUE(sc != NULL);
EXPECT_EQ(aiString("<3DSRoot>"), sc->mRootNode->mName);
EXPECT_EQ(1U, sc->mNumMeshes);
EXPECT_EQ(24U, sc->mMeshes[0]->mNumVertices);
EXPECT_EQ(12U, sc->mMeshes[0]->mNumFaces);
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testIntProperty)
{
bool b = pImp->SetPropertyInteger("quakquak",1503);
EXPECT_FALSE(b);
EXPECT_EQ(1503, pImp->GetPropertyInteger("quakquak",0));
EXPECT_EQ(314159, pImp->GetPropertyInteger("not_there",314159));
b = pImp->SetPropertyInteger("quakquak",1504);
EXPECT_TRUE(b);
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testFloatProperty)
{
bool b = pImp->SetPropertyFloat("quakquak",1503.f);
EXPECT_TRUE(!b);
EXPECT_EQ(1503.f, pImp->GetPropertyFloat("quakquak",0.f));
EXPECT_EQ(314159.f, pImp->GetPropertyFloat("not_there",314159.f));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testStringProperty)
{
bool b = pImp->SetPropertyString("quakquak","test");
EXPECT_TRUE(!b);
EXPECT_EQ("test", pImp->GetPropertyString("quakquak","weghwekg"));
EXPECT_EQ("ILoveYou", pImp->GetPropertyString("not_there","ILoveYou"));
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testPluginInterface)
{
pImp->RegisterLoader(new TestPlugin());
EXPECT_TRUE(pImp->IsExtensionSupported(".apple"));
EXPECT_TRUE(pImp->IsExtensionSupported(".mac"));
EXPECT_TRUE(pImp->IsExtensionSupported("*.linux"));
EXPECT_TRUE(pImp->IsExtensionSupported("windows"));
EXPECT_TRUE(pImp->IsExtensionSupported(".x")); /* x and 3ds must be available in this Assimp build, of course! */
EXPECT_TRUE(pImp->IsExtensionSupported(".3ds"));
EXPECT_FALSE(pImp->IsExtensionSupported("."));
TestPlugin* p = (TestPlugin*) pImp->GetImporter(".windows");
ASSERT_TRUE(NULL != p);
try {
p->InternReadFile("",0,NULL);
}
catch ( const DeadlyImportError& dead)
{
EXPECT_TRUE(!strcmp(dead.what(),AIUT_DEF_ERROR_TEXT));
// unregister the plugin and delete it
pImp->UnregisterLoader(p);
delete p;
return;
}
EXPECT_TRUE(false); // control shouldn't reach this point
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testExtensionCheck)
{
std::string s;
pImp->GetExtensionList(s);
// TODO
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testMultipleReads)
{
// see http://sourceforge.net/projects/assimp/forums/forum/817654/topic/3591099
// Check whether reading and post-processing multiple times using
// the same objects is *generally* fine. This test doesn't target
// importers. Testing post-processing stability is the main point.
const unsigned int flags =
aiProcess_Triangulate |
aiProcess_JoinIdenticalVertices |
aiProcess_GenSmoothNormals |
aiProcess_ValidateDataStructure |
aiProcess_RemoveRedundantMaterials |
aiProcess_SortByPType |
aiProcess_FindDegenerates |
aiProcess_FindInvalidData |
aiProcess_GenUVCoords |
aiProcess_OptimizeMeshes |
aiProcess_OptimizeGraph;
EXPECT_TRUE(pImp->ReadFile("../test/models/X/test.x",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
EXPECT_TRUE(pImp->ReadFile("../test/models/X/Testwuson.X",flags));
EXPECT_TRUE(pImp->ReadFile("../test/models/X/anim_test.x",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
EXPECT_TRUE(pImp->ReadFile("../test/models/X/anim_test.x",flags));
EXPECT_TRUE(pImp->ReadFile("../test/models/X/BCN_Epileptic.X",flags));
//EXPECT_TRUE(pImp->ReadFile("../../test/models/X/dwarf.x",flags)); # is in nonbsd
}

2
test/unit/utImproveCacheLocality.cpp
View File

@ -1,2 +1,2 @@
#include "UnitTestPCH.h"

210
test/unit/utJoinVertices.cpp
View File

@ -1,105 +1,105 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <JoinVerticesProcess.h>
using namespace std;
using namespace Assimp;
class JoinVerticesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
JoinVerticesProcess* piProcess;
aiMesh* pcMesh;
};
// ------------------------------------------------------------------------------------------------
void JoinVerticesTest::SetUp()
{
// construct the process
piProcess = new JoinVerticesProcess();
// create a quite small mesh for testing purposes -
// the mesh itself is *something* but it has redundant vertices
pcMesh = new aiMesh();
pcMesh->mNumVertices = 900;
aiVector3D*& pv = pcMesh->mVertices = new aiVector3D[900];
for (unsigned int i = 0; i < 3;++i)
{
const unsigned int base = i*300;
for (unsigned int a = 0; a < 300;++a)
{
pv[base+a].x = pv[base+a].y = pv[base+a].z = (float)a;
}
}
// generate faces - each vertex is referenced once
pcMesh->mNumFaces = 300;
pcMesh->mFaces = new aiFace[300];
for (unsigned int i = 0,p = 0; i < 300;++i)
{
aiFace& face = pcMesh->mFaces[i];
face.mIndices = new unsigned int[ face.mNumIndices = 3 ];
for (unsigned int a = 0; a < 3;++a)
face.mIndices[a] = p++;
}
// generate extra members - set them to zero to make sure they're identical
pcMesh->mTextureCoords[0] = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mTextureCoords[0][i] = aiVector3D( 0.f );
pcMesh->mNormals = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mNormals[i] = aiVector3D( 0.f );
pcMesh->mTangents = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mTangents[i] = aiVector3D( 0.f );
pcMesh->mBitangents = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mBitangents[i] = aiVector3D( 0.f );
}
// ------------------------------------------------------------------------------------------------
void JoinVerticesTest::TearDown()
{
delete this->pcMesh;
delete this->piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(JoinVerticesTest, testProcess)
{
// execute the step on the given data
piProcess->ProcessMesh(pcMesh,0);
// the number of faces shouldn't change
ASSERT_EQ(300U, pcMesh->mNumFaces);
ASSERT_EQ(300U, pcMesh->mNumVertices);
ASSERT_TRUE(NULL != pcMesh->mNormals);
ASSERT_TRUE(NULL != pcMesh->mTangents);
ASSERT_TRUE(NULL != pcMesh->mBitangents);
ASSERT_TRUE(NULL != pcMesh->mTextureCoords[0]);
// the order doesn't care
float fSum = 0.f;
for (unsigned int i = 0; i < 300;++i)
{
aiVector3D& v = pcMesh->mVertices[i];
fSum += v.x + v.y + v.z;
EXPECT_FALSE(pcMesh->mNormals[i].x);
EXPECT_FALSE(pcMesh->mTangents[i].x);
EXPECT_FALSE(pcMesh->mBitangents[i].x);
EXPECT_FALSE(pcMesh->mTextureCoords[0][i].x);
}
EXPECT_EQ(150.f*299.f*3.f, fSum); // gaussian sum equation
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <JoinVerticesProcess.h>
using namespace std;
using namespace Assimp;
class JoinVerticesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
JoinVerticesProcess* piProcess;
aiMesh* pcMesh;
};
// ------------------------------------------------------------------------------------------------
void JoinVerticesTest::SetUp()
{
// construct the process
piProcess = new JoinVerticesProcess();
// create a quite small mesh for testing purposes -
// the mesh itself is *something* but it has redundant vertices
pcMesh = new aiMesh();
pcMesh->mNumVertices = 900;
aiVector3D*& pv = pcMesh->mVertices = new aiVector3D[900];
for (unsigned int i = 0; i < 3;++i)
{
const unsigned int base = i*300;
for (unsigned int a = 0; a < 300;++a)
{
pv[base+a].x = pv[base+a].y = pv[base+a].z = (float)a;
}
}
// generate faces - each vertex is referenced once
pcMesh->mNumFaces = 300;
pcMesh->mFaces = new aiFace[300];
for (unsigned int i = 0,p = 0; i < 300;++i)
{
aiFace& face = pcMesh->mFaces[i];
face.mIndices = new unsigned int[ face.mNumIndices = 3 ];
for (unsigned int a = 0; a < 3;++a)
face.mIndices[a] = p++;
}
// generate extra members - set them to zero to make sure they're identical
pcMesh->mTextureCoords[0] = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mTextureCoords[0][i] = aiVector3D( 0.f );
pcMesh->mNormals = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mNormals[i] = aiVector3D( 0.f );
pcMesh->mTangents = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mTangents[i] = aiVector3D( 0.f );
pcMesh->mBitangents = new aiVector3D[900];
for (unsigned int i = 0; i < 900;++i)pcMesh->mBitangents[i] = aiVector3D( 0.f );
}
// ------------------------------------------------------------------------------------------------
void JoinVerticesTest::TearDown()
{
delete this->pcMesh;
delete this->piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(JoinVerticesTest, testProcess)
{
// execute the step on the given data
piProcess->ProcessMesh(pcMesh,0);
// the number of faces shouldn't change
ASSERT_EQ(300U, pcMesh->mNumFaces);
ASSERT_EQ(300U, pcMesh->mNumVertices);
ASSERT_TRUE(NULL != pcMesh->mNormals);
ASSERT_TRUE(NULL != pcMesh->mTangents);
ASSERT_TRUE(NULL != pcMesh->mBitangents);
ASSERT_TRUE(NULL != pcMesh->mTextureCoords[0]);
// the order doesn't care
float fSum = 0.f;
for (unsigned int i = 0; i < 300;++i)
{
aiVector3D& v = pcMesh->mVertices[i];
fSum += v.x + v.y + v.z;
EXPECT_FALSE(pcMesh->mNormals[i].x);
EXPECT_FALSE(pcMesh->mTangents[i].x);
EXPECT_FALSE(pcMesh->mBitangents[i].x);
EXPECT_FALSE(pcMesh->mTextureCoords[0][i].x);
}
EXPECT_EQ(150.f*299.f*3.f, fSum); // gaussian sum equation
}

202
test/unit/utLimitBoneWeights.cpp
View File

@ -1,101 +1,101 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <LimitBoneWeightsProcess.h>
using namespace std;
using namespace Assimp;
class LimitBoneWeightsTest : public ::testing::Test {
public:
virtual void SetUp();
virtual void TearDown();
protected:
LimitBoneWeightsProcess* piProcess;
aiMesh* pcMesh;
};
// ------------------------------------------------------------------------------------------------
void LimitBoneWeightsTest::SetUp()
{
// construct the process
this->piProcess = new LimitBoneWeightsProcess();
// now need to create a nice mesh for testing purposes
this->pcMesh = new aiMesh();
pcMesh->mNumVertices = 500;
pcMesh->mVertices = new aiVector3D[500]; // uninit.
pcMesh->mNumBones = 30;
pcMesh->mBones = new aiBone*[30];
unsigned int iCur = 0;
for (unsigned int i = 0; i < 30;++i)
{
aiBone* pc = pcMesh->mBones[i] = new aiBone();
pc->mNumWeights = 250;
pc->mWeights = new aiVertexWeight[pc->mNumWeights];
for (unsigned int qq = 0; qq < pc->mNumWeights;++qq)
{
aiVertexWeight& v = pc->mWeights[qq];
v.mVertexId = iCur++;
if (500 == iCur)iCur = 0;
v.mWeight = 1.0f / 15; // each vertex should occur once in two bones
}
}
}
// ------------------------------------------------------------------------------------------------
void LimitBoneWeightsTest::TearDown()
{
delete pcMesh;
delete piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(LimitBoneWeightsTest, testProcess)
{
// execute the step on the given data
piProcess->ProcessMesh(pcMesh);
// check whether everything is ok ...
typedef std::vector<LimitBoneWeightsProcess::Weight> VertexWeightList;
VertexWeightList* asWeights = new VertexWeightList[pcMesh->mNumVertices];
for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
asWeights[i].reserve(4);
// sort back as per-vertex lists
for (unsigned int i = 0; i < pcMesh->mNumBones;++i)
{
aiBone& pcBone = **(pcMesh->mBones+i);
for (unsigned int q = 0; q < pcBone.mNumWeights;++q)
{
aiVertexWeight weight = pcBone.mWeights[q];
asWeights[weight.mVertexId].push_back(LimitBoneWeightsProcess::Weight (i,weight.mWeight));
}
}
// now validate the size of the lists and check whether all weights sum to 1.0f
for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
{
EXPECT_LE(asWeights[i].size(), 4U);
float fSum = 0.0f;
for (VertexWeightList::const_iterator
iter = asWeights[i].begin();
iter != asWeights[i].end();++iter)
{
fSum += (*iter).mWeight;
}
EXPECT_GE(fSum, 0.95F);
EXPECT_LE(fSum, 1.04F);
}
// delete allocated storage
delete[] asWeights;
// everything seems to be OK
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <LimitBoneWeightsProcess.h>
using namespace std;
using namespace Assimp;
class LimitBoneWeightsTest : public ::testing::Test {
public:
virtual void SetUp();
virtual void TearDown();
protected:
LimitBoneWeightsProcess* piProcess;
aiMesh* pcMesh;
};
// ------------------------------------------------------------------------------------------------
void LimitBoneWeightsTest::SetUp()
{
// construct the process
this->piProcess = new LimitBoneWeightsProcess();
// now need to create a nice mesh for testing purposes
this->pcMesh = new aiMesh();
pcMesh->mNumVertices = 500;
pcMesh->mVertices = new aiVector3D[500]; // uninit.
pcMesh->mNumBones = 30;
pcMesh->mBones = new aiBone*[30];
unsigned int iCur = 0;
for (unsigned int i = 0; i < 30;++i)
{
aiBone* pc = pcMesh->mBones[i] = new aiBone();
pc->mNumWeights = 250;
pc->mWeights = new aiVertexWeight[pc->mNumWeights];
for (unsigned int qq = 0; qq < pc->mNumWeights;++qq)
{
aiVertexWeight& v = pc->mWeights[qq];
v.mVertexId = iCur++;
if (500 == iCur)iCur = 0;
v.mWeight = 1.0f / 15; // each vertex should occur once in two bones
}
}
}
// ------------------------------------------------------------------------------------------------
void LimitBoneWeightsTest::TearDown()
{
delete pcMesh;
delete piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(LimitBoneWeightsTest, testProcess)
{
// execute the step on the given data
piProcess->ProcessMesh(pcMesh);
// check whether everything is ok ...
typedef std::vector<LimitBoneWeightsProcess::Weight> VertexWeightList;
VertexWeightList* asWeights = new VertexWeightList[pcMesh->mNumVertices];
for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
asWeights[i].reserve(4);
// sort back as per-vertex lists
for (unsigned int i = 0; i < pcMesh->mNumBones;++i)
{
aiBone& pcBone = **(pcMesh->mBones+i);
for (unsigned int q = 0; q < pcBone.mNumWeights;++q)
{
aiVertexWeight weight = pcBone.mWeights[q];
asWeights[weight.mVertexId].push_back(LimitBoneWeightsProcess::Weight (i,weight.mWeight));
}
}
// now validate the size of the lists and check whether all weights sum to 1.0f
for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
{
EXPECT_LE(asWeights[i].size(), 4U);
float fSum = 0.0f;
for (VertexWeightList::const_iterator
iter = asWeights[i].begin();
iter != asWeights[i].end();++iter)
{
fSum += (*iter).mWeight;
}
EXPECT_GE(fSum, 0.95F);
EXPECT_LE(fSum, 1.04F);
}
// delete allocated storage
delete[] asWeights;
// everything seems to be OK
}

184
test/unit/utMaterialSystem.cpp
View File

@ -1,92 +1,92 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class MaterialSystemTest : public ::testing::Test
{
public:
virtual void SetUp() { this->pcMat = new aiMaterial(); }
virtual void TearDown() { delete this->pcMat; }
protected:
aiMaterial* pcMat;
};
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testFloatProperty)
{
float pf = 150392.63f;
this->pcMat->AddProperty(&pf,1,"testKey1");
pf = 0.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey1",0,0,pf));
EXPECT_EQ(150392.63f, pf);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testFloatArrayProperty)
{
float pf[] = {0.0f,1.0f,2.0f,3.0f};
unsigned int pMax = sizeof(pf) / sizeof(float);
this->pcMat->AddProperty(&pf,pMax,"testKey2");
pf[0] = pf[1] = pf[2] = pf[3] = 12.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey2",0,0,pf,&pMax));
EXPECT_EQ(sizeof(pf) / sizeof(float), pMax);
EXPECT_TRUE(!pf[0] && 1.0f == pf[1] && 2.0f == pf[2] && 3.0f == pf[3] );
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testIntProperty)
{
int pf = 15039263;
this->pcMat->AddProperty(&pf,1,"testKey3");
pf = 12;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey3",0,0,pf));
EXPECT_EQ(15039263, pf);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testIntArrayProperty)
{
int pf[] = {0,1,2,3};
unsigned int pMax = sizeof(pf) / sizeof(int);
this->pcMat->AddProperty(&pf,pMax,"testKey4");
pf[0] = pf[1] = pf[2] = pf[3] = 12;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey4",0,0,pf,&pMax));
EXPECT_EQ(sizeof(pf) / sizeof(int), pMax);
EXPECT_TRUE(!pf[0] && 1 == pf[1] && 2 == pf[2] && 3 == pf[3] );
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testColorProperty)
{
aiColor4D clr;
clr.r = 2.0f;clr.g = 3.0f;clr.b = 4.0f;clr.a = 5.0f;
this->pcMat->AddProperty(&clr,1,"testKey5");
clr.b = 1.0f;
clr.a = clr.g = clr.r = 0.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey5",0,0,clr));
EXPECT_TRUE(clr.r == 2.0f && clr.g == 3.0f && clr.b == 4.0f && clr.a == 5.0f);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testStringProperty)
{
aiString s;
s.Set("Hello, this is a small test");
this->pcMat->AddProperty(&s,"testKey6");
s.Set("358358");
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey6",0,0,s));
EXPECT_STREQ("Hello, this is a small test", s.data);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class MaterialSystemTest : public ::testing::Test
{
public:
virtual void SetUp() { this->pcMat = new aiMaterial(); }
virtual void TearDown() { delete this->pcMat; }
protected:
aiMaterial* pcMat;
};
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testFloatProperty)
{
float pf = 150392.63f;
this->pcMat->AddProperty(&pf,1,"testKey1");
pf = 0.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey1",0,0,pf));
EXPECT_EQ(150392.63f, pf);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testFloatArrayProperty)
{
float pf[] = {0.0f,1.0f,2.0f,3.0f};
unsigned int pMax = sizeof(pf) / sizeof(float);
this->pcMat->AddProperty(&pf,pMax,"testKey2");
pf[0] = pf[1] = pf[2] = pf[3] = 12.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey2",0,0,pf,&pMax));
EXPECT_EQ(sizeof(pf) / sizeof(float), pMax);
EXPECT_TRUE(!pf[0] && 1.0f == pf[1] && 2.0f == pf[2] && 3.0f == pf[3] );
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testIntProperty)
{
int pf = 15039263;
this->pcMat->AddProperty(&pf,1,"testKey3");
pf = 12;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey3",0,0,pf));
EXPECT_EQ(15039263, pf);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testIntArrayProperty)
{
int pf[] = {0,1,2,3};
unsigned int pMax = sizeof(pf) / sizeof(int);
this->pcMat->AddProperty(&pf,pMax,"testKey4");
pf[0] = pf[1] = pf[2] = pf[3] = 12;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey4",0,0,pf,&pMax));
EXPECT_EQ(sizeof(pf) / sizeof(int), pMax);
EXPECT_TRUE(!pf[0] && 1 == pf[1] && 2 == pf[2] && 3 == pf[3] );
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testColorProperty)
{
aiColor4D clr;
clr.r = 2.0f;clr.g = 3.0f;clr.b = 4.0f;clr.a = 5.0f;
this->pcMat->AddProperty(&clr,1,"testKey5");
clr.b = 1.0f;
clr.a = clr.g = clr.r = 0.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey5",0,0,clr));
EXPECT_TRUE(clr.r == 2.0f && clr.g == 3.0f && clr.b == 4.0f && clr.a == 5.0f);
}
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testStringProperty)
{
aiString s;
s.Set("Hello, this is a small test");
this->pcMat->AddProperty(&s,"testKey6");
s.Set("358358");
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey6",0,0,s));
EXPECT_STREQ("Hello, this is a small test", s.data);
}

144
test/unit/utNoBoostTest.cpp
View File

@ -1,72 +1,72 @@
#include "UnitTestPCH.h"
#include "BoostWorkaround/boost/tuple/tuple.hpp"
#define ASSIMP_FORCE_NOBOOST
#include "BoostWorkaround/boost/format.hpp"
using namespace std;
using namespace Assimp;
using boost::format;
using boost::str;
// ------------------------------------------------------------------------------------------------
TEST(NoBoostTest, testFormat)
{
EXPECT_EQ( "Ahoi!", boost::str( boost::format("Ahoi!") ));
EXPECT_EQ( "Ahoi! %", boost::str( boost::format("Ahoi! %%") ));
EXPECT_EQ( "Ahoi! ", boost::str( boost::format("Ahoi! %s") ));
EXPECT_EQ( "Ahoi! !!", boost::str( boost::format("Ahoi! %s") % "!!" ));
EXPECT_EQ( "Ahoi! !!", boost::str( boost::format("Ahoi! %s") % "!!" % "!!" ));
EXPECT_EQ( "abc", boost::str( boost::format("%s%s%s") % "a" % std::string("b") % "c" ));
}
struct another
{
int dummy;
};
// ------------------------------------------------------------------------------------------------
TEST(NoBoostTest, Tuple) {
// Implicit conversion
boost::tuple<unsigned,unsigned,unsigned> first = boost::make_tuple(4,4,4);
EXPECT_EQ(4U, first.get<0>());
EXPECT_EQ(4U, first.get<1>());
EXPECT_EQ(4U, first.get<2>());
boost::tuple<int,float,double,bool,another> second;
bool b = second.get<3>();
EXPECT_FALSE(b);
// check empty tuple, ignore compile warning
boost::tuple<> third;
// FIXME: Explicit conversion not really required yet
boost::tuple<float,float,float> last =
(boost::tuple<float,float,float>)boost::make_tuple(1.,2.,3.);
EXPECT_EQ(1.f, last.get<0>());
EXPECT_EQ(2.f, last.get<1>());
EXPECT_EQ(3.f, last.get<2>());
// Non-const access
first.get<0>() = 1;
first.get<1>() = 2;
first.get<2>() = 3;
EXPECT_EQ(1U, first.get<0>());
EXPECT_EQ(2U, first.get<1>());
EXPECT_EQ(3U, first.get<2>());
// Const cases
const boost::tuple<unsigned,unsigned,unsigned> constant = boost::make_tuple(5,5,5);
first.get<0>() = constant.get<0>();
EXPECT_EQ(5U, constant.get<0>());
EXPECT_EQ(5U, first.get<0>());
// Direct assignment w. explicit conversion
last = first;
EXPECT_EQ(5.f, last.get<0>());
EXPECT_EQ(2.f, last.get<1>());
EXPECT_EQ(3.f, last.get<2>());
}
#include "UnitTestPCH.h"
#include "BoostWorkaround/boost/tuple/tuple.hpp"
#define ASSIMP_FORCE_NOBOOST
#include "BoostWorkaround/boost/format.hpp"
using namespace std;
using namespace Assimp;
using boost::format;
using boost::str;
// ------------------------------------------------------------------------------------------------
TEST(NoBoostTest, testFormat)
{
EXPECT_EQ( "Ahoi!", boost::str( boost::format("Ahoi!") ));
EXPECT_EQ( "Ahoi! %", boost::str( boost::format("Ahoi! %%") ));
EXPECT_EQ( "Ahoi! ", boost::str( boost::format("Ahoi! %s") ));
EXPECT_EQ( "Ahoi! !!", boost::str( boost::format("Ahoi! %s") % "!!" ));
EXPECT_EQ( "Ahoi! !!", boost::str( boost::format("Ahoi! %s") % "!!" % "!!" ));
EXPECT_EQ( "abc", boost::str( boost::format("%s%s%s") % "a" % std::string("b") % "c" ));
}
struct another
{
int dummy;
};
// ------------------------------------------------------------------------------------------------
TEST(NoBoostTest, Tuple) {
// Implicit conversion
boost::tuple<unsigned,unsigned,unsigned> first = boost::make_tuple(4,4,4);
EXPECT_EQ(4U, first.get<0>());
EXPECT_EQ(4U, first.get<1>());
EXPECT_EQ(4U, first.get<2>());
boost::tuple<int,float,double,bool,another> second;
bool b = second.get<3>();
EXPECT_FALSE(b);
// check empty tuple, ignore compile warning
boost::tuple<> third;
// FIXME: Explicit conversion not really required yet
boost::tuple<float,float,float> last =
(boost::tuple<float,float,float>)boost::make_tuple(1.,2.,3.);
EXPECT_EQ(1.f, last.get<0>());
EXPECT_EQ(2.f, last.get<1>());
EXPECT_EQ(3.f, last.get<2>());
// Non-const access
first.get<0>() = 1;
first.get<1>() = 2;
first.get<2>() = 3;
EXPECT_EQ(1U, first.get<0>());
EXPECT_EQ(2U, first.get<1>());
EXPECT_EQ(3U, first.get<2>());
// Const cases
const boost::tuple<unsigned,unsigned,unsigned> constant = boost::make_tuple(5,5,5);
first.get<0>() = constant.get<0>();
EXPECT_EQ(5U, constant.get<0>());
EXPECT_EQ(5U, first.get<0>());
// Direct assignment w. explicit conversion
last = first;
EXPECT_EQ(5.f, last.get<0>());
EXPECT_EQ(2.f, last.get<1>());
EXPECT_EQ(3.f, last.get<2>());
}

222
test/unit/utPretransformVertices.cpp
View File

@ -1,111 +1,111 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <PretransformVertices.h>
using namespace std;
using namespace Assimp;
class PretransformVerticesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiScene* scene;
PretransformVertices* process;
};
// ------------------------------------------------------------------------------------------------
void AddNodes(unsigned int num, aiNode* father, unsigned int depth)
{
father->mChildren = new aiNode*[father->mNumChildren = 5];
for (unsigned int i = 0; i < 5; ++i) {
aiNode* nd = father->mChildren[i] = new aiNode();
nd->mName.length = sprintf(nd->mName.data,"%i%i",depth,i);
// spawn two meshes
nd->mMeshes = new unsigned int[nd->mNumMeshes = 2];
nd->mMeshes[0] = num*5+i;
nd->mMeshes[1] = 24-(num*5+i); // mesh 12 is special ... it references the same mesh twice
// setup an unique transformation matrix
nd->mTransformation.a1 = num*5.f+i + 1;
}
if (depth > 1) {
for (unsigned int i = 0; i < 5; ++i)
AddNodes(i, father->mChildren[i],depth-1);
}
}
// ------------------------------------------------------------------------------------------------
void PretransformVerticesTest::SetUp()
{
scene = new aiScene();
// add 5 empty materials
scene->mMaterials = new aiMaterial*[scene->mNumMaterials = 5];
for (unsigned int i = 0; i < 5;++i)
scene->mMaterials[i] = new aiMaterial();
// add 25 test meshes
scene->mMeshes = new aiMesh*[scene->mNumMeshes = 25];
for (unsigned int i = 0; i < 25;++i) {
aiMesh* mesh = scene->mMeshes[i] = new aiMesh();
mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
mesh->mFaces = new aiFace[ mesh->mNumFaces = 10+i ];
mesh->mVertices = new aiVector3D[mesh->mNumVertices = mesh->mNumFaces];
for (unsigned int a = 0; a < mesh->mNumFaces; ++a ) {
aiFace& f = mesh->mFaces[a];
f.mIndices = new unsigned int [f.mNumIndices = 1];
f.mIndices[0] = a*3;
mesh->mVertices[a] = aiVector3D((float)i,(float)a,0.f);
}
mesh->mMaterialIndex = i%5;
if (i % 2)
mesh->mNormals = new aiVector3D[mesh->mNumVertices];
}
// construct some nodes (1+25)
scene->mRootNode = new aiNode();
scene->mRootNode->mName.Set("Root");
AddNodes(0,scene->mRootNode,2);
process = new PretransformVertices();
}
// ------------------------------------------------------------------------------------------------
void PretransformVerticesTest::TearDown()
{
delete scene;
delete process;
}
// ------------------------------------------------------------------------------------------------
TEST_F(PretransformVerticesTest, testProcessCollapseHierarchy)
{
process->KeepHierarchy(false);
process->Execute(scene);
EXPECT_EQ(5U, scene->mNumMaterials);
EXPECT_EQ(10U, scene->mNumMeshes); // every second mesh has normals
}
// ------------------------------------------------------------------------------------------------
TEST_F(PretransformVerticesTest, testProcessKeepHierarchy)
{
process->KeepHierarchy(true);
process->Execute(scene);
EXPECT_EQ(5U, scene->mNumMaterials);
EXPECT_EQ(49U, scene->mNumMeshes); // see note on mesh 12 above
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <PretransformVertices.h>
using namespace std;
using namespace Assimp;
class PretransformVerticesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiScene* scene;
PretransformVertices* process;
};
// ------------------------------------------------------------------------------------------------
void AddNodes(unsigned int num, aiNode* father, unsigned int depth)
{
father->mChildren = new aiNode*[father->mNumChildren = 5];
for (unsigned int i = 0; i < 5; ++i) {
aiNode* nd = father->mChildren[i] = new aiNode();
nd->mName.length = sprintf(nd->mName.data,"%i%i",depth,i);
// spawn two meshes
nd->mMeshes = new unsigned int[nd->mNumMeshes = 2];
nd->mMeshes[0] = num*5+i;
nd->mMeshes[1] = 24-(num*5+i); // mesh 12 is special ... it references the same mesh twice
// setup an unique transformation matrix
nd->mTransformation.a1 = num*5.f+i + 1;
}
if (depth > 1) {
for (unsigned int i = 0; i < 5; ++i)
AddNodes(i, father->mChildren[i],depth-1);
}
}
// ------------------------------------------------------------------------------------------------
void PretransformVerticesTest::SetUp()
{
scene = new aiScene();
// add 5 empty materials
scene->mMaterials = new aiMaterial*[scene->mNumMaterials = 5];
for (unsigned int i = 0; i < 5;++i)
scene->mMaterials[i] = new aiMaterial();
// add 25 test meshes
scene->mMeshes = new aiMesh*[scene->mNumMeshes = 25];
for (unsigned int i = 0; i < 25;++i) {
aiMesh* mesh = scene->mMeshes[i] = new aiMesh();
mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
mesh->mFaces = new aiFace[ mesh->mNumFaces = 10+i ];
mesh->mVertices = new aiVector3D[mesh->mNumVertices = mesh->mNumFaces];
for (unsigned int a = 0; a < mesh->mNumFaces; ++a ) {
aiFace& f = mesh->mFaces[a];
f.mIndices = new unsigned int [f.mNumIndices = 1];
f.mIndices[0] = a*3;
mesh->mVertices[a] = aiVector3D((float)i,(float)a,0.f);
}
mesh->mMaterialIndex = i%5;
if (i % 2)
mesh->mNormals = new aiVector3D[mesh->mNumVertices];
}
// construct some nodes (1+25)
scene->mRootNode = new aiNode();
scene->mRootNode->mName.Set("Root");
AddNodes(0,scene->mRootNode,2);
process = new PretransformVertices();
}
// ------------------------------------------------------------------------------------------------
void PretransformVerticesTest::TearDown()
{
delete scene;
delete process;
}
// ------------------------------------------------------------------------------------------------
TEST_F(PretransformVerticesTest, testProcessCollapseHierarchy)
{
process->KeepHierarchy(false);
process->Execute(scene);
EXPECT_EQ(5U, scene->mNumMaterials);
EXPECT_EQ(10U, scene->mNumMeshes); // every second mesh has normals
}
// ------------------------------------------------------------------------------------------------
TEST_F(PretransformVerticesTest, testProcessKeepHierarchy)
{
process->KeepHierarchy(true);
process->Execute(scene);
EXPECT_EQ(5U, scene->mNumMaterials);
EXPECT_EQ(49U, scene->mNumMeshes); // see note on mesh 12 above
}

110
test/unit/utRemoveComments.cpp
View File

@ -1,55 +1,55 @@
#include "UnitTestPCH.h"
#include <RemoveComments.h>
using namespace std;
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
TEST(RemoveCommentsTest, testSingleLineComments)
{
const char* szTest = "int i = 0; \n"
"if (4 == //)\n"
"\ttrue) { // do something here \n"
"\t// hello ... and bye //\n";
char* szTest2 = new char[::strlen(szTest)+1];
::strcpy(szTest2,szTest);
const char* szTestResult = "int i = 0; \n"
"if (4 == \n"
"\ttrue) { \n"
"\t \n";
CommentRemover::RemoveLineComments("//",szTest2,' ');
EXPECT_STREQ(szTestResult, szTest2);
delete[] szTest2;
}
// ------------------------------------------------------------------------------------------------
TEST(RemoveCommentsTest, testMultiLineComments)
{
const char* szTest =
"/* comment to be removed */\n"
"valid text /* \n "
" comment across multiple lines */"
" / * Incomplete comment */ /* /* multiple comments */ */";
const char* szTestResult =
" \n"
"valid text "
" "
" / * Incomplete comment */ */";
char* szTest2 = new char[::strlen(szTest)+1];
::strcpy(szTest2,szTest);
CommentRemover::RemoveMultiLineComments("/*","*/",szTest2,' ');
EXPECT_STREQ(szTestResult, szTest2);
delete[] szTest2;
}
#include "UnitTestPCH.h"
#include <RemoveComments.h>
using namespace std;
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
TEST(RemoveCommentsTest, testSingleLineComments)
{
const char* szTest = "int i = 0; \n"
"if (4 == //)\n"
"\ttrue) { // do something here \n"
"\t// hello ... and bye //\n";
char* szTest2 = new char[::strlen(szTest)+1];
::strcpy(szTest2,szTest);
const char* szTestResult = "int i = 0; \n"
"if (4 == \n"
"\ttrue) { \n"
"\t \n";
CommentRemover::RemoveLineComments("//",szTest2,' ');
EXPECT_STREQ(szTestResult, szTest2);
delete[] szTest2;
}
// ------------------------------------------------------------------------------------------------
TEST(RemoveCommentsTest, testMultiLineComments)
{
const char* szTest =
"/* comment to be removed */\n"
"valid text /* \n "
" comment across multiple lines */"
" / * Incomplete comment */ /* /* multiple comments */ */";
const char* szTestResult =
" \n"
"valid text "
" "
" / * Incomplete comment */ */";
char* szTest2 = new char[::strlen(szTest)+1];
::strcpy(szTest2,szTest);
CommentRemover::RemoveMultiLineComments("/*","*/",szTest2,' ');
EXPECT_STREQ(szTestResult, szTest2);
delete[] szTest2;
}

380
test/unit/utRemoveComponent.cpp
View File

@ -1,190 +1,190 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <RemoveVCProcess.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class RemoveVCProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
RemoveVCProcess* piProcess;
aiScene* pScene;
};
// ------------------------------------------------------------------------------------------------
void RemoveVCProcessTest::SetUp()
{
// construct the process
piProcess = new RemoveVCProcess();
pScene = new aiScene();
// fill the scene ..
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes = 2];
pScene->mMeshes[0] = new aiMesh();
pScene->mMeshes[1] = new aiMesh();
pScene->mMeshes[0]->mNumVertices = 120;
pScene->mMeshes[0]->mVertices = new aiVector3D[120];
pScene->mMeshes[0]->mNormals = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[0] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[1] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[2] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[3] = new aiVector3D[120];
pScene->mMeshes[1]->mNumVertices = 120;
pScene->mMeshes[1]->mVertices = new aiVector3D[120];
pScene->mAnimations = new aiAnimation*[pScene->mNumAnimations = 2];
pScene->mAnimations[0] = new aiAnimation();
pScene->mAnimations[1] = new aiAnimation();
pScene->mTextures = new aiTexture*[pScene->mNumTextures = 2];
pScene->mTextures[0] = new aiTexture();
pScene->mTextures[1] = new aiTexture();
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = 2];
pScene->mMaterials[0] = new aiMaterial();
pScene->mMaterials[1] = new aiMaterial();
pScene->mLights = new aiLight*[pScene->mNumLights = 2];
pScene->mLights[0] = new aiLight();
pScene->mLights[1] = new aiLight();
pScene->mCameras = new aiCamera*[pScene->mNumCameras = 2];
pScene->mCameras[0] = new aiCamera();
pScene->mCameras[1] = new aiCamera();
// COMPILE TEST: aiMaterial may no add any extra members,
// so we don't need a virtual destructor
char check[sizeof(aiMaterial) == sizeof(aiMaterial) ? 10 : -1];
check[0] = 0;
// to remove compiler warning
EXPECT_TRUE( check );
}
// ------------------------------------------------------------------------------------------------
void RemoveVCProcessTest::TearDown()
{
delete pScene;
delete piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshRemove)
{
piProcess->SetDeleteFlags(aiComponent_MESHES);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mMeshes);
EXPECT_EQ(0U, pScene->mNumMeshes);
EXPECT_TRUE(pScene->mFlags == AI_SCENE_FLAGS_INCOMPLETE);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testAnimRemove)
{
piProcess->SetDeleteFlags(aiComponent_ANIMATIONS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mAnimations);
EXPECT_EQ(0U, pScene->mNumAnimations);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMaterialRemove)
{
piProcess->SetDeleteFlags(aiComponent_MATERIALS);
piProcess->Execute(pScene);
// there should be one default material now ...
EXPECT_TRUE(1 == pScene->mNumMaterials &&
pScene->mMeshes[0]->mMaterialIndex == 0 &&
pScene->mMeshes[1]->mMaterialIndex == 0);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testTextureRemove)
{
piProcess->SetDeleteFlags(aiComponent_TEXTURES);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mTextures);
EXPECT_EQ(0U, pScene->mNumTextures);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testCameraRemove)
{
piProcess->SetDeleteFlags(aiComponent_CAMERAS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mCameras);
EXPECT_EQ(0U, pScene->mNumCameras);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testLightRemove)
{
piProcess->SetDeleteFlags(aiComponent_LIGHTS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mLights);
EXPECT_EQ(0U, pScene->mNumLights);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshComponentsRemoveA)
{
piProcess->SetDeleteFlags(aiComponent_TEXCOORDSn(1) | aiComponent_TEXCOORDSn(2) | aiComponent_TEXCOORDSn(3));
piProcess->Execute(pScene);
EXPECT_TRUE(pScene->mMeshes[0]->mTextureCoords[0] &&
!pScene->mMeshes[0]->mTextureCoords[1] &&
!pScene->mMeshes[0]->mTextureCoords[2] &&
!pScene->mMeshes[0]->mTextureCoords[3]);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshComponentsRemoveB)
{
piProcess->SetDeleteFlags(aiComponent_TEXCOORDSn(1) | aiComponent_NORMALS);
piProcess->Execute(pScene);
EXPECT_TRUE(pScene->mMeshes[0]->mTextureCoords[0] &&
pScene->mMeshes[0]->mTextureCoords[1] &&
pScene->mMeshes[0]->mTextureCoords[2] && // shift forward ...
!pScene->mMeshes[0]->mTextureCoords[3] &&
!pScene->mMeshes[0]->mNormals);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testRemoveEverything)
{
piProcess->SetDeleteFlags(aiComponent_LIGHTS | aiComponent_ANIMATIONS |
aiComponent_MATERIALS | aiComponent_MESHES | aiComponent_CAMERAS | aiComponent_TEXTURES);
piProcess->Execute(pScene);
EXPECT_EQ(0U, pScene->mNumAnimations);
EXPECT_EQ(0U, pScene->mNumCameras);
EXPECT_EQ(0U, pScene->mNumLights);
EXPECT_EQ(0U, pScene->mNumMeshes);
EXPECT_EQ(0U, pScene->mNumTextures);
// Only the default material should remain.
EXPECT_EQ(1U, pScene->mNumMaterials);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <RemoveVCProcess.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class RemoveVCProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
RemoveVCProcess* piProcess;
aiScene* pScene;
};
// ------------------------------------------------------------------------------------------------
void RemoveVCProcessTest::SetUp()
{
// construct the process
piProcess = new RemoveVCProcess();
pScene = new aiScene();
// fill the scene ..
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes = 2];
pScene->mMeshes[0] = new aiMesh();
pScene->mMeshes[1] = new aiMesh();
pScene->mMeshes[0]->mNumVertices = 120;
pScene->mMeshes[0]->mVertices = new aiVector3D[120];
pScene->mMeshes[0]->mNormals = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[0] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[1] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[2] = new aiVector3D[120];
pScene->mMeshes[0]->mTextureCoords[3] = new aiVector3D[120];
pScene->mMeshes[1]->mNumVertices = 120;
pScene->mMeshes[1]->mVertices = new aiVector3D[120];
pScene->mAnimations = new aiAnimation*[pScene->mNumAnimations = 2];
pScene->mAnimations[0] = new aiAnimation();
pScene->mAnimations[1] = new aiAnimation();
pScene->mTextures = new aiTexture*[pScene->mNumTextures = 2];
pScene->mTextures[0] = new aiTexture();
pScene->mTextures[1] = new aiTexture();
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = 2];
pScene->mMaterials[0] = new aiMaterial();
pScene->mMaterials[1] = new aiMaterial();
pScene->mLights = new aiLight*[pScene->mNumLights = 2];
pScene->mLights[0] = new aiLight();
pScene->mLights[1] = new aiLight();
pScene->mCameras = new aiCamera*[pScene->mNumCameras = 2];
pScene->mCameras[0] = new aiCamera();
pScene->mCameras[1] = new aiCamera();
// COMPILE TEST: aiMaterial may no add any extra members,
// so we don't need a virtual destructor
char check[sizeof(aiMaterial) == sizeof(aiMaterial) ? 10 : -1];
check[0] = 0;
// to remove compiler warning
EXPECT_TRUE( check );
}
// ------------------------------------------------------------------------------------------------
void RemoveVCProcessTest::TearDown()
{
delete pScene;
delete piProcess;
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshRemove)
{
piProcess->SetDeleteFlags(aiComponent_MESHES);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mMeshes);
EXPECT_EQ(0U, pScene->mNumMeshes);
EXPECT_TRUE(pScene->mFlags == AI_SCENE_FLAGS_INCOMPLETE);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testAnimRemove)
{
piProcess->SetDeleteFlags(aiComponent_ANIMATIONS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mAnimations);
EXPECT_EQ(0U, pScene->mNumAnimations);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMaterialRemove)
{
piProcess->SetDeleteFlags(aiComponent_MATERIALS);
piProcess->Execute(pScene);
// there should be one default material now ...
EXPECT_TRUE(1 == pScene->mNumMaterials &&
pScene->mMeshes[0]->mMaterialIndex == 0 &&
pScene->mMeshes[1]->mMaterialIndex == 0);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testTextureRemove)
{
piProcess->SetDeleteFlags(aiComponent_TEXTURES);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mTextures);
EXPECT_EQ(0U, pScene->mNumTextures);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testCameraRemove)
{
piProcess->SetDeleteFlags(aiComponent_CAMERAS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mCameras);
EXPECT_EQ(0U, pScene->mNumCameras);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testLightRemove)
{
piProcess->SetDeleteFlags(aiComponent_LIGHTS);
piProcess->Execute(pScene);
EXPECT_TRUE(NULL == pScene->mLights);
EXPECT_EQ(0U, pScene->mNumLights);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshComponentsRemoveA)
{
piProcess->SetDeleteFlags(aiComponent_TEXCOORDSn(1) | aiComponent_TEXCOORDSn(2) | aiComponent_TEXCOORDSn(3));
piProcess->Execute(pScene);
EXPECT_TRUE(pScene->mMeshes[0]->mTextureCoords[0] &&
!pScene->mMeshes[0]->mTextureCoords[1] &&
!pScene->mMeshes[0]->mTextureCoords[2] &&
!pScene->mMeshes[0]->mTextureCoords[3]);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testMeshComponentsRemoveB)
{
piProcess->SetDeleteFlags(aiComponent_TEXCOORDSn(1) | aiComponent_NORMALS);
piProcess->Execute(pScene);
EXPECT_TRUE(pScene->mMeshes[0]->mTextureCoords[0] &&
pScene->mMeshes[0]->mTextureCoords[1] &&
pScene->mMeshes[0]->mTextureCoords[2] && // shift forward ...
!pScene->mMeshes[0]->mTextureCoords[3] &&
!pScene->mMeshes[0]->mNormals);
EXPECT_EQ(0U, pScene->mFlags);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveVCProcessTest, testRemoveEverything)
{
piProcess->SetDeleteFlags(aiComponent_LIGHTS | aiComponent_ANIMATIONS |
aiComponent_MATERIALS | aiComponent_MESHES | aiComponent_CAMERAS | aiComponent_TEXTURES);
piProcess->Execute(pScene);
EXPECT_EQ(0U, pScene->mNumAnimations);
EXPECT_EQ(0U, pScene->mNumCameras);
EXPECT_EQ(0U, pScene->mNumLights);
EXPECT_EQ(0U, pScene->mNumMeshes);
EXPECT_EQ(0U, pScene->mNumTextures);
// Only the default material should remain.
EXPECT_EQ(1U, pScene->mNumMaterials);
}

300
test/unit/utRemoveRedundantMaterials.cpp
View File

@ -1,150 +1,150 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <RemoveRedundantMaterials.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class RemoveRedundantMatsTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
RemoveRedundantMatsProcess* piProcess;
aiScene* pcScene1;
aiScene* pcScene2;
};
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial1()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("UniqueMat1");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
float f = 2.0f;
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_BUMPSCALING);
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_SHININESS_STRENGTH);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial2()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("Unique Mat2");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
float f = 4.0f;int i = 1;
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_BUMPSCALING);
pcMat->AddProperty<int>(&i, 1, AI_MATKEY_ENABLE_WIREFRAME);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial3()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("Complex material name");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
void RemoveRedundantMatsTest::SetUp()
{
// construct the process
piProcess = new RemoveRedundantMatsProcess();
// create a scene with 5 materials (2 is a duplicate of 0, 3 of 1)
pcScene1 = new aiScene();
pcScene1->mNumMaterials = 5;
pcScene1->mMaterials = new aiMaterial*[5];
pcScene1->mMaterials[0] = getUniqueMaterial1();
pcScene1->mMaterials[1] = getUniqueMaterial2();
pcScene1->mMaterials[4] = getUniqueMaterial3();
// all materials must be referenced
pcScene1->mNumMeshes = 5;
pcScene1->mMeshes = new aiMesh*[5];
for (unsigned int i = 0; i < 5;++i) {
pcScene1->mMeshes[i] = new aiMesh();
pcScene1->mMeshes[i]->mMaterialIndex = i;
}
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.length = 1;
mTemp.data[0] = 48;
mTemp.data[1] = 0;
aiMaterial* pcMat;
pcScene1->mMaterials[2] = pcMat = new aiMaterial();
aiMaterial::CopyPropertyList(pcMat,(const aiMaterial*)pcScene1->mMaterials[0]);
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
mTemp.data[0]++;
pcScene1->mMaterials[3] = pcMat = new aiMaterial();
aiMaterial::CopyPropertyList(pcMat,(const aiMaterial*)pcScene1->mMaterials[1]);
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
mTemp.data[0]++;
}
// ------------------------------------------------------------------------------------------------
void RemoveRedundantMatsTest::TearDown()
{
delete piProcess;
delete pcScene1;
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveRedundantMatsTest, testRedundantMaterials)
{
piProcess->SetFixedMaterialsString();
piProcess->Execute(pcScene1);
EXPECT_EQ(3U, pcScene1->mNumMaterials);
EXPECT_TRUE(0 != pcScene1->mMaterials &&
0 != pcScene1->mMaterials[0] &&
0 != pcScene1->mMaterials[1] &&
0 != pcScene1->mMaterials[2]);
aiString sName;
EXPECT_EQ(AI_SUCCESS, aiGetMaterialString(pcScene1->mMaterials[2],AI_MATKEY_NAME,&sName));
EXPECT_STREQ("Complex material name", sName.data);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveRedundantMatsTest, testRedundantMaterialsWithExcludeList)
{
piProcess->SetFixedMaterialsString("\'Unique Mat2\'\t\'Complex material name\' and_another_one_which_we_wont_use");
piProcess->Execute(pcScene1);
EXPECT_EQ(4U, pcScene1->mNumMaterials);
EXPECT_TRUE(0 != pcScene1->mMaterials &&
0 != pcScene1->mMaterials[0] &&
0 != pcScene1->mMaterials[1] &&
0 != pcScene1->mMaterials[2] &&
0 != pcScene1->mMaterials[3]);
aiString sName;
EXPECT_EQ(AI_SUCCESS, aiGetMaterialString(pcScene1->mMaterials[3],AI_MATKEY_NAME,&sName));
EXPECT_STREQ("Complex material name", sName.data);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <RemoveRedundantMaterials.h>
#include <MaterialSystem.h>
using namespace std;
using namespace Assimp;
class RemoveRedundantMatsTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
RemoveRedundantMatsProcess* piProcess;
aiScene* pcScene1;
aiScene* pcScene2;
};
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial1()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("UniqueMat1");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
float f = 2.0f;
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_BUMPSCALING);
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_SHININESS_STRENGTH);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial2()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("Unique Mat2");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
float f = 4.0f;int i = 1;
pcMat->AddProperty<float>(&f, 1, AI_MATKEY_BUMPSCALING);
pcMat->AddProperty<int>(&i, 1, AI_MATKEY_ENABLE_WIREFRAME);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
aiMaterial* getUniqueMaterial3()
{
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.Set("Complex material name");
aiMaterial* pcMat = new aiMaterial();
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
return pcMat;
}
// ------------------------------------------------------------------------------------------------
void RemoveRedundantMatsTest::SetUp()
{
// construct the process
piProcess = new RemoveRedundantMatsProcess();
// create a scene with 5 materials (2 is a duplicate of 0, 3 of 1)
pcScene1 = new aiScene();
pcScene1->mNumMaterials = 5;
pcScene1->mMaterials = new aiMaterial*[5];
pcScene1->mMaterials[0] = getUniqueMaterial1();
pcScene1->mMaterials[1] = getUniqueMaterial2();
pcScene1->mMaterials[4] = getUniqueMaterial3();
// all materials must be referenced
pcScene1->mNumMeshes = 5;
pcScene1->mMeshes = new aiMesh*[5];
for (unsigned int i = 0; i < 5;++i) {
pcScene1->mMeshes[i] = new aiMesh();
pcScene1->mMeshes[i]->mMaterialIndex = i;
}
// setup an unique name for each material - this shouldn't care
aiString mTemp;
mTemp.length = 1;
mTemp.data[0] = 48;
mTemp.data[1] = 0;
aiMaterial* pcMat;
pcScene1->mMaterials[2] = pcMat = new aiMaterial();
aiMaterial::CopyPropertyList(pcMat,(const aiMaterial*)pcScene1->mMaterials[0]);
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
mTemp.data[0]++;
pcScene1->mMaterials[3] = pcMat = new aiMaterial();
aiMaterial::CopyPropertyList(pcMat,(const aiMaterial*)pcScene1->mMaterials[1]);
pcMat->AddProperty(&mTemp,AI_MATKEY_NAME);
mTemp.data[0]++;
}
// ------------------------------------------------------------------------------------------------
void RemoveRedundantMatsTest::TearDown()
{
delete piProcess;
delete pcScene1;
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveRedundantMatsTest, testRedundantMaterials)
{
piProcess->SetFixedMaterialsString();
piProcess->Execute(pcScene1);
EXPECT_EQ(3U, pcScene1->mNumMaterials);
EXPECT_TRUE(0 != pcScene1->mMaterials &&
0 != pcScene1->mMaterials[0] &&
0 != pcScene1->mMaterials[1] &&
0 != pcScene1->mMaterials[2]);
aiString sName;
EXPECT_EQ(AI_SUCCESS, aiGetMaterialString(pcScene1->mMaterials[2],AI_MATKEY_NAME,&sName));
EXPECT_STREQ("Complex material name", sName.data);
}
// ------------------------------------------------------------------------------------------------
TEST_F(RemoveRedundantMatsTest, testRedundantMaterialsWithExcludeList)
{
piProcess->SetFixedMaterialsString("\'Unique Mat2\'\t\'Complex material name\' and_another_one_which_we_wont_use");
piProcess->Execute(pcScene1);
EXPECT_EQ(4U, pcScene1->mNumMaterials);
EXPECT_TRUE(0 != pcScene1->mMaterials &&
0 != pcScene1->mMaterials[0] &&
0 != pcScene1->mMaterials[1] &&
0 != pcScene1->mMaterials[2] &&
0 != pcScene1->mMaterials[3]);
aiString sName;
EXPECT_EQ(AI_SUCCESS, aiGetMaterialString(pcScene1->mMaterials[3],AI_MATKEY_NAME,&sName));
EXPECT_STREQ("Complex material name", sName.data);
}

326
test/unit/utScenePreprocessor.cpp
View File

@ -1,163 +1,163 @@
#include "UnitTestPCH.h"
#include <assimp/mesh.h>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <ScenePreprocessor.h>
using namespace std;
using namespace Assimp;
class ScenePreprocessorTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
void CheckIfOnly(aiMesh* p, unsigned int num, unsigned flag);
void ProcessAnimation(aiAnimation* anim) { pp->ProcessAnimation(anim); }
void ProcessMesh(aiMesh* mesh) { pp->ProcessMesh(mesh); }
ScenePreprocessor* pp;
aiScene* scene;
};
// ------------------------------------------------------------------------------------------------
void ScenePreprocessorTest::SetUp()
{
// setup a dummy scene with a single node
scene = new aiScene();
scene->mRootNode = new aiNode();
scene->mRootNode->mName.Set("<test>");
// add some translation
scene->mRootNode->mTransformation.a4 = 1.f;
scene->mRootNode->mTransformation.b4 = 2.f;
scene->mRootNode->mTransformation.c4 = 3.f;
// and allocate a ScenePreprocessor to operate on the scene
pp = new ScenePreprocessor(scene);
}
// ------------------------------------------------------------------------------------------------
void ScenePreprocessorTest::TearDown()
{
delete pp;
delete scene;
}
// ------------------------------------------------------------------------------------------------
// Check whether ProcessMesh() returns flag for a mesh that consist of primitives with num indices
void ScenePreprocessorTest::CheckIfOnly(aiMesh* p, unsigned int num, unsigned int flag)
{
// Triangles only
for (unsigned i = 0; i < p->mNumFaces;++i) {
p->mFaces[i].mNumIndices = num;
}
pp->ProcessMesh(p);
EXPECT_EQ(flag, p->mPrimitiveTypes);
p->mPrimitiveTypes = 0;
}
// ------------------------------------------------------------------------------------------------
// Check whether a mesh is preprocessed correctly. Case 1: The mesh needs preprocessing
TEST_F(ScenePreprocessorTest, testMeshPreprocessingPos)
{
aiMesh* p = new aiMesh();
p->mNumFaces = 100;
p->mFaces = new aiFace[p->mNumFaces];
p->mTextureCoords[0] = new aiVector3D[10];
p->mNumUVComponents[0] = 0;
p->mNumUVComponents[1] = 0;
CheckIfOnly(p,1,aiPrimitiveType_POINT);
CheckIfOnly(p,2,aiPrimitiveType_LINE);
CheckIfOnly(p,3,aiPrimitiveType_TRIANGLE);
CheckIfOnly(p,4,aiPrimitiveType_POLYGON);
CheckIfOnly(p,1249,aiPrimitiveType_POLYGON);
// Polygons and triangles mixed
unsigned i;
for (i = 0; i < p->mNumFaces/2;++i) {
p->mFaces[i].mNumIndices = 3;
}
for (; i < p->mNumFaces-p->mNumFaces/4;++i) {
p->mFaces[i].mNumIndices = 4;
}
for (; i < p->mNumFaces;++i) {
p->mFaces[i].mNumIndices = 10;
}
ProcessMesh(p);
EXPECT_EQ(static_cast<unsigned int>(aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON),
p->mPrimitiveTypes);
EXPECT_EQ(2U, p->mNumUVComponents[0]);
EXPECT_EQ(0U, p->mNumUVComponents[1]);
delete p;
}
// ------------------------------------------------------------------------------------------------
// Check whether a mesh is preprocessed correctly. Case 1: The mesh doesn't need preprocessing
TEST_F(ScenePreprocessorTest, testMeshPreprocessingNeg)
{
aiMesh* p = new aiMesh();
p->mPrimitiveTypes = aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON;
ProcessMesh(p);
// should be unmodified
EXPECT_EQ(static_cast<unsigned int>(aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON),
p->mPrimitiveTypes);
delete p;
}
// ------------------------------------------------------------------------------------------------
// Make a dummy animation with a single channel, '<test>'
aiAnimation* MakeDummyAnimation()
{
aiAnimation* p = new aiAnimation();
p->mNumChannels = 1;
p->mChannels = new aiNodeAnim*[1];
aiNodeAnim* anim = p->mChannels[0] = new aiNodeAnim();
anim->mNodeName.Set("<test>");
return p;
}
// ------------------------------------------------------------------------------------------------
// Check whether an anim is preprocessed correctly. Case 1: The anim needs preprocessing
TEST_F(ScenePreprocessorTest, testAnimationPreprocessingPos)
{
aiAnimation* p = MakeDummyAnimation();
aiNodeAnim* anim = p->mChannels[0];
// we don't set the animation duration, but generate scaling channels
anim->mNumScalingKeys = 10;
anim->mScalingKeys = new aiVectorKey[10];
for (unsigned int i = 0; i < 10;++i) {
anim->mScalingKeys[i].mTime = i;
anim->mScalingKeys[i].mValue = aiVector3D((float)i);
}
ProcessAnimation(p);
// we should now have a proper duration
EXPECT_NEAR(p->mDuration, 9., 0.005);
// ... one scaling key
EXPECT_TRUE(anim->mNumPositionKeys == 1 &&
anim->mPositionKeys &&
anim->mPositionKeys[0].mTime == 0.0 &&
anim->mPositionKeys[0].mValue == aiVector3D(1.f,2.f,3.f));
// ... and one rotation key
EXPECT_TRUE(anim->mNumRotationKeys == 1 && anim->mRotationKeys &&
anim->mRotationKeys[0].mTime == 0.0);
delete p;
}
#include "UnitTestPCH.h"
#include <assimp/mesh.h>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <ScenePreprocessor.h>
using namespace std;
using namespace Assimp;
class ScenePreprocessorTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
void CheckIfOnly(aiMesh* p, unsigned int num, unsigned flag);
void ProcessAnimation(aiAnimation* anim) { pp->ProcessAnimation(anim); }
void ProcessMesh(aiMesh* mesh) { pp->ProcessMesh(mesh); }
ScenePreprocessor* pp;
aiScene* scene;
};
// ------------------------------------------------------------------------------------------------
void ScenePreprocessorTest::SetUp()
{
// setup a dummy scene with a single node
scene = new aiScene();
scene->mRootNode = new aiNode();
scene->mRootNode->mName.Set("<test>");
// add some translation
scene->mRootNode->mTransformation.a4 = 1.f;
scene->mRootNode->mTransformation.b4 = 2.f;
scene->mRootNode->mTransformation.c4 = 3.f;
// and allocate a ScenePreprocessor to operate on the scene
pp = new ScenePreprocessor(scene);
}
// ------------------------------------------------------------------------------------------------
void ScenePreprocessorTest::TearDown()
{
delete pp;
delete scene;
}
// ------------------------------------------------------------------------------------------------
// Check whether ProcessMesh() returns flag for a mesh that consist of primitives with num indices
void ScenePreprocessorTest::CheckIfOnly(aiMesh* p, unsigned int num, unsigned int flag)
{
// Triangles only
for (unsigned i = 0; i < p->mNumFaces;++i) {
p->mFaces[i].mNumIndices = num;
}
pp->ProcessMesh(p);
EXPECT_EQ(flag, p->mPrimitiveTypes);
p->mPrimitiveTypes = 0;
}
// ------------------------------------------------------------------------------------------------
// Check whether a mesh is preprocessed correctly. Case 1: The mesh needs preprocessing
TEST_F(ScenePreprocessorTest, testMeshPreprocessingPos)
{
aiMesh* p = new aiMesh();
p->mNumFaces = 100;
p->mFaces = new aiFace[p->mNumFaces];
p->mTextureCoords[0] = new aiVector3D[10];
p->mNumUVComponents[0] = 0;
p->mNumUVComponents[1] = 0;
CheckIfOnly(p,1,aiPrimitiveType_POINT);
CheckIfOnly(p,2,aiPrimitiveType_LINE);
CheckIfOnly(p,3,aiPrimitiveType_TRIANGLE);
CheckIfOnly(p,4,aiPrimitiveType_POLYGON);
CheckIfOnly(p,1249,aiPrimitiveType_POLYGON);
// Polygons and triangles mixed
unsigned i;
for (i = 0; i < p->mNumFaces/2;++i) {
p->mFaces[i].mNumIndices = 3;
}
for (; i < p->mNumFaces-p->mNumFaces/4;++i) {
p->mFaces[i].mNumIndices = 4;
}
for (; i < p->mNumFaces;++i) {
p->mFaces[i].mNumIndices = 10;
}
ProcessMesh(p);
EXPECT_EQ(static_cast<unsigned int>(aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON),
p->mPrimitiveTypes);
EXPECT_EQ(2U, p->mNumUVComponents[0]);
EXPECT_EQ(0U, p->mNumUVComponents[1]);
delete p;
}
// ------------------------------------------------------------------------------------------------
// Check whether a mesh is preprocessed correctly. Case 1: The mesh doesn't need preprocessing
TEST_F(ScenePreprocessorTest, testMeshPreprocessingNeg)
{
aiMesh* p = new aiMesh();
p->mPrimitiveTypes = aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON;
ProcessMesh(p);
// should be unmodified
EXPECT_EQ(static_cast<unsigned int>(aiPrimitiveType_TRIANGLE|aiPrimitiveType_POLYGON),
p->mPrimitiveTypes);
delete p;
}
// ------------------------------------------------------------------------------------------------
// Make a dummy animation with a single channel, '<test>'
aiAnimation* MakeDummyAnimation()
{
aiAnimation* p = new aiAnimation();
p->mNumChannels = 1;
p->mChannels = new aiNodeAnim*[1];
aiNodeAnim* anim = p->mChannels[0] = new aiNodeAnim();
anim->mNodeName.Set("<test>");
return p;
}
// ------------------------------------------------------------------------------------------------
// Check whether an anim is preprocessed correctly. Case 1: The anim needs preprocessing
TEST_F(ScenePreprocessorTest, testAnimationPreprocessingPos)
{
aiAnimation* p = MakeDummyAnimation();
aiNodeAnim* anim = p->mChannels[0];
// we don't set the animation duration, but generate scaling channels
anim->mNumScalingKeys = 10;
anim->mScalingKeys = new aiVectorKey[10];
for (unsigned int i = 0; i < 10;++i) {
anim->mScalingKeys[i].mTime = i;
anim->mScalingKeys[i].mValue = aiVector3D((float)i);
}
ProcessAnimation(p);
// we should now have a proper duration
EXPECT_NEAR(p->mDuration, 9., 0.005);
// ... one scaling key
EXPECT_TRUE(anim->mNumPositionKeys == 1 &&
anim->mPositionKeys &&
anim->mPositionKeys[0].mTime == 0.0 &&
anim->mPositionKeys[0].mValue == aiVector3D(1.f,2.f,3.f));
// ... and one rotation key
EXPECT_TRUE(anim->mNumRotationKeys == 1 && anim->mRotationKeys &&
anim->mRotationKeys[0].mTime == 0.0);
delete p;
}

170
test/unit/utSharedPPData.cpp
View File

@ -1,85 +1,85 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <BaseProcess.h>
using namespace std;
using namespace Assimp;
class SharedPPDataTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SharedPostProcessInfo* shared;
};
static bool destructed;
struct TestType
{
~TestType()
{
destructed = true;
}
};
// ------------------------------------------------------------------------------------------------
void SharedPPDataTest::SetUp()
{
shared = new SharedPostProcessInfo();
destructed = false;
}
// ------------------------------------------------------------------------------------------------
void SharedPPDataTest::TearDown()
{
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPODProperty)
{
int i = 5;
shared->AddProperty("test",i);
int o;
EXPECT_TRUE(shared->GetProperty("test",o));
EXPECT_EQ(5, o);
EXPECT_FALSE(shared->GetProperty("test2",o));
EXPECT_EQ(5, o);
float f = 12.f, m;
shared->AddProperty("test",f);
EXPECT_TRUE(shared->GetProperty("test",m));
EXPECT_EQ(12.f, m);
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPropertyPointer)
{
int *i = new int[35];
shared->AddProperty("test16",i);
int* o;
EXPECT_TRUE(shared->GetProperty("test16",o));
EXPECT_EQ(i, o);
shared->RemoveProperty("test16");
EXPECT_FALSE(shared->GetProperty("test16",o));
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPropertyDeallocation)
{
TestType *out, * pip = new TestType();
shared->AddProperty("quak",pip);
EXPECT_TRUE(shared->GetProperty("quak",out));
EXPECT_EQ(pip, out);
delete shared;
EXPECT_TRUE(destructed);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <BaseProcess.h>
using namespace std;
using namespace Assimp;
class SharedPPDataTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SharedPostProcessInfo* shared;
};
static bool destructed;
struct TestType
{
~TestType()
{
destructed = true;
}
};
// ------------------------------------------------------------------------------------------------
void SharedPPDataTest::SetUp()
{
shared = new SharedPostProcessInfo();
destructed = false;
}
// ------------------------------------------------------------------------------------------------
void SharedPPDataTest::TearDown()
{
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPODProperty)
{
int i = 5;
shared->AddProperty("test",i);
int o;
EXPECT_TRUE(shared->GetProperty("test",o));
EXPECT_EQ(5, o);
EXPECT_FALSE(shared->GetProperty("test2",o));
EXPECT_EQ(5, o);
float f = 12.f, m;
shared->AddProperty("test",f);
EXPECT_TRUE(shared->GetProperty("test",m));
EXPECT_EQ(12.f, m);
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPropertyPointer)
{
int *i = new int[35];
shared->AddProperty("test16",i);
int* o;
EXPECT_TRUE(shared->GetProperty("test16",o));
EXPECT_EQ(i, o);
shared->RemoveProperty("test16");
EXPECT_FALSE(shared->GetProperty("test16",o));
}
// ------------------------------------------------------------------------------------------------
TEST_F(SharedPPDataTest, testPropertyDeallocation)
{
TestType *out, * pip = new TestType();
shared->AddProperty("quak",pip);
EXPECT_TRUE(shared->GetProperty("quak",out));
EXPECT_EQ(pip, out);
delete shared;
EXPECT_TRUE(destructed);
}

386
test/unit/utSortByPType.cpp
View File

@ -1,193 +1,193 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <ScenePreprocessor.h>
#include <SortByPTypeProcess.h>
using namespace std;
using namespace Assimp;
class SortByPTypeProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SortByPTypeProcess* process1;
aiScene* scene;
};
// ------------------------------------------------------------------------------------------------
static unsigned int num[10][4] =
{
{0,0,0,1000},
{0,0,1000,0},
{0,1000,0,0},
{1000,0,0,0},
{500,500,0,0},
{500,0,500,0},
{0,330,330,340},
{250,250,250,250},
{100,100,100,700},
{0,100,0,900},
};
// ------------------------------------------------------------------------------------------------
static unsigned int result[10] =
{
aiPrimitiveType_POLYGON,
aiPrimitiveType_TRIANGLE,
aiPrimitiveType_LINE,
aiPrimitiveType_POINT,
aiPrimitiveType_POINT | aiPrimitiveType_LINE,
aiPrimitiveType_POINT | aiPrimitiveType_TRIANGLE,
aiPrimitiveType_TRIANGLE | aiPrimitiveType_LINE | aiPrimitiveType_POLYGON,
aiPrimitiveType_POLYGON | aiPrimitiveType_LINE | aiPrimitiveType_TRIANGLE | aiPrimitiveType_POINT,
aiPrimitiveType_POLYGON | aiPrimitiveType_LINE | aiPrimitiveType_TRIANGLE | aiPrimitiveType_POINT,
aiPrimitiveType_LINE | aiPrimitiveType_POLYGON,
};
// ------------------------------------------------------------------------------------------------
void SortByPTypeProcessTest::SetUp()
{
// process0 = new DeterminePTypeHelperProcess();
process1 = new SortByPTypeProcess();
scene = new aiScene();
scene->mNumMeshes = 10;
scene->mMeshes = new aiMesh*[10];
bool five = false;
for (unsigned int i = 0; i < 10; ++i)
{
aiMesh* mesh = scene->mMeshes[i] = new aiMesh();
mesh->mNumFaces = 1000;
aiFace* faces = mesh->mFaces = new aiFace[1000];
aiVector3D* pv = mesh->mVertices = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pn = mesh->mNormals = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pt = mesh->mTangents = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pb = mesh->mBitangents = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* puv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumFaces*5];
unsigned int remaining[4] = {num[i][0],num[i][1],num[i][2],num[i][3]};
unsigned int n = 0;
for (unsigned int m = 0; m < 1000; ++m)
{
unsigned int idx = m % 4;
while (true)
{
if (!remaining[idx])
{
if (4 == ++idx)idx = 0;
continue;
}
break;
}
faces->mNumIndices = idx+1;
if (4 == faces->mNumIndices)
{
if(five)++faces->mNumIndices;
five = !five;
}
faces->mIndices = new unsigned int[faces->mNumIndices];
for (unsigned int q = 0; q <faces->mNumIndices;++q,++n)
{
faces->mIndices[q] = n;
float f = (float)remaining[idx];
// (the values need to be unique - otherwise all degenerates would be removed)
*pv++ = aiVector3D(f,f+1.f,f+q);
*pn++ = aiVector3D(f,f+1.f,f+q);
*pt++ = aiVector3D(f,f+1.f,f+q);
*pb++ = aiVector3D(f,f+1.f,f+q);
*puv++ = aiVector3D(f,f+1.f,f+q);
}
++faces;
--remaining[idx];
}
mesh->mNumVertices = n;
}
scene->mRootNode = new aiNode();
scene->mRootNode->mNumChildren = 5;
scene->mRootNode->mChildren = new aiNode*[5];
for (unsigned int i = 0; i< 5;++i )
{
aiNode* node = scene->mRootNode->mChildren[i] = new aiNode();
node->mNumMeshes = 2;
node->mMeshes = new unsigned int[2];
node->mMeshes[0] = (i<<1u);
node->mMeshes[1] = (i<<1u)+1;
}
}
// ------------------------------------------------------------------------------------------------
void SortByPTypeProcessTest::TearDown()
{
//delete process0;
delete process1;
delete scene;
}
// ------------------------------------------------------------------------------------------------
//TEST_F(SortByPTypeProcessTest, DeterminePTypeStep()
//{
// process0->Execute(scene);
//
// for (unsigned int i = 0; i < 10; ++i)
// {
// aiMesh* mesh = scene->mMeshes[i];
// EXPECT_TRUE(mesh->mPrimitiveTypes == result[i]);
// }
//}
// ------------------------------------------------------------------------------------------------
TEST_F(SortByPTypeProcessTest, SortByPTypeStep)
{
// process0->Execute(scene);
// and another small test for ScenePreprocessor
ScenePreprocessor s(scene);
s.ProcessScene();
for (unsigned int m = 0; m< 10;++m)
EXPECT_EQ(result[m], scene->mMeshes[m]->mPrimitiveTypes);
process1->Execute(scene);
unsigned int idx = 0;
for (unsigned int m = 0,real = 0; m< 10;++m)
{
for (unsigned int n = 0; n < 4;++n)
{
if ((idx = num[m][n]))
{
EXPECT_TRUE(real < scene->mNumMeshes);
aiMesh* mesh = scene->mMeshes[real];
EXPECT_TRUE(NULL != mesh);
EXPECT_EQ(AI_PRIMITIVE_TYPE_FOR_N_INDICES(n+1), mesh->mPrimitiveTypes);
EXPECT_TRUE(NULL != mesh->mVertices);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mTangents);
EXPECT_TRUE(NULL != mesh->mBitangents);
EXPECT_TRUE(NULL != mesh->mTextureCoords[0]);
EXPECT_TRUE(mesh->mNumFaces == idx);
for (unsigned int f = 0; f < mesh->mNumFaces;++f)
{
aiFace& face = mesh->mFaces[f];
EXPECT_TRUE(face.mNumIndices == (n+1) || (3 == n && face.mNumIndices > 3));
}
++real;
}
}
}
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <ScenePreprocessor.h>
#include <SortByPTypeProcess.h>
using namespace std;
using namespace Assimp;
class SortByPTypeProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SortByPTypeProcess* process1;
aiScene* scene;
};
// ------------------------------------------------------------------------------------------------
static unsigned int num[10][4] =
{
{0,0,0,1000},
{0,0,1000,0},
{0,1000,0,0},
{1000,0,0,0},
{500,500,0,0},
{500,0,500,0},
{0,330,330,340},
{250,250,250,250},
{100,100,100,700},
{0,100,0,900},
};
// ------------------------------------------------------------------------------------------------
static unsigned int result[10] =
{
aiPrimitiveType_POLYGON,
aiPrimitiveType_TRIANGLE,
aiPrimitiveType_LINE,
aiPrimitiveType_POINT,
aiPrimitiveType_POINT | aiPrimitiveType_LINE,
aiPrimitiveType_POINT | aiPrimitiveType_TRIANGLE,
aiPrimitiveType_TRIANGLE | aiPrimitiveType_LINE | aiPrimitiveType_POLYGON,
aiPrimitiveType_POLYGON | aiPrimitiveType_LINE | aiPrimitiveType_TRIANGLE | aiPrimitiveType_POINT,
aiPrimitiveType_POLYGON | aiPrimitiveType_LINE | aiPrimitiveType_TRIANGLE | aiPrimitiveType_POINT,
aiPrimitiveType_LINE | aiPrimitiveType_POLYGON,
};
// ------------------------------------------------------------------------------------------------
void SortByPTypeProcessTest::SetUp()
{
// process0 = new DeterminePTypeHelperProcess();
process1 = new SortByPTypeProcess();
scene = new aiScene();
scene->mNumMeshes = 10;
scene->mMeshes = new aiMesh*[10];
bool five = false;
for (unsigned int i = 0; i < 10; ++i)
{
aiMesh* mesh = scene->mMeshes[i] = new aiMesh();
mesh->mNumFaces = 1000;
aiFace* faces = mesh->mFaces = new aiFace[1000];
aiVector3D* pv = mesh->mVertices = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pn = mesh->mNormals = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pt = mesh->mTangents = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* pb = mesh->mBitangents = new aiVector3D[mesh->mNumFaces*5];
aiVector3D* puv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumFaces*5];
unsigned int remaining[4] = {num[i][0],num[i][1],num[i][2],num[i][3]};
unsigned int n = 0;
for (unsigned int m = 0; m < 1000; ++m)
{
unsigned int idx = m % 4;
while (true)
{
if (!remaining[idx])
{
if (4 == ++idx)idx = 0;
continue;
}
break;
}
faces->mNumIndices = idx+1;
if (4 == faces->mNumIndices)
{
if(five)++faces->mNumIndices;
five = !five;
}
faces->mIndices = new unsigned int[faces->mNumIndices];
for (unsigned int q = 0; q <faces->mNumIndices;++q,++n)
{
faces->mIndices[q] = n;
float f = (float)remaining[idx];
// (the values need to be unique - otherwise all degenerates would be removed)
*pv++ = aiVector3D(f,f+1.f,f+q);
*pn++ = aiVector3D(f,f+1.f,f+q);
*pt++ = aiVector3D(f,f+1.f,f+q);
*pb++ = aiVector3D(f,f+1.f,f+q);
*puv++ = aiVector3D(f,f+1.f,f+q);
}
++faces;
--remaining[idx];
}
mesh->mNumVertices = n;
}
scene->mRootNode = new aiNode();
scene->mRootNode->mNumChildren = 5;
scene->mRootNode->mChildren = new aiNode*[5];
for (unsigned int i = 0; i< 5;++i )
{
aiNode* node = scene->mRootNode->mChildren[i] = new aiNode();
node->mNumMeshes = 2;
node->mMeshes = new unsigned int[2];
node->mMeshes[0] = (i<<1u);
node->mMeshes[1] = (i<<1u)+1;
}
}
// ------------------------------------------------------------------------------------------------
void SortByPTypeProcessTest::TearDown()
{
//delete process0;
delete process1;
delete scene;
}
// ------------------------------------------------------------------------------------------------
//TEST_F(SortByPTypeProcessTest, DeterminePTypeStep()
//{
// process0->Execute(scene);
//
// for (unsigned int i = 0; i < 10; ++i)
// {
// aiMesh* mesh = scene->mMeshes[i];
// EXPECT_TRUE(mesh->mPrimitiveTypes == result[i]);
// }
//}
// ------------------------------------------------------------------------------------------------
TEST_F(SortByPTypeProcessTest, SortByPTypeStep)
{
// process0->Execute(scene);
// and another small test for ScenePreprocessor
ScenePreprocessor s(scene);
s.ProcessScene();
for (unsigned int m = 0; m< 10;++m)
EXPECT_EQ(result[m], scene->mMeshes[m]->mPrimitiveTypes);
process1->Execute(scene);
unsigned int idx = 0;
for (unsigned int m = 0,real = 0; m< 10;++m)
{
for (unsigned int n = 0; n < 4;++n)
{
if ((idx = num[m][n]))
{
EXPECT_TRUE(real < scene->mNumMeshes);
aiMesh* mesh = scene->mMeshes[real];
EXPECT_TRUE(NULL != mesh);
EXPECT_EQ(AI_PRIMITIVE_TYPE_FOR_N_INDICES(n+1), mesh->mPrimitiveTypes);
EXPECT_TRUE(NULL != mesh->mVertices);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mTangents);
EXPECT_TRUE(NULL != mesh->mBitangents);
EXPECT_TRUE(NULL != mesh->mTextureCoords[0]);
EXPECT_TRUE(mesh->mNumFaces == idx);
for (unsigned int f = 0; f < mesh->mNumFaces;++f)
{
aiFace& face = mesh->mFaces[f];
EXPECT_TRUE(face.mNumIndices == (n+1) || (3 == n && face.mNumIndices > 3));
}
++real;
}
}
}
}

254
test/unit/utSplitLargeMeshes.cpp
View File

@ -1,127 +1,127 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <SplitLargeMeshes.h>
using namespace std;
using namespace Assimp;
class SplitLargeMeshesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SplitLargeMeshesProcess_Triangle* piProcessTriangle;
SplitLargeMeshesProcess_Vertex* piProcessVertex;
aiMesh* pcMesh1;
aiMesh* pcMesh2;
};
// ------------------------------------------------------------------------------------------------
void SplitLargeMeshesTest::SetUp()
{
// construct the processes
this->piProcessTriangle = new SplitLargeMeshesProcess_Triangle();
this->piProcessVertex = new SplitLargeMeshesProcess_Vertex();
this->piProcessTriangle->SetLimit(1000);
this->piProcessVertex->SetLimit(1000);
this->pcMesh1 = new aiMesh();
pcMesh1->mNumVertices = 2100; // quersumme: 3
pcMesh1->mVertices = new aiVector3D[pcMesh1->mNumVertices];
pcMesh1->mNormals = new aiVector3D[pcMesh1->mNumVertices];
pcMesh1->mNumFaces = pcMesh1->mNumVertices / 3;
pcMesh1->mFaces = new aiFace[pcMesh1->mNumFaces];
unsigned int qq = 0;
for (unsigned int i = 0; i < pcMesh1->mNumFaces;++i)
{
aiFace& face = pcMesh1->mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
face.mIndices[0] = qq++;
face.mIndices[1] = qq++;
face.mIndices[2] = qq++;
}
// generate many, many faces with randomized indices for
// the second mesh
this->pcMesh2 = new aiMesh();
pcMesh2->mNumVertices = 3000;
pcMesh2->mVertices = new aiVector3D[pcMesh2->mNumVertices];
pcMesh2->mNormals = new aiVector3D[pcMesh2->mNumVertices];
pcMesh2->mNumFaces = 10000;
pcMesh2->mFaces = new aiFace[pcMesh2->mNumFaces];
for (unsigned int i = 0; i < pcMesh2->mNumFaces;++i)
{
aiFace& face = pcMesh2->mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
face.mIndices[0] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
face.mIndices[1] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
face.mIndices[2] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
}
}
// ------------------------------------------------------------------------------------------------
void SplitLargeMeshesTest::TearDown()
{
delete this->piProcessTriangle;
delete this->piProcessVertex;
}
// ------------------------------------------------------------------------------------------------
TEST_F(SplitLargeMeshesTest, testVertexSplit)
{
std::vector< std::pair<aiMesh*, unsigned int> > avOut;
int iOldFaceNum = (int)pcMesh1->mNumFaces;
piProcessVertex->SplitMesh(0,pcMesh1,avOut);
for (std::vector< std::pair<aiMesh*, unsigned int> >::const_iterator
iter = avOut.begin(), end = avOut.end();
iter != end; ++iter)
{
aiMesh* mesh = (*iter).first;
EXPECT_LT(mesh->mNumVertices, 1000U);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mVertices);
iOldFaceNum -= mesh->mNumFaces;
delete mesh;
}
EXPECT_EQ(0, iOldFaceNum);
}
// ------------------------------------------------------------------------------------------------
TEST_F(SplitLargeMeshesTest, testTriangleSplit)
{
std::vector< std::pair<aiMesh*, unsigned int> > avOut;
// the number of faces shouldn't change
int iOldFaceNum = (int)pcMesh2->mNumFaces;
piProcessTriangle->SplitMesh(0,pcMesh2,avOut);
for (std::vector< std::pair<aiMesh*, unsigned int> >::const_iterator
iter = avOut.begin(), end = avOut.end();
iter != end; ++iter)
{
aiMesh* mesh = (*iter).first;
EXPECT_LT(mesh->mNumFaces, 1000U);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mVertices);
iOldFaceNum -= mesh->mNumFaces;
delete mesh;
}
EXPECT_EQ(0, iOldFaceNum);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <SplitLargeMeshes.h>
using namespace std;
using namespace Assimp;
class SplitLargeMeshesTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
SplitLargeMeshesProcess_Triangle* piProcessTriangle;
SplitLargeMeshesProcess_Vertex* piProcessVertex;
aiMesh* pcMesh1;
aiMesh* pcMesh2;
};
// ------------------------------------------------------------------------------------------------
void SplitLargeMeshesTest::SetUp()
{
// construct the processes
this->piProcessTriangle = new SplitLargeMeshesProcess_Triangle();
this->piProcessVertex = new SplitLargeMeshesProcess_Vertex();
this->piProcessTriangle->SetLimit(1000);
this->piProcessVertex->SetLimit(1000);
this->pcMesh1 = new aiMesh();
pcMesh1->mNumVertices = 2100; // quersumme: 3
pcMesh1->mVertices = new aiVector3D[pcMesh1->mNumVertices];
pcMesh1->mNormals = new aiVector3D[pcMesh1->mNumVertices];
pcMesh1->mNumFaces = pcMesh1->mNumVertices / 3;
pcMesh1->mFaces = new aiFace[pcMesh1->mNumFaces];
unsigned int qq = 0;
for (unsigned int i = 0; i < pcMesh1->mNumFaces;++i)
{
aiFace& face = pcMesh1->mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
face.mIndices[0] = qq++;
face.mIndices[1] = qq++;
face.mIndices[2] = qq++;
}
// generate many, many faces with randomized indices for
// the second mesh
this->pcMesh2 = new aiMesh();
pcMesh2->mNumVertices = 3000;
pcMesh2->mVertices = new aiVector3D[pcMesh2->mNumVertices];
pcMesh2->mNormals = new aiVector3D[pcMesh2->mNumVertices];
pcMesh2->mNumFaces = 10000;
pcMesh2->mFaces = new aiFace[pcMesh2->mNumFaces];
for (unsigned int i = 0; i < pcMesh2->mNumFaces;++i)
{
aiFace& face = pcMesh2->mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
face.mIndices[0] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
face.mIndices[1] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
face.mIndices[2] = (unsigned int)((rand() / (float)RAND_MAX) * pcMesh2->mNumVertices);
}
}
// ------------------------------------------------------------------------------------------------
void SplitLargeMeshesTest::TearDown()
{
delete this->piProcessTriangle;
delete this->piProcessVertex;
}
// ------------------------------------------------------------------------------------------------
TEST_F(SplitLargeMeshesTest, testVertexSplit)
{
std::vector< std::pair<aiMesh*, unsigned int> > avOut;
int iOldFaceNum = (int)pcMesh1->mNumFaces;
piProcessVertex->SplitMesh(0,pcMesh1,avOut);
for (std::vector< std::pair<aiMesh*, unsigned int> >::const_iterator
iter = avOut.begin(), end = avOut.end();
iter != end; ++iter)
{
aiMesh* mesh = (*iter).first;
EXPECT_LT(mesh->mNumVertices, 1000U);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mVertices);
iOldFaceNum -= mesh->mNumFaces;
delete mesh;
}
EXPECT_EQ(0, iOldFaceNum);
}
// ------------------------------------------------------------------------------------------------
TEST_F(SplitLargeMeshesTest, testTriangleSplit)
{
std::vector< std::pair<aiMesh*, unsigned int> > avOut;
// the number of faces shouldn't change
int iOldFaceNum = (int)pcMesh2->mNumFaces;
piProcessTriangle->SplitMesh(0,pcMesh2,avOut);
for (std::vector< std::pair<aiMesh*, unsigned int> >::const_iterator
iter = avOut.begin(), end = avOut.end();
iter != end; ++iter)
{
aiMesh* mesh = (*iter).first;
EXPECT_LT(mesh->mNumFaces, 1000U);
EXPECT_TRUE(NULL != mesh->mNormals);
EXPECT_TRUE(NULL != mesh->mVertices);
iOldFaceNum -= mesh->mNumFaces;
delete mesh;
}
EXPECT_EQ(0, iOldFaceNum);
}

6
test/unit/utTargetAnimation.cpp
View File

@ -1,3 +1,3 @@
#include "UnitTestPCH.h"
// TODO
#include "UnitTestPCH.h"
// TODO

6
test/unit/utTextureTransform.cpp
View File

@ -1,3 +1,3 @@
#include "UnitTestPCH.h"
// TODO
#include "UnitTestPCH.h"
// TODO

226
test/unit/utTriangulate.cpp
View File

@ -1,113 +1,113 @@
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <TriangulateProcess.h>
using namespace std;
using namespace Assimp;
class TriangulateProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
TriangulateProcess* piProcess;
};
void TriangulateProcessTest::SetUp()
{
piProcess = new TriangulateProcess();
pcMesh = new aiMesh();
pcMesh->mNumFaces = 1000;
pcMesh->mFaces = new aiFace[1000];
pcMesh->mVertices = new aiVector3D[10000];
pcMesh->mPrimitiveTypes = aiPrimitiveType_POINT | aiPrimitiveType_LINE |
aiPrimitiveType_LINE | aiPrimitiveType_POLYGON;
for (unsigned int m = 0, t = 0, q = 4; m < 1000; ++m)
{
++t;
aiFace& face = pcMesh->mFaces[m];
face.mNumIndices = t;
if (4 == t)
{
face.mNumIndices = q++;
t = 0;
if (10 == q)q = 4;
}
face.mIndices = new unsigned int[face.mNumIndices];
for (unsigned int p = 0; p < face.mNumIndices; ++p)
{
face.mIndices[p] = pcMesh->mNumVertices;
// construct fully convex input data in ccw winding, xy plane
aiVector3D& v = pcMesh->mVertices[pcMesh->mNumVertices++];
v.z = 0.f;
v.x = cos (p * (float)(AI_MATH_TWO_PI)/face.mNumIndices);
v.y = sin (p * (float)(AI_MATH_TWO_PI)/face.mNumIndices);
}
}
}
void TriangulateProcessTest::TearDown()
{
delete piProcess;
delete pcMesh;
}
TEST_F(TriangulateProcessTest, testTriangulation)
{
piProcess->TriangulateMesh(pcMesh);
for (unsigned int m = 0, t = 0, q = 4, max = 1000, idx = 0; m < max;++m)
{
++t;
aiFace& face = pcMesh->mFaces[m];
if (4 == t)
{
t = 0;
max += q-3;
std::vector<bool> ait(q,false);
for (unsigned int i = 0, tt = q-2; i < tt; ++i,++m)
{
aiFace& face = pcMesh->mFaces[m];
EXPECT_EQ(3U, face.mNumIndices);
for (unsigned int qqq = 0; qqq < face.mNumIndices; ++qqq)
{
ait[face.mIndices[qqq]-idx] = true;
}
}
for (std::vector<bool>::const_iterator it = ait.begin(); it != ait.end(); ++it)
{
EXPECT_TRUE(*it);
}
--m;
idx+=q;
if(++q == 10)q = 4;
}
else
{
EXPECT_EQ(t, face.mNumIndices);
for (unsigned int i = 0; i < face.mNumIndices; ++i,++idx)
{
EXPECT_EQ(idx, face.mIndices[i]);
}
}
}
// we should have no valid normal vectors now necause we aren't a pure polygon mesh
EXPECT_TRUE(pcMesh->mNormals == NULL);
}
#include "UnitTestPCH.h"
#include <assimp/scene.h>
#include <TriangulateProcess.h>
using namespace std;
using namespace Assimp;
class TriangulateProcessTest : public ::testing::Test
{
public:
virtual void SetUp();
virtual void TearDown();
protected:
aiMesh* pcMesh;
TriangulateProcess* piProcess;
};
void TriangulateProcessTest::SetUp()
{
piProcess = new TriangulateProcess();
pcMesh = new aiMesh();
pcMesh->mNumFaces = 1000;
pcMesh->mFaces = new aiFace[1000];
pcMesh->mVertices = new aiVector3D[10000];
pcMesh->mPrimitiveTypes = aiPrimitiveType_POINT | aiPrimitiveType_LINE |
aiPrimitiveType_LINE | aiPrimitiveType_POLYGON;
for (unsigned int m = 0, t = 0, q = 4; m < 1000; ++m)
{
++t;
aiFace& face = pcMesh->mFaces[m];
face.mNumIndices = t;
if (4 == t)
{
face.mNumIndices = q++;
t = 0;
if (10 == q)q = 4;
}
face.mIndices = new unsigned int[face.mNumIndices];
for (unsigned int p = 0; p < face.mNumIndices; ++p)
{
face.mIndices[p] = pcMesh->mNumVertices;
// construct fully convex input data in ccw winding, xy plane
aiVector3D& v = pcMesh->mVertices[pcMesh->mNumVertices++];
v.z = 0.f;
v.x = cos (p * (float)(AI_MATH_TWO_PI)/face.mNumIndices);
v.y = sin (p * (float)(AI_MATH_TWO_PI)/face.mNumIndices);
}
}
}
void TriangulateProcessTest::TearDown()
{
delete piProcess;
delete pcMesh;
}
TEST_F(TriangulateProcessTest, testTriangulation)
{
piProcess->TriangulateMesh(pcMesh);
for (unsigned int m = 0, t = 0, q = 4, max = 1000, idx = 0; m < max;++m)
{
++t;
aiFace& face = pcMesh->mFaces[m];
if (4 == t)
{
t = 0;
max += q-3;
std::vector<bool> ait(q,false);
for (unsigned int i = 0, tt = q-2; i < tt; ++i,++m)
{
aiFace& face = pcMesh->mFaces[m];
EXPECT_EQ(3U, face.mNumIndices);
for (unsigned int qqq = 0; qqq < face.mNumIndices; ++qqq)
{
ait[face.mIndices[qqq]-idx] = true;
}
}
for (std::vector<bool>::const_iterator it = ait.begin(); it != ait.end(); ++it)
{
EXPECT_TRUE(*it);
}
--m;
idx+=q;
if(++q == 10)q = 4;
}
else
{
EXPECT_EQ(t, face.mNumIndices);
for (unsigned int i = 0; i < face.mNumIndices; ++i,++idx)
{
EXPECT_EQ(idx, face.mIndices[i]);
}
}
}
// we should have no valid normal vectors now necause we aren't a pure polygon mesh
EXPECT_TRUE(pcMesh->mNormals == NULL);
}

368
test/unit/utVertexTriangleAdjacency.cpp
View File

@ -1,184 +1,184 @@
#include "UnitTestPCH.h"
#include "assimp/types.h"
#include "assimp/mesh.h"
#include <VertexTriangleAdjacency.h>
using namespace std;
using namespace Assimp;
class VTAdjacencyTest : public ::testing::Test
{
protected:
void checkMesh(const aiMesh& mesh);
};
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, largeRandomDataSet)
{
// build a test mesh with randomized input data
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
while(face.mIndices[0] == ( face.mIndices[1] = (unsigned int)(((float)rand()/RAND_MAX)*499)));
while(face.mIndices[0] == ( face.mIndices[2] = (unsigned int)(((float)rand()/RAND_MAX)*499)) ||
face.mIndices[1] == face.mIndices[2]);
}
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, smallDataSet)
{
// build a test mesh - this one is extremely small
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 5;
mesh.mNumFaces = 3;
mesh.mFaces = new aiFace[3];
mesh.mFaces[0].mIndices = new unsigned int[3];
mesh.mFaces[1].mIndices = new unsigned int[3];
mesh.mFaces[2].mIndices = new unsigned int[3];
mesh.mFaces[0].mIndices[0] = 1;
mesh.mFaces[0].mIndices[1] = 3;
mesh.mFaces[0].mIndices[2] = 2;
mesh.mFaces[1].mIndices[0] = 0;
mesh.mFaces[1].mIndices[1] = 2;
mesh.mFaces[1].mIndices[2] = 3;
mesh.mFaces[2].mIndices[0] = 3;
mesh.mFaces[2].mIndices[1] = 0;
mesh.mFaces[2].mIndices[2] = 4;
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, unreferencedVerticesSet)
{
// build a test mesh which does not reference all vertices
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[1] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[2] = iCurrent++;
if (rand() > RAND_MAX/2 && face.mIndices[0])
{
face.mIndices[0]--;
}
else if (face.mIndices[1]) face.mIndices[1]--;
}
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
void VTAdjacencyTest::checkMesh(const aiMesh& mesh)
{
VertexTriangleAdjacency adj(mesh.mFaces,mesh.mNumFaces,mesh.mNumVertices,true);
unsigned int* const piNum = adj.mLiveTriangles;
// check the primary adjacency table and check whether all faces
// are contained in the list
unsigned int maxOfs = 0;
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
const unsigned int num = piNum[idx];
// go to this offset
const unsigned int ofs = adj.mOffsetTable[idx];
maxOfs = std::max(ofs+num,maxOfs);
unsigned int* pi = &adj.mAdjacencyTable[ofs];
// and search for us ...
unsigned int tt = 0;
for (; tt < num;++tt,++pi)
{
if (i == *pi)
{
// mask our entry in the table. Finally all entries should be masked
*pi = 0xffffffff;
// there shouldn't be two entries for the same face
break;
}
}
// assert if *this* vertex has not been found in the table
EXPECT_LT(tt, num);
}
}
// now check whether there are invalid faces
const unsigned int* pi = adj.mAdjacencyTable;
for (unsigned int i = 0; i < maxOfs;++i,++pi)
{
EXPECT_EQ(0xffffffff, *pi);
}
// check the numTrianglesPerVertex table
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
// we should not reach 0 here ...
EXPECT_NE(0U, piNum[idx]);
piNum[idx]--;
}
}
// check whether we reached 0 in all entries
for (unsigned int i = 0; i < mesh.mNumVertices;++i)
{
EXPECT_FALSE(piNum[i]);
}
}
#include "UnitTestPCH.h"
#include "assimp/types.h"
#include "assimp/mesh.h"
#include <VertexTriangleAdjacency.h>
using namespace std;
using namespace Assimp;
class VTAdjacencyTest : public ::testing::Test
{
protected:
void checkMesh(const aiMesh& mesh);
};
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, largeRandomDataSet)
{
// build a test mesh with randomized input data
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
while(face.mIndices[0] == ( face.mIndices[1] = (unsigned int)(((float)rand()/RAND_MAX)*499)));
while(face.mIndices[0] == ( face.mIndices[2] = (unsigned int)(((float)rand()/RAND_MAX)*499)) ||
face.mIndices[1] == face.mIndices[2]);
}
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, smallDataSet)
{
// build a test mesh - this one is extremely small
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 5;
mesh.mNumFaces = 3;
mesh.mFaces = new aiFace[3];
mesh.mFaces[0].mIndices = new unsigned int[3];
mesh.mFaces[1].mIndices = new unsigned int[3];
mesh.mFaces[2].mIndices = new unsigned int[3];
mesh.mFaces[0].mIndices[0] = 1;
mesh.mFaces[0].mIndices[1] = 3;
mesh.mFaces[0].mIndices[2] = 2;
mesh.mFaces[1].mIndices[0] = 0;
mesh.mFaces[1].mIndices[1] = 2;
mesh.mFaces[1].mIndices[2] = 3;
mesh.mFaces[2].mIndices[0] = 3;
mesh.mFaces[2].mIndices[1] = 0;
mesh.mFaces[2].mIndices[2] = 4;
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, unreferencedVerticesSet)
{
// build a test mesh which does not reference all vertices
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[1] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[2] = iCurrent++;
if (rand() > RAND_MAX/2 && face.mIndices[0])
{
face.mIndices[0]--;
}
else if (face.mIndices[1]) face.mIndices[1]--;
}
checkMesh(mesh);
}
// ------------------------------------------------------------------------------------------------
void VTAdjacencyTest::checkMesh(const aiMesh& mesh)
{
VertexTriangleAdjacency adj(mesh.mFaces,mesh.mNumFaces,mesh.mNumVertices,true);
unsigned int* const piNum = adj.mLiveTriangles;
// check the primary adjacency table and check whether all faces
// are contained in the list
unsigned int maxOfs = 0;
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
const unsigned int num = piNum[idx];
// go to this offset
const unsigned int ofs = adj.mOffsetTable[idx];
maxOfs = std::max(ofs+num,maxOfs);
unsigned int* pi = &adj.mAdjacencyTable[ofs];
// and search for us ...
unsigned int tt = 0;
for (; tt < num;++tt,++pi)
{
if (i == *pi)
{
// mask our entry in the table. Finally all entries should be masked
*pi = 0xffffffff;
// there shouldn't be two entries for the same face
break;
}
}
// assert if *this* vertex has not been found in the table
EXPECT_LT(tt, num);
}
}
// now check whether there are invalid faces
const unsigned int* pi = adj.mAdjacencyTable;
for (unsigned int i = 0; i < maxOfs;++i,++pi)
{
EXPECT_EQ(0xffffffff, *pi);
}
// check the numTrianglesPerVertex table
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
// we should not reach 0 here ...
EXPECT_NE(0U, piNum[idx]);
piNum[idx]--;
}
}
// check whether we reached 0 in all entries
for (unsigned int i = 0; i < mesh.mNumVertices;++i)
{
EXPECT_FALSE(piNum[i]);
}
}