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 // [INCLUDE FILES] - do not remove

    19 #include <mdeobject.h>

    20 #include <mdeconstants.h>

    21 #include <StifParser.h>

    22 #include <StifTestInterface.h>

    23 #include <StifTestEventInterface.h>

    24 #include "MdETestScripter.h"

    25 #include "MdETestScripterAO.h"

    26 

    27 // -----------------------------------------------------------------------------

    28 // CMdETestScripter::BelongsToSessionL

    29 // -----------------------------------------------------------------------------

    30 //

    31 TInt CMdETestScripter::BelongsToSessionL( CStifItemParser& aItem )

    32     {

    33     TInt mode;

    34     TInt state;

    35 

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

    37     CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

    38     User::LeaveIfError( aItem.GetNextInt( state ));

    39 

    40     TL( instanceItem->BelongsToSession() == (TBool)state );

    41 

    42     return KErrNone;

    43     }

    44 

    45 // -----------------------------------------------------------------------------

    46 // CMdETestScripter::SessionL

    47 // -----------------------------------------------------------------------------

    48 //

    49 TInt CMdETestScripter::SessionL( CStifItemParser& aItem )

    50     {

    51     TInt mode;

    52 

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

    54     CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

    55     TL( iMdeSession == &instanceItem->Session());

    56 

    57     return KErrNone;

    58     }

    59 

    60 // -----------------------------------------------------------------------------

    61 // CMdETestScripter::InDatabaseL

    62 // -----------------------------------------------------------------------------

    63 //

    64 TInt CMdETestScripter::InDatabaseL( CStifItemParser& aItem )

    65     {

    66     TInt mode;

    67     TInt state;

    68 

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

    70     CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

    71     User::LeaveIfError( aItem.GetNextInt( state ));

    72     TL( instanceItem->InDatabase() == (TBool)state );

    73 

    74     return KErrNone;

    75     }

    76 

    77 // -----------------------------------------------------------------------------

    78 // CMdETestScripter::AddItemsL

    79 // -----------------------------------------------------------------------------

    80 //

    81 TInt CMdETestScripter::AddItemsL( CStifItemParser& aItem )

    82     {

    83     TInt mode1, err = KErrNone;

    84     User::LeaveIfError( aItem.GetNextInt( mode1 ));

    85 

    86     if ( mode1 == KSync )

    87         {

    88         RPointerArray<CMdEInstanceItem> itemArray;

    89         FormInstanceItemArrayL( aItem, itemArray );

    90         err = iMdeSession->AddItemsL( itemArray );

    91         }

    92     else if ( mode1 == KAsync )

    93         {

    94         FormInstanceItemArrayL( aItem, iItemArray );

    95         TEventIf event( TEventIf::ESetEvent, TName( KMdEItemsAsyncAdd ) );

    96         iAsyncHandler->Start( this, event );

    97         iMdEDataBuf.Close();// make sure the last async request buffer cleaned before using again.

    98         iMdeSession->AddItemsAsyncL( iItemArray, iAsyncHandler->iStatus, iMdEDataBuf );

    99         }

   100     else

   101         {

   102         User::Leave( KErrArgument );

   103         }

   104 

   105     return err;

   106     }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CMdETestScripter::UpdateItemsL

   110 // -----------------------------------------------------------------------------

   111 //

   112 TInt CMdETestScripter::UpdateItemsL( CStifItemParser& aItem )

   113     {

   114     TInt mode1, err = KErrNone;

   115     User::LeaveIfError( aItem.GetNextInt( mode1 ));

   116 

   117     if ( mode1 == KSync )

   118         {

   119         RPointerArray<CMdEInstanceItem> itemArray;

   120         FormInstanceItemArrayL( aItem, itemArray );

   121         err = iMdeSession->UpdateItemsL( itemArray );

   122         }

   123     else if ( mode1 == KAsync )

   124         {

   125         FormInstanceItemArrayL( aItem, iItemArray );

   126         TEventIf event( TEventIf::ESetEvent, TName( KMdEItemsAsyncUpdate ) );

   127         iAsyncHandler->Start( this, event );

   128         iMdEDataBuf.Close();// make sure the last async request buffer cleaned before using again.

   129         iMdeSession->UpdateItemsAsyncL( iItemArray, iAsyncHandler->iStatus, iMdEDataBuf );

   130         }

   131     else

   132         {

   133         User::Leave( KErrArgument );

   134         }

   135 

   136     return err;

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CMdETestScripter::AddRelationDefL

   141 // -----------------------------------------------------------------------------

   142 //

   143 TInt CMdETestScripter::AddRelationDefL( CStifItemParser& aItem )

   144     {

   145     TPtrC relationString;

   146 

   147     CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

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

   149     TRAPD( err, iMdeSession->AddRelationDefL( *namespaceDef, relationString ) );

   150     if( KErrAlreadyExists == err )

   151         {

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

   153         TestModuleIf().Event( event );

   154         }

   155     return err;

   156     }

   157 

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

   159 // CMdETestScripter::AddEventDefL

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

   161 //

   162 TInt CMdETestScripter::AddEventDefL( CStifItemParser& aItem )

   163     {

   164     TPtrC eventString;

   165 

   166     CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

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

   168     TRAPD( err, iMdeSession->AddEventDefL( *namespaceDef, eventString ) );

   169     if( KErrAlreadyExists == err )

   170         {

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

   172         TestModuleIf().Event( event );

   173        	}

   174     return err;

   175     }

   176 

   177 // -----------------------------------------------------------------------------

   178 // CMdETestScripter::PropertyDefCountL

   179 // -----------------------------------------------------------------------------

   180 //

   181 TInt CMdETestScripter::PropertyDefCountL( CStifItemParser& aItem )

   182     {

   183     TInt count;

   184 

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

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

   187     TL( objectDef->PropertyDefCount() == count );

   188 

   189     return KErrNone;

   190     }

   191 

   192 // -----------------------------------------------------------------------------

   193 // CMdETestScripter::PropertyDefL

   194 // -----------------------------------------------------------------------------

   195 //

   196 TInt CMdETestScripter::PropertyDefL( CStifItemParser& aItem )

   197     {

   198     TInt index;

   199 

   200     TPtrC name;

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

   202 

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

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

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

   206     CMdEPropertyDef& propertyDef = objectDef->PropertyDefL( index );

   207     TL( &propertyDef );

   208     iPropertyDefArray.Append( &propertyDef );

   209     AppendNameL( iPropertyDefNameArray, name );

   210 

   211     return KErrNone;

   212     }

   213 

   214 // -----------------------------------------------------------------------------

   215 // CMdETestScripter::GetPropertyDefL

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

   217 //

   218 TInt CMdETestScripter::GetPropertyDefL( CStifItemParser& aItem )

   219     {

   220     TPtrC propertyString;

   221     

   222     TPtrC name;

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

   224 

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

   226     User::LeaveIfError( aItem.GetNextString( propertyString ));

   227     CMdEPropertyDef& propertyDef = objectDef->GetPropertyDefL( propertyString );

   228     iPropertyDefArray.Append( &propertyDef );

   229     AppendNameL( iPropertyDefNameArray, name );

   230 

   231     return KErrNone;

   232     }

   233 

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

   235 // CMdETestScripter::CompareL

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

   237 //

   238 TInt CMdETestScripter::CompareL( CStifItemParser& aItem )

   239     {

   240     TInt mode;

   241 

   242     TInt expected;

   243 

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

   245     TInt result( -1 );

   246 

   247     if ( mode == EObjectDef )

   248         {

   249         CMdEObjectDef* item1 = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   250         CMdEObjectDef* item2 = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   251         result = item1->Compare( *item2 );

   252         }

   253     else if ( mode == ERelationDef )

   254         {

   255         CMdERelationDef* item1 = SanitizeArrayIndexL( iRelationDefArray, *iRelationDefNameArray, aItem );

   256         CMdERelationDef* item2 = SanitizeArrayIndexL( iRelationDefArray, *iRelationDefNameArray, aItem );

   257         result = item1->Compare( *item2 );

   258         }

   259     else if ( mode == EEventDef )

   260         {

   261         CMdEEventDef* item1 = SanitizeArrayIndexL( iEventDefArray, *iEventDefNameArray, aItem );

   262         CMdEEventDef* item2 = SanitizeArrayIndexL( iEventDefArray, *iEventDefNameArray, aItem );

   263         result = item1->Compare( *item2 );

   264         }

   265     else if ( mode == EPropertyDef )

   266         {

   267         CMdEPropertyDef* item1 = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

   268         CMdEPropertyDef* item2 = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

   269         result = item1->Compare( *item2 );

   270         }

   271     else if ( mode == ENamespaceDef )

   272         {

   273         CMdENamespaceDef* item1 = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   274         CMdENamespaceDef* item2 = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   275         result = item1->Compare( *item2 );

   276         }

   277     else

   278         {

   279         User::Leave( KErrArgument );

   280         }

   281         

   282     User::LeaveIfError( aItem.GetNextInt( expected ));

   283     TL( result == expected );

   284 

   285     return KErrNone;

   286     }

   287 

   288 // -----------------------------------------------------------------------------

   289 // CMdETestScripter::ReadOnlyL

   290 // -----------------------------------------------------------------------------

   291 //

   292 TInt CMdETestScripter::ReadOnlyL( CStifItemParser& aItem )

   293     {

   294     TInt mode;

   295     TBool state;

   296 

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

   298 

   299     if ( mode == EPropertyDef )

   300         {

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

   302         User::LeaveIfError( aItem.GetNextInt( state ));

   303         TL( propertyDef->ReadOnly() == (TBool)state );

   304         }

   305     else if ( mode == ENamespaceDef )

   306         {

   307         CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   308         User::LeaveIfError( aItem.GetNextInt( state ));

   309         TL( namespaceDef->ReadOnly() == state );

   310         }

   311 

   312     return KErrNone;

   313     }

   314 

   315 // -----------------------------------------------------------------------------

   316 // CMdETestScripter::MandatoryL

   317 // -----------------------------------------------------------------------------

   318 //

   319 TInt CMdETestScripter::MandatoryL( CStifItemParser& aItem )

   320     {

   321     TBool state;

   322 

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

   324     User::LeaveIfError( aItem.GetNextInt( state ));

   325     TL( propertyDef->Mandatory() == (TBool)state );

   326 

   327     return KErrNone;

   328     }    

   329 

   330 // -----------------------------------------------------------------------------

   331 // CMdETestScripter::MinInt32ValueL

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

   333 //

   334 TInt CMdETestScripter::MinInt32ValueL( CStifItemParser& aItem )

   335     {

   336     TPtrC value;

   337 

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

   339     User::LeaveIfError( aItem.GetNextString( value ));

   340     TLex lex( value );

   341     TInt32 valueU;

   342     lex.BoundedVal( valueU, 0x7FFFFFFF );

   343     TL( propertyDef->MinInt32ValueL() == valueU );

   344 

   345     return KErrNone;

   346     }

   347 

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

   349 // CMdETestScripter::MaxInt32ValueL

   350 // -----------------------------------------------------------------------------

   351 //

   352 TInt CMdETestScripter::MaxInt32ValueL( CStifItemParser& aItem )

   353     {

   354     TPtrC value;

   355 

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

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

   358     TLex lex( value );

   359     TInt32 valueU;

   360     lex.BoundedVal( valueU, 0x7FFFFFFF );

   361     TL( propertyDef->MaxInt32ValueL() == valueU );

   362 

   363     return KErrNone;

   364     }

   365 

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

   367 // CMdETestScripter::MinUint32ValueL

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

   369 //

   370 TInt CMdETestScripter::MinUint32ValueL( CStifItemParser& aItem )

   371     {

   372     TPtrC value;

   373 

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

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

   376     TLex lex( value );

   377     TUint32 valueU;

   378     lex.BoundedVal( valueU, EDecimal, 0xFFFFFFFF );

   379     TL( propertyDef->MinUint32ValueL() == valueU );

   380 

   381     return KErrNone;

   382     }

   383 

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

   385 // CMdETestScripter::MaxUint32ValueL

   386 // -----------------------------------------------------------------------------

   387 //

   388 TInt CMdETestScripter::MaxUint32ValueL( CStifItemParser& aItem )

   389     {

   390     TPtrC value;

   391 

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

   393     User::LeaveIfError( aItem.GetNextString( value ));

   394     TLex lex( value );

   395     TUint32 valueU;

   396     lex.BoundedVal( valueU, EDecimal, 0xFFFFFFFF );

   397     TL( propertyDef->MaxUint32ValueL() == valueU );

   398 

   399     return KErrNone;

   400     }

   401 

   402 // -----------------------------------------------------------------------------

   403 // CMdETestScripter::MinInt64ValueL

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

   405 //

   406 TInt CMdETestScripter::MinInt64ValueL( CStifItemParser& aItem )

   407     {

   408     TPtrC value;

   409 

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

   411     User::LeaveIfError( aItem.GetNextString( value ));

   412     TLex lex( value );

   413     TInt64 value64;

   414     lex.Val( value64, 0x7FFFFFFFFFFFFFFF );

   415     TL( propertyDef->MinInt64ValueL() == value64 );

   416 

   417     return KErrNone;

   418     }

   419 

   420 // -----------------------------------------------------------------------------

   421 // CMdETestScripter::MaxInt64ValueL

   422 // -----------------------------------------------------------------------------

   423 //

   424 TInt CMdETestScripter::MaxInt64ValueL( CStifItemParser& aItem )

   425     {

   426     TPtrC value;

   427 

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

   429     User::LeaveIfError( aItem.GetNextString( value ));

   430     TLex lex( value );

   431     TInt64 value64;

   432     lex.Val( value64, 0x7FFFFFFFFFFFFFFF );

   433     TL( propertyDef->MaxInt64ValueL() == value64 );

   434 

   435     return KErrNone;

   436     }

   437 

   438 // -----------------------------------------------------------------------------

   439 // CMdETestScripter::MinRealValueL

   440 // -----------------------------------------------------------------------------

   441 //

   442 TInt CMdETestScripter::MinRealValueL( CStifItemParser& aItem )

   443     {

   444     TPtrC value;

   445 

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

   447     aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

   448     User::LeaveIfError( aItem.GetNextString( value ));

   449     TLex lex( value );

   450     TReal valueR;

   451     lex.Val( valueR );

   452     TL( propertyDef->MinRealValueL() == valueR );

   453 

   454     return KErrNone;

   455     }

   456 

   457 // -----------------------------------------------------------------------------

   458 // CMdETestScripter::MaxRealValueL

   459 // -----------------------------------------------------------------------------

   460 //

   461 TInt CMdETestScripter::MaxRealValueL( CStifItemParser& aItem )

   462     {

   463     TPtrC value;

   464 

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

   466     aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

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

   468     TLex lex( value );

   469     TReal valueR;

   470     lex.Val( valueR );

   471     TL( propertyDef->MaxRealValueL() == valueR );

   472 

   473     return KErrNone;

   474     }

   475 

   476 // -----------------------------------------------------------------------------

   477 // CMdETestScripter::MinTimeValueL

   478 // -----------------------------------------------------------------------------

   479 //

   480 TInt CMdETestScripter::MinTimeValueL( CStifItemParser& aItem )

   481     {

   482     TPtrC value;

   483 

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

   485     User::LeaveIfError( aItem.GetNextString( value ));

   486     TTime time;

   487     TL( time.Set( value ) == KErrNone );

   488     TL( propertyDef->MinTimeValueL() == time );

   489 

   490     return KErrNone;

   491     }

   492 

   493 // -----------------------------------------------------------------------------

   494 // CMdETestScripter::MaxTimeValueL

   495 // -----------------------------------------------------------------------------

   496 //

   497 TInt CMdETestScripter::MaxTimeValueL( CStifItemParser& aItem )

   498     {

   499     TPtrC value;

   500 

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

   502     User::LeaveIfError( aItem.GetNextString( value ));

   503     TTime time;

   504     TL( time.Set( value ) == KErrNone );

   505     TL( propertyDef->MaxTimeValueL() == time );

   506 

   507     return KErrNone;

   508     }

   509 

   510 // -----------------------------------------------------------------------------

   511 // CMdETestScripter::MinTextLengthL

   512 // -----------------------------------------------------------------------------

   513 //

   514 TInt CMdETestScripter::MinTextLengthL( CStifItemParser& aItem )

   515     {

   516     TInt value;

   517 

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

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

   520     TL( propertyDef->MinTextLengthL() == value );

   521 

   522     return KErrNone;

   523     }

   524 

   525 // -----------------------------------------------------------------------------

   526 // CMdETestScripter::MaxTextLengthL

   527 // -----------------------------------------------------------------------------

   528 //

   529 TInt CMdETestScripter::MaxTextLengthL( CStifItemParser& aItem )

   530     {

   531     TInt value;

   532 

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

   534     User::LeaveIfError( aItem.GetNextInt( value ));

   535     TL( propertyDef->MaxTextLengthL() == value );

   536 

   537     return KErrNone;

   538     }

   539 

   540 // -----------------------------------------------------------------------------

   541 // CMdETestScripter::DefL

   542 // -----------------------------------------------------------------------------

   543 //

   544 TInt CMdETestScripter::DefL( CStifItemParser& aItem )

   545     {

   546     TInt mode;

   547     TPtrC name;

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

   549 

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

   551 

   552     if ( mode == EObjectDef )

   553         {

   554            CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem);

   555            CMdEObjectDef& objDef = object->Def();

   556         TL( &objDef );

   557         iObjectDefArray.Append( &objDef );

   558         AppendNameL( iObjectDefNameArray, name );

   559         }

   560     else if ( mode == ERelationDef )

   561         {

   562            CMdERelation* relation = SanitizeArrayIndexL( iRelationArray, *iRelationNameArray, aItem);

   563            CMdERelationDef& relDef = relation->Def();        

   564         TL( &relDef );

   565         iRelationDefArray.Append( &relDef );

   566         AppendNameL( iRelationDefNameArray, name );

   567         }

   568     else if ( mode == EPropertyDef )

   569         {

   570            CMdEProperty* property = SanitizeArrayIndexL( iPropertyArray, *iPropertyNameArray, aItem);

   571            const CMdEPropertyDef& propDef = property->Def();      

   572         TL( &propDef );

   573         iPropertyDefArray.Append( &propDef );

   574         AppendNameL( iPropertyDefNameArray, name );

   575         }

   576     else if ( mode == EEventDef )

   577         {

   578         CMdEEvent* event = SanitizeArrayIndexL( iEventArray, *iEventNameArray, aItem );

   579         CMdEEventDef& eventDef = event->Def();

   580         TL( &eventDef );

   581         iEventDefArray.Append( &eventDef );

   582         AppendNameL( iEventDefNameArray, name );

   583         }

   584     else

   585         {

   586         User::Leave( KErrArgument );

   587         }

   588 

   589     return KErrNone;

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // CMdETestScripter::SetDefL

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

   595 //

   596 TInt CMdETestScripter::SetDefL( CStifItemParser& aItem )

   597     {

   598 

   599     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

   601     object->SetDefL( *objectDef );

   602 

   603     return KErrNone;

   604     }

   605 

   606 // -----------------------------------------------------------------------------

   607 // CMdETestScripter::UriL

   608 // -----------------------------------------------------------------------------

   609 //

   610 TInt CMdETestScripter::UriL( CStifItemParser& aItem )

   611     {

   612 

   613     TPtrC uri;

   614 

   615     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   616     User::LeaveIfError( aItem.GetNextString( uri ));

   617     TL( object->Uri().Compare( uri ) == 0 );

   618 

   619     return KErrNone;

   620     }

   621 

   622 // -----------------------------------------------------------------------------

   623 // CMdETestScripter::SetUriL

   624 // -----------------------------------------------------------------------------

   625 //

   626 TInt CMdETestScripter::SetUriL( CStifItemParser& aItem )

   627     {

   628 

   629     TPtrC uri;

   630 

   631     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   632     User::LeaveIfError( aItem.GetNextString( uri ));

   633     object->SetUriL( uri );

   634 

   635     return KErrNone;

   636     }

   637 

   638 // -----------------------------------------------------------------------------

   639 // CMdETestScripter::ConfidentialL

   640 // -----------------------------------------------------------------------------

   641 //

   642 TInt CMdETestScripter::ConfidentialL( CStifItemParser& aItem )

   643     {

   644     TInt state;

   645 

   646     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   647     User::LeaveIfError( aItem.GetNextInt( state ));

   648     TL( object->Confidential() == (TBool)state );

   649 

   650     return KErrNone;

   651     }

   652 

   653 // -----------------------------------------------------------------------------

   654 // CMdETestScripter::SetConfidentialL

   655 // -----------------------------------------------------------------------------

   656 //

   657 TInt CMdETestScripter::SetConfidentialL( CStifItemParser& aItem )

   658     {

   659     TInt state;

   660 

   661     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   662     User::LeaveIfError( aItem.GetNextInt( state ));

   663 

   664     object->SetConfidential( (TBool)state );

   665 

   666     return KErrNone;

   667     }

   668 

   669 // -----------------------------------------------------------------------------

   670 // CMdETestScripter::PlaceholderL

   671 // -----------------------------------------------------------------------------

   672 //

   673 TInt CMdETestScripter::PlaceholderL( CStifItemParser& aItem )

   674     {

   675     TInt state;

   676 

   677     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   678     User::LeaveIfError( aItem.GetNextInt( state ));

   679     TL( object->Placeholder() == (TBool)state );

   680 

   681     return KErrNone;

   682     }

   683 

   684 // -----------------------------------------------------------------------------

   685 // CMdETestScripter::SetPlaceholderL

   686 // -----------------------------------------------------------------------------

   687 //

   688 TInt CMdETestScripter::SetPlaceholderL( CStifItemParser& aItem )

   689     {

   690     TInt state;

   691 

   692     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   693     User::LeaveIfError( aItem.GetNextInt( state ));

   694 

   695     object->SetPlaceholder( (TBool)state );

   696 

   697     return KErrNone;

   698     }

   699 

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

   701 // CMdETestScripter::MediaIdL

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

   703 //

   704 TInt CMdETestScripter::MediaIdL( CStifItemParser& aItem )

   705     {

   706     TInt mediaId;

   707 

   708     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   709     User::LeaveIfError( aItem.GetNextInt( mediaId ));

   710 

   711     TL( object->MediaId() == mediaId );

   712 

   713     return KErrNone;

   714     }

   715 

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

   717 // CMdETestScripter::SetMediaIdL

   718 // -----------------------------------------------------------------------------

   719 //

   720 TInt CMdETestScripter::SetMediaIdL( CStifItemParser& aItem )

   721     {

   722     TInt mediaId;

   723 

   724     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

   726 

   727     object->SetMediaId( mediaId );

   728 

   729     return KErrNone;

   730     }

   731 

   732 // -----------------------------------------------------------------------------

   733 // CMdETestScripter::UsageCountL

   734 // -----------------------------------------------------------------------------

   735 //

   736 TInt CMdETestScripter::UsageCountL( CStifItemParser& aItem )

   737     {

   738 

   739     TInt count;

   740 

   741     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

   743 

   744     TL( object->UsageCount() == count );

   745 

   746     return KErrNone;

   747     }

   748 

   749 // -----------------------------------------------------------------------------

   750 // CMdETestScripter::GuidL

   751 // -----------------------------------------------------------------------------

   752 //

   753 TInt CMdETestScripter::GuidL( CStifItemParser& aItem )

   754     {

   755     TInt mode;

   756 

   757     TInt guidHighExpected;

   758     TInt guidLowExpected;

   759     TInt64 guidHigh;

   760     TInt64 guidLow;

   761 

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

   763     if ( mode == EObject )

   764         {

   765         CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

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

   768         object->Guid( guidHigh, guidLow );

   769         }

   770     else if ( mode == ERelation )

   771         {

   772         CMdERelation* relation = SanitizeArrayIndexL( iRelationArray, *iRelationNameArray, aItem );

   773         User::LeaveIfError( aItem.GetNextInt( guidHighExpected ));

   774         User::LeaveIfError( aItem.GetNextInt( guidLowExpected ));     

   775         relation->Guid( guidHigh, guidLow );

   776         }

   777           

   778     TL( guidHighExpected == guidHigh );

   779     TL( guidLowExpected == guidLow );

   780 

   781     return KErrNone;

   782     }

   783 

   784 // -----------------------------------------------------------------------------

   785 // CMdETestScripter::SetGuidL

   786 // -----------------------------------------------------------------------------

   787 //

   788 TInt CMdETestScripter::SetGuidL( CStifItemParser& aItem )

   789     {

   790     TInt mode;

   791     

   792     TInt guidHigh;

   793     TInt guidLow;

   794 

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

   796     if ( mode == EObject )

   797         {

   798         CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

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

   801         object->SetGuid( guidHigh, guidLow );

   802         }

   803     else if ( mode == ERelation )

   804         {

   805         CMdERelation* relation = SanitizeArrayIndexL( iRelationArray, *iRelationNameArray, aItem );

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

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

   808         relation->SetGuid( guidHigh, guidLow );

   809         }

   810         

   811     return KErrNone;

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // CMdETestScripter::OpenForModifications

   816 // -----------------------------------------------------------------------------

   817 //

   818 TInt CMdETestScripter::OpenForModificationsL( CStifItemParser& aItem )

   819     {

   820     TInt open;

   821 

   822     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   823     User::LeaveIfError( aItem.GetNextInt( open ));

   824 

   825     TBool state = object->OpenForModifications();

   826     TL( (TBool)open == state );

   827 

   828     return KErrNone;

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // CMdETestScripter::NewObjectL

   833 // -----------------------------------------------------------------------------

   834 //

   835 TInt CMdETestScripter::NewObjectL( CStifItemParser& aItem )

   836     {

   837     TInt mode;

   838     CMdEObject* object = NULL;

   839 

   840     TPtrC name;

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

   842     

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

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

   845 

   846     if ( mode == KL )

   847         {

   848         object = iMdeSession->NewObjectL(

   849             *objectDef, MdeConstants::Object::KAutomaticUri );

   850         }

   851     else if ( mode == KLC )

   852         {

   853         object = iMdeSession->NewObjectLC(

   854             *objectDef, MdeConstants::Object::KAutomaticUri );

   855         CleanupStack::Pop( object );

   856         }

   857     else

   858         {

   859         User::Leave( KErrArgument );

   860         }

   861 

   862     TL( object );

   863     iObjectArray.Append( object );

   864     AppendNameL( iObjectNameArray, name );    

   865 

   866     return KErrNone;

   867     }

   868 

   869 // -----------------------------------------------------------------------------

   870 // CMdETestScripter::AddObjectL

   871 // -----------------------------------------------------------------------------

   872 //

   873 TInt CMdETestScripter::AddObjectL( CStifItemParser& aItem )

   874     {

   875     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   876 

   877     TItemId id = iMdeSession->AddObjectL( *object );

   878     TL( id != KNoId );

   879     TL( object->Id() == id );

   880 

   881     return KErrNone;

   882     }

   883 

   884 // -----------------------------------------------------------------------------

   885 // CMdETestScripter::AddObjectsL

   886 // -----------------------------------------------------------------------------

   887 //

   888 TInt CMdETestScripter::AddObjectsL( CStifItemParser& aItem )

   889     {

   890     TInt count;

   891     RPointerArray<CMdEObject> objectArray;

   892 

   893     TInt firstIndex = GetObjectIndexL( aItem );

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

   895 

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

   897         {

   898         objectArray.Append( iObjectArray[ firstIndex + i ] );

   899         }

   900 

   901     TInt err = iMdeSession->AddObjectsL( objectArray );

   902     objectArray.Reset();

   903     T1L ( err, KErrNone );

   904 

   905     return KErrNone;

   906     }

   907 

   908 // -----------------------------------------------------------------------------

   909 // CMdETestScripter::GetObjectL

   910 // -----------------------------------------------------------------------------

   911 //

   912 TInt CMdETestScripter::GetObjectL( CStifItemParser& aItem )

   913     {

   914     TPtrC name;

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

   916 

   917     TInt mode1;

   918     TInt mode2;

   919     CMdEObject* newObject = NULL;

   920     CMdEObjectDef* objectDef = NULL;

   921     CMdENamespaceDef* namespaceDef = NULL;

   922     TInt64 guidHigh = 0;

   923     TInt64 guidLow = 0;

   924 

   925     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

   926 

   927     User::LeaveIfError( aItem.GetNextInt( mode1 ));

   928     User::LeaveIfError( aItem.GetNextInt( mode2 ));

   929 

   930     if ( mode2 == EObjectDef )

   931         {

   932         objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

   933         }

   934         else if ( mode2 == ENamespaceDef )

   935         {

   936         namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

   937         }

   938 

   939     if ( mode1 == KById && mode2 == EObjectDef )

   940         {

   941         newObject = iMdeSession->GetObjectL( object->Id(), *objectDef );

   942         }

   943     else if ( mode1 == KById && mode2 == ENamespaceDef )

   944         {

   945         newObject = iMdeSession->GetObjectL( object->Id(), namespaceDef );

   946         }

   947     else if ( mode1 == KByUri && mode2 == EObjectDef )

   948         {

   949         newObject = iMdeSession->GetObjectL( object->Uri(), *objectDef );

   950         }

   951     else if ( mode1 == KByUri && mode2 == ENamespaceDef )

   952         {

   953         newObject = iMdeSession->GetObjectL( object->Uri(), namespaceDef );

   954         }

   955     else if ( mode1 == KByGuid && mode2 == EObjectDef )

   956         {

   957         object->Guid( guidHigh, guidLow );

   958         newObject = iMdeSession->GetObjectL( guidHigh, guidLow, *objectDef );

   959         }

   960     else if ( mode1 == KByGuid && mode2 == ENamespaceDef )

   961         {

   962         object->Guid( guidHigh, guidLow );

   963         newObject = iMdeSession->GetObjectL( guidHigh, guidLow, namespaceDef );

   964         }

   965     else

   966         {

   967         User::Leave( KErrArgument );

   968         }

   969 

   970     TL( newObject );

   971     iObjectArray.Append( newObject );   

   972     AppendNameL( iObjectNameArray, name );

   973 

   974     iLog->Log( _L( "Object Id = %d URI = %S Propertycount = %d" ),

   975         newObject->Id(), &newObject->Uri(), newObject->PropertyCount() );

   976 

   977     return KErrNone;

   978     }

   979 

   980 // -----------------------------------------------------------------------------

   981 // CMdETestScripter::GetFullObjectL

   982 // -----------------------------------------------------------------------------

   983 //

   984 TInt CMdETestScripter::GetFullObjectL( CStifItemParser& aItem )

   985     {

   986     TInt mode;

   987     CMdEObject* newObject = NULL;

   988     TPtrC name;

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

   990     

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

   992     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

   994     if ( mode == KById )

   995         {

   996         newObject = iMdeSession->GetFullObjectL( object->Id());

   997        }

   998     else if ( mode == KByUri )

   999         {

  1000         newObject = iMdeSession->GetFullObjectL( object->Uri());

  1001         }

  1002     else if ( mode == KByGuid )

  1003         {

  1004         TInt64 guidHigh;

  1005         TInt64 guidLow;

  1006 

  1007         object->Guid( guidHigh, guidLow );

  1008         newObject = iMdeSession->GetFullObjectL( guidHigh, guidLow );

  1009         }

  1010     else

  1011         {

  1012         User::Leave( KErrArgument );

  1013         }

  1014     TL( newObject );

  1015     iObjectArray.Append( newObject );

  1016     AppendNameL( iObjectNameArray, name );

  1017 

  1018     return KErrNone;

  1019     }

  1020 

  1021 // -----------------------------------------------------------------------------

  1022 // CMdETestScripter::CheckObjectL

  1023 // -----------------------------------------------------------------------------

  1024 //

  1025 TInt CMdETestScripter::CheckObjectL( CStifItemParser& aItem )

  1026     {

  1027     TInt objIndex;

  1028     TInt mode;

  1029     TMdEObject tObject;

  1030 

  1031     objIndex = GetObjectIndexL( aItem );

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

  1033 

  1034     if ( mode == KById )

  1035         {

  1036         iMdeSession->CheckObjectL( tObject, iObjectArray[ objIndex ]->Id() );

  1037         CheckTMdEObjectL( tObject, *iObjectArray[ objIndex ] );

  1038         }

  1039     else if ( mode == KByUri )

  1040         {

  1041         iMdeSession->CheckObjectL( tObject, iObjectArray[ objIndex ]->Uri() );

  1042         CheckTMdEObjectL( tObject, *iObjectArray[ objIndex ] );

  1043         }

  1044     else if ( mode == KByIds )

  1045         {

  1046         TInt count;

  1047         RArray<TItemId> ids;

  1048         RArray<TMdEObject> tObjects;

  1049 

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

  1051         TL( iObjectArray.Count() > objIndex + count - 1 );

  1052 

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

  1054             {

  1055             ids.Append( iObjectArray[ objIndex + i ]->Id() );

  1056             }

  1057         iMdeSession->CheckObjectL( tObjects, ids );

  1058         CheckTMdEObjectArrayL( tObjects, objIndex, count );

  1059 

  1060         tObjects.Reset();

  1061         ids.Reset();

  1062         }

  1063     else

  1064         {

  1065         User::Leave( KErrArgument );

  1066         }

  1067 

  1068     return KErrNone;

  1069     }

  1070 

  1071 // -----------------------------------------------------------------------------

  1072 // CMdETestScripter::RemoveObjectL

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 TInt CMdETestScripter::RemoveObjectL( CStifItemParser& aItem )

  1076     {

  1077     TInt mode;

  1078 

  1079     CMdEObject* object = SanitizeArrayIndexL( iObjectArray, *iObjectNameArray, aItem );

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

  1081 

  1082     TItemId id = KNoId;

  1083 

  1084     if ( mode == KById )

  1085         {

  1086         id = iMdeSession->RemoveObjectL( object->Id() );

  1087         }

  1088     else if ( mode == KByUri )

  1089         {

  1090         id = iMdeSession->RemoveObjectL( object->Uri() );

  1091         }

  1092     else

  1093         {

  1094         User::Leave( KErrArgument );

  1095         }

  1096 

  1097     TL( id != KNoId );

  1098 

  1099     return KErrNone;

  1100     }

  1101 

  1102 // -----------------------------------------------------------------------------

  1103 // CMdETestScripter::RemoveObjectsL

  1104 // -----------------------------------------------------------------------------

  1105 //

  1106 TInt CMdETestScripter::RemoveObjectsL( CStifItemParser& aItem )

  1107     {

  1108     TInt mode1;

  1109     TInt mode2;

  1110     TInt objIndex;

  1111     TInt count;

  1112     TInt needMacroVerifyResult;

  1113     RArray<TItemId> objectIdArray;

  1114     RPointerArray<TDesC> objectUriArray;

  1115     RArray<TItemId> successful;

  1116     TRequestStatus status = KRequestPending;

  1117 

  1118     User::LeaveIfError( aItem.GetNextInt( mode1 ));

  1119     User::LeaveIfError( aItem.GetNextInt( mode2 ));

  1120     objIndex = GetObjectIndexL( aItem );

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

  1122     TL( iObjectArray.Count() > objIndex + count - 1 );

  1123     TRAPD( err, aItem.GetNextInt( needMacroVerifyResult ) );

  1124     if ( KErrNone != err )

  1125         {

  1126         needMacroVerifyResult = 1;

  1127         }

  1128 

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

  1130         {

  1131         if ( mode2 == KById )

  1132             {

  1133             objectIdArray.Append( iObjectArray[ objIndex + i ]->Id() );

  1134             }