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::AddObjectObserverWithUriL

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

    73 //

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

    75     {

    76     iMdeSession->AddObjectObserverWithUriL( *this );

    77 

    78     return KErrNone;

    79     }

    80 

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

    82 // CMdETestScripter::RemoveObjectObserverWithUriL

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

    84 //

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

    86     {

    87     iMdeSession->RemoveObjectObserverWithUriL( *this );

    88 

    89     return KErrNone;

    90     }

    91 

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

    93 // CMdETestScripter::AddObjectPresentObserverL

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

    95 //

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

    97     {

    98     iMdeSession->AddObjectPresentObserverL( *this );

    99 

   100     return KErrNone;

   101     }

   102 

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

   104 // CMdETestScripter::RemoveObjectPresentObserverL

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

   106 //

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

   108     {

   109     iMdeSession->RemoveObjectPresentObserverL( *this );

   110 

   111     return KErrNone;

   112     }

   113 

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

   115 // CMdETestScripter::AddRelationObserverL

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

   117 //

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

   119     {

   120     iMdeSession->AddRelationObserverL( *this );

   121 

   122     return KErrNone;

   123     }

   124 

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

   126 // CMdETestScripter::RemoveRelationObserverL

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

   128 //

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

   130     {

   131     iMdeSession->RemoveRelationObserverL( *this );

   132 

   133     return KErrNone;

   134     }

   135 

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

   137 // CMdETestScripter::AddRelationItemObserverL

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

   139 //

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

   141     {

   142     iMdeSession->AddRelationItemObserverL( *this );

   143 

   144     return KErrNone;

   145     }

   146 

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

   148 // CMdETestScripter::RemoveRelationItemObserverL

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

   150 //

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

   152     {

   153     iMdeSession->RemoveRelationItemObserverL( *this );

   154 

   155     return KErrNone;

   156     }

   157 

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

   159 // CMdETestScripter::AddRelationPresentObserverL

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

   161 //

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

   163     {

   164     iMdeSession->AddRelationPresentObserverL( *this );

   165 

   166     return KErrNone;

   167     }

   168 

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

   170 // CMdETestScripter::RemoveRelationPresentObserverL

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

   172 //

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

   174     {

   175     iMdeSession->RemoveRelationPresentObserverL( *this );

   176 

   177     return KErrNone;

   178     }

   179 

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

   181 // CMdETestScripter::AddEventObserverL

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

   183 //

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

   185     {

   186     iMdeSession->AddEventObserverL( *this );

   187 

   188     return KErrNone;

   189     }

   190 

   191 // -----------------------------------------------------------------------------

   192 // CMdETestScripter::RemoveEventObserverL

   193 // -----------------------------------------------------------------------------

   194 //

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

   196     {

   197     iMdeSession->RemoveEventObserverL( *this );

   198 

   199     return KErrNone;

   200     }

   201 

   202 // -----------------------------------------------------------------------------

   203 // CMdETestScripter::VerifyTItemIdsL

   204 // -----------------------------------------------------------------------------

   205 //

   206 TInt CMdETestScripter::VerifyTItemIdsL( CStifItemParser& aItem )

   207     {

   208     TInt mode;

   209     TInt index;

   210     TInt count;

   211 

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

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

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

   215 

   216     if ( mode == EObject )

   217         {

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

   219         }

   220     else if ( mode == EEvent )

   221         {

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

   223         }

   224     else if ( mode == ERelation )

   225         {

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

   227         }

   228     else

   229         {

   230         User::Leave( KErrArgument );

   231         }

   232 

   233     iNotificationItemIdArray.Reset();

   234 

   235     return KErrNone;

   236     }

   237 

   238 // -----------------------------------------------------------------------------

   239 // CMdETestScripter::VerifyMdERelationsL

   240 // -----------------------------------------------------------------------------

   241 //

   242 TInt CMdETestScripter::VerifyMdERelationsL( CStifItemParser& aItem )

   243     {

   244     TInt index;

   245     TInt count;

   246 

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

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

   249 

   250     CheckTMdERelationArrayL( iNotificationRelationArray, index, count );

   251     iNotificationRelationArray.Reset();

   252 

   253     return KErrNone;

   254     }

   255 

   256 // -----------------------------------------------------------------------------

   257 // CMdETestScripter::VerifyObserverNotificationTypeL

   258 // -----------------------------------------------------------------------------

   259 //

   260 TInt CMdETestScripter::VerifyObserverNotificationTypeL( CStifItemParser& aItem )

   261     {

   262     TInt type;

   263 

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

   265 

   266     TL( iNotificationType == type );

   267 

   268     return KErrNone;

   269     }

   270 

   271 // -----------------------------------------------------------------------------

   272 // CMdETestScripter::ParentL

   273 // -----------------------------------------------------------------------------

   274 //

   275 TInt CMdETestScripter::ParentL( CStifItemParser& aItem )

   276     {

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

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

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

   280 

   281     return KErrNone;

   282     }

   283 

   284 // -----------------------------------------------------------------------------

   285 // CMdETestScripter::NameL

   286 // -----------------------------------------------------------------------------

   287 //

   288 TInt CMdETestScripter::NameL( CStifItemParser& aItem )

   289     {

   290     TInt mode;

   291     TPtrC name;

   292 

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

   294     if ( mode == EPropertyDef )

   295         {

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

   297         aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

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

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

   300         }

   301     else if ( mode == ENamespaceDef )

   302         {

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

   304         aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

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

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

   307         }

   308     else

   309         {

   310         User::Leave( KErrArgument );

   311         }

   312 

   313     return KErrNone;

   314     }

   315 

   316 // -----------------------------------------------------------------------------

   317 // CMdETestScripter::ObjectDefCountL

   318 // -----------------------------------------------------------------------------

   319 //

   320 TInt CMdETestScripter::ObjectDefCountL( CStifItemParser& aItem )

   321     {

   322     TInt count;

   323 

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

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

   326 

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

   328 

   329     return KErrNone;

   330     }

   331 

   332 // -----------------------------------------------------------------------------

   333 // CMdETestScripter::ObjectDefL

   334 // -----------------------------------------------------------------------------

   335 //

   336 TInt CMdETestScripter::ObjectDefL( CStifItemParser& aItem )

   337     {

   338     TInt mode;

   339     TPtrC name;

   340     TInt index;

   341     CMdEObjectDef* objectDef = NULL;

   342 

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

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

   345     if ( mode == ENamespaceDef )

   346         {

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

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

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

   350         }

   351     else if ( mode == EPropertyDef )

   352         {

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

   354         objectDef = &propDef->ObjectDef();

   355         }

   356     else

   357         {

   358         User::Leave( KErrArgument );

   359         }

   360 

   361     TL( objectDef );

   362     iObjectDefArray.Append( objectDef );

   363     AppendNameL( iObjectDefNameArray, name );

   364 

   365     return KErrNone;

   366     }

   367 

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

   369 // CMdETestScripter::GetObjectDefL

   370 // -----------------------------------------------------------------------------

   371 //

   372 TInt CMdETestScripter::GetObjectDefL( CStifItemParser& aItem )

   373     {

   374     TPtrC name;

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

   376     

   377     TPtrC objectString;

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

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

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

   381     TL( &objectDef );

   382     iObjectDefArray.Append( &objectDef );

   383     AppendNameL( iObjectDefNameArray, name );

   384 

   385     return KErrNone;

   386     }

   387 

   388 // -----------------------------------------------------------------------------

   389 // CMdETestScripter::RelationDefCountL

   390 // -----------------------------------------------------------------------------

   391 //

   392 TInt CMdETestScripter::RelationDefCountL( CStifItemParser& aItem )

   393     {

   394     TInt count;

   395 

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

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

   398 

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

   400 

   401     return KErrNone;

   402     }

   403 

   404 // -----------------------------------------------------------------------------

   405 // CMdETestScripter::RelationDefL

   406 // -----------------------------------------------------------------------------

   407 //

   408 TInt CMdETestScripter::RelationDefL( CStifItemParser& aItem )

   409     {

   410 

   411     TPtrC name;

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

   413     TInt index;

   414 

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

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

   417     

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

   419     TL( &relationDef );

   420     iRelationDefArray.Append( &relationDef );

   421     AppendNameL( iRelationDefNameArray, name );

   422     return KErrNone;

   423     }

   424 

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

   426 // CMdETestScripter::GetRelationDefL

   427 // -----------------------------------------------------------------------------

   428 //

   429 TInt CMdETestScripter::GetRelationDefL( CStifItemParser& aItem )

   430     {

   431     TPtrC name;

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

   433     TPtrC relationString;

   434 

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

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

   437 

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

   439     TL( &relationDef );

   440     iRelationDefArray.Append( &relationDef );

   441     AppendNameL( iRelationDefNameArray, name );

   442     return KErrNone;

   443     }

   444 

   445 // -----------------------------------------------------------------------------

   446 // CMdETestScripter::EventDefCountL

   447 // -----------------------------------------------------------------------------

   448 //

   449 TInt CMdETestScripter::EventDefCountL( CStifItemParser& aItem )

   450     {

   451     TInt count;

   452 

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

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

   455 

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

   457 

   458     return KErrNone;

   459     }

   460 

   461 // -----------------------------------------------------------------------------

   462 // CMdETestScripter::EventDefL

   463 // -----------------------------------------------------------------------------

   464 //

   465 TInt CMdETestScripter::EventDefL( CStifItemParser& aItem )

   466     {

   467     

   468     TPtrC name;

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

   470     TInt index;

   471 

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

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

   474 

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

   476     TL( &eventDef );

   477     iEventDefArray.Append( &eventDef );

   478     AppendNameL( iEventDefNameArray, name );

   479     return KErrNone;

   480     }

   481 

   482 // -----------------------------------------------------------------------------

   483 // CMdETestScripter::GetEventDefL

   484 // -----------------------------------------------------------------------------

   485 //

   486 TInt CMdETestScripter::GetEventDefL( CStifItemParser& aItem )

   487     {

   488     TPtrC name;

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

   490     TPtrC eventString;

   491 

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

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

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

   495     TL( &eventDef );

   496     iEventDefArray.Append( &eventDef );

   497     AppendNameL( iEventDefNameArray, name );

   498     return KErrNone;

   499     }

   500 

   501 // -----------------------------------------------------------------------------

   502 // CMdETestScripter::ExportMetadataL

   503 // -----------------------------------------------------------------------------

   504 //

   505 TInt CMdETestScripter::ExportMetadataL( CStifItemParser& aItem )

   506     {

   507     TPtrC path;

   508     TInt mode;

   509     TInt useObjectDefs;

   510     TInt useRelationDefs;

   511     TInt useEventDefs;

   512 

   513     const RPointerArray<CMdEObjectDef>* objectDefs;

   514     const RPointerArray<CMdERelationDef>* relationDefs;

   515     const RPointerArray<CMdEEventDef>* eventDefs;

   516 

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

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

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

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

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

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

   523 

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

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

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

   527 

   528     TFileName filePath( iFilePath );

   529     filePath.Append( path );

   530     filePath.ZeroTerminate();

   531 

   532     if ( mode == KAsync )

   533         {

   534         TRequestStatus status = KRequestPending;

   535         RMdEDataBuffer buf;

   536 

   537         CleanupClosePushL( buf );

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

   539             objectDefs, relationDefs, eventDefs );

   540         User::WaitForRequest( status );

   541 

   542         CleanupStack::PopAndDestroy( &buf );

   543         }

   544     else if ( mode == KSync )

   545         {

   546         iMdeSession->ExportMetadataL( filePath, space,

   547             objectDefs, relationDefs, eventDefs );

   548         }

   549     else

   550         {

   551         User::Leave( KErrArgument );

   552         }

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

   554 

   555     return KErrNone;

   556     }

   557 

   558 // -----------------------------------------------------------------------------

   559 // CMdETestScripter::ImportMetadataL

   560 // -----------------------------------------------------------------------------

   561 //

   562 TInt CMdETestScripter::ImportMetadataL( CStifItemParser& aItem )

   563     {            

   564     TPtrC path;

   565     TInt mode;

   566     TInt ret = KErrNone;

   567 

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

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

   570 

   571     TFileName filePath( iFilePath );

   572     filePath.Append( path );

   573     filePath.ZeroTerminate();

   574 

   575     if ( mode == KAsync )

   576         {

   577         TRequestStatus status = KRequestPending;

   578         TPckgBuf<TInt> buf( ret );

   579 

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

   581         User::WaitForRequest( status );

   582         ret = buf();

   583         }

   584     else if ( mode == KSync )

   585         {

   586         ret = iMdeSession->ImportMetadataL( filePath );

   587         }

   588     else

   589         {

   590         User::Leave( KErrArgument );

   591         }

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

   593     TL ( ret >= 0 );

   594 

   595     return KErrNone;

   596     }

   597 

   598 // -----------------------------------------------------------------------------

   599 // CMdETestScripter::ImportSchemaL

   600 // -----------------------------------------------------------------------------

   601 //

   602 TInt CMdETestScripter::ImportSchemaL( CStifItemParser& aItem )

   603     {

   604     TPtrC path;

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

   606 

   607     TFileName filePath( iFilePath );

   608     filePath.Append( path );

   609     filePath.ZeroTerminate();

   610 

   611     iMdeSession->ImportSchemaL( filePath );

   612 

   613     return KErrNone;

   614     }

   615 

   616 // -----------------------------------------------------------------------------

   617 // CMdETestScripter::NamespaceDefCountL

   618 // -----------------------------------------------------------------------------

   619 //

   620 TInt CMdETestScripter::NamespaceDefCountL( CStifItemParser& aItem )

   621     {

   622     TInt count;

   623 

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

   625 

   626     TInt state = iMdeSession->NamespaceDefCount();

   627     TL( count == state );

   628 

   629     return KErrNone;

   630     }

   631 

   632 // -----------------------------------------------------------------------------

   633 // CMdETestScripter::NamespaceDefL

   634 // -----------------------------------------------------------------------------

   635 //

   636 TInt CMdETestScripter::NamespaceDefL( CStifItemParser& aItem )

   637     {

   638     TPtrC name;

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

   640         

   641     TInt mode;

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

   643 

   644     CMdENamespaceDef* namespaceDef = NULL;

   645     if ( mode == ESession )

   646         {

   647         TInt index;

   648 

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

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

   651         }

   652     if ( mode == EEventDef )

   653         {

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

   655         namespaceDef = &eventDef->NamespaceDef();

   656         }

   657     else if ( mode == EObjectDef )

   658         {

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

   660         namespaceDef = &objectDef->NamespaceDef();

   661         }

   662     else if ( mode == EPropertyDef )

   663         {

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

   665         namespaceDef = &propertyDef->NamespaceDef();

   666         }

   667     else if ( mode == ERelationDef )

   668         {

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

   670         namespaceDef = &relationDef->NamespaceDef();

   671         }

   672 

   673     iNamespaceDefArray.Append( namespaceDef );

   674     AppendNameL( iNamespaceDefNameArray, name );

   675 

   676     return KErrNone;

   677     }

   678 

   679 // -----------------------------------------------------------------------------

   680 // CMdETestScripter::GetNamespaceDefL

   681 // -----------------------------------------------------------------------------

   682 //

   683 TInt CMdETestScripter::GetNamespaceDefL( CStifItemParser& aItem )

   684     {

   685     TPtrC name;

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

   687 

   688     aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

   689     TPtrC nsName;

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

   691 

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

   693     iNamespaceDefArray.Append( &namespaceDef );

   694     AppendNameL( iNamespaceDefNameArray, name );

   695     return KErrNone;

   696     }

   697 

   698 // -----------------------------------------------------------------------------

   699 // CMdETestScripter::GetDefaultNamespaceDefL

   700 // -----------------------------------------------------------------------------

   701 //

   702 TInt CMdETestScripter::GetDefaultNamespaceDefL( CStifItemParser& aItem )

   703     {

   704     TPtrC name;

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

   706         

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

   708     iNamespaceDefArray.Append( &namespaceDef );

   709     AppendNameL( iNamespaceDefNameArray, name );

   710     return KErrNone;

   711     }

   712 

   713 // -----------------------------------------------------------------------------

   714 // CMdETestScripter::LoadSchemaL

   715 // -----------------------------------------------------------------------------

   716 //

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

   718     {

   719     iMdeSession->LoadSchemaL();

   720 

   721     return KErrNone;

   722     }

   723 

   724 // -----------------------------------------------------------------------------

   725 // CMdETestScripter::EngineSessionL

   726 // -----------------------------------------------------------------------------

   727 //

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

   729     {

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

   731     TL( &session );

   732 

   733     return KErrNone;

   734     }

   735 

   736 // -----------------------------------------------------------------------------

   737 // CMdETestScripter::GetSchemaVersionL

   738 // -----------------------------------------------------------------------------

   739 //

   740 TInt CMdETestScripter::GetSchemaVersionL( CStifItemParser& aItem )

   741     {

   742     TInt majorVersion;

   743     TInt minorVersion;

   744     TInt expectedMajorVersion;

   745     TInt expectedMinorVersion;

   746 

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

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

   749 

   750     iMdeSession->GetSchemaVersionL( majorVersion, minorVersion );

   751     TL( majorVersion == expectedMajorVersion );

   752     TL( minorVersion == expectedMinorVersion );

   753 

   754     return KErrNone;

   755     }

   756 

   757 // -----------------------------------------------------------------------------

   758 // CMdETestScripter::SetObjectToPresentByGuidL

   759 // -----------------------------------------------------------------------------

   760 //

   761 TInt CMdETestScripter::SetObjectToPresentByGuidL( CStifItemParser& aItem )

   762     {

   763     TInt guidHigh;

   764     TInt guidLow;

   765 

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

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

   768 

   769     iMdeSession->SetObjectToPresentByGuidL( guidHigh, guidLow );

   770 

   771     return KErrNone;

   772     }

   773 

   774 // -----------------------------------------------------------------------------

   775 // CMdETestScripter::ClearNamespaceDefArray

   776 // -----------------------------------------------------------------------------

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

   778     {

   779     iNamespaceDefArray.Reset();

   780     iNamespaceDefNameArray->Reset();

   781     return KErrNone;

   782     }

   783 

   784 // End of File