Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.

212 lines
9.8 KiB

5 years ago
//========= 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 );
}
}