You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
211 lines
9.8 KiB
211 lines
9.8 KiB
//========= 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 ); |
|
} |
|
}
|
|
|