Refactor: Use LF for end of line

test/unit/CCompilerTest.c

@@ -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>

test/unit/Main.cpp

@@ -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;
+}

test/unit/UnitTestPCH.h

@@ -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

test/unit/utExport.cpp

@@ -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

test/unit/utFindDegenerates.cpp

@@ -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);
+}
+

test/unit/utFindInvalidData.cpp

@@ -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]);
+}

test/unit/utFixInfacingNormals.cpp

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

test/unit/utGenNormals.cpp

@@ -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);
+}

test/unit/utImporter.cpp

@@ -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
+}

test/unit/utImproveCacheLocality.cpp

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

test/unit/utJoinVertices.cpp

@@ -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
+}
+

test/unit/utLimitBoneWeights.cpp

@@ -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
+}

test/unit/utMaterialSystem.cpp

@@ -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);
+}

test/unit/utNoBoostTest.cpp

@@ -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>());
+}

test/unit/utPretransformVertices.cpp

@@ -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
+}

test/unit/utRemoveComments.cpp

@@ -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;
+}

test/unit/utRemoveComponent.cpp

@@ -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);
+}

test/unit/utRemoveRedundantMaterials.cpp

@@ -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);
+}

test/unit/utScenePreprocessor.cpp

@@ -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;
+}
+

test/unit/utSharedPPData.cpp

@@ -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);
+}

test/unit/utSortByPType.cpp

@@ -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;
+			}
+		}
+	}
+}
+

test/unit/utSplitLargeMeshes.cpp

@@ -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);
+}

test/unit/utTargetAnimation.cpp

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

test/unit/utTextureTransform.cpp

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

test/unit/utTriangulate.cpp

@@ -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);
+}

test/unit/utVertexTriangleAdjacency.cpp

@@ -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]);
+	}
+}