1097 lines
34 KiB
C++
1097 lines
34 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Unit test program for DMX testing
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "unitlib/unitlib.h"
|
|
#include "datamodel/dmelement.h"
|
|
#include "datamodel/idatamodel.h"
|
|
#include "movieobjects/movieobjects.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "filesystem.h"
|
|
|
|
|
|
// From dmxtestserialization.cpp
|
|
|
|
bool AssertEqualElementHierarchies( bool quiet, DmElementHandle_t src1, DmElementHandle_t src2 );
|
|
bool AssertUnEqualElementHierarchies( DmElementHandle_t src1, DmElementHandle_t src2 );
|
|
|
|
void CreateTestScene( CUtlVector< DmElementHandle_t >& handles, DmFileId_t fileid );
|
|
|
|
bool AssertEqualElementHierarchies( bool quiet, CDmElement *src1, CDmElement *src2 )
|
|
{
|
|
DmElementHandle_t h1 = src1->GetHandle();
|
|
DmElementHandle_t h2 = src2->GetHandle();
|
|
|
|
return AssertEqualElementHierarchies( quiet, h1, h2 );
|
|
}
|
|
|
|
bool AssertUnEqualElementHierarchies( CDmElement *src1, CDmElement *src2 )
|
|
{
|
|
return AssertUnEqualElementHierarchies( src1->GetHandle(), src2->GetHandle() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
void DescribeUndo()
|
|
{
|
|
CUtlVector< UndoInfo_t > list;
|
|
g_pDataModel->GetUndoInfo( list );
|
|
|
|
for ( int i = list.Count() - 1; i >= 0; --i )
|
|
{
|
|
UndoInfo_t& entry = list[ i ];
|
|
if ( entry.terminator )
|
|
{
|
|
Msg( "[ '%s' ] -- %i operations\n", entry.undo, entry.numoperations );
|
|
}
|
|
|
|
Msg( " +[ '%s' ]\n", entry.desc );
|
|
}
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleSetAttributeUndoTest( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
pElement->SetValue( attribute, newVal );
|
|
}
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
void RunSingleSetAttributeUndoTestBinary( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const void *data, size_t size )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
pElement->SetValue( attribute, data, size );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleSetAttributeUndoTestArray( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.Set( slot, newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template<> void RunSingleSetAttributeUndoTestArray<DmElementHandle_t>( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, const DmElementHandle_t& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrElementArray<> array( pElement, attribute );
|
|
array.SetHandle( slot, newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayAddToHead( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.InsertBefore( 0, newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayAddToTail( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.AddToTail( newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayInsertBefore( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.InsertBefore( slot, newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayFastRemove( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, T typeDeducer )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.FastRemove( slot );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
|
|
void RunSingleAttributeUndoTestElementArrayRemove( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrElementArray<> array( pElement, attribute );
|
|
array.Remove( slot );
|
|
}
|
|
|
|
DescribeUndo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayRemove( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, T typeDeducer )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray<T> array( pElement, attribute );
|
|
array.Remove( slot );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayRemoveMultiple( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, int count, T typeDeducer )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
array.RemoveMultiple( slot, count );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayRemoveAll( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, bool purge )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray< T > array( pElement, attribute );
|
|
if( purge )
|
|
{
|
|
array.Purge();
|
|
}
|
|
else
|
|
{
|
|
array.RemoveAll();
|
|
}
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAttributeUndoTestArrayCopyFrom( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const CUtlVector<T>& list )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CDmrArray<T> array( pElement, attribute );
|
|
array.CopyArray( list.Base(), list.Count() );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
|
|
void RunSingleSetAttributeUndoTestArrayBinary( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, int slot, const void *data, size_t size )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
CUtlBinaryBlock block( (const void *)data, size );
|
|
CDmrArray< CUtlBinaryBlock > array( pElement, attribute );
|
|
array.Set( slot, block );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleSetAttributeUndoTestArrayWhole( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, CUtlVector< T >& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
IDmAttributeArray< T > *pArray = static_cast< IDmAttributeArray< T > * >( pElement->GetAttribute( "attribute" ) );
|
|
pArray->SetValue( newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
template< class T >
|
|
void RunSingleAddAttributeUndoTest( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute, const T& newVal )
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
pElement->SetValue( attribute, newVal );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
void RunSingleRemoveAttributeUndoTest( CDmElement *pTest, CDmElement *pOriginal, CDmElement *pElement, const char *attribute )
|
|
{
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
{
|
|
CUndoScopeGuard guard( attribute, attribute );
|
|
pElement->RemoveAttribute( attribute );
|
|
}
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
AssertUnEqualElementHierarchies( pTest, pOriginal );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
|
|
void RunUndoTestsArray( CUtlVector< DmElementHandle_t >& handles, CDmElement *pTest, CDmElement *pOriginal )
|
|
{
|
|
DmObjectId_t id;
|
|
CreateUniqueId( &id );
|
|
|
|
VMatrix mat, mat2;
|
|
MatrixBuildRotateZ( mat, 55 );
|
|
MatrixBuildRotateZ( mat2, -55 );
|
|
int i;
|
|
unsigned char buf[256];
|
|
unsigned char buf2[256];
|
|
for ( i = 0; i < 256; ++i )
|
|
{
|
|
buf[i] = i+55500;
|
|
buf2[i] = 55000 + 255 - i;
|
|
}
|
|
|
|
Assert( handles.Count() == 7 );
|
|
|
|
//CDmElement *pElement = pTest;
|
|
CDmElement *pElement2 = GetElement< CDmElement >( handles[ 1 ] );
|
|
CDmElement *pElement3 = GetElement< CDmElement >( handles[ 2 ] );
|
|
CDmElement *pElement4 = GetElement< CDmElement >( handles[ 3 ] );
|
|
CDmElement *pElement5 = GetElement< CDmElement >( handles[ 4 ] );
|
|
CDmElement *pElement6 = GetElement< CDmElement >( handles[ 5 ] );
|
|
CDmElement *pElement7 = GetElement< CDmElement >( handles[ 6 ] );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "int_array_test", 0, 55 );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "float_array_test", 0, 55.0f );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "bool_array_test", 0, true );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "color_array_test", 0, Color( 55, 55, 55, 55 ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "vector2d_array_test", 0, Vector2D( 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "vector3d_array_test", 0, Vector( 55.0f, -55.0f, 55.0f ) );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "vector4d_array_test", 0, Vector4D( 55.0f, -55.0f, 55.0f, 55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "qangle_array_test", 0, QAngle( 55.0f, 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "quat_array_test", 0, Quaternion( 1.0f, -1.0f, 0.0f, 55.0f ) );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement5, "vmatrix_array_test", 0, mat );
|
|
CUtlString newString( "55test" );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement5, "string_array_test", 0, newString );
|
|
RunSingleSetAttributeUndoTestArrayBinary( pTest, pOriginal, pElement5, "binary_array_test", 0, buf, 256 );
|
|
|
|
// RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement6, "elementid_array_test", 0, id );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement6, "element_array_test", 0, pElement2->GetHandle() );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement7, "element_array_test", 0, pElement5->GetHandle() );
|
|
|
|
{
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "int_array_test", 0, 55 );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "float_array_test", 0, 55.0f );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement2, "bool_array_test", 0, true );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "color_array_test", 0, Color( 55, 55, 55, 55 ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "vector2d_array_test", 0, Vector2D( 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement3, "vector3d_array_test", 0, Vector( 55.0f, -55.0f, 55.0f ) );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "vector4d_array_test", 0, Vector4D( 55.0f, -55.0f, 55.0f, 55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "qangle_array_test", 0, QAngle( 55.0f, 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement4, "quat_array_test", 0, Quaternion( 1.0f, -1.0f, 0.0f, 55.0f ) );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement5, "vmatrix_array_test", 0, mat );
|
|
CUtlString newString( "55test" );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement5, "string_array_test", 0, newString );
|
|
RunSingleSetAttributeUndoTestArrayBinary( pTest, pOriginal, pElement5, "binary_array_test", 0, buf, 256 );
|
|
|
|
// RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement6, "elementid_array_test", 0, id );
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement6, "element_array_test", 0, pElement2->GetHandle() );
|
|
|
|
RunSingleSetAttributeUndoTestArray( pTest, pOriginal, pElement7, "element_array_test", 0, pElement5->GetHandle() );
|
|
}
|
|
|
|
RunSingleAttributeUndoTestArrayAddToHead( pTest, pOriginal, pElement2, "int_array_test", 55 );
|
|
RunSingleAttributeUndoTestArrayAddToTail( pTest, pOriginal, pElement2, "int_array_test", 55 );
|
|
RunSingleAttributeUndoTestArrayInsertBefore( pTest, pOriginal, pElement2, "int_array_test", 0, 55 );
|
|
RunSingleAttributeUndoTestArrayFastRemove( pTest, pOriginal, pElement2, "int_array_test", 0, (int)0 );
|
|
RunSingleAttributeUndoTestArrayRemove( pTest, pOriginal, pElement2, "int_array_test", 0, (int)0 );
|
|
RunSingleAttributeUndoTestArrayRemoveMultiple( pTest, pOriginal, pElement2, "int_array_test", 0, 2, (int)0 );
|
|
RunSingleAttributeUndoTestElementArrayRemove( pTest, pOriginal, pElement7, "children", 0 );
|
|
|
|
// RemoveAll
|
|
RunSingleAttributeUndoTestArrayRemoveAll<int>( pTest, pOriginal, pElement2, "int_array_test", false );
|
|
// Purge
|
|
RunSingleAttributeUndoTestArrayRemoveAll<int>( pTest, pOriginal, pElement2, "int_array_test", true );
|
|
|
|
CUtlVector< int > foo;
|
|
foo.AddToTail( 55 );
|
|
foo.AddToTail( 56 );
|
|
foo.AddToTail( 57 );
|
|
foo.AddToTail( 58 );
|
|
foo.AddToTail( 59 );
|
|
|
|
RunSingleAttributeUndoTestArrayCopyFrom( pTest, pOriginal, pElement2, "int_array_test", foo );
|
|
}
|
|
|
|
void RunUndoTests( CUtlVector< DmElementHandle_t >& handles, CDmElement *pTest, CDmElement *pOriginal )
|
|
{
|
|
DmObjectId_t id;
|
|
CreateUniqueId( &id );
|
|
|
|
VMatrix mat, mat2;
|
|
MatrixBuildRotateZ( mat, 55 );
|
|
MatrixBuildRotateZ( mat2, -55 );
|
|
int i;
|
|
unsigned char buf[256];
|
|
unsigned char buf2[256];
|
|
for ( i = 0; i < 256; ++i )
|
|
{
|
|
buf[i] = i+100;
|
|
buf2[i] = 127 + 255 - i;
|
|
}
|
|
|
|
Assert( handles.Count() == 7 );
|
|
CDmElement *pElement = pTest;
|
|
CDmElement *pElement2 = GetElement<CDmElement>( handles[ 1 ] );
|
|
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "element_test", (CDmElement *)NULL );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "int_test", 55 );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "float_test", 55.0f );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "bool_test", false );
|
|
// RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "id_test", id );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "string_test", "55test" );
|
|
RunSingleSetAttributeUndoTestBinary( pTest, pOriginal, pElement, "binary_test", buf, 256 );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "color_test", Color( 55, 55, 55, 55 ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "vector2d_test", Vector2D( 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "vector3d_test", Vector( 55.0f, -55.0f, 55.0f ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "vector4d_test", Vector4D( 55.0f, -55.0f, 55.0f, 55.0f ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "qangle_test", QAngle( 55.0f, 55.0f, -55.0f ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "quat_test", Quaternion( 1.0f, -1.0f, 0.0f, 55.0f ) );
|
|
RunSingleSetAttributeUndoTest( pTest, pOriginal, pElement, "vmatrix_test", mat );
|
|
|
|
// Now run a single test with a bunch of operations occurring at the same time
|
|
{
|
|
{
|
|
CUndoScopeGuard guard( "biggish", "smallish" );
|
|
pElement->SetValue( "bool_test", false );
|
|
pElement->SetValue( "int_test", 55 );
|
|
pElement->SetValue( "float_test", 55.0f );
|
|
pElement->SetValue( "color_test", Color( 55, 55, 55, 55 ) );
|
|
pElement->SetValue( "vector2d_test", Vector2D( 55.0f, -55.0f ) );
|
|
pElement->SetValue( "vector3d_test", Vector( 55.0f, -55.0f, 55.0f ) );
|
|
pElement->SetValue( "vector4d_test", Vector4D( 55.0f, -55.0f, 55.0f, 55.0f ) );
|
|
pElement->SetValue( "qangle_test", QAngle( 55.0f, 55.0f, -55.0f ) );
|
|
pElement->SetValue( "quat_test", Quaternion( 1.0f, -1.0f, 0.0f, 55.0f ) );
|
|
pElement->SetValue( "vmatrix_test", mat );
|
|
pElement->SetValue( "string_test", "55test" );
|
|
pElement->SetValue( "binary_test", buf, 256 );
|
|
}
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
|
|
// Now run a test with multiple items in the stack
|
|
{
|
|
// Push 1
|
|
{
|
|
CUndoScopeGuard guard( "biggish1", "smallish1" );
|
|
pElement->SetValue( "bool_test", false );
|
|
pElement->SetValue( "int_test", 55 );
|
|
pElement->SetValue( "float_test", 55.0f );
|
|
pElement->SetValue( "color_test", Color( 55, 55, 55, 55 ) );
|
|
}
|
|
// Push 2
|
|
{
|
|
CUndoScopeGuard guard( "biggish2", "smallish2" );
|
|
pElement->SetValue( "vector2d_test", Vector2D( 55.0f, -55.0f ) );
|
|
pElement->SetValue( "vector3d_test", Vector( 55.0f, -55.0f, 55.0f ) );
|
|
pElement->SetValue( "vector4d_test", Vector4D( 55.0f, -55.0f, 55.0f, 55.0f ) );
|
|
pElement->SetValue( "qangle_test", QAngle( 55.0f, 55.0f, -55.0f ) );
|
|
pElement->SetValue( "quat_test", Quaternion( 1.0f, -1.0f, 0.0f, 55.0f ) );
|
|
}
|
|
// Push 3
|
|
{
|
|
CUndoScopeGuard guard( "biggish3", "smallish3" );
|
|
pElement->SetValue( "vmatrix_test", mat );
|
|
pElement->SetValue( "string_test", "55test" );
|
|
pElement->SetValue( "binary_test", buf, 256 );
|
|
}
|
|
// Tests
|
|
{
|
|
g_pDataModel->Undo();
|
|
g_pDataModel->Undo();
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
g_pDataModel->Redo();
|
|
g_pDataModel->Redo();
|
|
g_pDataModel->Redo();
|
|
|
|
g_pDataModel->Undo();
|
|
g_pDataModel->Undo();
|
|
g_pDataModel->Undo();
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
}
|
|
}
|
|
|
|
// Now run "add" tests on a subset -- add adds an attribute where one didn't already exist
|
|
RunSingleAddAttributeUndoTest( pTest, pOriginal, pElement2, "int_test_added", 55 );
|
|
|
|
// Now run "remove" tests on a subset of attributes -- removes an existing attribute by name
|
|
RunSingleRemoveAttributeUndoTest( pTest, pOriginal, pTest, "int_test" );
|
|
}
|
|
|
|
#include "datamodel/dmehandle.h"
|
|
|
|
void RunUndoTestCreateElement()
|
|
{
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( "<RunUndoTestCreateElement>" );
|
|
|
|
CDmElement *element = NULL;
|
|
{
|
|
CUndoScopeGuard guard( "create" );
|
|
element = CreateElement< CDmElement >( "test", fileid );
|
|
}
|
|
|
|
CDmeHandle< CDmElement > hChannel;
|
|
|
|
hChannel = element;
|
|
|
|
Assert( hChannel.Get() );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
Assert( !hChannel.Get() );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
Assert( hChannel.Get() );
|
|
|
|
g_pDataModel->Undo(); // It's on the redo stack, but marked as kill and all ptrs are NULL to it
|
|
|
|
Assert( !hChannel.Get() );
|
|
|
|
g_pDataModel->ClearUndo();
|
|
g_pDataModel->ClearRedo();
|
|
|
|
g_pDataModel->RemoveFileId( fileid );
|
|
}
|
|
|
|
DEFINE_TESTCASE_NOSUITE( DmxUndoRedoTest )
|
|
{
|
|
Msg( "Running undo tests...\n" );
|
|
|
|
#ifdef _DEBUG
|
|
int nStartingCount = g_pDataModel->GetAllocatedElementCount();
|
|
#endif
|
|
|
|
CUndoScopeGuard sg( "Create Test Scenes" );
|
|
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( "<DmxUndoRedoTest>" );
|
|
CUtlVector< DmElementHandle_t > handles;
|
|
CreateTestScene( handles, fileid );
|
|
DmElementHandle_t hOriginal = handles[ 0 ];
|
|
handles.RemoveAll();
|
|
CreateTestScene( handles, fileid );
|
|
DmElementHandle_t hTest = handles[ 0 ];
|
|
|
|
sg.Release();
|
|
|
|
CDmElement *pOriginal = static_cast<CDmElement*>( g_pDataModel->GetElement( hOriginal ) );
|
|
CDmElement *pTest = static_cast<CDmElement*>(g_pDataModel->GetElement( hTest ) );
|
|
|
|
AssertEqualElementHierarchies( false, pTest, pOriginal );
|
|
|
|
RunUndoTests( handles, pTest, pOriginal );
|
|
RunUndoTestsArray( handles, pTest, pOriginal );
|
|
RunUndoTestCreateElement();
|
|
|
|
g_pDataModel->ClearUndo();
|
|
|
|
g_pDataModel->RemoveFileId( fileid );
|
|
|
|
#ifdef _DEBUG
|
|
int nEndingCount = g_pDataModel->GetAllocatedElementCount();
|
|
AssertEquals( nEndingCount, nStartingCount );
|
|
if ( nEndingCount != nStartingCount )
|
|
{
|
|
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement() ;
|
|
hElement != DMELEMENT_HANDLE_INVALID;
|
|
hElement = g_pDataModel->NextAllocatedElement( hElement ) )
|
|
{
|
|
CDmElement *pElement = g_pDataModel->GetElement( hElement );
|
|
Assert( pElement );
|
|
if ( !pElement )
|
|
return;
|
|
|
|
Msg( "[%s : %s] in memory\n", pElement->GetName(), pElement->GetTypeString() );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#include "datamodel/dmelementfactoryhelper.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeExternal - element class used for testing external attributes
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CDmeExternal : public CDmElement
|
|
{
|
|
DEFINE_ELEMENT( CDmeExternal, CDmElement );
|
|
|
|
public:
|
|
CDmaVar< float > m_External;
|
|
};
|
|
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeExternal, CDmeExternal );
|
|
|
|
void CDmeExternal::OnConstruction()
|
|
{
|
|
m_External .InitAndSet( this, "external", 99.9f );
|
|
}
|
|
|
|
void CDmeExternal::OnDestruction()
|
|
{
|
|
}
|
|
|
|
USING_ELEMENT_FACTORY( DmeExternal );
|
|
|
|
|
|
DEFINE_TESTCASE_NOSUITE( DmxExternalAttributeTest )
|
|
{
|
|
Msg( "Running external attribute test...\n" );
|
|
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( "<DmxExternalAttributeTest>" );
|
|
|
|
CDmeExternal *pOriginal = 0;
|
|
|
|
#ifdef _DEBUG
|
|
int nStartingCount = g_pDataModel->GetAllocatedElementCount();
|
|
#endif
|
|
|
|
{
|
|
CUndoScopeGuard guard( "External" );
|
|
pOriginal = CreateElement<CDmeExternal>( "foo", fileid );
|
|
|
|
for ( int m = 0; m < 1; ++m )
|
|
{
|
|
CDmeExternal *discard = CreateElement<CDmeExternal>( "foo", fileid );
|
|
g_pDataModel->DestroyElement( discard->GetHandle() );
|
|
}
|
|
}
|
|
|
|
// Now mess with vars
|
|
|
|
g_pDataModel->Undo();
|
|
g_pDataModel->Redo();
|
|
|
|
{
|
|
CUndoScopeGuard guard( "External2" );
|
|
pOriginal->m_External.Set( 100.0f );
|
|
}
|
|
|
|
g_pDataModel->ClearUndo();
|
|
|
|
g_pDataModel->RemoveFileId( fileid );
|
|
|
|
#ifdef _DEBUG
|
|
int nEndingCount = g_pDataModel->GetAllocatedElementCount();
|
|
AssertEquals( nEndingCount, nStartingCount );
|
|
if ( nEndingCount != nStartingCount )
|
|
{
|
|
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement() ;
|
|
hElement != DMELEMENT_HANDLE_INVALID;
|
|
hElement = g_pDataModel->NextAllocatedElement( hElement ) )
|
|
{
|
|
CDmElement *pElement = g_pDataModel->GetElement( hElement );
|
|
Assert( pElement );
|
|
if ( !pElement )
|
|
return;
|
|
|
|
Msg( "[%s : %s] in memory\n", pElement->GetName(), pElement->GetTypeString() );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Assert_InvalidAndNULL( CDmeHandle< CDmElement > &hElement )
|
|
{
|
|
Shipping_Assert( !hElement.Get() );
|
|
if ( !hElement.Get() )
|
|
{
|
|
g_pDataModel->MarkHandleValid( hElement.GetHandle() );
|
|
Shipping_Assert( !hElement.Get() );
|
|
if ( hElement.Get() )
|
|
{
|
|
g_pDataModel->MarkHandleInvalid( hElement.GetHandle() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void Assert_InvalidButNonNULL( CDmeHandle< CDmElement > &hElement )
|
|
{
|
|
Shipping_Assert( !hElement.Get() );
|
|
if ( !hElement.Get() )
|
|
{
|
|
g_pDataModel->MarkHandleValid( hElement.GetHandle() );
|
|
Shipping_Assert( hElement.Get() );
|
|
if ( hElement.Get() )
|
|
{
|
|
g_pDataModel->MarkHandleInvalid( hElement.GetHandle() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void Assert_ValidAndNonNULL( CDmeHandle< CDmElement > &hElement )
|
|
{
|
|
Shipping_Assert( hElement.Get() );
|
|
}
|
|
|
|
DEFINE_TESTCASE_NOSUITE( DmxReferenceCountingTest )
|
|
{
|
|
Msg( "Running external attribute test...\n" );
|
|
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( "<DmxReferenceCountingTest>" );
|
|
|
|
CDmeHandle< CDmElement > hRoot;
|
|
CDmeHandle< CDmElement > hChild1, hChild2, hChild3, hChild4, hChild5;
|
|
CDmeHandle< CDmElement > hGrandChild1, hGrandChild2, hGrandChild3, hGrandChild4, hGrandChild5, hGrandChild6, hGrandChild7;
|
|
CDmeCountedHandle hStrong6, hStrong7;
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nStartingCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nStartingCount == 0 );
|
|
|
|
{
|
|
CUndoScopeGuard guard( "Create RefCountTest Elements" );
|
|
|
|
hRoot = CreateElement<CDmElement>( "root", fileid );
|
|
CDmrElementArray<> arrayRoot( hRoot, "children", true );
|
|
g_pDataModel->SetFileRoot( fileid, hRoot->GetHandle() );
|
|
|
|
hChild1 = CreateElement<CDmElement>( "child1", fileid );
|
|
CDmrElementArray<> arrayChild1( hChild1, "children", true );
|
|
arrayRoot.AddToTail( hChild1.Get() );
|
|
|
|
hChild2 = CreateElement<CDmElement>( "child2", fileid );
|
|
hChild2->AddAttributeElement<CDmElement>( "child" );
|
|
arrayRoot.AddToTail( hChild2.Get() );
|
|
|
|
hChild3 = CreateElement<CDmElement>( "child3", fileid );
|
|
hChild3->AddAttributeElement<CDmElement>( "child" );
|
|
arrayRoot.AddToTail( hChild3.Get() );
|
|
|
|
hChild4 = CreateElement<CDmElement>( "child4", fileid );
|
|
hChild4->AddAttributeElement<CDmElement>( "child" );
|
|
arrayRoot.AddToTail( hChild4.Get() );
|
|
|
|
hChild5 = CreateElement<CDmElement>( "child5", fileid );
|
|
CDmrElementArray<> arrayChild5( hChild5, "children", true );
|
|
arrayRoot.AddToTail( hChild5.Get() );
|
|
|
|
hGrandChild1 = CreateElement<CDmElement>( "grandchild1", fileid );
|
|
arrayChild1.AddToTail( hGrandChild1.Get() );
|
|
|
|
hGrandChild2 = CreateElement<CDmElement>( "grandchild2", fileid );
|
|
arrayChild1.AddToTail( hGrandChild2.Get() );
|
|
hChild2->SetValue( "child", hGrandChild2.GetHandle() );
|
|
|
|
hGrandChild3 = CreateElement<CDmElement>( "grandchild3", fileid );
|
|
arrayChild1.AddToTail( hGrandChild3.Get() );
|
|
hChild3->SetValue( "child", hGrandChild3.GetHandle() );
|
|
|
|
hGrandChild4 = CreateElement<CDmElement>( "grandchild4", fileid );
|
|
arrayChild1.AddToTail( hGrandChild4.Get() );
|
|
hChild4->SetValue( "child", hGrandChild4.GetHandle() );
|
|
|
|
hGrandChild5 = CreateElement<CDmElement>( "grandchild5", fileid );
|
|
arrayChild1.AddToTail( hGrandChild5.Get() );
|
|
arrayChild5.AddToTail( hGrandChild5.Get() );
|
|
|
|
hGrandChild6 = CreateElement<CDmElement>( "grandchild6", fileid );
|
|
arrayChild1.AddToTail( hGrandChild6.Get() );
|
|
hStrong6 = hGrandChild6;
|
|
|
|
hGrandChild7 = CreateElement<CDmElement>( "grandchild7", fileid );
|
|
arrayChild1.AddToTail( hGrandChild7.Get() );
|
|
hStrong7 = hGrandChild7;
|
|
}
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nCreateCount = g_pDataModel->GetAllocatedElementCount();
|
|
Assert( nCreateCount == nStartingCount + 13 );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_ValidAndNonNULL ( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild1 );
|
|
Assert_ValidAndNonNULL ( hGrandChild2 );
|
|
Assert_ValidAndNonNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_ValidAndNonNULL ( hGrandChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
g_pDataModel->ClearUndo();
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nPostCreateCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nPostCreateCount == nCreateCount );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_ValidAndNonNULL ( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild1 );
|
|
Assert_ValidAndNonNULL ( hGrandChild2 );
|
|
Assert_ValidAndNonNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_ValidAndNonNULL ( hGrandChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
{
|
|
CUndoScopeGuard guard( "Edit RefCountTest Elements" );
|
|
|
|
CDmrGenericArray children( hChild1, "children" );
|
|
children.RemoveAll(); // grandchild1 unref'ed to 0, grandchild2..6 unref'ed to 1
|
|
|
|
hChild2->SetValue( "child", DMELEMENT_HANDLE_INVALID ); // grandchild2 unref'ed to 0
|
|
|
|
g_pDataModel->DestroyElement( hChild3 ); // grandchild3 is unref'ed to 0
|
|
|
|
CDmrElementArray<> children5( hChild5, "children" );
|
|
children5.Set( 0, NULL ); // grandchild5 is unref'ed to 0
|
|
|
|
hStrong6 = DMELEMENT_HANDLE_INVALID; // grandchild6 is unref'ed to 0
|
|
}
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nEditCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nEditCount == nCreateCount - 1 );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_InvalidButNonNULL( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild1 );
|
|
Assert_ValidAndNonNULL ( hGrandChild2 );
|
|
Assert_ValidAndNonNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_ValidAndNonNULL ( hGrandChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
g_pDataModel->Undo();
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nUndoCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nUndoCount == nCreateCount );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_ValidAndNonNULL ( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild1 );
|
|
Assert_ValidAndNonNULL ( hGrandChild2 );
|
|
Assert_ValidAndNonNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_ValidAndNonNULL ( hGrandChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
g_pDataModel->Redo();
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nRedoCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nRedoCount == nEditCount );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_InvalidButNonNULL( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild1 );
|
|
Assert_ValidAndNonNULL ( hGrandChild2 );
|
|
Assert_ValidAndNonNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_ValidAndNonNULL ( hGrandChild5 );
|
|
Assert_ValidAndNonNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
g_pDataModel->ClearUndo();
|
|
|
|
g_pDmElementFramework->BeginEdit();
|
|
|
|
int nClearUndoCount = g_pDataModel->GetAllocatedElementCount();
|
|
Shipping_Assert( nClearUndoCount == nCreateCount - 6 );
|
|
|
|
Assert_ValidAndNonNULL ( hRoot );
|
|
Assert_ValidAndNonNULL ( hChild1 );
|
|
Assert_ValidAndNonNULL ( hChild2 );
|
|
Assert_InvalidAndNULL ( hChild3 );
|
|
Assert_ValidAndNonNULL ( hChild4 );
|
|
Assert_ValidAndNonNULL ( hChild5 );
|
|
Assert_InvalidAndNULL ( hGrandChild1 );
|
|
Assert_InvalidAndNULL ( hGrandChild2 );
|
|
Assert_InvalidAndNULL ( hGrandChild3 );
|
|
Assert_ValidAndNonNULL ( hGrandChild4 );
|
|
Assert_InvalidAndNULL ( hGrandChild5 );
|
|
Assert_InvalidAndNULL ( hGrandChild6 );
|
|
Assert_ValidAndNonNULL ( hGrandChild7 );
|
|
|
|
g_pDataModel->RemoveFileId( fileid );
|
|
}
|