/*
* 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 )
{
iLog->Log(_L( "HandleEventNotification" ));
iNotificationSession = &aSession;
iNotificationType = aType;
for ( TInt i = 0; i < aEventIdArray.Count(); ++i )
{
iNotificationItemIdArray.Append( aEventIdArray[ i ] );
}
Signal();
}
// -----------------------------------------------------------------------------
// CMdETestScripter::GetInstanceItemByArrayIndexL
// -----------------------------------------------------------------------------
//
CMdEInstanceItem* CMdETestScripter::GetInstanceItemByArrayIndexL(
const TInt aMode, CStifItemParser& aItem )
{
CMdEInstanceItem* ret = NULL;
if ( aMode == EObject )
{
ret = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );
TL( ret->InstanceType() == EMdETypeObject )
}
else if ( aMode == ERelation )
{
ret = SanitizeArrayIndexL( iRelationArray, *iRelationNameArray, aItem );
TL( ret->InstanceType() == EMdETypeRelation )
}
else if ( aMode == EEvent )
{
ret = SanitizeArrayIndexL( iEventArray, *iEventNameArray, aItem );
TL( ret->InstanceType() == EMdETypeEvent )
}
else if ( aMode == EProperty )
{
ret = SanitizeArrayIndexL( iPropertyArray, *iPropertyNameArray, aItem );
TL( ret->InstanceType() == EMdETypeProperty )
}
else
{
User::Leave( KErrArgument );
}
return ret;
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTMdEObjectL
// -----------------------------------------------------------------------------
//
void CMdETestScripter::CheckTMdEObjectL( const TMdEObject& aTObject, const CMdEObject& aObject )
{
TL( aObject.Id() == aTObject.Id());
TL( aObject.Def().Compare( aTObject.DefL()) == 0 );
TL( aObject.Confidential() == aTObject.Confidential());
TL( aObject.Placeholder() == aTObject.Placeholder());
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTMdERelationL
// -----------------------------------------------------------------------------
//
void CMdETestScripter::CheckTMdERelationL( const TMdERelation& aTRelation, const CMdERelation& aRelation )
{
TL( aRelation.Id() == aTRelation.Id());
TL( aRelation.Def().Compare( aTRelation.DefL()) == 0 );
TL( aRelation.LeftObjectId() == aTRelation.LeftObjectId())
TL( aRelation.RightObjectId() == aTRelation.RightObjectId())
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTMdEObjectArrayL
// -----------------------------------------------------------------------------
//
void CMdETestScripter::CheckTMdEObjectArrayL(
const RArray<TMdEObject>& aTObjects, const TInt aIndex, const TInt aCount )
{
TL( aTObjects.Count() == aCount );
for ( TInt i = 0; i < aTObjects.Count(); ++i )
{
const CMdEObject* object = NULL;
TInt j;
for ( j = 0; aIndex + j < iObjectArray.Count(); ++j )
{
if ( iObjectArray[ aIndex + j ]->Id() == aTObjects[ i ].Id())
{
object = iObjectArray[ aIndex + j ];
CheckTMdEObjectL( aTObjects[ i ], *object );
break;
}
}
TL( object );
}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTMdERelationArrayL
// -----------------------------------------------------------------------------
//
void CMdETestScripter::CheckTMdERelationArrayL(
const RArray<TMdERelation>& aTRelations, const TInt aIndex, const TInt aCount )
{
TL( aTRelations.Count() == aCount );
for ( TInt i = 0; i < aTRelations.Count(); ++i )
{
const CMdERelation* relation = NULL;
TInt j;
for ( j = 0; aIndex + j < iRelationArray.Count(); ++j )
{
if ( iRelationArray[ aIndex + j ]->Id() == aTRelations[ i ].Id())
{
relation = iRelationArray[ aIndex + j ];
CheckTMdERelationL( aTRelations[ i ], *relation );
break;
}
}
TL( relation );
}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTItemIdArrayL
// -----------------------------------------------------------------------------
//
template <class T> void CMdETestScripter::CheckTItemIdArrayL(
const RArray<TItemId>& aTItemIds, const RPointerArray<T>& aArray,
const TInt aIndex, const TInt aCount )
{
TL( aTItemIds.Count() == aCount );
for ( TInt i = 0; i < aTItemIds.Count(); ++i )
{
const T* t = NULL;
TInt j;
for ( j = 0; aIndex + j < aArray.Count(); ++j )
{
if ( aArray[ aIndex + j ]->Id() == aTItemIds[ i ] )
{
t = aArray[ aIndex + j ];
break;
}
}
TL( t );
}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckAsyncResultArrayL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::CheckAsyncResultArrayL( TEventIf aEvent )
{
TInt err = KErrNone;
if ( 0 == aEvent.Name().Compare( KMdEItemsAsyncAdd )
|| 0 == aEvent.Name().Compare( KMdEItemsAsyncUpdate ) )
{
//Check result item ids count of iMdEDataBuf
//Update ids of iItemArray( iObjectArray, iRelationArray, iEventsArray ) to clear temp test data in delete() later.
err = iMdeSession->DeserializeItemsL( iMdEDataBuf, iItemArray );
}
else if ( 0 == aEvent.Name().Compare( KMdEObjectsAsyncRemoved )
|| 0 == aEvent.Name().Compare( KMdEEventsAsyncRemoved )
|| 0 == aEvent.Name().Compare( KMdERelationsAsyncRemoved ) )
{
RArray<TItemId> objectIds, eventIds, relationIds;
err = iMdeSession->DeserializeIdsL( iMdEDataBuf, &objectIds, &eventIds, &relationIds );
//Check result item ids count of iMdEDataBuf
if ( 0 == aEvent.Name().Compare( KMdEObjectsAsyncRemoved ) )
{
TL( objectIds.Count() == iItemCount );
}
else if ( 0 == aEvent.Name().Compare( KMdEEventsAsyncRemoved ) )
{
TL( eventIds.Count() == iItemCount );
}
else if ( 0 == aEvent.Name().Compare( KMdERelationsAsyncRemoved ) )
{
TL( relationIds.Count() == iItemCount );
}
objectIds.Close();
eventIds.Close();
relationIds.Close();
}
iItemCount = 0;
iItemArray.Reset();
iMdEDataBuf.Close();//Clean mde buffer
return err;
}
// -----------------------------------------------------------------------------
// CMdETestScripter::FormInstanceItemArrayL
// -----------------------------------------------------------------------------
//
void CMdETestScripter::FormInstanceItemArrayL(
CStifItemParser& aItem, RPointerArray<CMdEInstanceItem>& aItemArray ) const
{
TInt mode2;
TInt index;
TInt count;
User::LeaveIfError( aItem.GetNextInt( mode2 ));
User::LeaveIfError( aItem.GetNextInt( index ));
User::LeaveIfError( aItem.GetNextInt( count ));
for ( TInt i = 0; i < count; ++i )
{
if ( mode2 == EObject )
{
aItemArray.Append( iObjectArray[ index + i ] );
}
else if ( mode2 == ERelation )
{
aItemArray.Append( iRelationArray[ index + i ] );
}
else if ( mode2 == EEvent )
{
aItemArray.Append( iEventArray[ index + i ] );
}
else if ( mode2 == EProperty )
{
aItemArray.Append( iPropertyArray[ index + i ] );
}
}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::SanitizeArrayIndexL
// -----------------------------------------------------------------------------
//
template <class T> T* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<T>& aArray, const CDesCArrayFlat& aNameArray,
CStifItemParser& aItem )
{
__ASSERT_ALWAYS( aArray.Count() == aNameArray.Count(),
User::Panic( KMdETestScripter, KErrGeneral ));
TPtrC nameOrIndex;
User::LeaveIfError( aItem.GetNextString( nameOrIndex ));
TLex lex( nameOrIndex );
TInt index;
TInt err = lex.Val( index );
if ( err == KErrGeneral )
{ // string is name identifier
for ( TInt nameIndex = 0; nameIndex < aNameArray.Count(); nameIndex++)
{
if ( nameOrIndex.Compare( aNameArray[ nameIndex ] ) == 0 )
{
return aArray[ nameIndex ];
}
}
User::Leave( KErrNotFound );
return NULL; // suppress compile warning
}
else
{
if ( index == KLast )
{
index = aArray.Count() - 1;
}
TL( aArray.Count() > index );
return aArray[ index ];
}
}
// ========================== TEMPLATE METHOD INSTANTIATIONS ===================
// -----------------------------------------------------------------------------
// CMdETestScripter::SanitizeArrayIndexL
// -----------------------------------------------------------------------------
//
template CMdEObjectDef* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEObjectDef>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdERelationDef* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdERelationDef>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEEventDef* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEEventDef>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEPropertyDef* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEPropertyDef>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdENamespaceDef* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdENamespaceDef>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEObject* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEObject>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdERelation* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdERelation>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEEvent* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEEvent>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEProperty* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEProperty>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdERelationCondition* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdERelationCondition>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdELogicCondition* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdELogicCondition>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEPropertyCondition* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEPropertyCondition>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
template CMdEEventCondition* CMdETestScripter::SanitizeArrayIndexL(
RPointerArray<CMdEEventCondition>& aArray, const CDesCArrayFlat& aNameArray, CStifItemParser& aItem );
// -----------------------------------------------------------------------------
// CMdETestScripter::CheckTItemIdArrayL
// -----------------------------------------------------------------------------
//
template void CMdETestScripter::CheckTItemIdArrayL(
const RArray<TItemId>& aTItemIds, const RPointerArray<CMdEObject>& aArray,
const TInt aIndex, const TInt aCount );
template void CMdETestScripter::CheckTItemIdArrayL(
const RArray<TItemId>& aTItemIds, const RPointerArray<CMdEEvent>& aArray,
const TInt aIndex, const TInt aCount );
template void CMdETestScripter::CheckTItemIdArrayL(
const RArray<TItemId>& aTItemIds, const RPointerArray<CMdERelation>& aArray,
const TInt aIndex, const TInt aCount );
// ========================== OTHER EXPORTED FUNCTIONS =========================
// None
// [End of File] - Do not remove