1 /*

     2  * Copyright (c) 2002 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:        Implementation of Module Test Automation Code for 

    15  *  Provisioning  

    16  *

    17  */

    18 

    19 // INCLUDE FILES

    20 #include <e32svr.h>

    21 #include <e32def.h>

    22 #include <StifParser.h>

    23 #include <Stiftestinterface.h>

    24 #include "moduletestprovisioning.h"

    25 #include <PushMessage.h>

    26 #include <MWPPhone.h>

    27 #include "CWPBootstrap.h"

    28 #include "CWPAdapter.h"

    29 #include "ProvisioningUIDs.h"

    30 #include <S32FILE.h>

    31 #include <S32STOR.h>

    32 #include <S32STD.h>

    33 #include <CWPParameter.h>

    34 #include <CWPCharacteristic.h>

    35 #include <WPAdapterUtil.h>

    36 #include "MWPBuilder.h"

    37 #include <WPWVAdapterResource.rsg>

    38 #include "ProvisioningInternalCRKeys.h"

    39 #include <centralrepository.h>

    40 #include <commdb.h>

    41 #include <ApAccessPointItem.h>

    42 #include <ApDataHandler.h>

    43 

    44 

    45 // EXTERNAL DATA STRUCTURES

    46 //extern  ?external_data;

    47 

    48 // EXTERNAL FUNCTION PROTOTYPES  

    49 //extern ?external_function( ?arg_type,?arg_type );

    50 

    51 // CONSTANTS

    52 //const ?type ?constant_var = ?constant;

    53 

    54 // MACROS

    55 //#define ?macro ?macro_def

    56 

    57 // LOCAL CONSTANTS AND MACROS

    58 //const ?type ?constant_var = ?constant;

    59 //#define ?macro_name ?macro_def

    60 

    61 // MODULE DATA STRUCTURES

    62 //enum ?declaration

    63 //typedef ?declaration

    64 

    65 // LOCAL FUNCTION PROTOTYPES

    66 //?type ?function_name( ?arg_type, ?arg_type );

    67 

    68 // FORWARD DECLARATIONS

    69 //class ?FORWARD_CLASSNAME;

    70 

    71 // ============================= LOCAL FUNCTIONS ===============================

    72 

    73 // -----------------------------------------------------------------------------

    74 // ?function_name ?description.

    75 // ?description

    76 // Returns: ?value_1: ?description

    77 //          ?value_n: ?description_line1

    78 //                    ?description_line2

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

    80 //

    81 /*

    82  ?type ?function_name(

    83  ?arg_type arg,  // ?description

    84  ?arg_type arg)  // ?description

    85  {

    86 

    87  ?code  // ?comment

    88 

    89  // ?comment

    90  ?code

    91  }

    92  */

    93 

    94 // ============================ MEMBER FUNCTIONS ===============================

    95 

    96 // -----------------------------------------------------------------------------

    97 // Cmoduletestprovisioning::Delete

    98 // Delete here all resources allocated and opened from test methods. 

    99 // Called from destructor. 

   100 // -----------------------------------------------------------------------------

   101 //

   102 void Cmoduletestprovisioning::Delete()

   103     {

   104 

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 // Cmoduletestprovisioning::RunMethodL

   109 // Run specified method. Contains also table of test mothods and their names.

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

   111 //

   112 TInt Cmoduletestprovisioning::RunMethodL(CStifItemParser& aItem)

   113     {

   114 

   115     TStifFunctionInfo const

   116             KFunctions[] =

   117                 {

   118                 // Copy this line for every implemented function.

   119                         // First string is the function name used in TestScripter script file.

   120                         // Second is the actual implementation member function. 

   121                         // Copy this line for every implemented function.

   122                         // First string is the function name used in TestScripter script file.

   123                         // Second is the actual implementation member function. 

   124                         ENTRY("Example", Cmoduletestprovisioning::ExampleL),

   125                         ENTRY("Create",

   126                                 Cmoduletestprovisioning::CreateandDeleteL),

   127                         ENTRY("CreateNewL",

   128                                 Cmoduletestprovisioning::CreateandDeleteNewL),

   129                         ENTRY("Import",

   130                                 Cmoduletestprovisioning::ImportDocumentL),

   131                         ENTRY("Populate", Cmoduletestprovisioning::PopulateL),

   132                         ENTRY("ItemCount",

   133                                 Cmoduletestprovisioning::ItemCountL),

   134                         ENTRY("InternAndExtern",

   135                                 Cmoduletestprovisioning::InternAndExternL),

   136                         ENTRY("Save", Cmoduletestprovisioning::SaveL),

   137                         ENTRY("Summary",

   138                                 Cmoduletestprovisioning::SummaryTitleandTextL),

   139                         ENTRY("SetAsDefault",

   140                                 Cmoduletestprovisioning::SetAsDefaultL),

   141                         ENTRY("StoreAndRestore",

   142                                 Cmoduletestprovisioning::StoreAndRestoreL),

   143                         ENTRY("Details", Cmoduletestprovisioning::DetailsL),

   144                         ENTRY("CreateContext",

   145                                 Cmoduletestprovisioning::CreateContextL),

   146                         ENTRY("DeleteContext",

   147                                 Cmoduletestprovisioning::DeleteContextL),

   148                         ENTRY("ContextDataCount",

   149                                 Cmoduletestprovisioning::ContextDataCountL),

   150                         ENTRY("ContextUids",

   151                                 Cmoduletestprovisioning::ContextUidsL),

   152                         ENTRY("ContextName",

   153                                 Cmoduletestprovisioning::ContextNameL),

   154                         ENTRY("ContextTPS",

   155                                 Cmoduletestprovisioning::ContextTPSL),

   156                         ENTRY("ContextProxies",

   157                                 Cmoduletestprovisioning::ContextProxiesL),

   158                         ENTRY("Context", Cmoduletestprovisioning::ContextL),

   159                         ENTRY("Builder", Cmoduletestprovisioning::BuilderL),

   160                         ENTRY("CurrentContext",

   161                                 Cmoduletestprovisioning::CurrentContextL),

   162                         ENTRY("CreateparameterNewL",

   163                                 Cmoduletestprovisioning::CreateparameterNewL),

   164                         ENTRY("CreateparameterNewLC",

   165                                 Cmoduletestprovisioning::CreateparameterNewL),

   166                         ENTRY("CSetandGetparamID",

   167                                 Cmoduletestprovisioning::CSetandGetparamIDL),

   168                         ENTRY("CSetandGetparamName",

   169                                 Cmoduletestprovisioning::CSetandGetparamNameL),

   170                         ENTRY(

   171                                 "CSetandGetparamValue",

   172                                 Cmoduletestprovisioning::CSetandGetparamValueL),

   173                         ENTRY(

   174                                 "InternAndExternparam",

   175                                 Cmoduletestprovisioning::InternAndExternparamL),

   176                         ENTRY("GetparamType",

   177                                 Cmoduletestprovisioning::GetparamTypeL),

   178                         ENTRY(

   179                                 "InsertCharacteristic",

   180                                 Cmoduletestprovisioning::InsertCharacteristicL),

   181                         ENTRY(

   182                                 "InsertLinkCharacteristic",

   183                                 Cmoduletestprovisioning::InsertLinkCharacteristicL),

   184                         ENTRY(

   185                                 "SetandGetCharactername",

   186                                 Cmoduletestprovisioning::SetandGetCharacternameL),

   187                         ENTRY(

   188                                 "SetDataCharacteristic",

   189                                 Cmoduletestprovisioning::SetDataCharacteristicL),

   190                         ENTRY(

   191                                 "SetIndexDataCharacteristic",

   192                                 Cmoduletestprovisioning::SetIndexDataCharacteristicL),

   193                         ENTRY(

   194                                 "DeleteAllDataCharacteristic",

   195                                 Cmoduletestprovisioning::DeleteAllDataCharacteristicL),

   196                         ENTRY(

   197                                 "GetParamValuecharactristic",

   198                                 Cmoduletestprovisioning::GetParamValuecharactristicL),

   199                         ENTRY("Accesspoint",

   200                                 Cmoduletestprovisioning::AccesspointL),

   201                         ENTRY("ReadBuf", Cmoduletestprovisioning::ReadHBufCL),

   202                         ENTRY("CheckURI", Cmoduletestprovisioning::CheckURI),

   203                         ENTRY("CheckIPV6", Cmoduletestprovisioning::CheckIPV6),

   204                         ENTRY("CheckIPV4", Cmoduletestprovisioning::CheckIPV4),

   205                         ENTRY("CWPAdapter",

   206                                 Cmoduletestprovisioning::CWPAdapterL),

   207                         ENTRY("DeleteContextData",

   208                                 Cmoduletestprovisioning::DeleteContextDataL),

   209                         ENTRY("ContextExistsForUid",

   210                                 Cmoduletestprovisioning::ContextExistsForUidL),

   211                         ENTRY("ContextExistsForTPS",

   212                                 Cmoduletestprovisioning::ContextExistsForTPSL),

   213                         ENTRY("ExternparamL",

   214                                 Cmoduletestprovisioning::ExternparamL),

   215                         ENTRY(

   216                                 "RegisterContextObserver",

   217                                 Cmoduletestprovisioning::RegisterContextObserverL),

   218                         ENTRY(

   219                                 "UnRegisterContextObserver",

   220                                 Cmoduletestprovisioning::UnRegisterContextObserverL),

   221         				ENTRY("SetAPDetails",

   222                                 Cmoduletestprovisioning::SetAPDetailsL),

   223                         ENTRY("GetAPID", Cmoduletestprovisioning::GetAPIDL),

   224                 };

   225 

   226     const TInt count = sizeof(KFunctions) / sizeof(TStifFunctionInfo);

   227 

   228     return RunInternalL(KFunctions, count, aItem);

   229 

   230     }

   231 

   232 // -----------------------------------------------------------------------------

   233 // Cmoduletestprovisioning::CreateandDeleteL

   234 // Example test method function.

   235 // (other items were commented in a header).

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

   237 //

   238 TInt Cmoduletestprovisioning::CreateandDeleteL()

   239     {

   240     CWPEngine* engine = CWPEngine::NewLC();

   241     CleanupStack::PopAndDestroy();

   242     return KErrNone;

   243     }

   244 

   245 // -----------------------------------------------------------------------------

   246 // Cmoduletestprovisioning::CreateandDeleteNewL

   247 // Example test method function.

   248 // (other items were commented in a header).

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

   250 //

   251 TInt Cmoduletestprovisioning::CreateandDeleteNewL()

   252     {

   253     CWPEngine* engine = CWPEngine::NewL();

   254     delete engine;

   255     return KErrNone;

   256     }

   257 

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

   259 // Cmoduletestprovisioning::SetUpEngineL

   260 // Example test method function.

   261 // (other items were commented in a header).

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

   263 //

   264 void Cmoduletestprovisioning::SetUpEngineL()

   265     {

   266     iEngine = CWPEngine::NewL();

   267     }

   268 

   269 // -----------------------------------------------------------------------------

   270 // Cmoduletestprovisioning::ImportDocumentL

   271 // Example test method function.

   272 // (other items were commented in a header).

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

   274 //

   275 TInt Cmoduletestprovisioning::ImportDocumentL(CStifItemParser& aItem)

   276     {

   277     TPtrC string;

   278     TInt error = aItem.GetNextString(string);

   279     if (error != KErrNone)

   280         {

   281         return error;

   282 

   283         }

   284     HBufC8* buf8 = GetfilecontentsL(string);

   285     TPtr8 buf8Ptr = buf8->Des();

   286 

   287     CWPEngine* engine = CWPEngine::NewLC();

   288     TRAPD(err, engine->ImportDocumentL(buf8Ptr));

   289 

   290     CleanupStack::PopAndDestroy();//engine

   291     delete buf8;//buf

   292 

   293     if (err == KErrNone)

   294         return KErrNone;

   295 

   296     else

   297         return err;

   298 

   299     }

   300 // -----------------------------------------------------------------------------

   301 // Cmoduletestprovisioning::CreateandDeleteL

   302 // Example test method function.

   303 // (other items were commented in a header).

   304 // -----------------------------------------------------------------------------

   305 //

   306 TInt Cmoduletestprovisioning::PopulateL()

   307     {

   308     SetUpEngineL();

   309     TRAPD(err, iEngine->PopulateL());

   310 

   311     if (err != KErrNone)

   312         return err;

   313 

   314     else

   315         return KErrNone;

   316     }

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

   318 // Cmoduletestprovisioning::ImportL

   319 // Example test method function.

   320 // (other items were commented in a header).

   321 // -----------------------------------------------------------------------------

   322 //

   323 

   324 TInt Cmoduletestprovisioning::ImportL(CStifItemParser& aItem)

   325     {

   326     TPtrC string;

   327 

   328     TInt error = aItem.GetNextString(string);

   329     if (error != KErrNone)

   330         {

   331         return error;

   332 

   333         }

   334 

   335     HBufC8 *buf8 = GetfilecontentsL(string);

   336     TPtr8 buf8Ptr = buf8->Des();

   337 

   338     iEngine = CWPEngine::NewL();

   339     TRAPD(err, iEngine->ImportDocumentL(buf8Ptr));

   340 

   341     delete buf8;

   342     if (err != KErrNone)

   343         return err;

   344     else

   345         return KErrNone;

   346     }

   347 

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

   349 // Cmoduletestprovisioning::ItemCountL

   350 // Example test method function.

   351 // (other items were commented in a header).

   352 // -----------------------------------------------------------------------------

   353 //

   354 

   355 TInt Cmoduletestprovisioning::ItemCountL(CStifItemParser& aItem)

   356     {

   357     TInt err = ImportL(aItem);

   358 

   359     TRAPD(err1, iEngine->PopulateL());

   360 

   361     if (err1 != KErrNone || err != KErrNone)

   362         return err1;

   363 

   364     TInt count = iEngine->ItemCount();

   365 

   366     if (count == 0)

   367         {

   368 

   369         return KErrGeneral;

   370         }

   371     else

   372         {

   373         return KErrNone;

   374         }

   375     }

   376 

   377 // -----------------------------------------------------------------------------

   378 // Cmoduletestprovisioning::SaveL

   379 // Example test method function.

   380 // (other items were commented in a header).

   381 // -----------------------------------------------------------------------------

   382 //

   383 

   384 TInt Cmoduletestprovisioning::SaveL(CStifItemParser& aItem)

   385     {

   386 

   387     TInt err = ImportL(aItem);

   388     TBool flag = ETrue;

   389     TInt errSave = KErrNone;

   390 

   391     TRAPD(err1, iEngine->PopulateL());

   392 

   393     if (err1 != KErrNone || err != KErrNone)

   394         {

   395         return err1;

   396         }

   397 

   398     TInt count = iEngine->ItemCount();

   399 

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

   401         {

   402         TRAP(errSave, iEngine->SaveL(i));

   403         if (errSave != KErrNone)

   404             {

   405 

   406             flag = EFalse;

   407             break;

   408             }

   409         }

   410 

   411     if (flag == EFalse)

   412         {

   413 

   414         return errSave;

   415         }

   416     else

   417         {

   418         return KErrNone;

   419         }

   420 

   421     }

   422 

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

   424 // Cmoduletestprovisioning::SummaryTitleandTextL

   425 // Example test method function.

   426 // (other items were commented in a header).

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

   428 //

   429 

   430 TInt Cmoduletestprovisioning::SummaryTitleandTextL(CStifItemParser& aItem)

   431     {

   432     TInt err = ImportL(aItem);

   433 

   434     TRAPD(err1, iEngine->PopulateL());

   435 

   436     if (err1 != KErrNone || err != KErrNone)

   437         {

   438         return err1;

   439         }

   440 

   441     TInt count = iEngine->ItemCount();

   442 

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

   444         {

   445         TBuf<30> ibuf1(iEngine->SummaryTitle(i));

   446         TBuf<30> ibuf2(iEngine->SummaryText(i));

   447         TestModuleIf().Printf(i, ibuf1, ibuf2);

   448 

   449         }

   450 

   451     return KErrNone;

   452     }

   453 

   454 // -----------------------------------------------------------------------------

   455 // Cmoduletestprovisioning::InternAndExternL

   456 // Example test method function.

   457 // (other items were commented in a header).

   458 // -----------------------------------------------------------------------------

   459 //

   460 

   461 TInt Cmoduletestprovisioning::InternAndExternL(CStifItemParser& aItem)

   462     {

   463 

   464     CStreamStore* store = CBufStore::NewLC(5000);

   465     TBuf8<1000> buf1;

   466     TInt err = ImportL(aItem);

   467     RStoreWriteStream writeStream;

   468     TStreamId id(writeStream.CreateLC(*store));

   469 

   470     iEngine->ExternalizeL(writeStream);

   471     writeStream.CommitL();

   472     CleanupStack::PopAndDestroy();

   473 

   474     RStoreReadStream instream;

   475     instream.OpenLC(*store, id);

   476 

   477     iEngine->InternalizeL(instream);

   478 

   479     CleanupStack::PopAndDestroy();//instream

   480     CleanupStack::PopAndDestroy();//store

   481 

   482     return KErrNone;

   483 

   484     }

   485 

   486 // -----------------------------------------------------------------------------

   487 // Cmoduletestprovisioning::SetAsDefaultL

   488 // Example test method function.

   489 // (other items were commented in a header).

   490 // -----------------------------------------------------------------------------

   491 //

   492 TInt Cmoduletestprovisioning::SetAsDefaultL(CStifItemParser& aItem)

   493     {

   494 

   495     TInt err = ImportL(aItem);

   496 

   497     TRAPD(err1, iEngine->PopulateL());

   498 

   499     if (err1 != KErrNone || err != KErrNone)

   500         {

   501         return err1;

   502         }

   503 

   504     TInt count = iEngine->ItemCount();

   505 

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

   507         {

   508 

   509         TRAPD(errSave, iEngine->SaveL(i));

   510         if (errSave == KErrNone)

   511             {

   512 

   513             if (iEngine->CanSetAsDefault(i))

   514                 {

   515                 TRAPD(errdefset, iEngine->SetAsDefaultL(i));

   516                 if (errdefset)

   517                     {

   518                     return errdefset;

   519                     }

   520                 }

   521 

   522             }

   523 

   524         else

   525             {

   526             return errSave;

   527             }

   528         }

   529 

   530     return KErrNone;

   531 

   532     }

   533 

   534 // -----------------------------------------------------------------------------

   535 // Cmoduletestprovisioning::StoreAndRestoreL

   536 // Example test method function.

   537 // (other items were commented in a header).

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

   539 //

   540 

   541 TInt Cmoduletestprovisioning::StoreAndRestoreL(CStifItemParser& aItem)

   542     {

   543 

   544     TInt err = ImportL(aItem);

   545     CStreamStore* store = CBufStore::NewLC(5000);

   546     TStreamId id(iEngine->StoreL(*store));

   547     iEngine->RestoreL(*store, id);

   548     CleanupStack::PopAndDestroy();

   549 

   550     if (err != KErrNone)

   551         return err;

   552     else

   553         return KErrNone;

   554 

   555     }

   556 

   557 // -----------------------------------------------------------------------------

   558 // Cmoduletestprovisioning::DetailsL

   559 // Example test method function.

   560 // (other items were commented in a header).

   561 // -----------------------------------------------------------------------------

   562 //

   563 

   564 TInt Cmoduletestprovisioning::DetailsL(CStifItemParser& aItem)

   565     {

   566 

   567     TInt err = ImportL(aItem);

   568 

   569     TRAPD(err1, iEngine->PopulateL());

   570 

   571     if (err1 != KErrNone || err != KErrNone)

   572         {

   573         return err1;

   574         }

   575 

   576     MWPPairVisitor *visitor = NULL;

   577 

   578     TInt error = iEngine->DetailsL(0, *visitor);

   579 

   580     if (error == KErrNotSupported)

   581         return KErrNone;

   582     else

   583         return KErrNone;

   584 

   585     }

   586 

   587 // -----------------------------------------------------------------------------

   588 // Cmoduletestprovisioning::CreateContextL

   589 // Example test method function.

   590 // (other items were commented in a header).

   591 // -----------------------------------------------------------------------------

   592 //

   593 

   594 TInt Cmoduletestprovisioning::CreateContextL(CStifItemParser& aItem)

   595     {

   596 

   597     TBuf<30> tps;

   598 

   599     _LIT(KProxy, "PROXY_TEST");

   600     _LIT(KTPS, "TPS");

   601     _LIT(KName, "TEST_CASE_CONTEXT");

   602 

   603     TBuf<256> proxies(KProxy);

   604     TBuf<256> Names(KName);

   605     TBuf<256> Tps(KTPS);

   606 

   607     iProxies->InsertL(0, proxies);

   608 

   609     iEngine = CWPEngine::NewL();

   610 

   611     TUint32 origUid1 = iEngine -> ContextExistsL(Tps);

   612     //TRAPD(err,iEngine -> ContextExistsL(Tps));

   613 

   614     if (origUid1)

   615         {

   616         TUint32 contextuid = iEngine -> ContextL(Tps);

   617         iEngine -> DeleteContextL(contextuid);

   618         }

   619 

   620     TUint32 origUid(iEngine -> CreateContextL(Names, Tps, *iProxies));

   621 

   622     return KErrNone;

   623     }

   624 

   625 // -----------------------------------------------------------------------------

   626 // Cmoduletestprovisioning::DeleteContextL

   627 // Example test method function.

   628 // (other items were commented in a header).

   629 // -----------------------------------------------------------------------------

   630 //

   631 

   632 TInt Cmoduletestprovisioning::DeleteContextL(CStifItemParser& aItem)

   633     {

   634 

   635     TUint32 origUid(ContextcreateL());

   636 

   637     iEngine -> DeleteContextL(origUid);

   638 

   639     return KErrNone;

   640 

   641     }

   642 

   643 // -----------------------------------------------------------------------------

   644 // Cmoduletestprovisioning::CreateDataCountL

   645 // Example test method function.

   646 // (other items were commented in a header).

   647 // -----------------------------------------------------------------------------

   648 //

   649 

   650 TInt Cmoduletestprovisioning::ContextDataCountL()

   651     {

   652 

   653     TUint32 origUid(ContextcreateL());

   654 

   655     TInt DataCount = iEngine->ContextDataCountL(origUid);

   656 

   657     iEngine -> DeleteContextL(origUid);

   658 

   659     if (DataCount == 0)

   660         return KErrNone;

   661     else

   662         return KErrNone;

   663 

   664     }

   665 

   666 // -----------------------------------------------------------------------------

   667 // Cmoduletestprovisioning::ContextL

   668 // Example test method function.

   669 // (other items were commented in a header).

   670 // -----------------------------------------------------------------------------

   671 //

   672 

   673 TInt Cmoduletestprovisioning::ContextL(CStifItemParser& aItem)

   674     {

   675     TBuf<30> tps;

   676     TPtrC string;

   677     TUint32 origUid, retUid;

   678     TBool Failed = EFalse;

   679     _LIT(KProxy, "PROXY_TEST");

   680     _LIT(KTPS, "TPS");

   681     _LIT(KName, "TEST_CASE_CONTEXT");

   682     TBuf<256> proxiesdata(KProxy);

   683     TBuf<256> Names(KName);

   684     TBuf<256> Tps(KTPS);

   685     CDesC16Array* proxies;

   686     proxies = new (ELeave) CDesC16ArrayFlat(1);

   687     CleanupStack::PushL(proxies);

   688     proxies->InsertL(0, proxiesdata);

   689 

   690     TInt error = aItem.GetNextString(string);

   691     if (error != KErrNone)

   692         {

   693         return error;

   694 

   695         }

   696 

   697     iEngine = CWPEngine::NewL();

   698 

   699     if (iEngine -> ContextExistsL(string))

   700         {

   701         retUid = iEngine -> ContextL(string);

   702         if (retUid == 0)

   703             Failed = ETrue;

   704         }

   705     else

   706         {

   707         origUid = iEngine -> CreateContextL(Names, Tps, *proxies);

   708 

   709         //origUid = ContextcreateL();

   710 

   711         retUid = iEngine -> ContextL(string);

   712         if (retUid != origUid)

   713             Failed = ETrue;

   714         }

   715 

   716     CleanupStack::PopAndDestroy();

   717 

   718     if (Failed)

   719         return KErrGeneral;

   720     else

   721         return KErrNone;

   722 

   723     }

   724 

   725 // -----------------------------------------------------------------------------

   726 // Cmoduletestprovisioning::ContextcreateL

   727 // Example test method function.

   728 // (other items were commented in a header).

   729 // -----------------------------------------------------------------------------

   730 //

   731 

   732 TUint32 Cmoduletestprovisioning::ContextcreateL()

   733     {

   734     TBuf<30> tps;

   735     TPtrC string;

   736 

   737     TBuf<256> proxies(KProxy);

   738     TBuf<256> Names(KName);

   739     TBuf<256> Tps(KTPS);

   740 

   741     iProxies->InsertL(0, proxies);

   742 

   743     iEngine = CWPEngine::NewL();

   744     if (iEngine -> ContextExistsL(Tps))

   745         return (iEngine -> ContextL(Tps));

   746 

   747     TUint32 origUid(iEngine -> CreateContextL(Names, Tps, *iProxies));

   748 

   749     return origUid;

   750     }

   751 

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

   753 // Cmoduletestprovisioning::CreateDataCountL

   754 // Example test method function.

   755 // (other items were commented in a header).

   756 // -----------------------------------------------------------------------------

   757 //

   758 

   759 TInt Cmoduletestprovisioning::ContextUidsL()

   760     {

   761 

   762     TUint32 origUid(ContextcreateL());

   763 

   764     CArrayFix<TUint32>* array = iEngine->ContextUidsL();

   765     CleanupStack::PushL(array);

   766 

   767     TUint32 retrUid(array->At(0));

   768 

   769     iEngine -> DeleteContextL(origUid);

   770 

   771     CleanupStack::PopAndDestroy(); // array

   772 

   773 

   774     if (origUid != retrUid)

   775         return KErrGeneral;

   776     else

   777         return KErrNone;

   778     }

   779 

   780 // -----------------------------------------------------------------------------

   781 // Cmoduletestprovisioning::ContextNameL

   782 // Example test method function.

   783 // (other items were commented in a header).

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

   785 //

   786 

   787 TInt Cmoduletestprovisioning::ContextNameL()

   788     {

   789 

   790     TUint32 origUid(ContextcreateL());

   791     TInt ErrorNum;

   792 

   793     CArrayFix<TUint32>* array = iEngine->ContextUidsL();

   794     CleanupStack::PushL(array);

   795 

   796     TUint32 retrUid(array->At(0));

   797 

   798     HBufC* name = iEngine->ContextNameL(retrUid);

   799     CleanupStack::PushL(name);

   800 

   801     if (*name == KName)

   802         ErrorNum = KErrNone;

   803     else

   804         ErrorNum = KErrGeneral;

   805 

   806     CleanupStack::PopAndDestroy(); //  name

   807 

   808     iEngine -> DeleteContextL(origUid);

   809 

   810     CleanupStack::PopAndDestroy(); // array

   811 

   812 

   813     return ErrorNum;

   814     }

   815 

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

   817 // Cmoduletestprovisioning::CreateTPSL

   818 // Example test method function.

   819 // (other items were commented in a header).

   820 // -----------------------------------------------------------------------------

   821 //

   822 

   823 TInt Cmoduletestprovisioning::ContextTPSL()

   824     {

   825 

   826     TUint32 origUid(ContextcreateL());

   827     TInt ErrorNum;

   828 

   829     CArrayFix<TUint32>* array = iEngine->ContextUidsL();

   830     CleanupStack::PushL(array);

   831 

   832     TUint32 retrUid(array->At(0));

   833 

   834     HBufC* tps = iEngine->ContextTPSL(retrUid);

   835     CleanupStack::PushL(tps);

   836 

   837     if (*tps == KTPS)

   838         ErrorNum = KErrNone;

   839     else

   840         ErrorNum = KErrGeneral;

   841 

   842     CleanupStack::PopAndDestroy(); //  name

   843 

   844     iEngine -> DeleteContextL(origUid);

   845 

   846     CleanupStack::PopAndDestroy(); // array

   847 

   848 

   849     return ErrorNum;

   850     }

   851 

   852 // -----------------------------------------------------------------------------

   853 // Cmoduletestprovisioning::ContextProxiesL

   854 // Example test method function.

   855 // (other items were commented in a header).

   856 // -----------------------------------------------------------------------------

   857 //

   858 

   859 TInt Cmoduletestprovisioning::ContextProxiesL()

   860     {

   861 

   862     TUint32 origUid(ContextcreateL());

   863     TInt ErrorNum;

   864 

   865     CArrayFix<TUint32>* array = iEngine->ContextUidsL();

   866     CleanupStack::PushL(array);

   867 

   868     TUint32 retrUid(array->At(0));

   869 

   870     CDesCArray *proxies = iEngine->ContextProxiesL(retrUid);

   871     CleanupStack::PushL(proxies);

   872 

   873     if (proxies->MdcaPoint(0) == KProxy)

   874         ErrorNum = KErrNone;

   875     else

   876         ErrorNum = KErrGeneral;

   877 

   878     CleanupStack::PopAndDestroy(); //  name

   879 

   880     iEngine -> DeleteContextL(origUid);

   881 

   882     CleanupStack::PopAndDestroy(); // array

   883 

   884     return ErrorNum;

   885     }

   886 

   887 // -----------------------------------------------------------------------------

   888 // Cmoduletestprovisioning::GetfilecontentsL

   889 // Example test method function.

   890 // (other items were commented in a header).

   891 // -----------------------------------------------------------------------------

   892 //

   893 HBufC8* Cmoduletestprovisioning::GetfilecontentsL(TPtrC aString)

   894     {

   895     RFs fs;

   896     User::LeaveIfError(fs.Connect());

   897     CleanupClosePushL(fs);

   898     RFile file;

   899 

   900     TInt err = file.Open(fs, aString, EFileShareAny);

   901     if (err != KErrNone)

   902         {

   903         CleanupStack::PopAndDestroy();//fs

   904         User::LeaveIfError(err);

   905         }

   906 

   907     CleanupClosePushL(file);

   908     TInt size;

   909     file.Size(size);

   910     HBufC8 *buf8 = HBufC8::NewLC(size);

   911     TPtr8 buf8Ptr = buf8->Des();

   912     file.Read(buf8Ptr);

   913     CleanupStack::Pop(buf8);

   914     CleanupStack::PopAndDestroy();//file

   915     CleanupStack::PopAndDestroy();//fs

   916     return buf8;

   917     }

   918 

   919 // -----------------------------------------------------------------------------

   920 // Cmoduletestprovisioning::ExampleL

   921 // Example test method function.

   922 // (other items were commented in a header).

   923 // -----------------------------------------------------------------------------

   924 //

   925 TInt Cmoduletestprovisioning::ExampleL(CStifItemParser& aItem)

   926     {

   927 

   928     // Print to UI

   929     _LIT(Ktestengineapis, "testengineapis");

   930     _LIT(KExample, "In Example");

   931     TestModuleIf().Printf(0, Ktestengineapis, KExample);

   932     // Print to log file

   933     iLog->Log(KExample);

   934 

   935     TInt i = 0;

   936     TPtrC string;

   937     _LIT(KParam, "Param[%i]: %S");

   938     while (aItem.GetNextString(string) == KErrNone)

   939         {

   940         TestModuleIf().Printf(i, Ktestengineapis, KParam, i, &string);

   941         i++;

   942         }

   943 

   944     return KErrNone;

   945 

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // Cmoduletestprovisioning::ExampleL

   950 // Example test method function.

   951 // (other items were commented in a header).

   952 // -----------------------------------------------------------------------------

   953 //

   954 TInt Cmoduletestprovisioning::BuilderL()

   955     {

   956     MWPBuilder* builder;

   957     CWPEngine* engine = CWPEngine::NewLC();

   958     *builder = engine -> Builder();

   959     CleanupStack::PopAndDestroy();//fs

   960     return KErrNone;

   961 

   962     }

   963 

   964 // -----------------------------------------------------------------------------

   965 // Cmoduletestprovisioning::ExampleL

   966 // Example test method function.

   967 // (other items were commented in a header).

   968 // -----------------------------------------------------------------------------

   969 //

   970 TInt Cmoduletestprovisioning::CurrentContextL()

   971     {

   972     TUint32 contextuid = ContextcreateL();

   973 

   974     iEngine->SetCurrentContextL(contextuid);

   975 

   976     TUint32 retUid = iEngine->CurrentContextL();

   977 

   978     if (contextuid == retUid)

   979         {

   980         return KErrNone;

   981         }

   982     else

   983         {

   984         return KErrGeneral;

   985         }

   986     }

   987 

   988 // -----------------------------------------------------------------------------

   989 // Cmoduletestprovisioning::CreateparameterNewL

   990 // Example test method function.

   991 // (other items were commented in a header).

   992 // -----------------------------------------------------------------------------

   993 //

   994 TInt Cmoduletestprovisioning::CreateparameterNewL()

   995     {

   996     CWPParameter* param = CWPParameter::NewL();

   997     delete param;

   998     return KErrNone;

   999     }

  1000 

  1001 // -----------------------------------------------------------------------------

  1002 // Cmoduletestprovisioning::CreateparameterNewL

  1003 // Example test method function.

  1004 // (other items were commented in a header).

  1005 // -----------------------------------------------------------------------------

  1006 //

  1007 TInt Cmoduletestprovisioning::CreateparameterNewLC()

  1008     {

  1009     CWPParameter* param = CWPParameter::NewLC();

  1010     CleanupStack::PopAndDestroy();

  1011     return KErrNone;

  1012 

  1013     }

  1014 

  1015 // -----------------------------------------------------------------------------

  1016 // Cmoduletestprovisioning::CSetandGetparamID

  1017 // Example test method function.

  1018 // (other items were commented in a header).

  1019 // -----------------------------------------------------------------------------

  1020 //

  1021 TInt Cmoduletestprovisioning::CSetandGetparamIDL()

  1022     {

  1023     CWPParameter* param = CWPParameter::NewLC();

  1024     TInt aID = 10;

  1025     param -> SetID(aID);

  1026     TInt getID = param ->ID();

  1027     if (aID != getID)

  1028         {

  1029         CleanupStack::PopAndDestroy();

  1030         return KErrGeneral;

  1031         }

  1032     else

  1033         {

  1034         CleanupStack::PopAndDestroy();

  1035         return KErrNone;

  1036 

  1037         }

  1038 

  1039     }

  1040 

  1041 // -----------------------------------------------------------------------------

  1042 // Cmoduletestprovisioning::CSetandGetparamName

  1043 // Example test method function.

  1044 // (other items were commented in a header).

  1045 // -----------------------------------------------------------------------------

  1046 //

  1047 TInt Cmoduletestprovisioning::CSetandGetparamNameL()

  1048     {

  1049     CWPParameter* param = CWPParameter::NewLC();

  1050     _LIT(KParamName, "name");

  1051     TBufC<10> paramname(KParamName);

  1052     param -> SetNameL(paramname);

  1053     TBufC<10> getparamname;

  1054     getparamname = param -> Name();

  1055 

  1056     CWPParameter* param1 = CWPParameter::NewLC();

  1057 

  1058     TBufC<10> getparamname1;

  1059     getparamname1 = param1 -> Name();

  1060 

  1061     if (getparamname.Compare(KParamName) && getparamname1.Compare(KNullDesC))

  1062         {

  1063         CleanupStack::PopAndDestroy();

  1064         CleanupStack::PopAndDestroy();

  1065         return KErrGeneral;

  1066         }

  1067     else

  1068         {

  1069         CleanupStack::PopAndDestroy();

  1070         CleanupStack::PopAndDestroy();

  1071         return KErrNone;

  1072 

  1073         }

  1074 

  1075     }

  1076 

  1077 // -----------------------------------------------------------------------------

  1078 // Cmoduletestprovisioning::CSetandGetparamName

  1079 // Example test method function.

  1080 // (other items were commented in a header).

  1081 // -----------------------------------------------------------------------------

  1082 //

  1083 TInt Cmoduletestprovisioning::CSetandGetparamValueL()

  1084     {

  1085     CWPParameter* param = CWPParameter::NewLC();

  1086     _LIT(KParamValue, "Value");

  1087     TBufC<10> paramvalue(KParamValue);

  1088     param -> SetValueL(paramvalue);

  1089     TBufC<10> getparamvalue;

  1090     getparamvalue = param -> Value();

  1091 

  1092     CWPParameter* param1 = CWPParameter::NewLC();

  1093 

  1094     TBufC<10> getparamvalue1;

  1095     getparamvalue1 = param1 -> Value();

  1096 

  1097     if (getparamvalue.Compare(KParamValue) && getparamvalue1.Compare(

  1098             KNullDesC))

  1099         {

  1100         CleanupStack::PopAndDestroy();

  1101         CleanupStack::PopAndDestroy();

  1102         return KErrGeneral;

  1103         }

  1104     else

  1105         {

  1106         CleanupStack::PopAndDestroy();

  1107         CleanupStack::PopAndDestroy();

  1108         return KErrNone;

  1109 

  1110         }

  1111 

  1112     }

  1113 

  1114 // -----------------------------------------------------------------------------

  1115 // Cmoduletestprovisioning::CSetandGetparamName

  1116 // Example test method function.

  1117 // (other items were commented in a header).

  1118 // -----------------------------------------------------------------------------

  1119 //

  1120 TInt Cmoduletestprovisioning::InternAndExternparamL()

  1121     {

  1122 

  1123     CStreamStore* store = CBufStore::NewLC(5000);

  1124     RStoreWriteStream aStream;

  1125     TStreamId id(aStream.CreateLC(*store));

  1126 

  1127     TInt aID = 10;

  1128     _LIT(KParamName, "name");

  1129     _LIT(KParamValue, "Value");

  1130     TBufC<10> paramname(KParamName);

  1131     TBufC<10> paramvalue(KParamValue);

  1132     const TInt KBitsPerWord = 16;

  1133 

  1134     HBufC* pname = paramname.AllocL();

  1135     HBufC* pvalue = paramvalue.AllocL();