1HEADmaster

1 files changed, 211 insertions, 0 deletions

diff --git a/unittests/dmxtest/dmxtestloader.cpp b/unittests/dmxtest/dmxtestloader.cpp
new file mode 100644
index 0000000..ab3adbf
--- /dev/null
+++ b/unittests/dmxtest/dmxtestloader.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Unit test program  for DMX testing
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "unitlib/unitlib.h"
+#include "dmxloader/dmxloader.h"
+#include "dmxloader/dmxelement.h"
+
+struct TestStruct_t
+{
+	DmObjectId_t m_nId;
+	bool m_bBool;
+	int m_nInt;
+	float m_flFloat;
+	Color m_Color;
+	Vector2D m_Vector2D;
+	Vector m_Vector3D;
+	Vector4D m_Vector4D;
+	QAngle m_Angles;
+	Quaternion m_Quaternion;
+	VMatrix m_Matrix;
+	char m_pStringBuf[256];
+};
+
+BEGIN_DMXELEMENT_UNPACK( TestStruct_t ) 
+	DMXELEMENT_UNPACK_FIELD( "id_test", NULL, DmObjectId_t, m_nId )
+	DMXELEMENT_UNPACK_FIELD( "bool_test", "1", bool, m_bBool )
+	DMXELEMENT_UNPACK_FIELD( "int_test", "5", int, m_nInt )
+	DMXELEMENT_UNPACK_FIELD( "float_test", "4.0", float, m_flFloat )
+	DMXELEMENT_UNPACK_FIELD( "color_test", "200 200 200 200", Color, m_Color )
+	DMXELEMENT_UNPACK_FIELD( "vector2d_test", "5.0 1.0", Vector2D, m_Vector2D )
+	DMXELEMENT_UNPACK_FIELD( "vector3d_test", "5.0 1.0 -3.0", Vector, m_Vector3D )
+	DMXELEMENT_UNPACK_FIELD( "vector4d_test", "5.0 1.0 -4.0 2.0", Vector4D, m_Vector4D )
+	DMXELEMENT_UNPACK_FIELD( "qangle_test", "5.0 1.0 -3.0", QAngle, m_Angles )
+	DMXELEMENT_UNPACK_FIELD( "quat_test", "5.0 1.0 -4.0 2.0", Quaternion, m_Quaternion )
+	DMXELEMENT_UNPACK_FIELD( "vmatrix_test", NULL, VMatrix, m_Matrix )
+	DMXELEMENT_UNPACK_FIELD_STRING( "string_test", "default", m_pStringBuf )
+END_DMXELEMENT_UNPACK( TestStruct_t, s_TestStructUnpack )
+
+void TestReadFile( CDmxElement *pRoot )
+{
+	VMatrix mattest, mat2test;
+	MatrixBuildRotateZ( mattest, 45 );
+	MatrixBuildRotateZ( mat2test, 30 );
+
+	int i;
+	unsigned char buftest[256];
+	unsigned char buf2test[256];
+	for ( i = 0; i < 256; ++i )
+	{
+		buftest[i] = i;
+		buf2test[i] = 255 - i;
+	}
+
+
+	// Make sure everything was read in ok.
+	AssertEquals( pRoot->GetValue<bool>( "bool_test" ), true );
+	AssertEquals( pRoot->GetValue<int>( "int_test" ), 2 );
+	AssertFloatEquals( pRoot->GetValue<float>( "float_test" ), 3.0f, 1e-3 );
+	const Color& color = pRoot->GetValue<Color>( "color_test" );
+	Shipping_Assert( color.r() == 0 && color.g() == 64 && color.b() == 128 && color.a() == 255 );
+	const Vector2D& vec2D = pRoot->GetValue<Vector2D>( "vector2d_test" );
+	Shipping_Assert( vec2D.x == 1.0f && vec2D.y == -1.0f );
+	const Vector& vec3D = pRoot->GetValue<Vector>( "vector3d_test" );
+	Shipping_Assert( vec3D.x == 1.0f && vec3D.y == -1.0f && vec3D.z == 0.0f );
+	const Vector4D& vec4D = pRoot->GetValue<Vector4D>( "vector4d_test" );
+	Shipping_Assert( vec4D.x == 1.0f && vec4D.y == -1.0f && vec4D.z == 0.0f && vec4D.w == 2.0f );
+	const QAngle& ang = pRoot->GetValue<QAngle>( "qangle_test" );
+	Shipping_Assert( ang.x == 0.0f && ang.y == 90.0f && ang.z == -90.0f );
+	const Quaternion& quat = pRoot->GetValue<Quaternion>( "quat_test" );
+	Shipping_Assert( quat.x == 1.0f && quat.y == -1.0f && quat.z == 0.0f && quat.w == 2.0f );
+
+	const VMatrix& mat = pRoot->GetValue<VMatrix>( "vmatrix_test" );
+	Shipping_Assert( MatricesAreEqual( mat, mattest, 1e-3 ) );
+
+	Shipping_Assert( !Q_stricmp( pRoot->GetValueString( "string_test" ), "test" ) );
+	const CUtlBinaryBlock& blob = pRoot->GetValue<CUtlBinaryBlock>( "binary_test" );
+	Shipping_Assert( blob.Length() == 256 );
+	Shipping_Assert( !memcmp( blob.Get(), buftest, 256 ) );
+
+	CDmxElement *pElement7 = pRoot->GetValue<CDmxElement*>( "element_test" );
+	Shipping_Assert( pElement7 != NULL );
+	CDmxElement *pElement6 = pRoot->GetValue<CDmxElement*>( "shared_element_test" );
+	Shipping_Assert( pElement6 != NULL );
+	const CUtlVector< CDmxElement* >& elementList = pRoot->GetArray<CDmxElement*>( "children" );
+	Shipping_Assert( elementList.Count() == 2 );
+	CDmxElement *pElement2 = elementList[0];
+	CDmxElement *pElement3 = elementList[1];
+	Shipping_Assert( pElement2 != NULL && pElement3 != NULL );
+	Shipping_Assert( pElement7->GetValue<CDmxElement*>( "shared_element_test" ) == pElement6 );
+	const CUtlVector< CDmxElement* >& elementList3 = pElement6->GetArray<CDmxElement*>( "element_array_test" );
+	CDmxElement *pElement4 = elementList3[0];
+	CDmxElement *pElement5 = elementList3[1];
+
+	const CUtlVector< bool > &boolVec = pElement2->GetArray<bool>( "bool_array_test" );
+	Shipping_Assert( boolVec.Count() == 2 && boolVec[0] == false && boolVec[1] == true );
+
+	const CUtlVector< int > &intVec = pElement2->GetArray<int>( "int_array_test" );
+	Shipping_Assert( intVec.Count() == 3 && intVec[0] == 0 && intVec[1] == 1 && intVec[2] == 2 );
+
+	const CUtlVector< float > &floatVec = pElement2->GetArray<float>( "float_array_test" );
+	Shipping_Assert( floatVec.Count() == 3 && floatVec[0] == -1.0f && floatVec[1] == 0.0f && floatVec[2] == 1.0f );
+
+	const CUtlVector< Color > &colorVec = pElement3->GetArray<Color>( "color_array_test" );
+	Shipping_Assert( colorVec.Count() == 3 && colorVec[0].r() == 0 && colorVec[1].r() == 64 && colorVec[2].r() == 128 );
+
+	const CUtlVector< Vector2D > &vec2DVec = pElement3->GetArray<Vector2D>( "vector2d_array_test" );
+	Shipping_Assert( vec2DVec.Count() == 2 && vec2DVec[0].x == -1.0f && vec2DVec[1].x == 1.0f );
+
+	const CUtlVector< Vector > &vec3DVec = pElement3->GetArray<Vector>( "vector3d_array_test" );
+	Shipping_Assert( vec3DVec.Count() == 2 && vec3DVec[0].x == 1.0f && vec3DVec[1].x == 2.0f );
+
+	const CUtlVector< Vector4D > &vec4DVec = pElement4->GetArray<Vector4D>( "vector4d_array_test" );
+	Shipping_Assert( vec4DVec.Count() == 2 && vec4DVec[0].x == 1.0f && vec4DVec[1].x == 2.0f );
+
+	const CUtlVector< QAngle > &angVec = pElement4->GetArray<QAngle>( "qangle_array_test" );
+	Shipping_Assert( angVec.Count() == 2 && angVec[0].x == 1.0f && angVec[1].x == 2.0f );
+
+	const CUtlVector< Quaternion > &quatVec = pElement4->GetArray<Quaternion>( "quat_array_test" );
+	Shipping_Assert( quatVec.Count() == 2 && quatVec[0].x == 1.0f && quatVec[1].x == 2.0f );
+
+	const CUtlVector< VMatrix > &matVec = pElement5->GetArray<VMatrix>( "vmatrix_array_test" );
+	Shipping_Assert( matVec.Count() == 2  );
+	Shipping_Assert( MatricesAreEqual( matVec[0], mattest, 1e-3 ) );
+	Shipping_Assert( MatricesAreEqual( matVec[1], mat2test, 1e-3 ) );
+
+	const CUtlVector< CUtlString > &stringVec = pElement5->GetArray<CUtlString>( "string_array_test" );
+	Shipping_Assert( stringVec.Count() == 3 && !Q_stricmp( stringVec[2], "string3" ) );
+
+	const CUtlVector< CUtlBinaryBlock > &binaryVec = pElement5->GetArray<CUtlBinaryBlock>( "binary_array_test" );
+	Shipping_Assert( binaryVec.Count() == 2 && !memcmp( binaryVec[1].Get(), buf2test, 256 ) );
+
+	const CUtlVector< DmObjectId_t > &idVec = pElement6->GetArray<DmObjectId_t>( "elementid_array_test" );
+	Shipping_Assert( idVec.Count() == 3 );
+
+	TestStruct_t testStruct;
+	pRoot->UnpackIntoStructure( &testStruct, sizeof( testStruct ), s_TestStructUnpack );
+
+	Shipping_Assert( testStruct.m_bBool == true );
+	Shipping_Assert( testStruct.m_nInt == 2 );
+	AssertFloatEquals( testStruct.m_flFloat, 3.0f, 1e-3 );
+	Shipping_Assert( testStruct.m_Color.r() == 0 && testStruct.m_Color.g() == 64 && testStruct.m_Color.b() == 128 && testStruct.m_Color.a() == 255 );
+	Shipping_Assert( testStruct.m_Vector2D.x == 1.0f && testStruct.m_Vector2D.y == -1.0f );
+	Shipping_Assert( testStruct.m_Vector3D.x == 1.0f && testStruct.m_Vector3D.y == -1.0f && testStruct.m_Vector3D.z == 0.0f );
+	Shipping_Assert( testStruct.m_Vector4D.x == 1.0f && testStruct.m_Vector4D.y == -1.0f && testStruct.m_Vector4D.z == 0.0f && testStruct.m_Vector4D.w == 2.0f );
+	Shipping_Assert( testStruct.m_Angles.x == 0.0f && testStruct.m_Angles.y == 90.0f && testStruct.m_Angles.z == -90.0f );
+	Shipping_Assert( testStruct.m_Quaternion.x == 1.0f && testStruct.m_Quaternion.y == -1.0f && testStruct.m_Quaternion.z == 0.0f && testStruct.m_Quaternion.w == 2.0f );
+	Shipping_Assert( MatricesAreEqual( testStruct.m_Matrix, mattest, 1e-3 ) );
+	Shipping_Assert( !Q_stricmp( testStruct.m_pStringBuf, "test" ) );
+
+	pElement6->UnpackIntoStructure( &testStruct, sizeof( testStruct ), s_TestStructUnpack );
+
+	Shipping_Assert( testStruct.m_bBool == true );
+	Shipping_Assert( testStruct.m_nInt == 5 );
+	AssertFloatEquals( testStruct.m_flFloat, 4.0f, 1e-3 );
+	Shipping_Assert( testStruct.m_Color.r() == 200 && testStruct.m_Color.g() == 200 && testStruct.m_Color.b() == 200 && testStruct.m_Color.a() == 200 );
+	Shipping_Assert( testStruct.m_Vector2D.x == 5.0f && testStruct.m_Vector2D.y == 1.0f );
+	Shipping_Assert( testStruct.m_Vector3D.x == 5.0f && testStruct.m_Vector3D.y == 1.0f && testStruct.m_Vector3D.z == -3.0f );
+	Shipping_Assert( testStruct.m_Vector4D.x == 5.0f && testStruct.m_Vector4D.y == 1.0f && testStruct.m_Vector4D.z == -4.0f && testStruct.m_Vector4D.w == 2.0f );
+	Shipping_Assert( testStruct.m_Angles.x == 5.0f && testStruct.m_Angles.y == 1.0f && testStruct.m_Angles.z == -3.0f );
+	Shipping_Assert( testStruct.m_Quaternion.x == 5.0f && testStruct.m_Quaternion.y == 1.0f && testStruct.m_Quaternion.z == -4.0f && testStruct.m_Quaternion.w == 2.0f );
+	Shipping_Assert( !Q_stricmp( testStruct.m_pStringBuf, "default" ) );
+}
+
+DEFINE_TESTCASE_NOSUITE( DmxLoaderTest )
+{
+	Msg( "Running dmx loader tests...\n" );
+	
+	CDmxElement *pRoot;
+	bool bOk = UnserializeDMX( "dmxtestloader.dmx", NULL, false, &pRoot );
+	Shipping_Assert( bOk );
+	Shipping_Assert( pRoot );
+	if ( pRoot )
+	{
+		TestReadFile( pRoot );
+		CleanupDMX( pRoot );
+	}
+
+	bOk = UnserializeDMX( "dmxtestloadertext.dmx", NULL, true, &pRoot );
+	Shipping_Assert( bOk );
+	Shipping_Assert( pRoot );
+	if ( pRoot )
+	{
+		TestReadFile( pRoot );
+		CleanupDMX( pRoot );
+	}
+
+	// Test serialization
+	bOk = UnserializeDMX( "dmxtestloader.dmx", NULL, false, &pRoot );
+	Shipping_Assert( bOk );
+	Shipping_Assert( pRoot );
+	if ( pRoot )
+	{
+		bOk = SerializeDMX( "dmxtestscratch.dmx", NULL, false, pRoot );
+		Shipping_Assert( bOk );
+		CleanupDMX( pRoot );
+	}
+	CleanupDMX( pRoot );
+
+	bOk = UnserializeDMX( "dmxtestscratch.dmx", NULL, false, &pRoot );
+	Shipping_Assert( bOk );
+	Shipping_Assert( pRoot );
+	if ( pRoot )
+	{
+		TestReadFile( pRoot );
+		CleanupDMX( pRoot );
+	}
+}