/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/Io/SaveLoad/unit-tests/BMSerializerTest.cpp

//
// Copyright (c) 2005           Model-based Embedded and Robotic Systems Group
// All Rights Reserved          Massachusetts Institute of Technology
//
// This software is provided as is. Model-based Embedded and Robotic Systems
// (MERS) group does not assume any responsibility.
//

#include <tut.h>
#include <Mers/Models/Base/Io/SaveLoad/Serializer.h>
#include <Mers/Models/Base/BaseModel.h>
#include <Mers/Models/Base/unit-tests/BMHelper.h>
#include <Mers/Utils/Lang/String.h>
#include <Mers/Utils/Io/Xml/XercesSetup.h>
#include <Mers/Utils/Io/Xml/ScopedTranscoder.h>
#include <Mers/Utils/Io/Xml/Dom/XMLSaveLoad.h>
#include <xercesc/dom/DOM.hpp>
#include <memory>


using Mers::Models::Base::Io::SaveLoad::Serializer;
using tut::BMHelper;
using Mers::Models::Base::BaseModel;
using Mers::Models::Base::BaseModelValue;
using Mers::Models::Base::BaseModelValueArray;
using Mers::Models::Base::BaseModelDomain;
using Mers::Models::Base::BaseModelDomainArray;
using Mers::Models::Base::BaseModelVariable;
using Mers::Models::Base::BaseModelVariableArray;
using Mers::Models::Base::BaseModelVariableArrayArray;
using Mers::Models::Base::BaseModelAssignment;
using Mers::Models::Base::BaseModelAssignmentArray;
using Mers::Models::Base::BaseModelClause;
using Mers::Models::Base::BaseModelClauseArray;
using Mers::Models::Base::BaseModelSentence;
using Mers::Utils::Lang::String;
using Mers::Utils::Io::Xml::XercesSetup;
using Mers::Utils::Io::Xml::CScopedTranscoder;
using Mers::Utils::Io::Xml::XMLScopedTranscoder;
using Mers::Utils::Io::Xml::Dom::XMLSaveLoad;
using XERCES_CPP_NAMESPACE::DOMImplementation;
using XERCES_CPP_NAMESPACE::DOMDocument;
using XERCES_CPP_NAMESPACE::DOMElement;
using XERCES_CPP_NAMESPACE::DOMImplementationRegistry;
using XERCES_CPP_NAMESPACE::DOMAttr;
using XERCES_CPP_NAMESPACE::DOMNode;
using XERCES_CPP_NAMESPACE::DOMNodeList;
using tut::ensure;
using tut::ensure_equals;
using std::auto_ptr;


namespace {

class BMSerializerData : public BMHelper
{
public:
        BMSerializerData() :
                m_model( "BMS_Model" ),
                m_serializer( &m_model ),
                m_xerces( NULL )
        {
                // Setup Xerces.
                m_xerces = new XercesSetup;

                // Create an XML document.
                XMLScopedTranscoder sXMLV1("XML");
                m_implementation = 
                        DOMImplementationRegistry::getDOMImplementation( sXMLV1 );
                XMLScopedTranscoder sDocRootName("save_test");
                m_document =
                        m_implementation->createDocument(NULL, sDocRootName, NULL);
        }

        ~BMSerializerData()
        {
                m_document->release();
                delete m_xerces;
        }

protected:

        void createValues( BaseModelValueArray &values, const String &name,
                unsigned int numValues )
        {
                // Create a set of values for the array of values.
                for( unsigned int i = 0; i < numValues; ++i ) {
                        // Create a (unique) name for this value
                        String valueName( name );
                        valueName += i;
                        // Create the value
                        BaseModelValue * value = new BaseModelValue( valueName );
                        // Add it to the array of values
                        values.pushBack( value );
                }
        }

protected:
        // A model
        BaseModel m_model;

        // The object we're using to serialize.
        Serializer m_serializer;

        // Setup Xerces for the test.
        XercesSetup * m_xerces;

        // The DOM implementation of Xerces.
        DOMImplementation * m_implementation;

        // The document we're going to use for testing.
        DOMDocument * m_document;
};

        
typedef tut::test_group<BMSerializerData, 10> t_SaveSerializationFactory;
typedef t_SaveSerializationFactory::object t_SaveSerializationObject;


t_SaveSerializationFactory ssFactory( "BaseModel Serialization Tests" );


} // End nameless namespace


// Save/Load Versions that we will test.
unsigned int kSaveLoadVersion_Initial = 1;


namespace tut {

template<> template<> void t_SaveSerializationObject::test<1>()
{
        // The values in the domain.  We're just going to save the first one.
        const char * domainVals[] = {"Val1", "Val2", NULL};
        // The list of domains (just one)
        const struct BMDomainEntry domains[] = {
                {"Dom1", domainVals}
        };
        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );

        // We're going to save/load into these variables.
        BaseModelDomainArray savDomains( true ), refDomains( true ),
                loadDomains( true );

        // Get our saving domain
        loadDomainData( numDomains, domains, savDomains );
        // Get our reference domain
        loadDomainData( numDomains, domains, refDomains );
        // Get our loaded domain (since we're only changing one value)
        loadDomainData( numDomains, domains, loadDomains );

        // Get a reference to the values we're dealing with.
        BaseModelValue * savValue = (*savDomains[0])[0];
        BaseModelValue * refValue = (*refDomains[0])[0];

        // Make sure this is going to work
        ensure_equals( "Two values created are equal.", *savValue, *refValue );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Save the value.
        savingSaveLoad.saveLoad( savValue, m_serializer );

        // Make sure that we didn't mess up sValue.
        ensure_equals( "Saving does not alter pointer",
                (*savDomains[0])[0], savValue );
        // Make sure we didn't mess up the value.
        ensure_equals( "Saving did not alter the data", *savValue, *refValue );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Load a new value.
        BaseModelValue * value( NULL );
        loadingSaveLoad.saveLoad( value, m_serializer );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Value was loaded (not NULL)", value != NULL );

        // Replace the domain value with this value.
        delete (*loadDomains[0])[0];
        (*loadDomains[0])[0] = value;
        value->setDomain( loadDomains[0] );

        // Make sure the values are the same.
        ensure_equals( "Value is the same", *value, *refValue );
}


template<> template<> void t_SaveSerializationObject::test<2>()
{
        // Our domain
        const char * vals[] = {"BM_DomVal_0", "BM_DomVal_1", "BM_DomVal_2",
                "BM_DomVal_3" };
        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;
        // The number of values
        const unsigned int numVals = sizeof( vals ) / sizeof( vals[0] );

        // We're going to save/load into these variables.
        auto_ptr<BaseModelValueArray>
                autoSavVals( new BaseModelValueArray( true ) ),
                refVals( new BaseModelValueArray( true ) );

        // Load our values
        for( unsigned int v = 0; v < numVals; ++v ) {
                autoSavVals->pushBack( new BaseModelValue( vals[v] ) );
                refVals->pushBack( new BaseModelValue( vals[v] ) );
        }

        // Get a reference to the values we're dealing with.
        BaseModelValueArray * savVals = autoSavVals.get();

        // These should be the same
        ensure_equals( "Valss created are the same", *savVals, *refVals );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Save the vals.
        savingSaveLoad.saveLoad( savVals, m_serializer );

        // Make sure that we didn't mess up savVals.
        ensure_equals( "Saving does not alter pointer", savVals,
                autoSavVals.get() );

        // Make sure we didn't mess up the vals.
        ensure_equals( "Saving did not alter the data", *savVals, *refVals );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Load a new value array
        BaseModelValueArray * loadVals( NULL );
        loadingSaveLoad.saveLoad( loadVals, m_serializer );

        // auto-cleanup this loaded value.
        auto_ptr<BaseModelValueArray> autoLoadVals( loadVals );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Domain was loaded (not NULL)", loadVals != NULL );

        // The vals should match exactly.
        ensure_equals( "values are the same", *loadVals, *refVals );
}


template<> template<> void t_SaveSerializationObject::test<3>()
{
        // Our domain
        const char * domainVals[] = {"BM_DomVal_0", "BM_DomVal_1", "BM_DomVal_2",
                "BM_DomVal_3", NULL};
        const struct BMDomainEntry domains[] = {
                {"Dom1", domainVals}
        };
        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );

        // We're going to save/load into these variables.
        BaseModelDomainArray savDomains( true ), refDomains( true ),
                loadDomains( true );

        // Get our saving domain
        loadDomainData( numDomains, domains, savDomains );
        // Get our reference domain
        loadDomainData( numDomains, domains, refDomains );

        // Get a reference to the values we're dealing with.
        BaseModelDomain * savDomain = savDomains[0];
        BaseModelDomain * refDomain = refDomains[0];

        // These should be the same
        ensure_equals( "Domains created are the same", *savDomain, *refDomain );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Save the domain.
        savingSaveLoad.saveLoad( savDomain, m_serializer );

        // Make sure that we didn't mess up sDomain.
        ensure_equals( "Saving does not alter pointer", savDomain, savDomains[0] );

        // Make sure we didn't mess up the domain.
        ensure_equals( "Saving did not alter the data", *savDomain, *refDomain );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Change the model, to be able to match the data.
        BaseModel bModel( "TestModel" );
        m_serializer.setModel( &bModel );
        // Load a new domain.
        BaseModelDomain * domain( NULL );
        loadingSaveLoad.saveLoad( domain, m_serializer );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Domain was loaded (not NULL)", domain != NULL );

        // The domain should match exactly (due to the way we construct
        // them).
        ensure_equals( "Domain is the same", *domain, *refDomain );
}


template<> template<> void t_SaveSerializationObject::test<4>()
{
        // Our domain
        const char * domainVals[] = {"BM_VarVal_0", "BM_VarVal_1", "BM_VarVal_2",
                "BM_VarVal_3", "BM_VarVal_4", NULL};
        const struct BMDomainEntry domains[] = {
                {"FakeTestDomain", domainVals},
                {"TestDomain", domainVals}
        };
        enum Domain { FakeTestDomain = 0, TestDomain = 1 };

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );

        // Our variable
        const struct BMVariableEntry variables[] = {
                { "SomeVariable.Name", TestDomain, BaseModelVariable::State }
        };

        // The number of variables
        const unsigned int numVars = sizeof( variables ) / sizeof( variables[0] );

        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // Our domains
        BaseModelDomainArray savDomains( true ), loadDomains( false );

        // Our variables
        BaseModelVariableArray savVariables( true ), refVariables( true );

        // Create our domain data
        loadDomainData( numDomains, domains, savDomains );
        loadDomainData( numDomains, domains, loadDomains );
        // Create our variable data
        loadVariableData( numVars, variables, savDomains, savVariables );
        loadVariableData( numVars, variables, savDomains, refVariables );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Keep a copy of the original variable handy.
        BaseModelVariable * refVar = refVariables[ 0 ];
        BaseModelVariable * savVar = savVariables[ 0 ];

        // Make sure that they're the same.
        ensure_equals( "Data is initially the same", *savVar, *refVar );

        // Save the variable.
        savingSaveLoad.saveLoad( savVar, m_serializer );

        // Make sure that we didn't mess up savVar.
        ensure_equals( "Saving does not alter pointer", savVar, savVariables[0] );

        // Make sure we didn't mess up the variable.
        ensure_equals( "Saving did not alter the data", *savVar, *refVar );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Change the model, to be able to match the data.
        BaseModel bModel( "TestModel" );
        m_serializer.setModel( &bModel );
        // Add the load domains to the model.
        bModel.addDomain( loadDomains[ 0 ] );
        bModel.addDomain( loadDomains[ 1 ] );
        // Load a new variable.
        BaseModelVariable * loadVar( NULL );
        loadingSaveLoad.saveLoad( loadVar, m_serializer );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Variable was loaded (not NULL)", loadVar != NULL );

        // The variables should match.
        ensure_equals( "Variable is the same", *loadVar, *refVar );
}


template<> template<> void t_SaveSerializationObject::test<5>()
{
        // Our domain
        const char * domainVals[] = {"BM_VarVal_0", "BM_VarVal_1", "BM_VarVal_2",
                "BM_VarVal_3", "BM_VarVal_4", NULL};
        const struct BMDomainEntry domains[] = {
                {"TestDomain", domainVals}
        };
        enum Domain { TestDomain = 0 };

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );

        // Our variable
        const struct BMVariableEntry variables[] = {
                { "SomeVariable.Name", TestDomain, BaseModelVariable::State }
        };

        // The number of variables
        const unsigned int numVars = sizeof( variables ) / sizeof( variables[0] );

        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // The operator of our assignment.
        BaseModelAssignment::OperatorType opType =
                BaseModelAssignment::Negative;

        // Our domains
        BaseModelDomainArray savDomains( true ), loadDomains( false );

        // Our variables
        BaseModelVariableArray savVariables( true ), loadVariables( false );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Load our data
        loadDomainData( numDomains, domains, savDomains );
        loadDomainData( numDomains, domains, loadDomains );
        loadVariableData( numVars, variables, savDomains, savVariables );
        loadVariableData( numVars, variables, loadDomains, loadVariables );

        // Create our assignments.
        BaseModelVariable * savVar( savVariables[0] );
        BaseModelVariable * loadVar( loadVariables[0] );
        BaseModelValue * savVal( (*savVar->getDomain())[0] );
        BaseModelValue * loadVal( (*loadVar->getDomain())[0] );
        BaseModelAssignment * savAssign(
                new BaseModelAssignment( savVar, savVal, opType ) );
        auto_ptr<BaseModelAssignment> autoSavAssign( savAssign );
        auto_ptr<BaseModelAssignment> refAssign(
                new BaseModelAssignment( savVar, savVal, opType ) );

        // Make sure that these are equal
        ensure_equals( "Data is the same.", *savAssign, *refAssign );

        // Save the assignment.
        savingSaveLoad.saveLoad( savAssign, m_serializer );

        // Make sure that we didn't mess up the pointer
        ensure_equals( "Saving does not alter pointer", savAssign,
                autoSavAssign.get() );

        // Make sure we didn't mess up the assignment.
        ensure_equals( "Saving did not alter the data", *savAssign, *refAssign );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Change the model, to be able to match the data.
        BaseModel bModel( "TestModel" );
        m_serializer.setModel( &bModel );
        // Add the load domains to the model.
        bModel.addDomain( loadDomains[ 0 ] );
        bModel.addVariable( loadVariables[ 0 ] );
        // Load a new assignment.
        BaseModelAssignment * loadAssign( NULL );
        loadingSaveLoad.saveLoad( loadAssign, m_serializer );

        // Auto clean our loaded assignment
        auto_ptr<BaseModelAssignment> autoLoadAssign( loadAssign );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Assignment was loaded (not NULL)", loadAssign != NULL );

        // The assignments should match.  To make our life a bit easier,
        // we'll construct an appropriate copy of what we wanted to load.
        auto_ptr<BaseModelAssignment> loadRefAssign(
                new BaseModelAssignment( loadVar, loadVal, opType ) );
        ensure_equals( "Assignment is the same", *loadAssign, *loadRefAssign );
}


template<> template<> void t_SaveSerializationObject::test<6>()
{
        // Our domains
        const char * domainVals1[] = {"BM_DomVal_0", "BM_DomVal_1", "BM_DomVal_2",
                "BM_DomVal_3", NULL};
        const char * domainVals2[] = {"BM_Test_0", "BM_Test_1", "BM_Foo_2",
                "BM_Wow_3", "BM_No", NULL};
        const struct BMDomainEntry domains[] = {
                {"Dom1", domainVals1},
                {"Dom2", domainVals2}
        };
        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );

        // We're going to save/load into these variables.
        auto_ptr<BaseModelDomainArray>
                autoSavDomains( new BaseModelDomainArray( true ) ),
                refDomains( new BaseModelDomainArray( true ) );

        // Get our domain data
        loadDomainData( numDomains, domains, *autoSavDomains );
        loadDomainData( numDomains, domains, *refDomains );

        // Get a reference to our save data
        BaseModelDomainArray * savDomains( autoSavDomains.get() );

        // These should be the same
        ensure_equals( "Domains created are the same", *savDomains, *refDomains );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Save the domain.
        savingSaveLoad.saveLoad( savDomains, m_serializer );

        // Make sure that we didn't mess up sDomain.
        ensure_equals( "Saving does not alter pointer", savDomains,
                autoSavDomains.get() );

        // Make sure we didn't mess up the domain.
        ensure_equals( "Saving did not alter the data", *savDomains, *refDomains );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Change the model, to be able to match the data.
        BaseModel bModel( "TestModel" );
        m_serializer.setModel( &bModel );
        // Load a new domain.
        BaseModelDomainArray * loadDomains( NULL );
        loadingSaveLoad.saveLoad( loadDomains, m_serializer );

        // Auto-cleanup
        auto_ptr<BaseModelDomainArray> autoLoadDomains( loadDomains );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Domain was loaded (not NULL)", loadDomains != NULL );

        // The domain should match exactly (due to the way we construct
        // them).
        ensure_equals( "Domain is the same", *loadDomains, *refDomains );
}


template<> template<> void t_SaveSerializationObject::test<7>()
{
        // Our domains
        const char * domainVals1[] = {"BM_DomVal_0", "BM_DomVal_1", "BM_DomVal_2",
                "BM_DomVal_3", NULL};
        const char * domainVals2[] = {"BM_Test_0", "BM_Test_1", "BM_Foo_2",
                "BM_Wow_3", "BM_No", NULL};
        const struct BMDomainEntry domains[] = {
                {"Dom1", domainVals1},
                {"Dom2", domainVals2}
        };
        enum Domain {TestDomain, NextDomain};
        // Our variables
        const struct BMVariableEntry variables[] = {
                { "SomeVariable.Name", TestDomain, BaseModelVariable::State },
                { "VarA", NextDomain, BaseModelVariable::Control },
                { "VarQ", TestDomain, BaseModelVariable::State },
                { "VarC", NextDomain, BaseModelVariable::Control },
                { "VarM", NextDomain, BaseModelVariable::Dependent }
        };

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );
        // The number of variables
        const unsigned int numVars = sizeof( variables ) / sizeof( variables[0] );

        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        // We're going to save/load our domain as well.
        BaseModelDomainArray refDomains( true );
        BaseModelDomainArray * pRefDomains( &refDomains );
        // Get our domain data
        loadDomainData( numDomains, domains, refDomains );

        // We're going to save/load into these variables.
        auto_ptr<BaseModelVariableArray>
                autoSavVariables( new BaseModelVariableArray( true ) ),
                refVariables( new BaseModelVariableArray( true ) );
        // Our local save pointer
        BaseModelVariableArray * savVariables( autoSavVariables.get() );

        // Load our variable data
        loadVariableData( numVars, variables, refDomains, *autoSavVariables );
        loadVariableData( numVars, variables, refDomains, *refVariables );

        // These should be the same
        ensure_equals( "Variables created are the same",
                *savVariables, *refVariables );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );

        // Save the domains & variables.
        savingSaveLoad.saveLoad( pRefDomains, m_serializer );
        savingSaveLoad.saveLoad( savVariables, m_serializer );

        // Make sure that we didn't mess up sDomain.
        ensure_equals( "Saving does not alter pointer", savVariables,
                autoSavVariables.get() );

        // Make sure we didn't mess up the variable.
        ensure_equals( "Saving did not alter the data",
                *savVariables, *refVariables );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Change the model, to be able to match the data.
        BaseModel bModel( "TestModel" );
        m_serializer.setModel( &bModel );
        // Load our domains and variables.
        BaseModelDomainArray * loadDomains( NULL );
        BaseModelVariableArray * loadVariables( NULL );
        loadingSaveLoad.saveLoad( loadDomains, m_serializer );
        loadingSaveLoad.saveLoad( loadVariables, m_serializer );

        // Auto-cleanup
        auto_ptr<BaseModelDomainArray> autoLoadDomains( loadDomains );
        auto_ptr<BaseModelVariableArray> autoLoadVariables( loadVariables );

        // Check that we were able to re-load our domain object.
        // First, make sure it's not NULL.
        ensure( "Domain was loaded (not NULL)", loadDomains != NULL );

        // Create a new set of reference variables
        BaseModelVariableArray loadRefVariables( true );
        loadVariableData( numVars, variables, *loadDomains, loadRefVariables );

        // Check that we were able to re-load our object.
        // First, make sure it's not NULL.
        ensure( "Variable was loaded (not NULL)", loadVariables != NULL );

        // The variable list should match.
        ensure_equals( "Domain is the same", *loadVariables, loadRefVariables );
}


template<> template<> void t_SaveSerializationObject::test<8>()
{
        // Our domains
        const char * domainVals1[] = {"BM_DomVal_0", "BM_DomVal_1", "BM_DomVal_2",
                "BM_DomVal_3", NULL};
        const char * domainVals2[] = {"BM_Test_0", "BM_Test_1", "BM_Foo_2",
                "BM_Wow_3", "BM_No", NULL};
        const struct BMDomainEntry domains[] = {
                {"Dom1", domainVals1},
                {"Dom2", domainVals2}
        };
        enum Domain {TestDomain, NextDomain};
        // Our variables
        const struct BMVariableEntry variables[] = {
                { "SomeVariable.Name", TestDomain, BaseModelVariable::State },
                { "VarA", NextDomain, BaseModelVariable::Control },
                { "VarQ", TestDomain, BaseModelVariable::State },
                { "VarC", NextDomain, BaseModelVariable::Control },
                { "VarM", NextDomain, BaseModelVariable::Dependent }
        };

        // The number of domains
        const unsigned int numDomains = sizeof( domains ) / sizeof( domains[0] );
        // The number of variables
        const unsigned int numVars = sizeof( variables ) / sizeof( variables[0] );

        // The version we're testing.
        const unsigned int version = kSaveLoadVersion_Initial;

        auto_ptr<BaseModel> autoSavModel( new BaseModel( "Test" ) ),
                refModel( new BaseModel( "Test" ) );
        BaseModel * savModel( autoSavModel.get() );

        // Get our model data
        loadModelData( numDomains, domains, numVars, variables, *autoSavModel );
        loadModelData( numDomains, domains, numVars, variables, *refModel );

        // These should be the same
        ensure_equals( "Models created are the same", *savModel, *refModel );

        // Create our SaveLoad object for saving.
        XMLSaveLoad savingSaveLoad( m_document, XMLSaveLoad::kSave, version );
        m_serializer.setModel( savModel );

        // Save the model
        savingSaveLoad.saveLoad( savModel, m_serializer );

        // Make sure that we didn't mess up sDomain.
        ensure_equals( "Saving does not alter pointer", savModel,
                autoSavModel.get() );

        // Make sure we didn't mess up the variable.
        ensure_equals( "Saving did not alter the data",
                *savModel, *refModel );

        // Create our SaveLoad object for loading.
        XMLSaveLoad loadingSaveLoad( m_document, XMLSaveLoad::kLoad );
        // Loading this model
        BaseModel * loadModel( NULL );
        m_serializer.setModel( loadModel );

        // Load our model
        loadingSaveLoad.saveLoad( loadModel, m_serializer );

        // Auto-cleanup
        auto_ptr<BaseModel> autoLoadModel( loadModel );

        // Check that we were able to re-load our model object.
        // First, make sure it's not NULL.
        ensure( "Model was loaded (not NULL)", loadModel != NULL );

        // The model should match.
        ensure_equals( "Model is the same", *loadModel, *refModel );
}


} // tut

---