1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  ?Description

    15 *

    16 */

    17 

    18 

    19 // [INCLUDE FILES] - do not remove

    20 #include <mdeobject.h>

    21 #include <mdeconstants.h>

    22 #include <StifParser.h>

    23 #include <StifTestInterface.h>

    24 #include "MdETestScripter.h"

    25 

    26 // -----------------------------------------------------------------------------

    27 // CMdETestScripter::AddSchemaObserverL

    28 // -----------------------------------------------------------------------------

    29 //

    30 TInt CMdETestScripter::AddSchemaObserverL( CStifItemParser& /* aItem */ )

    31     {

    32     iMdeSession->AddSchemaObserverL( *this );

    33 

    34     return KErrNone;

    35     }

    36 

    37 // -----------------------------------------------------------------------------

    38 // CMdETestScripter::RemoveSchemaObserverL

    39 // -----------------------------------------------------------------------------

    40 //

    41 TInt CMdETestScripter::RemoveSchemaObserverL( CStifItemParser& /* aItem */ )

    42     {

    43     iMdeSession->RemoveSchemaObserverL( *this );

    44 

    45     return KErrNone;

    46     }

    47 

    48 // -----------------------------------------------------------------------------

    49 // CMdETestScripter::AddObjectObserverL

    50 // -----------------------------------------------------------------------------

    51 //

    52 TInt CMdETestScripter::AddObjectObserverL( CStifItemParser& /* aItem */ )

    53     {

    54     iMdeSession->AddObjectObserverL( *this );

    55 

    56     return KErrNone;

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // CMdETestScripter::RemoveObjectObserverL

    61 // -----------------------------------------------------------------------------

    62 //

    63 TInt CMdETestScripter::RemoveObjectObserverL( CStifItemParser& /* aItem */ )

    64     {

    65     iMdeSession->RemoveObjectObserverL( *this );

    66 

    67     return KErrNone;

    68     }

    69 

    70 // -----------------------------------------------------------------------------

    71 // CMdETestScripter::AddObjectPresentObserverL

    72 // -----------------------------------------------------------------------------

    73 //

    74 TInt CMdETestScripter::AddObjectPresentObserverL( CStifItemParser& /* aItem */ )

    75     {

    76     iMdeSession->AddObjectPresentObserverL( *this );

    77 

    78     return KErrNone;

    79     }

    80 

    81 // -----------------------------------------------------------------------------

    82 // CMdETestScripter::RemoveObjectPresentObserverL

    83 // -----------------------------------------------------------------------------

    84 //

    85 TInt CMdETestScripter::RemoveObjectPresentObserverL( CStifItemParser& /* aItem */ )

    86     {

    87     iMdeSession->RemoveObjectPresentObserverL( *this );

    88 

    89     return KErrNone;

    90     }

    91 

    92 // -----------------------------------------------------------------------------

    93 // CMdETestScripter::AddRelationObserverL

    94 // -----------------------------------------------------------------------------

    95 //

    96 TInt CMdETestScripter::AddRelationObserverL( CStifItemParser& /* aItem */ )

    97     {

    98     iMdeSession->AddRelationObserverL( *this );

    99 

   100     return KErrNone;

   101     }

   102 

   103 // -----------------------------------------------------------------------------

   104 // CMdETestScripter::RemoveRelationObserverL

   105 // -----------------------------------------------------------------------------

   106 //

   107 TInt CMdETestScripter::RemoveRelationObserverL( CStifItemParser& /* aItem */ )

   108     {

   109     iMdeSession->RemoveRelationObserverL( *this );

   110 

   111     return KErrNone;

   112     }

   113 

   114 // -----------------------------------------------------------------------------

   115 // CMdETestScripter::AddRelationItemObserverL

   116 // -----------------------------------------------------------------------------

   117 //

   118 TInt CMdETestScripter::AddRelationItemObserverL( CStifItemParser& /* aItem */ )

   119     {

   120     iMdeSession->AddRelationItemObserverL( *this );

   121 

   122     return KErrNone;

   123     }

   124 

   125 // -----------------------------------------------------------------------------

   126 // CMdETestScripter::RemoveRelationItemObserverL

   127 // -----------------------------------------------------------------------------

   128 //

   129 TInt CMdETestScripter::RemoveRelationItemObserverL( CStifItemParser& /* aItem */ )

   130     {

   131     iMdeSession->RemoveRelationItemObserverL( *this );

   132 

   133     return KErrNone;

   134     }

   135 

   136 // -----------------------------------------------------------------------------

   137 // CMdETestScripter::AddRelationPresentObserverL

   138 // -----------------------------------------------------------------------------

   139 //

   140 TInt CMdETestScripter::AddRelationPresentObserverL( CStifItemParser& /* aItem */ )

   141     {

   142     iMdeSession->AddRelationPresentObserverL( *this );

   143 

   144     return KErrNone;

   145     }

   146 

   147 // -----------------------------------------------------------------------------

   148 // CMdETestScripter::RemoveRelationPresentObserverL

   149 // -----------------------------------------------------------------------------

   150 //

   151 TInt CMdETestScripter::RemoveRelationPresentObserverL( CStifItemParser& /* aItem */ )

   152     {

   153     iMdeSession->RemoveRelationPresentObserverL( *this );

   154 

   155     return KErrNone;

   156     }

   157 

   158 // -----------------------------------------------------------------------------

   159 // CMdETestScripter::AddEventObserverL

   160 // -----------------------------------------------------------------------------

   161 //

   162 TInt CMdETestScripter::AddEventObserverL( CStifItemParser& /* aItem */ )

   163     {

   164     iMdeSession->AddEventObserverL( *this );

   165 

   166     return KErrNone;

   167     }

   168 

   169 // -----------------------------------------------------------------------------

   170 // CMdETestScripter::RemoveEventObserverL

   171 // -----------------------------------------------------------------------------

   172 //

   173 TInt CMdETestScripter::RemoveEventObserverL( CStifItemParser& /* aItem */ )

   174     {

   175     iMdeSession->RemoveEventObserverL( *this );

   176 

   177     return KErrNone;

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // CMdETestScripter::VerifyTItemIdsL

   182 // -----------------------------------------------------------------------------

   183 //

   184 TInt CMdETestScripter::VerifyTItemIdsL( CStifItemParser& aItem )

   185     {

   186     TInt mode;

   187     TInt index;

   188     TInt count;

   189 

   190     User::LeaveIfError( aItem.GetNextInt( mode ));

   191     User::LeaveIfError( aItem.GetNextInt( index ));

   192     User::LeaveIfError( aItem.GetNextInt( count ));

   193 

   194     if ( mode == EObject )

   195         {

   196         CheckTItemIdArrayL( iNotificationItemIdArray, iObjectArray, index, count );

   197         }

   198     else if ( mode == EEvent )

   199         {

   200         CheckTItemIdArrayL( iNotificationItemIdArray, iEventArray, index, count );

   201         }

   202     else if ( mode == ERelation )

   203         {

   204         CheckTItemIdArrayL( iNotificationItemIdArray, iRelationArray, index, count );

   205         }

   206     else

   207         {

   208         User::Leave( KErrArgument );

   209         }

   210 

   211     iNotificationItemIdArray.Reset();

   212 

   213     return KErrNone;

   214     }

   215 

   216 // -----------------------------------------------------------------------------

   217 // CMdETestScripter::VerifyMdERelationsL

   218 // -----------------------------------------------------------------------------

   219 //

   220 TInt CMdETestScripter::VerifyMdERelationsL( CStifItemParser& aItem )

   221     {

   222     TInt index;

   223     TInt count;

   224 

   225     User::LeaveIfError( aItem.GetNextInt( index ));

   226     User::LeaveIfError( aItem.GetNextInt( count ));

   227 

   228     CheckTMdERelationArrayL( iNotificationRelationArray, index, count );

   229     iNotificationRelationArray.Reset();

   230 

   231     return KErrNone;

   232     }

   233 

   234 // -----------------------------------------------------------------------------

   235 // CMdETestScripter::VerifyObserverNotificationTypeL

   236 // -----------------------------------------------------------------------------

   237 //

   238 TInt CMdETestScripter::VerifyObserverNotificationTypeL( CStifItemParser& aItem )

   239     {

   240     TInt type;

   241 

   242     User::LeaveIfError( aItem.GetNextInt( type ));

   243 

   244     TL( iNotificationType == type );

   245 

   246     return KErrNone;

   247     }

   248 

   249 // -----------------------------------------------------------------------------

   250 // CMdETestScripter::ParentL

   251 // -----------------------------------------------------------------------------

   252 //

   253 TInt CMdETestScripter::ParentL( CStifItemParser& aItem )

   254     {

   255     CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   256     CMdEObjectDef* parentDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   257     TL( objectDef->ParentL() == parentDef );

   258 

   259     return KErrNone;

   260     }

   261 

   262 // -----------------------------------------------------------------------------

   263 // CMdETestScripter::NameL

   264 // -----------------------------------------------------------------------------

   265 //

   266 TInt CMdETestScripter::NameL( CStifItemParser& aItem )

   267     {

   268     TInt mode;

   269     TPtrC name;

   270 

   271     User::LeaveIfError( aItem.GetNextInt( mode ));

   272     if ( mode == EPropertyDef )

   273         {

   274         CMdEPropertyDef* propDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

   275         aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

   276         User::LeaveIfError( aItem.GetNextString( name ));

   277         TL( name.Compare( propDef->Name()) == 0 );           

   278         }

   279     else if ( mode == ENamespaceDef )

   280         {

   281         CMdENamespaceDef* spaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   282         aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

   283         User::LeaveIfError( aItem.GetNextString( name ));

   284         TL( name.Compare( spaceDef->Name()) == 0 );

   285         }

   286     else

   287         {

   288         User::Leave( KErrArgument );

   289         }

   290 

   291     return KErrNone;

   292     }

   293 

   294 // -----------------------------------------------------------------------------

   295 // CMdETestScripter::ObjectDefCountL

   296 // -----------------------------------------------------------------------------

   297 //

   298 TInt CMdETestScripter::ObjectDefCountL( CStifItemParser& aItem )

   299     {

   300     TInt count;

   301 

   302     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   303     User::LeaveIfError( aItem.GetNextInt( count ));

   304 

   305     TL( space->ObjectDefCount() == count );

   306 

   307     return KErrNone;

   308     }

   309 

   310 // -----------------------------------------------------------------------------

   311 // CMdETestScripter::ObjectDefL

   312 // -----------------------------------------------------------------------------

   313 //

   314 TInt CMdETestScripter::ObjectDefL( CStifItemParser& aItem )

   315     {

   316     TInt mode;

   317     TPtrC name;

   318     TInt index;

   319     CMdEObjectDef* objectDef = NULL;

   320 

   321     User::LeaveIfError( aItem.GetNextInt( mode ));

   322     User::LeaveIfError( aItem.GetNextString( name ));

   323     if ( mode == ENamespaceDef )

   324         {

   325         CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   326         User::LeaveIfError( aItem.GetNextInt( index ));

   327         objectDef = &space->ObjectDefL( index );

   328         }

   329     else if ( mode == EPropertyDef )

   330         {

   331         CMdEPropertyDef* propDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

   332         objectDef = &propDef->ObjectDef();

   333         }

   334     else

   335         {

   336         User::Leave( KErrArgument );

   337         }

   338 

   339     TL( objectDef );

   340     iObjectDefArray.Append( objectDef );

   341     AppendNameL( iObjectDefNameArray, name );

   342 

   343     return KErrNone;

   344     }

   345 

   346 // -----------------------------------------------------------------------------

   347 // CMdETestScripter::GetObjectDefL

   348 // -----------------------------------------------------------------------------

   349 //

   350 TInt CMdETestScripter::GetObjectDefL( CStifItemParser& aItem )

   351     {

   352     TPtrC name;

   353     User::LeaveIfError( aItem.GetNextString( name ));    

   354     

   355     TPtrC objectString;

   356     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   357     User::LeaveIfError( aItem.GetNextString( objectString ));

   358     CMdEObjectDef& objectDef = space->GetObjectDefL( objectString );

   359     TL( &objectDef );

   360     iObjectDefArray.Append( &objectDef );

   361     AppendNameL( iObjectDefNameArray, name );

   362 

   363     return KErrNone;

   364     }

   365 

   366 // -----------------------------------------------------------------------------

   367 // CMdETestScripter::RelationDefCountL

   368 // -----------------------------------------------------------------------------

   369 //

   370 TInt CMdETestScripter::RelationDefCountL( CStifItemParser& aItem )

   371     {

   372     TInt count;

   373 

   374     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   375     User::LeaveIfError( aItem.GetNextInt( count ));

   376 

   377     TL( space->RelationDefCount() == count );

   378 

   379     return KErrNone;

   380     }

   381 

   382 // -----------------------------------------------------------------------------

   383 // CMdETestScripter::RelationDefL

   384 // -----------------------------------------------------------------------------

   385 //

   386 TInt CMdETestScripter::RelationDefL( CStifItemParser& aItem )

   387     {

   388 

   389     TPtrC name;

   390     User::LeaveIfError( aItem.GetNextString( name ));  

   391     TInt index;

   392 

   393     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   394     User::LeaveIfError( aItem.GetNextInt( index ));

   395     

   396     CMdERelationDef& relationDef = space->RelationDefL( index );

   397     TL( &relationDef );

   398     iRelationDefArray.Append( &relationDef );

   399     AppendNameL( iRelationDefNameArray, name );

   400     return KErrNone;

   401     }

   402 

   403 // -----------------------------------------------------------------------------

   404 // CMdETestScripter::GetRelationDefL

   405 // -----------------------------------------------------------------------------

   406 //

   407 TInt CMdETestScripter::GetRelationDefL( CStifItemParser& aItem )

   408     {

   409     TPtrC name;

   410     User::LeaveIfError( aItem.GetNextString( name ));      

   411     TPtrC relationString;

   412 

   413     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   414     User::LeaveIfError( aItem.GetNextString( relationString ));

   415 

   416     CMdERelationDef& relationDef = space->GetRelationDefL( relationString );

   417     TL( &relationDef );

   418     iRelationDefArray.Append( &relationDef );

   419     AppendNameL( iRelationDefNameArray, name );

   420     return KErrNone;

   421     }

   422 

   423 // -----------------------------------------------------------------------------

   424 // CMdETestScripter::EventDefCountL

   425 // -----------------------------------------------------------------------------

   426 //

   427 TInt CMdETestScripter::EventDefCountL( CStifItemParser& aItem )

   428     {

   429     TInt count;

   430 

   431     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   432     User::LeaveIfError( aItem.GetNextInt( count ));

   433 

   434     TL( space->EventDefCount() == count );

   435 

   436     return KErrNone;

   437     }

   438 

   439 // -----------------------------------------------------------------------------

   440 // CMdETestScripter::EventDefL

   441 // -----------------------------------------------------------------------------

   442 //

   443 TInt CMdETestScripter::EventDefL( CStifItemParser& aItem )

   444     {

   445     

   446     TPtrC name;

   447     User::LeaveIfError( aItem.GetNextString( name ));     

   448     TInt index;

   449 

   450     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   451     User::LeaveIfError( aItem.GetNextInt( index ));

   452 

   453     CMdEEventDef& eventDef = space->EventDefL( index );

   454     TL( &eventDef );

   455     iEventDefArray.Append( &eventDef );

   456     AppendNameL( iEventDefNameArray, name );

   457     return KErrNone;

   458     }

   459 

   460 // -----------------------------------------------------------------------------

   461 // CMdETestScripter::GetEventDefL

   462 // -----------------------------------------------------------------------------

   463 //

   464 TInt CMdETestScripter::GetEventDefL( CStifItemParser& aItem )

   465     {

   466     TPtrC name;

   467     User::LeaveIfError( aItem.GetNextString( name ));   

   468     TPtrC eventString;

   469 

   470     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   471     User::LeaveIfError( aItem.GetNextString( eventString ));

   472     CMdEEventDef& eventDef = space->GetEventDefL( eventString );

   473     TL( &eventDef );

   474     iEventDefArray.Append( &eventDef );

   475     AppendNameL( iEventDefNameArray, name );

   476     return KErrNone;

   477     }

   478 

   479 // -----------------------------------------------------------------------------

   480 // CMdETestScripter::ExportMetadataL

   481 // -----------------------------------------------------------------------------

   482 //

   483 TInt CMdETestScripter::ExportMetadataL( CStifItemParser& aItem )

   484     {

   485     TPtrC path;

   486     TInt mode;

   487     TInt useObjectDefs;

   488     TInt useRelationDefs;

   489     TInt useEventDefs;

   490 

   491     const RPointerArray<CMdEObjectDef>* objectDefs;

   492     const RPointerArray<CMdERelationDef>* relationDefs;

   493     const RPointerArray<CMdEEventDef>* eventDefs;

   494 

   495     CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   496     User::LeaveIfError( aItem.GetNextString( path ));

   497     User::LeaveIfError( aItem.GetNextInt( mode ));

   498     User::LeaveIfError( aItem.GetNextInt( useObjectDefs ));

   499     User::LeaveIfError( aItem.GetNextInt( useRelationDefs ));

   500     User::LeaveIfError( aItem.GetNextInt( useEventDefs ));

   501 

   502     objectDefs = (useObjectDefs) ? &iObjectDefArray : NULL;

   503     relationDefs = (useRelationDefs) ? &iRelationDefArray : NULL;

   504     eventDefs = (useEventDefs) ? &iEventDefArray : NULL;

   505 

   506     TFileName filePath( iFilePath );

   507     filePath.Append( path );

   508     filePath.ZeroTerminate();

   509 

   510     if ( mode == KAsync )

   511         {

   512         TRequestStatus status = KRequestPending;

   513         RMdEDataBuffer buf;

   514 

   515         CleanupClosePushL( buf );

   516         iMdeSession->ExportMetadataL( filePath, status, buf, space,

   517             objectDefs, relationDefs, eventDefs );

   518         User::WaitForRequest( status );

   519 

   520         CleanupStack::PopAndDestroy( &buf );

   521         }

   522     else if ( mode == KSync )

   523         {

   524         iMdeSession->ExportMetadataL( filePath, space,

   525             objectDefs, relationDefs, eventDefs );

   526         }

   527     else

   528         {

   529         User::Leave( KErrArgument );

   530         }

   531     iLog->Log( _L( "ExportMetadataL End"));

   532 

   533     return KErrNone;

   534     }

   535 

   536 // -----------------------------------------------------------------------------

   537 // CMdETestScripter::ImportMetadataL

   538 // -----------------------------------------------------------------------------

   539 //

   540 TInt CMdETestScripter::ImportMetadataL( CStifItemParser& aItem )

   541     {            

   542     TPtrC path;

   543     TInt mode;

   544     TInt ret = KErrNone;

   545 

   546     User::LeaveIfError( aItem.GetNextString( path ));

   547     User::LeaveIfError( aItem.GetNextInt( mode ));

   548 

   549     TFileName filePath( iFilePath );

   550     filePath.Append( path );

   551     filePath.ZeroTerminate();

   552 

   553     if ( mode == KAsync )

   554         {

   555         TRequestStatus status = KRequestPending;

   556         TPckgBuf<TInt> buf( ret );

   557 

   558         iMdeSession->ImportMetadata( filePath, buf, status );

   559         User::WaitForRequest( status );

   560         ret = buf();

   561         }

   562     else if ( mode == KSync )

   563         {

   564         ret = iMdeSession->ImportMetadataL( filePath );

   565         }

   566     else

   567         {

   568         User::Leave( KErrArgument );

   569         }

   570        iLog->Log( _L( "ImportMetadataL ret: %d" ), ret );

   571     TL ( ret >= 0 );

   572 

   573     return KErrNone;

   574     }

   575 

   576 // -----------------------------------------------------------------------------

   577 // CMdETestScripter::ImportSchemaL

   578 // -----------------------------------------------------------------------------

   579 //

   580 TInt CMdETestScripter::ImportSchemaL( CStifItemParser& aItem )

   581     {

   582     TPtrC path;

   583     User::LeaveIfError( aItem.GetNextString( path ));

   584 

   585     TFileName filePath( iFilePath );

   586     filePath.Append( path );

   587     filePath.ZeroTerminate();

   588 

   589     iMdeSession->ImportSchemaL( filePath );

   590 

   591     return KErrNone;

   592     }

   593 

   594 // -----------------------------------------------------------------------------

   595 // CMdETestScripter::NamespaceDefCountL

   596 // -----------------------------------------------------------------------------

   597 //

   598 TInt CMdETestScripter::NamespaceDefCountL( CStifItemParser& aItem )

   599     {

   600     TInt count;

   601 

   602     User::LeaveIfError( aItem.GetNextInt( count ));

   603 

   604     TInt state = iMdeSession->NamespaceDefCount();

   605     TL( count == state );

   606 

   607     return KErrNone;

   608     }

   609 

   610 // -----------------------------------------------------------------------------

   611 // CMdETestScripter::NamespaceDefL

   612 // -----------------------------------------------------------------------------

   613 //

   614 TInt CMdETestScripter::NamespaceDefL( CStifItemParser& aItem )

   615     {

   616     TPtrC name;

   617     User::LeaveIfError( aItem.GetNextString( name ));

   618         

   619     TInt mode;

   620     User::LeaveIfError( aItem.GetNextInt( mode ));

   621 

   622     CMdENamespaceDef* namespaceDef = NULL;

   623     if ( mode == ESession )

   624         {

   625         TInt index;

   626 

   627         User::LeaveIfError( aItem.GetNextInt( index ));

   628         namespaceDef = &iMdeSession->NamespaceDefL( index );

   629         }

   630     if ( mode == EEventDef )

   631         {

   632         CMdEEventDef* eventDef = SanitizeArrayIndexL( iEventDefArray, *iEventDefNameArray, aItem );

   633         namespaceDef = &eventDef->NamespaceDef();

   634         }

   635     else if ( mode == EObjectDef )

   636         {

   637         CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   638         namespaceDef = &objectDef->NamespaceDef();

   639         }

   640     else if ( mode == EPropertyDef )

   641         {

   642         CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );        

   643         namespaceDef = &propertyDef->NamespaceDef();

   644         }

   645     else if ( mode == ERelationDef )

   646         {

   647         CMdERelationDef* relationDef = SanitizeArrayIndexL( iRelationDefArray, *iRelationDefNameArray, aItem );

   648         namespaceDef = &relationDef->NamespaceDef();

   649         }

   650 

   651     iNamespaceDefArray.Append( namespaceDef );

   652     AppendNameL( iNamespaceDefNameArray, name );

   653 

   654     return KErrNone;

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CMdETestScripter::GetNamespaceDefL

   659 // -----------------------------------------------------------------------------

   660 //

   661 TInt CMdETestScripter::GetNamespaceDefL( CStifItemParser& aItem )

   662     {

   663     TPtrC name;

   664     User::LeaveIfError( aItem.GetNextString( name ));    

   665 

   666     aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

   667     TPtrC nsName;

   668     User::LeaveIfError( aItem.GetNextString( nsName ));

   669 

   670     CMdENamespaceDef& namespaceDef = iMdeSession->GetNamespaceDefL( nsName );

   671     iNamespaceDefArray.Append( &namespaceDef );

   672     AppendNameL( iNamespaceDefNameArray, name );

   673     return KErrNone;

   674     }

   675 

   676 // -----------------------------------------------------------------------------

   677 // CMdETestScripter::GetDefaultNamespaceDefL

   678 // -----------------------------------------------------------------------------

   679 //

   680 TInt CMdETestScripter::GetDefaultNamespaceDefL( CStifItemParser& aItem )

   681     {

   682     TPtrC name;

   683     User::LeaveIfError( aItem.GetNextString( name ));    

   684         

   685     CMdENamespaceDef& namespaceDef = iMdeSession->GetDefaultNamespaceDefL();

   686     iNamespaceDefArray.Append( &namespaceDef );

   687     AppendNameL( iNamespaceDefNameArray, name );

   688     return KErrNone;

   689     }

   690 

   691 // -----------------------------------------------------------------------------

   692 // CMdETestScripter::LoadSchemaL

   693 // -----------------------------------------------------------------------------

   694 //

   695 TInt CMdETestScripter::LoadSchemaL( CStifItemParser& /* aItem */ )

   696     {

   697     iMdeSession->LoadSchemaL();

   698 

   699     return KErrNone;

   700     }

   701 

   702 // -----------------------------------------------------------------------------

   703 // CMdETestScripter::EngineSessionL

   704 // -----------------------------------------------------------------------------

   705 //

   706 TInt CMdETestScripter::EngineSessionL( CStifItemParser& /* aItem */ )

   707     {

   708     RMdEEngineSession& session = iMdeSession->EngineSession();

   709     TL( &session );

   710 

   711     return KErrNone;

   712     }

   713 

   714 // -----------------------------------------------------------------------------

   715 // CMdETestScripter::GetSchemaVersionL

   716 // -----------------------------------------------------------------------------

   717 //

   718 TInt CMdETestScripter::GetSchemaVersionL( CStifItemParser& aItem )

   719     {

   720     TInt majorVersion;

   721     TInt minorVersion;

   722     TInt expectedMajorVersion;

   723     TInt expectedMinorVersion;

   724 

   725     User::LeaveIfError( aItem.GetNextInt( expectedMajorVersion ));

   726     User::LeaveIfError( aItem.GetNextInt( expectedMinorVersion ));

   727 

   728     iMdeSession->GetSchemaVersionL( majorVersion, minorVersion );

   729     TL( majorVersion == expectedMajorVersion );

   730     TL( minorVersion == expectedMinorVersion );

   731 

   732     return KErrNone;

   733     }

   734 

   735 // -----------------------------------------------------------------------------

   736 // CMdETestScripter::SetObjectToPresentByGuidL

   737 // -----------------------------------------------------------------------------

   738 //

   739 TInt CMdETestScripter::SetObjectToPresentByGuidL( CStifItemParser& aItem )

   740     {

   741     TInt guidHigh;

   742     TInt guidLow;

   743 

   744     User::LeaveIfError( aItem.GetNextInt( guidHigh ));

   745     User::LeaveIfError( aItem.GetNextInt( guidLow ));

   746 

   747     iMdeSession->SetObjectToPresentByGuidL( guidHigh, guidLow );

   748 

   749     return KErrNone;

   750     }

   751 

   752 // -----------------------------------------------------------------------------

   753 // CMdETestScripter::ClearNamespaceDefArray

   754 // -----------------------------------------------------------------------------

   755 TInt CMdETestScripter::ResetNamespaceDefArray( CStifItemParser& /*aItem*/ )

   756     {

   757     iNamespaceDefArray.Reset();

   758     iNamespaceDefNameArray->Reset();

   759     return KErrNone;

   760     }

   761 

   762 // End of File