/*

* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <mdeobject.h>

#include <mdeobjectdef.h>

#include <mdesession.h>

#include <mdeconstants.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <StifTestEventInterface.h>

#include "MdETestScripter.h"

#include "MdETestScripterAO.h"

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CMdETestScripter::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CMdETestScripter::Delete() 

    {

    iObjectDefArray.Reset();

    iRelationDefArray.Reset();

    iEventDefArray.Reset();

    iLogicConditionArray.Reset();

    iRelationConditionArray.Reset();

    iNotificationRelationArray.Reset();

	RArray<TItemId> objectIds;

	RArray<TItemId> resultObjectIds;

	RArray<TItemId> eventIds;

	RArray<TItemId> resultEventIds;

	RArray<TItemId> relationIds;

	RArray<TItemId> resultRelationIds;

	TInt count = iObjectArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		objectIds.Append(iObjectArray[i]->Id());	

		}

	count = iEventArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		eventIds.Append(iEventArray[i]->Id());	

		}

	count = iRelationArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		relationIds.Append(iRelationArray[i]->Id());	

		}			

	if (objectIds.Count())

		{

		TRAP_IGNORE( iMdeSession->RemoveObjectsL( objectIds, resultObjectIds) );	

		}

    iObjectArray.ResetAndDestroy();

	if (eventIds.Count())

		{    

		TRAP_IGNORE( iMdeSession->RemoveEventsL( eventIds, resultEventIds) );

		}

    iEventArray.ResetAndDestroy();

	if (relationIds.Count())

		{          

		TRAP_IGNORE( iMdeSession->RemoveRelationsL( relationIds, resultRelationIds) );

		}

    iRelationArray.ResetAndDestroy();

    TInt allRemoved = ETrue;

	count = iObjectArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		if (resultObjectIds[i] == KNoId)

			{

			allRemoved = EFalse;

			break;	

			}			

		}

	if (!allRemoved)

		{

		iLog->Log(_L( "All objects not removed from DB!!"));

		}

    allRemoved = ETrue;		

	count = iEventArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		if (resultEventIds[i] == KNoId)

			{

			allRemoved = EFalse;

			break;	

			}		

		}

	if (!allRemoved)

		{

		iLog->Log(_L( "All events not removed from DB!!"));

		}

    iEventArray.ResetAndDestroy();

    allRemoved = ETrue;		

	count = iRelationArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		if (resultRelationIds[i] == KNoId)

			{

			allRemoved = EFalse;

			break;	

			}		

		}

	if (!allRemoved)

		{

		iLog->Log(_L( "All relations not removed from DB!!"));

		}

	objectIds.Close();

	resultObjectIds.Close();

	eventIds.Close();

	resultEventIds.Close();

	relationIds.Close();

	resultRelationIds.Close();

	iPropertyDefArray.Reset();

    delete iObjectDefNameArray;

    delete iRelationDefNameArray;

	delete iEventDefNameArray;

	delete iPropertyDefNameArray;

	delete iNamespaceDefNameArray;

	delete iObjectNameArray;	

    delete iRelationNameArray;

    delete iEventNameArray;

    delete iPropertyNameArray;

	delete iLogicConditionNameArray;

	delete iRelationConditionNameArray;

	delete iObjectConditionNameArray;

	delete iPropertyConditionNameArray;

	delete iEventConditionNameArray;	

	delete iQuery;

    delete iMdeSession;

    iMdeSession = NULL;

    delete iAsyncHandler;

    iAsyncHandler = NULL;

    iMdEDataBuf.Close();

    iItemArray.Close();//Do not need call destroy because it does not own its pointers

    }

// -----------------------------------------------------------------------------

// CMdETestScripter::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::RunMethodL( CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Observer add/remove methods

        ENTRY( "AddSchemaObserverL", CMdETestScripter::AddSchemaObserverL ),

        ENTRY( "RemoveSchemaObserverL", CMdETestScripter::RemoveSchemaObserverL ),

        ENTRY( "AddObjectObserverL", CMdETestScripter::AddObjectObserverL ),

        ENTRY( "RemoveObjectObserverL", CMdETestScripter::RemoveObjectObserverL ),

        ENTRY( "AddObjectPresentObserverL", CMdETestScripter::AddObjectPresentObserverL ),

        ENTRY( "RemoveObjectPresentObserverL", CMdETestScripter::RemoveObjectPresentObserverL ),

        ENTRY( "AddRelationObserverL", CMdETestScripter::AddRelationObserverL ),

        ENTRY( "RemoveRelationObserverL", CMdETestScripter::RemoveRelationObserverL ),

        ENTRY( "AddRelationItemObserverL", CMdETestScripter::AddRelationItemObserverL ),

        ENTRY( "RemoveRelationItemObserverL", CMdETestScripter::RemoveRelationItemObserverL ),

        ENTRY( "AddRelationPresentObserverL", CMdETestScripter::AddRelationPresentObserverL ),

        ENTRY( "RemoveRelationPresentObserverL", CMdETestScripter::RemoveRelationPresentObserverL ),

        ENTRY( "AddEventObserverL", CMdETestScripter::AddEventObserverL ),

        ENTRY( "RemoveEventObserverL", CMdETestScripter::RemoveEventObserverL ),

        // Notification resulated test primitives

        ENTRY( "VerifyTItemIdsL", CMdETestScripter::VerifyTItemIdsL ),

        ENTRY( "VerifyMdERelationsL", CMdETestScripter::VerifyMdERelationsL ),

        ENTRY( "VerifyObserverNotificationTypeL", CMdETestScripter::VerifyObserverNotificationTypeL ),

        // Metadata/schema/namespace test primitives.

        ENTRY( "ObjectDefCountL", CMdETestScripter::ObjectDefCountL ),

        ENTRY( "ObjectDefL", CMdETestScripter::ObjectDefL ),

        ENTRY( "GetObjectDefL", CMdETestScripter::GetObjectDefL ),

        ENTRY( "RelationDefCountL", CMdETestScripter::RelationDefCountL ),

        ENTRY( "RelationDefL", CMdETestScripter::RelationDefL ),

        ENTRY( "GetRelationDefL", CMdETestScripter::GetRelationDefL ),

        ENTRY( "EventDefCountL", CMdETestScripter::EventDefCountL ),

        ENTRY( "EventDefL", CMdETestScripter::EventDefL ),

        ENTRY( "GetEventDefL", CMdETestScripter::GetEventDefL ),

        ENTRY( "ExportMetadataL", CMdETestScripter::ExportMetadataL ),

        ENTRY( "ImportMetadataL", CMdETestScripter::ImportMetadataL ),

        ENTRY( "ImportSchemaL", CMdETestScripter::ImportSchemaL ),

        ENTRY( "NamespaceDefCountL", CMdETestScripter::NamespaceDefCountL ),

        ENTRY( "NamespaceDefL", CMdETestScripter::NamespaceDefL ),

        ENTRY( "GetNamespaceDefL", CMdETestScripter::GetNamespaceDefL ),

        ENTRY( "GetDefaultNamespaceDefL", CMdETestScripter::GetDefaultNamespaceDefL ),

        ENTRY( "ResetNamespaceDefArray", CMdETestScripter::ResetNamespaceDefArray ),

        ENTRY( "LoadSchemaL", CMdETestScripter::LoadSchemaL ),

        ENTRY( "EngineSessionL", CMdETestScripter::EngineSessionL ),

        ENTRY( "GetSchemaVersionL", CMdETestScripter::GetSchemaVersionL ),

        ENTRY( "SetObjectToPresentByGuidL", CMdETestScripter::SetObjectToPresentByGuidL ),

        // Item / InstanceItem test primitives.

        ENTRY( "BelongsToSessionL", CMdETestScripter::BelongsToSessionL ),

        ENTRY( "SessionL", CMdETestScripter::SessionL ),

        ENTRY( "InDatabaseL", CMdETestScripter::InDatabaseL ),

        ENTRY( "AddItemsL", CMdETestScripter::AddItemsL ),

        ENTRY( "UpdateItemsL", CMdETestScripter::UpdateItemsL ),

        // Definition test primitives.

        ENTRY( "AddRelationDefL", CMdETestScripter::AddRelationDefL ),

        ENTRY( "AddEventDefL", CMdETestScripter::AddEventDefL ),

        ENTRY( "PropertyDefCountL", CMdETestScripter::PropertyDefCountL ),

        ENTRY( "PropertyDefL", CMdETestScripter::PropertyDefL ),

        ENTRY( "GetPropertyDefL", CMdETestScripter::GetPropertyDefL ),

        ENTRY( "MandatoryL", CMdETestScripter::MandatoryL ),

        ENTRY( "MinInt32ValueL", CMdETestScripter::MinInt32ValueL ),

        ENTRY( "MaxInt32ValueL", CMdETestScripter::MaxInt32ValueL ),

        ENTRY( "MinUint32ValueL", CMdETestScripter::MinUint32ValueL ),

        ENTRY( "MaxUint32ValueL", CMdETestScripter::MaxUint32ValueL ),

        ENTRY( "MinInt64ValueL", CMdETestScripter::MinInt64ValueL ),

        ENTRY( "MaxInt64ValueL", CMdETestScripter::MaxInt64ValueL ),

        ENTRY( "MinRealValueL", CMdETestScripter::MinRealValueL ),

        ENTRY( "MaxRealValueL", CMdETestScripter::MaxRealValueL ),

        ENTRY( "MinTimeValueL", CMdETestScripter::MinTimeValueL ),

        ENTRY( "MaxTimeValueL", CMdETestScripter::MaxTimeValueL ),

        ENTRY( "MinTextLengthL", CMdETestScripter::MinTextLengthL ),

        ENTRY( "MaxTextLengthL", CMdETestScripter::MaxTextLengthL ),

        ENTRY( "CompareL", CMdETestScripter::CompareL ),

        ENTRY( "ParentL", CMdETestScripter::ParentL ),

        ENTRY( "NameL", CMdETestScripter::NameL ),

        ENTRY( "ReadOnlyL", CMdETestScripter::ReadOnlyL ),

        ENTRY( "DefL", CMdETestScripter::DefL ),

        // Object test primitives.

        ENTRY( "SetDefL", CMdETestScripter::SetDefL ),

        ENTRY( "UriL", CMdETestScripter::UriL ),

        ENTRY( "SetUriL", CMdETestScripter::SetUriL ),

        ENTRY( "ConfidentialL", CMdETestScripter::ConfidentialL ),

        ENTRY( "SetConfidentialL", CMdETestScripter::SetConfidentialL ),

        ENTRY( "PlaceholderL", CMdETestScripter::PlaceholderL ),

        ENTRY( "SetPlaceholderL", CMdETestScripter::SetPlaceholderL ),

        ENTRY( "MediaIdL", CMdETestScripter::MediaIdL ),

        ENTRY( "SetMediaIdL", CMdETestScripter::SetMediaIdL ),

        ENTRY( "UsageCountL", CMdETestScripter::UsageCountL ),

        ENTRY( "GuidL", CMdETestScripter::GuidL ),

        ENTRY( "SetGuidL", CMdETestScripter::SetGuidL ),

        ENTRY( "OpenForModificationsL", CMdETestScripter::OpenForModificationsL ),

        ENTRY( "NewObjectL", CMdETestScripter::NewObjectL ),

        ENTRY( "AddObjectL", CMdETestScripter::AddObjectL ),

        ENTRY( "AddObjectsL", CMdETestScripter::AddObjectsL ),

        ENTRY( "GetObjectL", CMdETestScripter::GetObjectL ),

        ENTRY( "GetFullObjectL", CMdETestScripter::GetFullObjectL ),

        ENTRY( "CheckObjectL", CMdETestScripter::CheckObjectL ),

        ENTRY( "RemoveObjectL", CMdETestScripter::RemoveObjectL ),

        ENTRY( "RemoveObjectsL", CMdETestScripter::RemoveObjectsL ),

        ENTRY( "RemoveAllObjectsL", CMdETestScripter::RemoveAllObjectsL ),

        ENTRY( "OpenObjectL", CMdETestScripter::OpenObjectL ),

        ENTRY( "OpenFullObjectL", CMdETestScripter::OpenFullObjectL ),

        ENTRY( "CommitObjectL", CMdETestScripter::CommitObjectL ),

        ENTRY( "CommitObjectsL", CMdETestScripter::CommitObjectsL ),

        ENTRY( "CancelObjectL", CMdETestScripter::CancelObjectL ),

        ENTRY( "PropertyL", CMdETestScripter::PropertyL ),

        ENTRY( "PropertyCountL", CMdETestScripter::PropertyCountL ),

        ENTRY( "AddBoolPropertyL", CMdETestScripter::AddBoolPropertyL ),

        ENTRY( "AddInt8PropertyL", CMdETestScripter::AddInt8PropertyL ),

        ENTRY( "AddUint8PropertyL", CMdETestScripter::AddUint8PropertyL ),

        ENTRY( "AddInt16PropertyL", CMdETestScripter::AddInt16PropertyL ),

        ENTRY( "AddUint16PropertyL", CMdETestScripter::AddUint16PropertyL ),

        ENTRY( "AddInt32PropertyL", CMdETestScripter::AddInt32PropertyL ),

        ENTRY( "AddUint32PropertyL", CMdETestScripter::AddUint32PropertyL ),

        ENTRY( "AddInt64PropertyL", CMdETestScripter::AddInt64PropertyL ),

        ENTRY( "AddReal32PropertyL", CMdETestScripter::AddReal32PropertyL ),

        ENTRY( "AddReal64PropertyL", CMdETestScripter::AddReal64PropertyL ),

        ENTRY( "AddTextPropertyL", CMdETestScripter::AddTextPropertyL ),

        ENTRY( "AddTimePropertyL", CMdETestScripter::AddTimePropertyL ),

        // Property test primitives.

        ENTRY( "ObjectL", CMdETestScripter::ObjectL ),

        ENTRY( "BoolValueL", CMdETestScripter::BoolValueL ),

        ENTRY( "Int8ValueL", CMdETestScripter::Int8ValueL ),

        ENTRY( "Uint8ValueL", CMdETestScripter::Uint8ValueL ),

        ENTRY( "Int16ValueL", CMdETestScripter::Int16ValueL ),

        ENTRY( "Uint16ValueL", CMdETestScripter::Uint16ValueL ),

        ENTRY( "Int32ValueL", CMdETestScripter::Int32ValueL ),

        ENTRY( "Uint32ValueL", CMdETestScripter::Uint32ValueL ),

        ENTRY( "Int64ValueL", CMdETestScripter::Int64ValueL ),

        ENTRY( "Real32ValueL", CMdETestScripter::Real32ValueL ),

        ENTRY( "Real64ValueL", CMdETestScripter::Real64ValueL ),

        ENTRY( "TimeValueL", CMdETestScripter::TimeValueL ),

        ENTRY( "TextValueL", CMdETestScripter::TextValueL ),

        ENTRY( "SetBoolValueL", CMdETestScripter::SetBoolValueL ),

        ENTRY( "SetInt8ValueL", CMdETestScripter::SetInt8ValueL ),

        ENTRY( "SetUint8ValueL", CMdETestScripter::SetUint8ValueL ),

        ENTRY( "SetInt16ValueL", CMdETestScripter::SetInt16ValueL ),

        ENTRY( "SetUint16ValueL", CMdETestScripter::SetUint16ValueL ),

        ENTRY( "SetInt32ValueL", CMdETestScripter::SetInt32ValueL ),

        ENTRY( "SetUint32ValueL", CMdETestScripter::SetUint32ValueL ),

        ENTRY( "SetInt64ValueL", CMdETestScripter::SetInt64ValueL ),

        ENTRY( "SetReal32ValueL", CMdETestScripter::SetReal32ValueL ),

        ENTRY( "SetReal64ValueL", CMdETestScripter::SetReal64ValueL ),

        ENTRY( "SetTimeValueL", CMdETestScripter::SetTimeValueL ),

        ENTRY( "SetTextValueL", CMdETestScripter::SetTextValueL ),

        ENTRY( "RemovePropertyL", CMdETestScripter::RemovePropertyL ),

        ENTRY( "MovePropertiesL", CMdETestScripter::MovePropertiesL ),

        // Free text test primitives.

        ENTRY( "FreeTextCountL", CMdETestScripter::FreeTextCountL ),

        ENTRY( "FreeTextL", CMdETestScripter::FreeTextL ),

        ENTRY( "FreeTextIndexL", CMdETestScripter::FreeTextIndexL ),

        ENTRY( "AddFreeTextL", CMdETestScripter::AddFreeTextL ),

        ENTRY( "RemoveFreeTextL", CMdETestScripter::RemoveFreeTextL ),

        // Relation test primitives.

        ENTRY( "NewRelationL", CMdETestScripter::NewRelationL ),

        ENTRY( "AddRelationL", CMdETestScripter::AddRelationL ),

        ENTRY( "LeftObjectIdL", CMdETestScripter::LeftObjectIdL ),

        ENTRY( "RightObjectIdL", CMdETestScripter::RightObjectIdL ),

        ENTRY( "ParameterL", CMdETestScripter::ParameterL ),

        ENTRY( "SetParameterL", CMdETestScripter::SetParameterL ),

        ENTRY( "SetLeftObjectIdL", CMdETestScripter::SetLeftObjectIdL ),

        ENTRY( "SetRightObjectIdL", CMdETestScripter::SetRightObjectIdL ),

        ENTRY( "LastModifiedDateL", CMdETestScripter::LastModifiedDateL ),

        ENTRY( "SetLastModifiedDateL", CMdETestScripter::SetLastModifiedDateL ),

        ENTRY( "GetRelationL", CMdETestScripter::GetRelationL ),

        ENTRY( "UpdateRelationL", CMdETestScripter::UpdateRelationL ),

        ENTRY( "RemoveRelationL", CMdETestScripter::RemoveRelationL ),

        ENTRY( "RemoveRelationsL", CMdETestScripter::RemoveRelationsL ),

        // Event test primitives.

        ENTRY( "NewEventL", CMdETestScripter::NewEventL ),

        ENTRY( "AddEventL", CMdETestScripter::AddEventL ),

        ENTRY( "ObjectIdL", CMdETestScripter::ObjectIdL ),

        ENTRY( "TimeL", CMdETestScripter::TimeL ),

        ENTRY( "SourceL", CMdETestScripter::SourceL ),

        ENTRY( "ParticipantL", CMdETestScripter::ParticipantL ),

        ENTRY( "GetEventL", CMdETestScripter::GetEventL ),

        ENTRY( "RemoveEventL", CMdETestScripter::RemoveEventL ),

        ENTRY( "RemoveEventsL", CMdETestScripter::RemoveEventsL ),

        ENTRY( "NewObjectQueryL", CMdETestScripter::NewObjectQueryL ),

        ENTRY( "NewRelationQueryL", CMdETestScripter::NewRelationQueryL ),

        ENTRY( "NewEventQueryL", CMdETestScripter::NewEventQueryL ),

        ENTRY( "QueryObjectL", CMdETestScripter::QueryObjectL ),

        ENTRY( "QueryRelationL", CMdETestScripter::QueryRelationL ),

        ENTRY( "QueryEventL", CMdETestScripter::QueryEventL ),

        ENTRY( "AddPropertyFilterL", CMdETestScripter::AddPropertyFilterL ),

        ENTRY( "AppendOrderRuleL", CMdETestScripter::AppendOrderRuleL ),

        ENTRY( "NewLogicConditionL", CMdETestScripter::NewLogicConditionL ),

        ENTRY( "AddLogicConditionL", CMdETestScripter::AddLogicConditionL ),

        ENTRY( "AddObjectConditionL", CMdETestScripter::AddObjectConditionL ),

        ENTRY( "AddPropertyConditionL", CMdETestScripter::AddPropertyConditionL ),

        ENTRY( "AddRelationConditionL", CMdETestScripter::AddRelationConditionL ),

        ENTRY( "AddEventConditionL", CMdETestScripter::AddEventConditionL ),

        ENTRY( "FindL", CMdETestScripter::FindL ),

        ENTRY( "SetObjectQueryResultL", CMdETestScripter::SetObjectQueryResultL ),

        ENTRY( "SetEventQueryResultL", CMdETestScripter::SetEventQueryResultL ),

        ENTRY( "SetRelationQueryResultL", CMdETestScripter::SetRelationQueryResultL ),

        ENTRY( "RightL", CMdETestScripter::RightL ),

        ENTRY( "LeftL", CMdETestScripter::LeftL ),

        ENTRY( "SetOperatorL", CMdETestScripter::SetOperatorL ), 

        ENTRY( "SetNegateL", CMdETestScripter::SetNegateL ),

        ENTRY( "ObjectConditionsL", CMdETestScripter::ObjectConditionsL ),     

        ENTRY( "TestPopulateDbL", CMdETestScripter::TestPopulateDbL )

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleObjectNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleObjectNotification( CMdESession& aSession, 

    TObserverNotificationType aType,

    const RArray<TItemId>& aObjectIdArray )

    {

    iLog->Log(_L( "HandleObjectNotification" ));

    iNotificationSession = &aSession;

    iNotificationType = aType;

    for ( TInt i = 0; i < aObjectIdArray.Count(); ++i )

        {

        iNotificationItemIdArray.Append( aObjectIdArray[ i ] );

        }

    Signal();

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleObjectPresentNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleObjectPresentNotification( CMdESession& /* aSession */, 

    TBool /* aPresent */, const RArray<TItemId>& /* aObjectIdArray */ )

    {

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleSessionOpened

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleSessionOpened( CMdESession& /* aSession */, TInt aError )

    {

    iLog->Log(_L( "HandleSessionOpened, aError == %d"), aError );

    Signal();

    iError = aError;

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleSessionError

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleSessionError( CMdESession& /*aSession*/, TInt aError )

    {

    iLog->Log(_L( "HandleSessionError, aError == %d"), aError );

    iError = aError;

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleSchemaModified

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleSchemaModified()

    {

    iLog->Log(_L( "HandleSchemaModified" ));

    TEventIf event( TEventIf::ESetEvent, TName( KMdESchemaModified ) );

    TestModuleIf().Event( event );

    Signal();// This can be removed after modify all related cases.

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleRelationNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleRelationNotification( CMdESession& aSession, 

    TObserverNotificationType aType,

    const RArray<TItemId>& aRelationIdArray )

    {

    iLog->Log(_L( "HandleRelationNotification" ));

    iNotificationSession = &aSession;

    iNotificationType = aType;

    for ( TInt i = 0; i < aRelationIdArray.Count(); ++i )

        {

        iNotificationItemIdArray.Append( aRelationIdArray[ i ] );

        }

    Signal();

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleRelationItemNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleRelationItemNotification(CMdESession& aSession, 

    TObserverNotificationType aType,

    const RArray<TMdERelation>& aRelationArray )

    {

    iLog->Log(_L( "HandleRelationItemNotification" ));

    iNotificationSession = &aSession;

    iNotificationType = aType;

    for ( TInt i = 0; i < aRelationArray.Count(); ++i )

        {

        iNotificationRelationArray.Append( aRelationArray[ i ] );

        }

    Signal();

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleRelationPresentNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleRelationPresentNotification(CMdESession& /* aSession */,

    TBool /* aPresent */,

    const RArray<TItemId>& /* aRelationIdArray */ )

    {

    }

// -----------------------------------------------------------------------------

// CHarvesterPluginTestScripter::HandleEventNotification

// -----------------------------------------------------------------------------

//

void CMdETestScripter::HandleEventNotification( CMdESession& aSession, 

    TObserverNotificationType aType,

    const RArray<TItemId>& aEventIdArray )