--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mds_plat/metadata_engine_api/tsrc/src/MdETestScripterQueryCommands.cpp Mon Jan 18 20:34:07 2010 +0200
@@ -0,0 +1,1826 @@
+/*
+* 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: ?Description
+*
+*/
+
+// [INCLUDE FILES] - do not remove
+#include <mdeobject.h>
+#include <mdeobjectquery.h>
+#include <mdeconstants.h>
+#include <StifParser.h>
+#include <StifTestInterface.h>
+#include "MdETestScripter.h"
+
+const TInt KRootCond = -1;
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::FindL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::FindL( CStifItemParser& aItem )
+ {
+ TInt maxCount;
+ User::LeaveIfError( aItem.GetNextInt( maxCount ) );
+ TInt notifyCount;
+ User::LeaveIfError( aItem.GetNextInt( notifyCount ) );
+
+ iQuery->FindL( maxCount, notifyCount );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::QueryObjectL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::QueryObjectL( CStifItemParser& aItem )
+ {
+ TPtrC objectString;
+
+ CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
+
+ User::LeaveIfError( aItem.GetNextString( objectString ));
+ CMdEObjectDef& objdef = space->GetObjectDefL( objectString );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iMdeSession->NewObjectQueryL( *space, objdef, this );
+ iQuery->SetResultMode( EQueryResultModeId );
+ iQuery->FindL(1);
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::NewObjectQueryL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::NewObjectQueryL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
+ TPtrC modeString;
+ User::LeaveIfError( aItem.GetNextString( modeString ));
+ TQueryResultMode modeEnum = ResultModeL( modeString );
+
+ TPtrC objectString;
+ User::LeaveIfError( aItem.GetNextString( objectString ));
+
+ CMdEObjectDef& objdef = space->GetObjectDefL( objectString );
+
+ delete iQuery;
+ iQuery = NULL;
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ if ( type.Compare(_L("Object")) == 0 )
+ {
+ iQuery = iMdeSession->NewObjectQueryL( *space, objdef, this );
+ }
+ else if ( type.Compare(_L("LookupObject")) == 0 )
+ {
+ RPointerArray<CMdEObjectDef> *objDefs = new (ELeave) RPointerArray<CMdEObjectDef>;
+ TPtrC startMark;
+ User::LeaveIfError( aItem.GetNextString( startMark ));
+ if ( startMark.Compare(_L("{")) == 0)
+ {
+ TInt index;
+ while( ETrue )
+ {
+ index = GetObjectDefIndexL( aItem );
+ if ( index == KErrCompletion )
+ {
+ break;
+ }
+ objDefs->Append( iObjectDefArray[ index ] );
+ }
+ }
+ iQuery = iMdeSession->NewObjectQueryL( objdef, objDefs, this );
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+
+ iQuery->SetResultMode( modeEnum );
+ CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();
+ iLogicConditionArray.Append( rootLogicCondition );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::NewRelationQueryL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::NewRelationQueryL( CStifItemParser& aItem )
+ {
+
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ delete iQuery;
+ iQuery = NULL;
+ CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
+ TPtrC modeString;
+ User::LeaveIfError( aItem.GetNextString( modeString ));
+ TQueryResultMode modeEnum = ResultModeL( modeString );
+
+ iQuery = iMdeSession->NewRelationQueryL( *space, this );
+ iQuery->SetResultMode( modeEnum );
+ CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();
+ iLogicConditionArray.Append( rootLogicCondition );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::NewEventQueryL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::NewEventQueryL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ delete iQuery;
+ iQuery = NULL;
+ CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
+ TPtrC modeString;
+ User::LeaveIfError( aItem.GetNextString( modeString ));
+ TQueryResultMode modeEnum = ResultModeL( modeString );
+
+ iQuery = iMdeSession->NewEventQueryL( *space, this );
+ iQuery->SetResultMode( modeEnum );
+ CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();
+ iLogicConditionArray.Append( rootLogicCondition );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdEObjectQuery::AddPropertyFilterL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddPropertyFilterL( CStifItemParser& aItem )
+ {
+ CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem);
+ ((CMdEObjectQuery *)iQuery)->AddPropertyFilterL( propertyDef );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdEObjectQuery::AppendOrderRuleL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AppendOrderRuleL( CStifItemParser& aItem )
+ {
+ TInt ascending;
+ User::LeaveIfError( aItem.GetNextInt( ascending ) );
+ TInt orderRule;
+ User::LeaveIfError( aItem.GetNextInt( orderRule ) );
+ if ( orderRule == EOrderRuleTypeProperty )
+ {
+ CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem);
+ ((CMdEObjectQuery *)iQuery)->AppendOrderRuleL( TMdEOrderRule( *propertyDef, ascending ));
+ }
+ else
+ {
+ ((CMdEObjectQuery *)iQuery)->AppendOrderRuleL( TMdEOrderRule( (TOrderRuleType) orderRule, ascending ));
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::HandleQueryNewResults
+// -----------------------------------------------------------------------------
+//
+void CMdETestScripter::HandleQueryNewResults( CMdEQuery& /*aQuery*/,
+ TInt /*aFirstNewItemIndex*/, TInt aNewItemCount )
+ {
+ _LIT( KMessage, "Query new results count: " );
+ _LIT( KMessage2, " new count: " );
+ TBuf<128> buf( KMessage );
+ buf.Append( KMessage2 );
+ buf.AppendNum( aNewItemCount );
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::QueryRelationL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::QueryRelationL( CStifItemParser& aItem )
+ {
+ TPtrC relationString;
+ User::LeaveIfError( aItem.GetNextString( relationString ));
+
+ CMdERelationDef& reldef = iNamespaceDefArray[0]->GetRelationDefL( relationString );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iMdeSession->NewRelationQueryL( *iNamespaceDefArray[0], this );
+ iQuery->SetResultMode( EQueryResultModeId );
+ iQueryRoot = &iQuery->Conditions();
+ iQueryRoot->AddRelationConditionL( reldef );
+ iQuery->FindL(1);
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::QueryEventL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::QueryEventL( CStifItemParser& aItem )
+ {
+ TPtrC eventString;
+ User::LeaveIfError( aItem.GetNextString( eventString ));
+
+ CMdEEventDef& evdef = iNamespaceDefArray[0]->GetEventDefL( eventString );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iMdeSession->NewEventQueryL( *iNamespaceDefArray[0], this );
+ iQuery->SetResultMode( EQueryResultModeId );
+ iQueryRoot = &iQuery->Conditions();
+ iQueryRoot->AddEventConditionL( evdef );
+ iQuery->FindL(1);
+
+ return KErrNone;
+ }
+
+_LIT(KAND , "AND");
+_LIT(KOR , "OR");
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::NewLogicConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::NewLogicConditionL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ TPtrC logicOperator;
+ User::LeaveIfError( aItem.GetNextString( logicOperator ));
+ TLogicConditionOperator logCondOperator = ELogicConditionOperatorAnd;
+ if ( logicOperator.Compare( KAND ) == 0)
+ {
+ logCondOperator = ELogicConditionOperatorAnd;
+ }
+ else if ( logicOperator.Compare( KOR ) == 0)
+ {
+ logCondOperator = ELogicConditionOperatorOr;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ CMdELogicCondition* condition = CMdELogicCondition::NewL( logCondOperator );
+ iLogicConditionArray.Append( condition );
+ AppendNameL( iEventConditionNameArray, name );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::RightL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::RightL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ CMdERelationCondition* relationCond = SanitizeArrayIndexL(
+ iRelationConditionArray, *iRelationConditionNameArray, aItem );
+ CMdELogicCondition* rightCond = &relationCond->RightL();
+ iLogicConditionArray.Append( rightCond );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::LeftL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::LeftL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ CMdERelationCondition* relationCond = SanitizeArrayIndexL(
+ iRelationConditionArray, *iRelationConditionNameArray, aItem );
+ CMdELogicCondition* leftCond = &relationCond->LeftL();
+ iLogicConditionArray.Append( leftCond );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::SetOperatorL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::SetOperatorL( CStifItemParser& aItem )
+ {
+ CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );
+ TInt logicalOperator;
+ User::LeaveIfError( aItem.GetNextInt( logicalOperator ));
+ logicCondition->SetOperator( ( TLogicConditionOperator )logicalOperator );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::SetNegateL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::SetNegateL( CStifItemParser& aItem )
+ {
+ CMdEPropertyCondition* condition = SanitizeArrayIndexL( iPropertyConditionArray, *iPropertyConditionNameArray, aItem );
+ TInt boolean;
+ User::LeaveIfError( aItem.GetNextInt( boolean ));
+ ((CMdECondition *)condition)->SetNegate( boolean );
+ return KErrNone;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::AddLogicConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddLogicConditionL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );
+
+ TPtrC logicOperator;
+ User::LeaveIfError( aItem.GetNextString( logicOperator ));
+ TLogicConditionOperator logCondOperator = ELogicConditionOperatorAnd;
+ if ( logicOperator.Compare( KAND ) == 0)
+ {
+ logCondOperator = ELogicConditionOperatorAnd;
+ }
+ else if ( logicOperator.Compare( KOR ) == 0)
+ {
+ logCondOperator = ELogicConditionOperatorOr;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ CMdELogicCondition* condition = &logicCondition->AddLogicConditionL( logCondOperator );
+ iLogicConditionArray.Append( condition );
+ AppendNameL( iLogicConditionNameArray, name );
+ return KErrNone;
+ }
+
+
+ _LIT(KRelationDef, "RelationDef");
+ _LIT(KRelationDefRange, "RelationDefRange");
+
+ _LIT(KAny, "Any");
+ _LIT(KEqual, "Equal");
+ _LIT(KNotEqual, "NotEqual");
+ _LIT(KLess, "Less");
+ _LIT(KLessOrEqual, "LessOrEqual");
+ _LIT(KGreater, "Greater");
+ _LIT(KGreaterOrEqual, "GreaterOrEqual");
+ _LIT(KBetween, "Between");
+ _LIT(KNotBetween, "NotBetween");
+
+ _LIT(KObject , "Object");
+ _LIT(KObjectDef , "ObjectDef");
+ _LIT(KGuid , "Guid");
+
+ _LIT(KNone , "None");
+ _LIT(KId , "Id");
+ _LIT(KIds , "Ids");
+ _LIT(KUri , "Uri");
+ _LIT(KUriBeginsWith , "UriBeginsWith");
+ _LIT(KFreeText , "FreeText");
+ _LIT(KFreeTextContains , "FreeTextContains");
+ _LIT(KFreeTextBeginsWith , "FreeTextBeginsWith");
+ _LIT(KFreeTextEndsWith , "FreeTextEndsWith");
+ _LIT(KFreeTextUsageCount , "FreeTextUsageCount");
+
+
+ _LIT(KCount , "Count");
+ _LIT(KItem , "Item");
+ _LIT(KDistinctValues , "DistinctValues");
+ _LIT(KObjectWithFreetexts , "ObjectWithFreetexts");
+
+
+
+TQueryResultMode CMdETestScripter::ResultModeL(TDesC& aModeString)
+ {
+ TQueryResultMode modeEnum = EQueryResultModeId;
+ if ( aModeString.Compare( KId ) == 0 )
+ {
+ modeEnum = EQueryResultModeId;
+ }
+ else if ( aModeString.Compare( KItem ) == 0 )
+ {
+ modeEnum = EQueryResultModeItem;
+ }
+ else if ( aModeString.Compare( KCount ) == 0 )
+ {
+ modeEnum = EQueryResultModeCount;
+ }
+ else if ( aModeString.Compare( KDistinctValues ) == 0 )
+ {
+ modeEnum = EQueryResultModeDistinctValues;
+ }
+ else if ( aModeString.Compare( KObjectWithFreetexts ) == 0 )
+ {
+ modeEnum = EQueryResultModeObjectWithFreetexts;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ return modeEnum;
+ }
+
+
+CMdERelationDef& CMdETestScripter::GetRelationDefStrL( CStifItemParser& aItem )
+ {
+ TPtrC relationDefStr;
+ User::LeaveIfError( aItem.GetNextString( relationDefStr ));
+ TLex lex( relationDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ return iNamespaceDefArray[0]->GetRelationDefL( relationDefStr );
+ }
+ else
+ {
+ return *iRelationDefArray[ integer ];
+ }
+ }
+
+TInt CMdETestScripter::GetObjectDefIndexL( CStifItemParser& aItem )
+ {
+ TPtrC objectDefStr;
+ User::LeaveIfError( aItem.GetNextString( objectDefStr ));
+ TLex lex( objectDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ if ( objectDefStr.Compare( _L("}")) == 0)
+ {
+ return KErrCompletion; // indictes end of list
+ }
+ for ( TInt i = 0; i < iObjectDefNameArray->Count(); i++)
+ {
+ if ( objectDefStr.Compare( (*iObjectDefNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetRelationDefIndexL( CStifItemParser& aItem )
+ {
+ TPtrC relationDefStr;
+ User::LeaveIfError( aItem.GetNextString( relationDefStr ));
+ TLex lex( relationDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ for ( TInt i = 0; i < iRelationDefNameArray->Count(); i++)
+ {
+ if ( relationDefStr.Compare( (*iRelationDefNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetEventDefIndexL( CStifItemParser& aItem )
+ {
+ TPtrC eventDefStr;
+ User::LeaveIfError( aItem.GetNextString( eventDefStr ));
+ TLex lex( eventDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ for ( TInt i = 0; i < iEventDefNameArray->Count(); i++)
+ {
+ if ( eventDefStr.Compare( (*iEventDefNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetObjectIndexL( CStifItemParser& aItem )
+ {
+ TPtrC objectStr;
+ User::LeaveIfError( aItem.GetNextString( objectStr ));
+ TLex lex( objectStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ if ( objectStr.Compare( _L("}")) == 0)
+ {
+ return KErrCompletion; // indictes end of list
+ }
+ for ( TInt i = 0; i < iObjectNameArray->Count(); i++)
+ {
+ if ( objectStr.Compare( (*iObjectNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+
+TInt CMdETestScripter::GetEventIndexL( CStifItemParser& aItem )
+ {
+ TPtrC eventStr;
+ User::LeaveIfError( aItem.GetNextString( eventStr ));
+ TLex lex( eventStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ if ( eventStr.Compare( _L("}")) == 0)
+ {
+ return KErrCompletion; // indictes end of list
+ }
+ for ( TInt i = 0; i < iEventNameArray->Count(); i++)
+ {
+ if ( eventStr.Compare( (*iEventNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetRelationIndexL( CStifItemParser& aItem )
+ {
+ TPtrC relationStr;
+ User::LeaveIfError( aItem.GetNextString( relationStr ));
+ TLex lex( relationStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ if ( relationStr.Compare( _L("}")) == 0)
+ {
+ return KErrCompletion; // indictes end of list
+ }
+ for ( TInt i = 0; i < iRelationNameArray->Count(); i++)
+ {
+ if ( relationStr.Compare( (*iRelationNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetLogicConditionIndexL( CStifItemParser& aItem )
+ {
+ TPtrC logicConditionStr;
+ User::LeaveIfError( aItem.GetNextString( logicConditionStr ));
+ TLex lex( logicConditionStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ for ( TInt i = 0; i < iLogicConditionNameArray->Count(); i++)
+ {
+ if ( logicConditionStr.Compare( (*iLogicConditionNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+
+TInt CMdETestScripter::GetRelationConditionIndexL( CStifItemParser& aItem )
+ {
+ TPtrC relationConditionStr;
+ User::LeaveIfError( aItem.GetNextString( relationConditionStr ));
+ TLex lex( relationConditionStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ for ( TInt i = 0; i < iRelationConditionNameArray->Count(); i++)
+ {
+ if ( relationConditionStr.Compare( (*iRelationConditionNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+
+
+TInt CMdETestScripter::GetPropertyDefIndexL( CStifItemParser& aItem )
+ {
+ TPtrC propertyDefStr;
+ User::LeaveIfError( aItem.GetNextString( propertyDefStr ));
+ TLex lex( propertyDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ if ( propertyDefStr.Compare( _L("}")) == 0)
+ {
+ return KErrCompletion; // indictes end of list
+ }
+ for ( TInt i = 0; i < iPropertyDefNameArray->Count(); i++)
+ {
+ if ( propertyDefStr.Compare( (*iPropertyDefNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+TInt CMdETestScripter::GetPropertyIndexL( CStifItemParser& aItem )
+ {
+ TPtrC propertyStr;
+ User::LeaveIfError( aItem.GetNextString( propertyStr ));
+ TLex lex( propertyStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ for ( TInt i = 0; i < iPropertyNameArray->Count(); i++)
+ {
+ if ( propertyStr.Compare( (*iPropertyNameArray)[i] ) == 0 )
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+ else
+ {
+ return integer ;
+ }
+ }
+
+
+CMdEObjectDef& CMdETestScripter::GetObjectDefStrL( CStifItemParser& aItem )
+ {
+ TPtrC objectDefStr;
+ User::LeaveIfError( aItem.GetNextString( objectDefStr ));
+ TLex lex( objectDefStr );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ {
+ return iNamespaceDefArray[0]->GetObjectDefL( objectDefStr );
+ }
+ else
+ {
+ return *iObjectDefArray[ integer ];
+ }
+ }
+
+TObjectConditionCompareMethod CMdETestScripter::CompareMethodL(TDesC& aMethodString)
+ {
+ TObjectConditionCompareMethod methodEnum = EObjectConditionCompareNone;
+ if ( aMethodString.Compare( KNone ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareNone;
+ }
+ else if ( aMethodString.Compare( KId ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareId;
+ }
+ else if ( aMethodString.Compare( KIds ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareIds;
+ }
+ else if ( aMethodString.Compare( KGuid ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareGuid;
+ }
+ else if ( aMethodString.Compare( KObjectDef ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareObjectDef;
+ }
+ else if ( aMethodString.Compare( KUri ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareUri;
+ }
+ else if ( aMethodString.Compare( KUriBeginsWith ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareUriBeginsWith;
+ }
+ else if ( aMethodString.Compare( KFreeText ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareFreeText;
+ }
+ else if ( aMethodString.Compare( KFreeTextContains ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareFreeTextContains;
+ }
+ else if ( aMethodString.Compare( KFreeTextBeginsWith ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareFreeTextBeginsWith;
+ }
+ else if ( aMethodString.Compare( KFreeTextEndsWith ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareFreeTextEndsWith;
+ }
+ else if ( aMethodString.Compare( KFreeTextUsageCount ) == 0 )
+ {
+ methodEnum = EObjectConditionCompareUsageCount;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ return methodEnum;
+ }
+
+
+TMdERangeType CMdETestScripter::RangeTypeL(TDesC& aTypeString)
+ {
+ TMdERangeType rangeType = EMdERangeTypeAny;
+ if ( aTypeString.Compare( KAny ) == 0 )
+ {
+ rangeType = EMdERangeTypeAny;
+ }
+ else if ( aTypeString.Compare( KEqual ) == 0 )
+ {
+ rangeType = EMdERangeTypeEqual;
+ }
+ else if ( aTypeString.Compare( KNotEqual ) == 0 )
+ {
+ rangeType = EMdERangeTypeNotEqual;
+ }
+ else if ( aTypeString.Compare( KLess ) == 0 )
+ {
+ rangeType = EMdERangeTypeLess;
+ }
+ else if ( aTypeString.Compare( KLessOrEqual ) == 0 )
+ {
+ rangeType = EMdERangeTypeLessOrEqual;
+ }
+ else if ( aTypeString.Compare( KGreater ) == 0 )
+ {
+ rangeType = EMdERangeTypeGreater;
+ }
+ else if ( aTypeString.Compare( KGreaterOrEqual ) == 0 )
+ {
+ rangeType = EMdERangeTypeGreaterOrEqual;
+ }
+ else if ( aTypeString.Compare( KBetween ) == 0 )
+ {
+ rangeType = EMdERangeTypeBetween;
+ }
+ else if ( aTypeString.Compare( KNotBetween ) == 0 )
+ {
+ rangeType = EMdERangeTypeNotBetween;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ return rangeType;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::AddObjectConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddObjectConditionL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ CMdEObjectCondition* newObjectCondition = NULL;
+
+
+ CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );
+
+#if 0
+ logicConditionIndex = GetLogicConditionIndexL( aItem );
+ CMdELogicCondition* logicCondition;
+ if ( logicConditionIndex >= 0 )
+ {
+ logicCondition = iLogicConditionArray[ logicConditionIndex ];
+ }
+ else if ( logicConditionIndex == KRootCond )
+ {
+ logicCondition = &iQuery->Conditions();
+ }
+ else
+ {
+ User::Leave( logicConditionIndex );
+ }
+
+#endif
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ _LIT(KObjectConditionCompare , "ObjectConditionCompare");
+
+ _LIT(KRange , "Range");
+
+ if ( type.Compare( KObject ) == 0)
+ {
+ TInt firstIndex = GetObjectIndexL( aItem );
+ TInt objectCount;
+ User::LeaveIfError( aItem.GetNextInt( objectCount ));
+ if ( objectCount == 1 )
+ {
+ newObjectCondition = &logicCondition->AddObjectConditionL( iObjectArray[ firstIndex ]->Id() );
+ }
+ else
+ {
+ RArray<TItemId> objectIdArray;
+ for ( TInt i = firstIndex ; i < firstIndex + objectCount ; i++ )
+ {
+ objectIdArray.Append( iObjectArray[ i ]->Id() );
+ }
+ newObjectCondition = &logicCondition->AddObjectConditionL( objectIdArray );
+ objectIdArray.Reset();
+ }
+ }
+ else if ( type.Compare( KObjectDef ) == 0 )
+ {
+ newObjectCondition = &logicCondition->AddObjectConditionL( GetObjectDefStrL( aItem ) );
+ }
+ else if ( type.Compare( KGuid ) == 0 )
+ {
+ TInt guidHigh;
+ TInt guidLow;
+ TInt64 guidHigh64;
+ TInt64 guidLow64;
+ User::LeaveIfError( aItem.GetNextInt( guidHigh ));
+ guidHigh64 = guidHigh;
+ User::LeaveIfError( aItem.GetNextInt( guidLow ));
+ guidLow64 = guidLow;
+ newObjectCondition = &logicCondition->AddObjectConditionL( guidHigh64, guidLow64 );
+ }
+ else if ( type.Compare( KObjectConditionCompare ) == 0 )
+ {
+ TPtrC method;
+ User::LeaveIfError( aItem.GetNextString( method ));
+ TObjectConditionCompareMethod methodEnum = CompareMethodL( method );
+
+ TPtrC string;
+ User::LeaveIfError( aItem.GetNextString( string ));
+ if ( methodEnum == EObjectConditionCompareId )
+ {
+ TLex lex( string );
+ TInt integer;
+ TInt err = lex.Val( integer );
+ if ( err == KErrGeneral )
+ { // string is not a number so it should be a object name
+ for ( TInt i = 0; i < iObjectNameArray->Count(); i++)
+ {
+ if ( string.Compare( (*iObjectNameArray)[i] ) == 0 )
+ {
+ TBuf<20> objIdString;
+ objIdString.Num(iObjectArray[i]->Id());
+ newObjectCondition = &logicCondition->AddObjectConditionL(
+ EObjectConditionCompareId,
+ objIdString );
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ newObjectCondition = &logicCondition->AddObjectConditionL(
+ methodEnum,
+ string);
+ }
+ }
+ else if ( type.Compare( KRange ) == 0 )
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt min;
+ User::LeaveIfError( aItem.GetNextInt( min ) );
+ TInt max;
+ User::LeaveIfError( aItem.GetNextInt( max ) );
+ newObjectCondition = &logicCondition->AddObjectConditionL( TMdEUintRange(min, max, rangeType));
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ iObjectConditionArray.Append( newObjectCondition );
+ AppendNameL( iObjectConditionNameArray, name );
+
+ return KErrNone;
+ }
+
+
+_LIT(KTimeRange, "TimeRange");
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::AddPropertyConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddPropertyConditionL( CStifItemParser& aItem )
+ {
+
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );
+
+ CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem);
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ _LIT(KPropCond, "PropCond");
+ _LIT(KBool, "Bool");
+ _LIT(KIntRange, "IntRange");
+ _LIT(KInt64Range, "Int64Range");
+ _LIT(KUintRange, "UintRange");
+ _LIT(KRealRange, "RealRange");
+
+ _LIT(KTextCompare, "TextCompare");
+ _LIT(KEquals, "Equals");
+ _LIT(KContains, "Contains");
+ _LIT(KBeginsWith, "BeginsWith");
+ _LIT(KEndsWith, "EndsWith");
+
+ CMdEPropertyCondition* propertyCondition = NULL;
+ if (type.Compare( KPropCond ) == 0)
+ {
+
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef );
+ }
+ else if (type.Compare( KBool ) == 0)
+ {
+ TInt boolean;
+ User::LeaveIfError( aItem.GetNextInt( boolean ) );
+ }
+ else if (type.Compare( KIntRange ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt min;
+ User::LeaveIfError( aItem.GetNextInt( min ) );
+ TInt max;
+ User::LeaveIfError( aItem.GetNextInt( max ) );
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef, TMdEIntRange( min, max, rangeType ) );
+ }
+ else if (type.Compare( KInt64Range ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt min;
+ User::LeaveIfError( aItem.GetNextInt( min ) );
+ TInt64 min64 = min ;
+ TInt max;
+ User::LeaveIfError( aItem.GetNextInt( max ) );
+ TInt64 max64 = max ;
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef, TMdEInt64Range( min64, max64, rangeType ) );
+ }
+ else if (type.Compare( KUintRange ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TUint min;
+ User::LeaveIfError( aItem.GetNextInt( min ) );
+ TUint max;
+ User::LeaveIfError( aItem.GetNextInt( max ) );
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef, TMdEUintRange( min, max, rangeType ) );
+ }
+ else if (type.Compare( KRealRange ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TReal min;
+ TPtrC minStr;
+ User::LeaveIfError( aItem.GetNextString( minStr ) );
+ TLex lex( minStr );
+ lex.Val( min );
+
+ TReal max;
+ TPtrC maxStr;
+ User::LeaveIfError( aItem.GetNextString( maxStr ) );
+ lex.Assign( maxStr );
+ lex.Val( max );
+
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef, TMdEIntRange( min, max, rangeType ) );
+ }
+ else if (type.Compare( KTimeRange ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TTime min;
+ TPtrC minStr;
+ User::LeaveIfError( aItem.GetNextString( minStr ) );
+ min.Set( minStr );
+
+ TTime max;
+ TPtrC maxStr;
+ User::LeaveIfError( aItem.GetNextString( maxStr ) );
+ max.Set( maxStr );
+
+
+ propertyCondition = &logicCondition->AddPropertyConditionL( *propertyDef, TMdETimeRange( min, max, rangeType ) );
+ }
+ else if (type.Compare( KTextCompare ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TTextPropertyConditionCompareMethod compareMethod = ETextPropertyConditionCompareEquals;
+ if (type.Compare( KEquals ) == 0)
+ {
+ compareMethod = ETextPropertyConditionCompareEquals;
+ }
+ else if (type.Compare( KContains ) == 0)
+ {
+ compareMethod = ETextPropertyConditionCompareContains;
+ }
+ else if (type.Compare( KBeginsWith ) == 0)
+ {
+ compareMethod = ETextPropertyConditionCompareBeginsWith;
+ }
+ else if (type.Compare( KEndsWith ) == 0)
+ {
+ compareMethod = ETextPropertyConditionCompareEndsWith;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ TPtrC text;
+ User::LeaveIfError( aItem.GetNextString( text ) );
+ propertyCondition = &logicCondition->AddPropertyConditionL(
+ *propertyDef,
+ compareMethod,
+ text);
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ iPropertyConditionArray.Append( propertyCondition );
+
+ AppendNameL(iPropertyConditionNameArray, name );
+ return KErrNone;
+ }
+
+
+_LIT(KTimeAndEventCompare, "TimeAndEventCompare");
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::AddRelationConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddRelationConditionL( CStifItemParser& aItem )
+ {
+ _LIT(KRelationId, "RelationId");
+ _LIT(KLeft, "Left");
+ _LIT(KRight, "Right");
+ _LIT(KEither, "Either");
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+
+ CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );
+
+#if 0
+ TInt logicConditionIndex = GetLogicConditionIndexL( aItem );
+ CMdELogicCondition* logicCondition;
+ if ( logicConditionIndex >= 0 )
+ {
+ logicCondition = iLogicConditionArray[ logicConditionIndex ];
+ }
+ else if ( logicConditionIndex == KRootCond )
+ {
+ logicCondition = &iQuery->Conditions();
+ }
+ else
+ {
+ User::Leave( logicConditionIndex );
+ }
+#endif
+
+ CMdERelationCondition* newRelation = NULL;
+
+ TPtrC side;
+ User::LeaveIfError( aItem.GetNextString( side ));
+ TRelationConditionSide condSide = ERelationConditionSideEither;
+ if (side.Compare( KLeft ) == 0)
+ {
+ condSide = ERelationConditionSideLeft;
+ }
+ else if (side.Compare( KRight ) == 0)
+ {
+ condSide = ERelationConditionSideRight;
+ }
+ else if (side.Compare( KEither ) == 0)
+ {
+ condSide = ERelationConditionSideEither;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ if (type.Compare( KRelationId ) == 0)
+ {
+ TInt id;
+
+ TInt relationIdCount;
+ User::LeaveIfError( aItem.GetNextInt( relationIdCount ));
+ if ( relationIdCount == 1 )
+ {
+ User::LeaveIfError( aItem.GetNextInt( id ) );
+ newRelation = &logicCondition->AddRelationConditionL( TItemId ( id ) , condSide);
+ }
+ else
+ {
+ RArray<TItemId> relationIdArray;
+ for ( TInt i = 0 ; i < relationIdCount ; i++ )
+ {
+ aItem.GetNextInt( id );
+ relationIdArray.Append( TItemId ( id ));
+ }
+ newRelation = &logicCondition->AddRelationConditionL( TItemId ( id ), condSide );
+ relationIdArray.Reset();
+ }
+
+ }
+ else if ( type.Compare( KRelationDef ) == 0)
+ {
+ CMdERelationDef& relationDef = GetRelationDefStrL( aItem );
+ newRelation = &logicCondition->AddRelationConditionL( relationDef, condSide );
+ }
+ else if (type.Compare( KRelationDefRange ) == 0)
+ {
+ CMdERelationDef& relationDef = GetRelationDefStrL( aItem );
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt min;
+ User::LeaveIfError( aItem.GetNextInt( min ) );
+ TInt max;
+ User::LeaveIfError( aItem.GetNextInt( max ) );
+
+ newRelation = &logicCondition->AddRelationConditionL( relationDef,
+ TMdEIntRange( min, max, rangeType ), condSide );
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ iRelationConditionArray.Append( newRelation );
+ AppendNameL( iRelationConditionNameArray, name );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::AddEventConditionL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::AddEventConditionL( CStifItemParser& aItem )
+ {
+ _LIT(KEventId, "EventId");
+ _LIT(KNoParam, "NoParam");
+ _LIT(KEventDef, "EventDef");
+ _LIT(KEventCompare, "EventCompare");
+
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ CMdEEventCondition* newEvent = NULL;
+
+ TInt logicConditionIndex = GetLogicConditionIndexL( aItem );
+ CMdELogicCondition* logicCondition = NULL;
+ if ( logicConditionIndex >= 0 )
+ {
+ logicCondition = iLogicConditionArray[ logicConditionIndex ];
+ }
+ else if ( logicConditionIndex == KRootCond )
+ {
+ logicCondition = &iQuery->Conditions();
+ }
+ else
+ {
+ User::Leave( logicConditionIndex );
+ }
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+ if (type.Compare( KNoParam ) == 0)
+ {
+ logicCondition->AddEventConditionL();
+ }
+ else if (type.Compare( KEventId ) == 0)
+ {
+ TInt id;
+ User::LeaveIfError( aItem.GetNextInt( id ) );
+ newEvent = &logicCondition->AddEventConditionL( TItemId(id) );
+ }
+ else if (type.Compare( KEventDef ) == 0)
+ {
+ TPtrC eventString;
+ User::LeaveIfError( aItem.GetNextString( eventString ));
+
+ CMdEEventDef& evdef = iNamespaceDefArray[0]->GetEventDefL( eventString );
+ newEvent = &logicCondition->AddEventConditionL( evdef );
+ }
+ else if (type.Compare( KTimeRange ) == 0)
+ {
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt64 min;
+ TPtrC minStr;
+ User::LeaveIfError( aItem.GetNextString( minStr ) );
+ TLex lex( minStr );
+ lex.Val( min );
+
+ TInt64 max;
+ TPtrC maxStr;
+ User::LeaveIfError( aItem.GetNextString( maxStr ) );
+ lex.Assign( maxStr );
+ lex.Val( max );
+
+ newEvent = &logicCondition->AddEventConditionL( TMdETimeRange( min, max, rangeType ) );
+ }
+ else if (type.Compare( KEventCompare ) == 0)
+ {
+
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ _LIT( KNone, "None");
+ _LIT( KSourceURI, "SourceURI");
+ _LIT( KParticipantURI, "ParticipantURI");
+ _LIT( KId, "Id");
+
+ TEventConditionCompareMethod compareMethod = EEventConditionCompareNone;
+ if (type.Compare( KNone ) == 0)
+ {
+ compareMethod = EEventConditionCompareNone;
+ }
+ else if (type.Compare( KSourceURI ) == 0)
+ {
+ compareMethod = EEventConditionCompareSourceURI;
+ }
+ else if (type.Compare( KParticipantURI ) == 0)
+ {
+ compareMethod = EEventConditionCompareParticipantURI;
+ }
+ else if (type.Compare( KId ) == 0)
+ {
+ compareMethod = EEventConditionCompareId;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TPtrC text;
+ User::LeaveIfError( aItem.GetNextString( text ) );
+ newEvent = &logicCondition->AddEventConditionL( compareMethod, text );
+ }
+ else if (type.Compare( KTimeAndEventCompare ) == 0)
+ {
+
+ _LIT( KNone, "None");
+ _LIT( KSourceURI, "SourceURI");
+ _LIT( KParticipantURI, "ParticipantURI");
+ _LIT( KId, "Id");
+
+ TPtrC type;
+ User::LeaveIfError( aItem.GetNextString( type ));
+
+ TMdERangeType rangeType = RangeTypeL( type );
+
+ TInt64 min;
+ TPtrC minStr;
+ User::LeaveIfError( aItem.GetNextString( minStr ) );
+ TLex lex( minStr );
+ lex.Val( min );
+
+ TInt64 max;
+ TPtrC maxStr;
+ User::LeaveIfError( aItem.GetNextString( maxStr ) );
+ lex.Assign( maxStr );
+ lex.Val( max );
+
+ TEventConditionCompareMethod compareMethod = EEventConditionCompareNone;
+ if (type.Compare( KNone ) == 0)
+ {
+ compareMethod = EEventConditionCompareNone;
+ }
+ else if (type.Compare( KSourceURI ) == 0)
+ {
+ compareMethod = EEventConditionCompareSourceURI;
+ }
+ else if (type.Compare( KParticipantURI ) == 0)
+ {
+ compareMethod = EEventConditionCompareParticipantURI;
+ }
+ else if (type.Compare( KId ) == 0)
+ {
+ compareMethod = EEventConditionCompareId;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TPtrC text;
+ User::LeaveIfError( aItem.GetNextString( text ) );
+ newEvent = &logicCondition->AddEventConditionL( TMdETimeRange( min, max, rangeType ),
+ compareMethod, text );
+ }
+
+ AppendNameL( iEventConditionNameArray , name );
+ iEventConditionArray.AppendL( newEvent );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::ObjectConditionsL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::ObjectConditionsL( CStifItemParser& aItem )
+ {
+ TPtrC name;
+ User::LeaveIfError( aItem.GetNextString( name ));
+ CMdEEventCondition* eventCondition = SanitizeArrayIndexL( iEventConditionArray, *iEventConditionNameArray, aItem );
+ CMdELogicCondition& objectConditions = eventCondition->ObjectConditionsL();
+ AppendNameL( iLogicConditionNameArray , name );
+ iLogicConditionArray.AppendL( &objectConditions );
+ return KErrNone;
+ }
+
+#if 0
+
+void CMdETestScripter::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError)
+ {
+ TBuf<128> buf;
+
+ Signal();
+
+ if (aQuery.Type() == EQueryTypeObject)
+ {
+ iLog->Log(_L("Object query completed notification: Error=%d"), aError);
+
+ TQueryResultMode mode = aQuery.ResultMode();
+ if ( mode == EQueryResultModeItem )
+ {
+ TInt cou = aQuery.Count();
+
+ buf.Format(_L(" EModeItem, results=%d"), cou);
+ iLog->Log(buf);
+
+ for( TInt i = 0; i < cou; i++ )
+ {
+ const TInt64 rid = (TInt64)aQuery.ResultItem( i ).Id();
+ buf.Format(_L(" Id %d = %Ld"), i, rid);
+ iLog->Log(buf);
+ }
+ }
+ else if ( mode == EQueryResultModeId )
+ {
+ TInt cou = aQuery.Count();
+
+ buf.Format(_L(" EModeId, results=%d"), cou);
+ iLog->Log(buf);
+ TInt i;
+ TInt64 rid;
+ RArray<TInt64> ridArray;
+ for( i = 0; i < cou; i++ )
+ {
+ rid = (TInt64)aQuery.ResultId( i );
+ ridArray.Append( rid );
+ }
+
+ for( i = cou; --i >= 0; )
+ {
+ for( TInt j = iResultIndices.Count(); --j >= 0 ; )
+ {
+ if ( iObjectArray[ iResultIndices[j]]->Id() == ridArray[i] )
+ { // matching result
+ iResultIndices.Remove( j );
+ ridArray.Remove( i );
+ }
+ }
+ }
+
+ if ( iResultIndices.Count() != 0 || iObjectArray.Count() != 0 )
+ {
+ _LIT( KTestMessage1, "Not expected object query result" );
+ iLog->Log( KTestMessage1 );
+ return;
+ }
+ }
+ else if ( mode == EQueryResultModeCount )
+ {
+ TInt cou = aQuery.Count();
+ buf.Format(_L(" EModeCount, results=%d"), cou);
+ iLog->Log(buf);
+ }
+ }
+ else if (aQuery.Type() == EQueryTypeRelation)
+ {
+ iLog->Log(_L("Relation query completed notification: Error=%d"), aError);
+
+ TInt cou = aQuery.Count();
+
+ buf.Format(_L(" results=%d"), cou);
+ iLog->Log(buf);
+ }
+ else if (aQuery.Type() == EQueryTypeEvent)
+ {
+ iLog->Log(_L("Event query completed notification: Error=%d"), aError);
+
+ TInt cou = aQuery.Count();
+
+ buf.Format(_L(" results=%d"), cou);
+ iLog->Log(buf);
+ }
+ else
+ {
+ _LIT( KTestMessage2, "Query completed notification of unknown query" );
+ iLog->Log( KTestMessage2 );
+ }
+ }
+
+#else
+
+void CMdETestScripter::HandleQueryCompleted(CMdEQuery& aQuery, TInt /* aError */ )
+ {
+ TBuf<128> buf;
+
+ Signal();
+
+ RArray<TInt64> expectedIdArray;
+ RArray<TInt64> resultIdArray;
+
+ if (aQuery.Type() == EQueryTypeObject)
+ {
+ for( TInt j = iResultIndices.Count(); --j >= 0 ; )
+ {
+ expectedIdArray.Append( iObjectArray[ iResultIndices[j]]->Id() );
+ }
+ }
+ else if (aQuery.Type() == EQueryTypeRelation)
+ {
+ for( TInt j = iResultIndices.Count(); --j >= 0 ; )
+ {
+ expectedIdArray.Append( iRelationArray[ iResultIndices[j]]->Id() );
+ }
+ }
+ else if (aQuery.Type() == EQueryTypeEvent)
+ {
+ for( TInt j = iResultIndices.Count(); --j >= 0 ; )
+ {
+ expectedIdArray.Append( iEventArray[ iResultIndices[j]]->Id() );
+ }
+ }
+ else
+ {
+ _LIT( KTestMessage3, "Query completed notification of unknown query" );
+ iLog->Log( KTestMessage3 );
+ }
+
+ TQueryResultMode mode = aQuery.ResultMode();
+ if ( mode == EQueryResultModeCount )
+ {
+ if (aQuery.Count() != iResultIndices.Count())
+ {
+ _LIT( KTestMessage4, "Not expected query result count" );
+ iLog->Log( KTestMessage4 );
+ expectedIdArray.Reset();
+ return;
+ }
+ }
+ else
+ {
+ for (TInt i = 0; i < aQuery.Count(); i++)
+ {
+ if (aQuery.ResultMode() == EQueryResultModeId)
+ {
+ _LIT(KFormat3,"ID: %Ld");
+ const TInt64 id = (TInt64)aQuery.ResultId(i);
+ resultIdArray.Append( id );
+ iLog->Log(KFormat3, id);
+ }
+ else if (aQuery.ResultMode() == EQueryResultModeItem
+ || aQuery.ResultMode() == EQueryResultModeObjectWithFreetexts)
+ {
+ switch( aQuery.Type() )
+ {
+ case EQueryTypeObject:
+ {
+ _LIT(KFormat5o,"Object ID: %Ld URI: '%S' Def: '%S' Properties: %d Freetexts: %d UsageCount: %d");
+
+ CMdEObject& obj = (CMdEObject&)aQuery.ResultItem(i);
+ const TInt64 objId = (TInt64)obj.Id();
+ resultIdArray.Append( objId );
+ iLog->Log(KFormat5o, objId, &obj.Uri(), &obj.Def().Name(), obj.PropertyCount(), obj.FreeTextCount(), obj.UsageCount());
+ }
+ break;
+ case EQueryTypeRelation:
+ {
+ _LIT(KFormat4r,"Relation ID: %Ld Def: '%S' Left ID: %Ld Right ID: %Ld Param: %d");
+
+ CMdERelation& rel = (CMdERelation&)aQuery.ResultItem(i);
+ const TInt64 relId = (TInt64)rel.Id();
+ resultIdArray.Append( relId );
+ const TInt64 relLId = (TInt64)rel.LeftObjectId();
+ const TInt64 relRId = (TInt64)rel.RightObjectId();
+ iLog->Log(KFormat4r, relId, &rel.Def().Name(), relLId, relRId, rel.Parameter());
+ }
+ break;
+ case EQueryTypeEvent:
+ {
+ _LIT(KFormat4e,"Event ID: %Ld Def: '%S' Object ID: %Ld");
+
+ CMdEEvent& eve = (CMdEEvent&)aQuery.ResultItem(i);
+ const TInt64 eveId = (TInt64)eve.Id();
+ resultIdArray.Append( eveId );
+ const TInt64 eveOId = (TInt64)eve.ObjectId();
+ iLog->Log(KFormat4e, eveId, &eve.Def().Name(), eveOId);
+ }
+ break;
+ }
+ }
+ else if (aQuery.ResultMode() == EQueryResultModeDistinctValues)
+ {
+ _LIT(KFormat5,"Found with text: ");
+
+ buf = KFormat5;
+ buf.Append( aQuery.ResultDistinctValue(i) );
+ iLog->Log( buf );
+ }
+ }
+
+
+ if (aQuery.ResultMode() == EQueryResultModeId || aQuery.ResultMode() == EQueryResultModeItem
+ || aQuery.ResultMode() == EQueryResultModeObjectWithFreetexts )
+ {
+ for(TInt i = resultIdArray.Count(); --i >= 0; )
+ {
+ for( TInt j = expectedIdArray.Count(); --j >= 0 ; )
+ {
+ if ( expectedIdArray[j] == resultIdArray[i] )
+ { // matching result
+ expectedIdArray.Remove( j );
+ resultIdArray.Remove( i );
+ break;
+ }
+ }
+ }
+
+ if ( expectedIdArray.Count() != 0 || resultIdArray.Count() != 0 )
+ {
+ expectedIdArray.Reset();
+ resultIdArray.Reset();
+ _LIT( KTestMessage5, "Not expected object query result" );
+ iLog->Log( KTestMessage5 );
+ return;
+ }
+ }
+ }
+ }
+
+#endif
+
+
+
+TInt CMdETestScripter::SetEventQueryResultL( CStifItemParser& aItem )
+ {
+ iResultIndices.Reset();
+ TPtrC startMark;
+ User::LeaveIfError( aItem.GetNextString( startMark ));
+ TLex lex;
+ TPtrC indexStr;
+ TInt index;
+
+ if ( startMark.Compare(_L("{")) == 0)
+ {
+ while( ETrue )
+ {
+ index = GetEventIndexL( aItem );
+ if ( index == KErrCompletion )
+ {
+ break;
+ }
+ iResultIndices.Append( index );
+ }
+ }
+ return KErrNone;
+ }
+
+TInt CMdETestScripter::SetRelationQueryResultL( CStifItemParser& aItem )
+ {
+ iResultIndices.Reset();
+ TPtrC startMark;
+ User::LeaveIfError( aItem.GetNextString( startMark ));
+ TLex lex;
+ TPtrC indexStr;
+ TInt index;
+
+ if ( startMark.Compare(_L("{")) == 0)
+ {
+ while( ETrue )
+ {
+ index = GetRelationIndexL( aItem );
+ if ( index == KErrCompletion )
+ {
+ break;
+ }
+ iResultIndices.Append( index );
+ }
+ }
+ return KErrNone;
+ }
+
+
+TInt CMdETestScripter::SetObjectQueryResultL( CStifItemParser& aItem )
+ {
+ iResultIndices.Reset();
+ TPtrC startMark;
+ User::LeaveIfError( aItem.GetNextString( startMark ));
+ TLex lex;
+ TPtrC indexStr;
+ TInt index;
+
+ if ( startMark.Compare(_L("{")) == 0)
+ {
+ while( ETrue )
+ {
+ index = GetObjectIndexL( aItem );
+ if ( index == KErrCompletion )
+ {
+ break;
+ }
+ iResultIndices.Append( index );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMdETestScripter::TestPopulateDbL
+// -----------------------------------------------------------------------------
+//
+TInt CMdETestScripter::TestPopulateDbL( CStifItemParser& /*aItem*/ )
+ {
+ CMdENamespaceDef& namespaceDef = iMdeSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef = namespaceDef.GetObjectDefL( MdeConstants::Album::KAlbumObject );
+ CMdEObject* albumObject = iMdeSession->NewObjectL(
+ objectDef, MdeConstants::Object::KAutomaticUri );
+ CMdEPropertyDef& creationDatePropertyDef = objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );
+ TTime time( 0 );
+ albumObject->AddTimePropertyL( creationDatePropertyDef, time );
+
+ CMdEPropertyDef& lastModifiedDatePropertyDef = objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );
+
+ albumObject->AddTimePropertyL( lastModifiedDatePropertyDef, time );
+ iMdeSession->AddObjectL( *albumObject );
+
+ CMdEObjectDef& audioObjectDef = namespaceDef.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+ CMdEObject* audioObject = iMdeSession->NewObjectL(
+ audioObjectDef, MdeConstants::Object::KAutomaticUri );
+
+ audioObject->AddTimePropertyL( creationDatePropertyDef, time );
+
+ audioObject->AddTimePropertyL( lastModifiedDatePropertyDef, time );
+ iMdeSession->AddObjectL( *audioObject );
+ CMdERelationDef& relationDef = namespaceDef.GetRelationDefL( MdeConstants::Relations::KContains );
+
+ CMdERelation* relation = iMdeSession->NewRelationL( relationDef, albumObject->Id(), audioObject->Id(), 0 );
+ iMdeSession->AddRelationL( *relation );
+
+ CMdEObjectDef& objDef = namespaceDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iMdeSession->NewObjectQueryL( namespaceDef, objDef, this );
+
+ CMdELogicCondition& rootCond = iQuery->Conditions();
+
+ CMdERelationDef& containsRelDef = namespaceDef.GetRelationDefL(
+ MdeConstants::Relations::KContains );
+
+ CMdERelationCondition& relCond = rootCond.AddRelationConditionL(
+ containsRelDef, ERelationConditionSideRight );
+ CMdELogicCondition& leftRelCond = relCond.LeftL();
+
+ leftRelCond.AddObjectConditionL( albumObject->Id() );
+
+ iQuery->SetResultMode( EQueryResultModeId );
+
+ iQuery->FindL();
+ return KErrNone;
+ }
+