1 /*

     2 * Copyright (c) 2002 - 2007 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 the License "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 

    20 

    21 

    22 

    23 

    24 

    25 // [INCLUDE FILES] - do not remove

    26 #include <e32svr.h>

    27 #include <StifParser.h>

    28 #include <StifTestInterface.h>

    29 #include "liwtestcases.h"

    30 

    31 #include  <aknViewAppUi.h>

    32 #include  <liwservicehandler.h>

    33 //#include  "liwTC1.h"

    34 //#include  "liwtestapp.hrh"

    35 //#include  <liwtestapp.rsg>

    36 #include  <s32mem.h> // for read write stream

    37 

    38 #include <rtsecmanager.h>

    39 #include <rtsecmgrutility.h>

    40 #include <rtsecmgrscriptsession.h>

    41 #include <rtsecmgrcommondef.h>

    42 #include "liwtestapplit.h"

    43 

    44 #include  "liw_async_testcase.h"

    45 

    46 using namespace LIW;

    47 

    48 // EXTERNAL DATA STRUCTURES

    49 //extern  ?external_data;

    50 

    51 // EXTERNAL FUNCTION PROTOTYPES  

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

    53 

    54 // CONSTANTS

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

    56 

    57 // MACROS

    58 //#define ?macro ?macro_def

    59 

    60 // LOCAL CONSTANTS AND MACROS

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

    62 //#define ?macro_name ?macro_def

    63 

    64 // MODULE DATA STRUCTURES

    65 //enum ?declaration

    66 //typedef ?declaration

    67 

    68 // LOCAL FUNCTION PROTOTYPES

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

    70 

    71 // FORWARD DECLARATIONS

    72 //class ?FORWARD_CLASSNAME;

    73 

    74 // ============================= LOCAL FUNCTIONS ===============================

    75 

    76 // -----------------------------------------------------------------------------

    77 // ?function_name ?description.

    78 // ?description

    79 // Returns: ?value_1: ?description

    80 //          ?value_n: ?description_line1

    81 //                    ?description_line2

    82 // -----------------------------------------------------------------------------

    83 //

    84 /*

    85 ?type ?function_name(

    86     ?arg_type arg,  // ?description

    87     ?arg_type arg)  // ?description

    88     {

    89 

    90     ?code  // ?comment

    91 

    92     // ?comment

    93     ?code

    94     }

    95 */

    96 

    97 // ============================ MEMBER FUNCTIONS ===============================

    98 

    99 // -----------------------------------------------------------------------------

   100 // Cliwtestcases::Delete

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

   102 // Called from destructor. 

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

   104 //

   105 void Cliwtestcases::Delete() 

   106     {

   107 		if(iServiceHandler)

   108 		{

   109     	iServiceHandler->Reset();

   110     	delete iServiceHandler;	

   111     	iServiceHandler = NULL;

   112 		}

   113     

   114     }

   115 

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

   117 // CLiwtcbase::HandleNotifyL

   118 // From - MLiwNotifyCallback

   119 // ---------------------------------------------------------

   120 TInt Cliwtestcases::HandleNotifyL

   121     (

   122     TInt /*aCmdId*/,

   123     TInt /*aEventId*/,

   124     CLiwGenericParamList& /*aEventParamList*/,

   125     const CLiwGenericParamList& /*aInParamList*/)

   126     {

   127     return KErrNone;    

   128     }

   129     

   130 

   131 TInt Cliwtestcases::LoadL( )

   132     {

   133     RCriteriaArray interest;

   134     CleanupClosePushL(interest);

   135     

   136     CLiwCriteriaItem* criteria = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   137     criteria->SetServiceClass(TUid::Uid(KLiwClassBase));

   138     

   139     interest.AppendL(criteria);

   140     

   141     // Attach the MyServiceName provider to the LIW framework.

   142     TInt status = iServiceHandler->AttachL(interest);

   143 

   144     // Detach The MyServiceName Provider

   145     //iServiceHandler->DetachL(interest);    

   146     CleanupStack::PopAndDestroy(criteria);

   147     CleanupStack::PopAndDestroy(&interest);   

   148     return status;

   149     }   

   150         

   151 // -----------------------------------------------------------------------------

   152 // Cliwtestcases::RunMethodL

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

   154 // -----------------------------------------------------------------------------

   155 //

   156 TInt Cliwtestcases::RunMethodL( 

   157     CStifItemParser& aItem ) 

   158     {

   159         TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles );

   160         

   161         static TStifFunctionInfo const KFunctions[] =

   162         {  

   163         // Copy this line for every implemented function.

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

   165         // Second is the actual implementation member function. 

   166         ENTRY( "LIW_DATA_TYPES_001", Cliwtestcases::LIW_DATA_TYPES_001 ),

   167         ENTRY( "LIW_DATA_TYPES_002", Cliwtestcases::LIW_DATA_TYPES_002 ),

   168         ENTRY( "LIW_DATA_TYPES_003", Cliwtestcases::LIW_DATA_TYPES_003 ),

   169         ENTRY( "LIW_DATA_TYPES_004", Cliwtestcases::LIW_DATA_TYPES_004 ),

   170         ENTRY( "LIW_DATA_TYPES_005", Cliwtestcases::LIW_DATA_TYPES_005 ),

   171         ENTRY( "LIW_DATA_TYPES_006", Cliwtestcases::LIW_DATA_TYPES_006 ),

   172         ENTRY( "LIW_DATA_TYPES_007", Cliwtestcases::LIW_DATA_TYPES_007 ),

   173         ENTRY( "LIW_DATA_TYPES_008", Cliwtestcases::LIW_DATA_TYPES_008 ),

   174         ENTRY( "LIW_DATA_TYPES_009", Cliwtestcases::LIW_DATA_TYPES_009 ),

   175         ENTRY( "LIW_Map_AtL_New", Cliwtestcases::LIW_Map_AtL_New ),

   176         ENTRY( "LIW_DATA_TYPES_010", Cliwtestcases::LIW_DATA_TYPES_010 ),

   177         ENTRY( "LIW_DATA_TYPES_011", Cliwtestcases::LIW_DATA_TYPES_011 ),

   178         ENTRY( "LIW_DATA_TYPES_012", Cliwtestcases::LIW_DATA_TYPES_012 ),

   179         ENTRY( "LIW_DATA_TYPES_013", Cliwtestcases::LIW_DATA_TYPES_013 ),

   180         ENTRY( "LIW_DATA_TYPES_014", Cliwtestcases::LIW_DATA_TYPES_014 ),

   181         ENTRY( "LIW_DATA_TYPES_016", Cliwtestcases::LIW_DATA_TYPES_016 ),

   182         ENTRY( "LIW_DATA_TYPES_017", Cliwtestcases::LIW_DATA_TYPES_017 ),

   183         ENTRY( "LIW_DATA_TYPES_018", Cliwtestcases::LIW_DATA_TYPES_018 ),

   184         ENTRY( "LIW_DATA_TYPES_020", Cliwtestcases::LIW_DATA_TYPES_020 ),

   185         ENTRY( "LIW_DATA_TYPES_021", Cliwtestcases::LIW_DATA_TYPES_021 ),

   186         ENTRY( "LIW_DATA_TYPES_022", Cliwtestcases::LIW_DATA_TYPES_022 ),

   187         ENTRY( "LIW_DATA_TYPES_023", Cliwtestcases::LIW_DATA_TYPES_023 ),

   188         ENTRY( "LIW_DATA_TYPES_024", Cliwtestcases::LIW_DATA_TYPES_024 ),

   189         ENTRY( "LIW_DATA_TYPES_025", Cliwtestcases::LIW_DATA_TYPES_025 ),

   190         ENTRY( "LIW_DATA_TYPES_026", Cliwtestcases::LIW_DATA_TYPES_026 ),

   191         ENTRY( "LIW_DATA_TYPES_029", Cliwtestcases::LIW_DATA_TYPES_029 ),

   192         ENTRY( "LIW_DATA_TYPES_030", Cliwtestcases::LIW_DATA_TYPES_030 ),

   193         ENTRY( "LIW_DATA_TYPES_033", Cliwtestcases::LIW_DATA_TYPES_033 ),

   194         ENTRY( "LIW_DATA_TYPES_034", Cliwtestcases::LIW_DATA_TYPES_034 ),

   195         ENTRY( "LIW_DATA_TYPES_037", Cliwtestcases::LIW_DATA_TYPES_037 ),

   196         ENTRY( "LIW_DATA_TYPES_038", Cliwtestcases::LIW_DATA_TYPES_038 ),

   197         ENTRY( "LIW_DATA_TYPES_039", Cliwtestcases::LIW_DATA_TYPES_039 ),

   198         ENTRY( "LIW_DATA_TYPES_041", Cliwtestcases::LIW_DATA_TYPES_041 ),

   199         ENTRY( "LIW_DATA_TYPES_042", Cliwtestcases::LIW_DATA_TYPES_042 ),

   200         ENTRY( "LIW_DATA_TYPES_043", Cliwtestcases::LIW_DATA_TYPES_043 ),

   201         ENTRY( "LIW_DATA_TYPES_045", Cliwtestcases::LIW_DATA_TYPES_045 ),

   202         ENTRY( "LIW_DATA_TYPES_046", Cliwtestcases::LIW_DATA_TYPES_046 ),

   203         ENTRY( "LIW_DATA_TYPES_047", Cliwtestcases::LIW_DATA_TYPES_047 ),

   204         ENTRY( "LIW_DATA_TYPES_048", Cliwtestcases::LIW_DATA_TYPES_048 ),

   205         ENTRY( "LIW_DATA_TYPES_049", Cliwtestcases::LIW_DATA_TYPES_049 ),

   206         ENTRY( "LIW_MDAT_VER1", Cliwtestcases::LIW_MDAT_VER1 ),

   207         ENTRY( "LIW_MDAT_VER2", Cliwtestcases::LIW_MDAT_VER2 ),

   208         ENTRY( "LIW_MDAT_VER3", Cliwtestcases::LIW_MDAT_VER3 ),

   209         ENTRY( "LIW_MDAT_VER4", Cliwtestcases::LIW_MDAT_VER4 ),

   210         ENTRY( "LIW_MDAT_VER5", Cliwtestcases::LIW_MDAT_VER5 ),

   211         ENTRY( "LIW_MDAT_CAP1", Cliwtestcases::LIW_MDAT_CAP1 ),

   212         ENTRY( "LIW_ContainerCleanup", Cliwtestcases::LIW_ContainerCleanup ),

   213         ENTRY( "LIW_ParamCleanup", Cliwtestcases::LIW_ParamCleanup ),

   214         ENTRY( "LIW_VariantCleanup", Cliwtestcases::LIW_VariantCleanup ),

   215         ENTRY( "LIW_ASYNC_001", Cliwtestcases::LIW_ASYNC_001 ),

   216         ENTRY( "LIW_ASYNC_002", Cliwtestcases::LIW_ASYNC_002 ),

   217         ENTRY( "LIW_ASYNC_003", Cliwtestcases::LIW_ASYNC_003 ),

   218         ENTRY( "LIW_ASYNC_004", Cliwtestcases::LIW_ASYNC_004 ),

   219         ENTRY( "LIW_ASYNC_LongServiceCmd", Cliwtestcases::LIW_ASYNC_LongServiceCmd ),

   220         ENTRY( "LIW_ASYNC_LongInterface", Cliwtestcases::LIW_ASYNC_LongInterface ),

   221         ENTRY( "LIW_ASYNC_LongInterface1", Cliwtestcases::LIW_ASYNC_LongInterface1 ),

   222         ENTRY( "LIW_ASYNC_LongInvalidServiceCmd", Cliwtestcases::LIW_ASYNC_LongInvalidServiceCmd ),

   223         ENTRY( "LIW_ASYNC_LongInvalidInterface", Cliwtestcases::LIW_ASYNC_LongInvalidInterface ),

   224         ENTRY( "LIW_ParamCleanup1", Cliwtestcases::LIW_ParamCleanup1 ),

   225         ENTRY( "LIW_GetInterest", Cliwtestcases::LIW_GetInterest ),

   226         ENTRY( "LIW_Defaut_list_externalize", Cliwtestcases::LIW_Defaut_list_externalize ),

   227         ENTRY( "LIW_DATA_TYPES_013_A", Cliwtestcases::LIW_DATA_TYPES_013_A ),

   228         ENTRY( "LIW_DATA_TYPES_015_A", Cliwtestcases::LIW_DATA_TYPES_015_A ),

   229         ENTRY( "LIW_DATA_TYPES_015", Cliwtestcases::LIW_DATA_TYPES_015 ),

   230         ENTRY( "LIW_DATA_GenericParamList", Cliwtestcases::LIW_DATA_GenericParamList ),

   231         ENTRY( "LIW_DATA_NewLOverLoad", Cliwtestcases::LIW_DATA_NewLOverLoad )

   232                         

   233         //ADD NEW ENTRY HERE

   234         // [test cases entries] - Do not remove

   235 

   236         };

   237 

   238     const TInt count = sizeof( KFunctions ) / 

   239                         sizeof( TStifFunctionInfo );

   240 

   241     return RunInternalL( KFunctions, count, aItem );

   242 

   243     }

   244 

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

   246 // Cliwtestcases::ExampleL

   247 // Example test method function.

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

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

   250 //

   251 TInt Cliwtestcases::ExampleL( CStifItemParser& aItem )

   252     {

   253 

   254     // Print to UI

   255     _LIT( Kliwtestcases, "liwtestcases" );

   256     _LIT( KExample, "In Example" );

   257     TestModuleIf().Printf( 0, Kliwtestcases, KExample );

   258     // Print to log file

   259     iLog->Log( KExample );

   260 

   261     TInt i = 0;

   262     TPtrC string;

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

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

   265         {

   266         TestModuleIf().Printf( i, Kliwtestcases, 

   267                                 KParam, i, &string );

   268         i++;

   269         }

   270 

   271     return KErrNone;

   272 

   273     }

   274 

   275 // ---------------------------------------------------------

   276 // Test Case Deffinition for LIW Data Types

   277 // 

   278 // ---------------------------------------------------------

   279 TBool Cliwtestcases::LIW_DATA_TYPES_001()

   280     {

   281 	    TBool flag = 0;

   282 	    /*Testing String Based Command*/

   283 	    //LoadL();

   284 	    TLiwGenericParam param;

   285 	    param.Value().Set(KLIW_DATA_TYPES_001);

   286 	    param.SetNameL(KTestPARAMNanmeTC1);

   287 	    CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   288 	    CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   289 	    inps->AppendL(param);

   290 	    param.Reset();

   291 	    

   292 	    // Get the Test result from MyServiceName provider "ExecuteServiceCmdL"

   293 	    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   294 	    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   295 	    iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps);  

   296 	    CleanupStack::PopAndDestroy(crit); // crit

   297 	    

   298 	    TInt pos = 0;

   299 	    outps->FindFirst(pos, EGenericParamError);

   300 	    if(pos != KErrNotFound)

   301 	        if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   302 	        {

   303 	            flag = 1;

   304 	        }

   305 	        else

   306 	        {

   307 	            flag = 0;

   308 	        }

   309 		else

   310 		{

   311 	        flag = 0;

   312 		}

   313 		

   314         // Detach The MyServiceName Provider

   315 	    //iServiceHandler->DetachL(interest);    

   316     	//CleanupStack::PopAndDestroy(criteria);

   317     	//CleanupStack::PopAndDestroy(&interest);   

   318 		return !flag;

   319     }

   320    

   321 TBool Cliwtestcases::LIW_DATA_TYPES_002()

   322     {

   323         TBool flag = 0;

   324         /*Testing Boolean data Type*/

   325         

   326         //LoadL();

   327         

   328         TLiwGenericParam param;

   329         param.Value().Set(KLIW_DATA_TYPES_002);

   330         param.SetNameL(KTestPARAMNanmeTC1);

   331         CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   332         CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   333         inps->AppendL(param);

   334         param.Reset();

   335         

   336         // Set up Tbool varient and append TBool parameter (EGenericParamError).

   337         // One Argument constructer 

   338         TLiwVariant boolVarient(ETrue);

   339         // Test TLiwVariant::SetL(TLiwVariant&)

   340         TLiwGenericParam boolParam(EGenericParamError);

   341         boolParam.Value().SetL(boolVarient);

   342         

   343         inps->AppendL(boolParam);

   344         

   345         boolVarient.Reset();

   346         boolParam.Reset();

   347         

   348         // Call ExecuteServiceCmdL TO GET THE RESULT

   349         CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   350         crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   351         iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps); 

   352         CleanupStack::PopAndDestroy(crit); // crit

   353         

   354         // CHECK RESULT 

   355         TInt pos = 0;

   356         outps->FindFirst(pos, EGenericParamError);

   357         

   358         if(pos != KErrNotFound)

   359             if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   360                 flag = 1;

   361             else

   362                 flag = 0;

   363          else

   364             flag = 0;

   365          

   366         return !flag;

   367     }

   368 

   369 TBool Cliwtestcases::LIW_DATA_TYPES_003( )

   370     {

   371         TBool flag = 0;

   372         CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   373         CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   374         

   375         //LoadL();

   376         

   377         /*Testing List Data Type for TLiwVariant interface and container interface*/

   378         TLiwGenericParam param;

   379         param.Value().Set(KLIW_DATA_TYPES_003);

   380         param.SetNameL(KTestPARAMNanmeTC1);

   381         inps->AppendL(param);

   382         param.Reset();

   383         /*Checks Default constructer "CLiwDefaultList" Creation*/

   384         CLiwList* listType = CLiwDefaultList::NewL();

   385         

   386         /*Create list of 10 integer Varient Checks CLiwList::AppendL*/

   387         TLiwVariant intVairent;

   388         for (TInt32 index = 100; index < 110; index++)

   389             {

   390             intVairent.Set(index);

   391             listType->AppendL(intVairent);    

   392             }

   393             

   394         /*Checks CLiwList::TLiwVariant.Set(CLiwList*)*/  

   395         param.Value().Set(listType);

   396         param.SetNameL(_L8("IntegerList"));

   397         inps->AppendL(param);

   398         

   399         intVairent.Reset();

   400         param.Reset();

   401         

   402         CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   403         crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   404         iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps);  

   405         CleanupStack::PopAndDestroy(crit); // crit

   406 

   407         TInt pos = 0;

   408         TBool result = FALSE;

   409         listType->Remove(listType->Count() - 1);

   410         outps->FindFirst(pos, _L8("IntegerList"));

   411         if(pos != KErrNotFound)

   412             {

   413                const CLiwList* resultList = (*outps)[pos].Value().AsList();

   414                if(resultList != NULL )

   415                {

   416                if(resultList->Count() == listType->Count() && listType->Size() == resultList->Size())

   417                    {

   418                    result = TRUE;

   419                    } 

   420                }

   421             }

   422         /*Decrement count to delete the instance of list its self managed memory allocation*/      

   423         if (listType) listType->DecRef();

   424         pos = 0;

   425         outps->FindFirst(pos, EGenericParamError);

   426         

   427         if(pos != KErrNotFound)

   428             if ((*outps)[pos].Value().AsTInt32() == KErrNone && result)

   429                 flag = 1;

   430             else

   431                 flag = 0;

   432         else

   433             flag = 0;

   434         

   435         // Detach The MyServiceName Provider

   436         //iServiceHandler->DetachL(interest);    

   437         //CleanupStack::PopAndDestroy(criteria);

   438         //CleanupStack::PopAndDestroy(&interest);   

   439         

   440         return !flag;

   441     }

   442     

   443 TBool Cliwtestcases::LIW_DATA_TYPES_004( )

   444     {

   445         TBool flag = 0;

   446         CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   447         CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   448         

   449         /*Testing List Data Type for TLiwVariant interface and container interface*/

   450         TLiwGenericParam param;

   451         param.Value().Set(KLIW_DATA_TYPES_004);

   452         param.SetNameL(KTestPARAMNanmeTC1);

   453         inps->AppendL(param);

   454         param.Reset();

   455         /*Checks Default constructer "CLiwDefaultMap" Creation*/

   456         CLiwMap* mapType = CLiwDefaultMap::NewL();

   457         

   458         /*Create Map of 10 integer Varient Checks CLiwMap::InsertL*/

   459         TLiwVariant contactNbr;

   460         TBuf8<32> contactName;

   461         for (TInt32 index = 100; index < 110; index++)

   462             {

   463             contactName.Format(KContact, index - 99);

   464             contactNbr.Set(index);

   465             mapType->InsertL(contactName, contactNbr);    

   466             }

   467             

   468         /*Checks CLiwList::TLiwVariant.Set(CLiwMap*)*/  

   469         param.Value().Set(mapType);

   470         param.SetNameL(_L8("ContactNumbers"));

   471         inps->AppendL(param);

   472         

   473         contactNbr.Reset();

   474         param.Reset();

   475         

   476         CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   477         crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   478         iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps);  

   479         CleanupStack::PopAndDestroy(crit); // crit

   480 

   481         TInt pos = 0;

   482         TBool result = FALSE;

   483         mapType->Remove(_L8("Contact 10"));

   484         outps->FindFirst(pos, _L8("ContactNumbers"));

   485         if(pos != KErrNotFound)

   486             {

   487                const CLiwMap* resultMap = (*outps)[pos].Value().AsMap();

   488                if(resultMap != NULL )

   489                    {

   490                    if( resultMap->Count() == mapType->Count() && mapType->Size() == resultMap->Size())

   491                        {

   492                        result = TRUE;

   493                        } 

   494                    }

   495             }

   496         /*Decrement count to delete the instance of Map its self managed memory allocation*/      

   497         if (mapType) mapType->DecRef();

   498         

   499         pos = 0;

   500         outps->FindFirst(pos, EGenericParamError);

   501         

   502         if(pos != KErrNotFound)

   503             if ((*outps)[pos].Value().AsTInt32() == KErrNone && result)

   504                 flag = 1;

   505             else

   506                 flag = 0;

   507         else

   508             flag = 0;

   509         

   510         return !flag;

   511     }

   512     

   513 TBool Cliwtestcases::LIW_DATA_TYPES_005( )

   514     {

   515     TBool flag = 0;

   516     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   517     CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   518     

   519     /*Testing List Data Type for TLiwVariant interface and container interface*/

   520     TLiwGenericParam param;

   521     param.Value().Set(KLIW_DATA_TYPES_005);

   522     param.SetNameL(KTestPARAMNanmeTC1);

   523     inps->AppendL(param);

   524     param.Reset();

   525     

   526     /*Checks Default constructer "CLiwDefaultMap" and "CLiwDefaultMap" Creation*/

   527     CLiwMap* mapType = CLiwDefaultMap::NewL();

   528     CLiwList* listType = CLiwDefaultList::NewL();

   529     

   530     /*Create list of 10 integer Varient Checks CLiwList::AppendL*/

   531     TLiwVariant intVairent;

   532     for (TInt32 index2 = 100; index2 < 110; index2++)

   533         {

   534         intVairent.Set(index2);

   535         listType->AppendL(intVairent);    

   536         }

   537         

   538     TBuf8<32> listName;

   539     TLiwVariant listVarient;

   540     listVarient.Set(listType);

   541     

   542     for (TInt32 index = 1; index < 11; index++)

   543         {

   544         listName.Format(KContact, index);

   545         mapType->InsertL(listName, listVarient);

   546         }

   547         

   548     listVarient.Reset();    

   549     /*Checks CLiwList::TLiwVariant.Set(CLiwMap*)*/  

   550     param.Value().Set(mapType);

   551     param.SetNameL(_L8("MapOfLists"));

   552     

   553     inps->AppendL(param);

   554     

   555     param.Reset();

   556         

   557     

   558     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   559     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   560     iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps);  

   561     CleanupStack::PopAndDestroy(crit); // crit

   562 

   563     //remove the last list (10) and remove the last entry (9)in first List (0)

   564     mapType->Remove(_L8("Contact 10"));

   565     mapType->FindL(_L8("Contact 1"), listVarient);

   566     listVarient.Get(*listType);

   567     listType->Remove(9);

   568     

   569     listVarient.Reset();

   570     

   571     TInt pos = 0;

   572     TBool result = FALSE;

   573     outps->FindFirst(pos, _L8("MapOfLists"));

   574     if(pos != KErrNotFound)

   575         {

   576            const CLiwMap* resultMap = (*outps)[pos].Value().AsMap();

   577            if(resultMap != NULL && resultMap->Count() == mapType->Count() && mapType->Size() == resultMap->Size())

   578            {

   579            TBuf8<32> mapKey;

   580            resultMap->AtL(0, mapKey);

   581            resultMap->FindL(mapKey, listVarient);

   582            if(listVarient.AsList() != NULL )

   583                {

   584                if (listVarient.AsList()->Count() == listType->Count() && listType->Size() == listVarient.AsList()->Size())

   585                    {

   586                    result = TRUE; 

   587                    }

   588                }

   589            }

   590            listVarient.Reset();

   591         }

   592     

   593     

   594     pos = 0;

   595     outps->FindFirst(pos, EGenericParamError);

   596     

   597     if(pos != KErrNotFound)

   598         if ((*outps)[pos].Value().AsTInt32() == KErrNone && result)

   599             flag = 1;

   600         else

   601             flag = 0;

   602     else

   603         flag = 0;

   604     

   605     //Decrement count to delete the instance of Map its self managed memory allocation

   606     inps->Reset();

   607     outps->Reset();

   608     if (mapType) mapType->DecRef();

   609     if (listType) listType->DecRef();

   610     

   611     return !flag;

   612     }

   613 

   614 TBool Cliwtestcases::LIW_DATA_TYPES_006( )

   615     {

   616     TBool flag = 0;    

   617     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   618     CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   619     TLiwGenericParam param;

   620     param.Value().Set(KLIW_DATA_TYPES_006);

   621     param.SetNameL(KTestPARAMNanmeTC1);

   622     inps->AppendL(param);

   623     param.Reset();

   624       

   625     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   626     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   627     iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps);  

   628     CleanupStack::PopAndDestroy(crit); // crit

   629     

   630     TInt pos = 0;

   631     MLiwInterface* ifp = NULL;

   632     outps->FindFirst(pos, KLIW_DATA_TYPES_006);

   633     if(pos != KErrNotFound)

   634         {

   635         ifp = (*outps)[pos].Value().AsInterface();

   636         outps->Reset();

   637         ifp->ExecuteCmdL(KLIW_DATA_TYPES_006, *inps, *outps);      

   638         }

   639     else

   640         {

   641         flag = 0;

   642         }

   643     pos = 0;

   644     outps->FindFirst(pos, EGenericParamError);

   645     if(pos != KErrNotFound)

   646         if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   647             flag = 1;

   648         else

   649             flag = 0;

   650     else

   651         flag = 0;

   652     

   653     if(ifp) ifp->Close();

   654     inps->Reset();

   655     outps->Reset();

   656     return !flag;

   657     }

   658 

   659 TBool Cliwtestcases::LIW_DATA_TYPES_007( )

   660     {

   661     TBool flag = 0;

   662     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   663     TLiwGenericParam param;

   664     CLiwList* listType = CLiwDefaultList::NewL();

   665     CLiwMap* mapType = CLiwDefaultMap::NewL();

   666     listType->AppendL(TLiwVariant(_L8("Testing Stream Operations")));  

   667     mapType->InsertL(KLIW_DATA_TYPES_007, TLiwVariant(listType));

   668     param.Value().Set(mapType);

   669     param.SetNameL(KTestPARAMNanmeTC1);

   670     inps->AppendL(param);

   671     

   672     param.Reset();

   673     if (listType) listType->DecRef();

   674     if (mapType) mapType->DecRef();

   675     

   676     TInt sz = inps->Size();

   677     TAny* buf = User::AllocL(sz);

   678     RMemWriteStream ws(buf, sz);

   679     inps->ExternalizeL(ws);

   680     RMemReadStream rs(buf, sz);

   681     CLiwGenericParamList* ltmp = &(iServiceHandler->OutParamListL());

   682     ltmp->InternalizeL(rs);

   683     if ((ltmp->Count() == inps->Count()) && ((*inps)[0] == (*ltmp)[0]))

   684         flag = 1;

   685     else

   686         flag = 0;

   687     User::Free(buf);

   688     return !flag;

   689     }

   690 

   691 TBool Cliwtestcases::LIW_DATA_TYPES_008( )

   692     {

   693     TBool flag = 0;

   694     /*Checks Default constructer "CLiwDefaultList" Creation*/

   695     CLiwList* listType = CLiwDefaultList::NewL();

   696     CLiwList* resultList;

   697     

   698     /*Create list of 10 integer Varient Checks CLiwList::AppendL*/

   699     TLiwVariant intVairent;

   700     for (TInt32 index = 100; index < 110; index++)

   701         {

   702         intVairent.Set(index);

   703         listType->AppendL(intVairent);    

   704         }

   705     

   706     intVairent.Reset();    

   707     TBool result = TRUE;

   708     

   709     // Checking Bound conditions

   710     resultList = listType;

   711     resultList->Remove(listType->Count() + 1);

   712     resultList->Remove(-1);

   713     if (resultList != listType)

   714         result = FALSE;

   715     result ? result = !(listType->AtL(listType->Count() + 1, intVairent)): result = FALSE;

   716     result ? result = !(listType->AtL(-1, intVairent)) : result = FALSE;      

   717     

   718     if(result == TRUE)

   719         {

   720         flag = 1;

   721         }

   722     else

   723         {

   724         flag = 0;

   725         }

   726     /*Decrement count to delete the instance of list its self managed memory allocation*/      

   727     if (listType) listType->DecRef(); 

   728     return !flag;

   729     }

   730     

   731 TBool Cliwtestcases::LIW_DATA_TYPES_009( )

   732     {

   733     TBool flag = 0;

   734     /*Checks Default constructer "CLiwDefaultMap" Creation*/

   735     CLiwMap* mapType = CLiwDefaultMap::NewL();

   736     CLiwMap* resultMap;

   737     

   738     /*Create Map of 10 integer Varient Checks CLiwMap::InsertL*/

   739     TLiwVariant contactNbr;

   740     TBuf8<32> contactName;

   741     for (TInt32 index = 100; index < 110; index++)

   742         {

   743         contactName.Format(KContact, index - 99);

   744         contactNbr.Set(index);

   745         mapType->InsertL(contactName, contactNbr);    

   746         }

   747         

   748     /*Checks CLiwList::TLiwVariant.Set(CLiwMap*)*/  

   749        

   750     contactNbr.Reset();

   751     contactName.FillZ();

   752     contactName.Zero();

   753     TBool result = TRUE;

   754         

   755     // Checking Bound conditions

   756     resultMap = mapType;

   757     resultMap->Remove(_L8("Contact 11"));

   758     if (resultMap != mapType)

   759         result = FALSE;

   760     result ? result = !(mapType->AtL(mapType->Count() + 1, contactName)) : result = FALSE;

   761     result ? result = !(mapType->AtL(-1, contactName) ): result = FALSE;

   762     

   763     

   764     if(result == TRUE)

   765         {

   766         flag = 1;

   767         }

   768     else

   769         {

   770         flag = 0;

   771         }

   772     /*Decrement count to delete the instance of list its self managed memory allocation*/      

   773     if (mapType) mapType->DecRef();

   774     return !flag;

   775     }

   776     

   777 TBool Cliwtestcases::LIW_Map_AtL_New( )

   778     {

   779     TBool flag = 0;

   780     /*Checks Default constructer "CLiwDefaultMap" Creation*/

   781     CLiwDefaultMap* mapType = CLiwDefaultMap::NewL();

   782     CLiwDefaultMap* resultMap;

   783     

   784     /*Create Map of 10 integer Varient Checks CLiwMap::InsertL*/

   785     TLiwVariant contactNbr;

   786     TBuf8<32> contactName;

   787     for (TInt32 index = 100; index < 110; index++)

   788         {

   789         contactName.Format(KContact, index - 99);

   790         contactNbr.Set(index);

   791         mapType->InsertL(contactName, contactNbr);    

   792         }

   793         

   794     /*Checks CLiwList::TLiwVariant.Set(CLiwMap*)*/  

   795        

   796     contactNbr.Reset();

   797     contactName.FillZ();

   798     contactName.Zero();

   799     TBool result = TRUE;

   800         

   801     // Checking Bound conditions

   802     resultMap = mapType;

   803     resultMap->Remove(_L8("Contact 11"));

   804     if (resultMap != mapType)

   805         result = FALSE;

   806     

   807     TRAPD(err1, contactName = mapType->AtL(mapType->Count() + 1));

   808     

   809     //result ? result = !(contactName.operator==(KNullDesC8)) : result = FALSE;

   810     

   811     TRAPD(err2, contactName = mapType->AtL(-1));

   812     

   813     //result ? result = !(contactName.operator==(KNullDesC8)): result = FALSE;

   814     

   815     if(err1 && err2)

   816         flag = 1;

   817     else

   818         flag = 0;

   819     

   820     

   821     /*

   822     if(err)

   823         flag = 0;

   824     

   825     if(result == TRUE)

   826         {

   827         flag = 1;

   828         }

   829     else

   830         {

   831         flag = 0;

   832         }

   833     */

   834     

   835     //Decrement count to delete the instance of list its self managed memory allocation

   836     if (mapType) mapType->DecRef();

   837     return !flag;

   838     }

   839 

   840 TBool Cliwtestcases::LIW_DATA_TYPES_010()

   841     {

   842     TBool flag = 0;

   843     /*Testing Unsigned Integer data Type*/

   844     TLiwGenericParam param;

   845     param.Value().Set(KLIW_DATA_TYPES_010);

   846     param.SetNameL(KTestPARAMNanmeTC1);

   847     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   848     CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   849     inps->AppendL(param);

   850     param.Reset();

   851     

   852     // Set up Tbool varient and append Unsigned Integer parameter (EGenericParamError).

   853     // One Argument constructer

   854     TUint arg = 10; 

   855     TLiwVariant uIntVarient(arg);

   856     // Test TLiwVariant::SetL(TLiwVariant&)

   857     TLiwGenericParam uIntParam(EGenericParamError);

   858     uIntParam.Value().SetL(uIntVarient);

   859     

   860     inps->AppendL(uIntParam);

   861     

   862     uIntVarient.Reset();

   863     uIntParam.Reset();

   864     

   865     // Call ExecuteServiceCmdL TO GET THE RESULT

   866     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   867     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   868     iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps); 

   869     CleanupStack::PopAndDestroy(crit); // crit

   870     

   871     // CHECK RESULT 

   872     TInt pos = 0;

   873     outps->FindFirst(pos, EGenericParamError);

   874     

   875     if(pos != KErrNotFound)

   876         {

   877             if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   878                 {

   879                 flag = 1;

   880                 }

   881             else

   882                 {

   883                 

   884                 flag = 0;

   885                 }

   886         }

   887      else

   888         {

   889         

   890         flag = 0;

   891         }

   892     return !flag;

   893     }   

   894  

   895 //CHECK FROM HERE

   896 

   897 TBool Cliwtestcases::LIW_DATA_TYPES_011()

   898     {

   899     TBool flag = 0;

   900     TLiwGenericParam param;

   901     param.Value().Set(KLIW_DATA_TYPES_011);

   902     param.SetNameL(KTestPARAMNanmeTC1);

   903     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   904     CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   905     inps->AppendL(param);

   906     param.Reset();

   907     

   908     // Call ExecuteServiceCmdL TO GET THE RESULT

   909     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   910     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   911     iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps); 

   912     CleanupStack::PopAndDestroy(crit); // crit

   913     

   914     // CHECK RESULT 

   915     TInt pos = 0;

   916     outps->FindFirst(pos, EGenericParamError);

   917     

   918     if(pos != KErrNotFound)

   919         {

   920             if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   921                 {

   922                 

   923                 _LIT8(KIter,"Iterator");

   924                 TInt iterPos=0;

   925                 outps->FindFirst(iterPos, KIter);

   926                 if(pos != KErrNotFound)

   927                 {

   928                     CLiwIterable* pIter=(*outps)[iterPos].Value().AsIterable();

   929                     

   930                     //Iterate over the list

   931                     TLiwVariant var;

   932                     

   933                     while(EFalse != pIter->NextL(var))

   934                     {       

   935                         TPtrC8 entry;

   936                         var.Get(entry);

   937                         

   938                         if(0==entry.Length())

   939                         {

   940                             flag = 0;                               

   941                         }                       

   942                     }

   943                     

   944                     var.Reset();

   945                     

   946                 }

   947                 else

   948                 {

   949                     flag = 0;

   950                 }

   951                 

   952                 flag = 1;

   953                 }

   954             else

   955                 {

   956                 flag = 0;

   957                 }

   958         }

   959      else

   960         {

   961         

   962         flag = 0;

   963         }

   964     return !flag;

   965     }   

   966     

   967  TBool Cliwtestcases::LIW_DATA_TYPES_012()

   968     {

   969     TBool flag = 0;

   970     TLiwGenericParam param;

   971     param.Value().Set(KLIW_DATA_TYPES_012);

   972     param.SetNameL(KTestPARAMNanmeTC1);

   973     CLiwGenericParamList* inps = &(iServiceHandler->InParamListL());

   974     CLiwGenericParamList* outps = &(iServiceHandler->OutParamListL());

   975     inps->AppendL(param);

   976     param.Reset();

   977     

   978     // Call ExecuteServiceCmdL TO GET THE RESULT

   979     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, KTestCommandTC1, KContentTypeTxt);

   980     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   981     iServiceHandler->ExecuteServiceCmdL(*crit, *inps, *outps); 

   982     CleanupStack::PopAndDestroy(crit); // crit

   983     

   984     // CHECK RESULT 

   985     TInt pos = 0;

   986     outps->FindFirst(pos, EGenericParamError);

   987     

   988     if(pos != KErrNotFound)

   989         {

   990             if ((*outps)[pos].Value().AsTInt32() == KErrNone)

   991                 {                

   992                 flag = 1;

   993                 }

   994             else

   995                 {

   996                 flag = 0;

   997                 }

   998         }

   999      else

  1000         {

  1001         

  1002         flag = 0;

  1003         }

  1004     return !flag;

  1005     }   

  1006     

  1007     

  1008  TBool Cliwtestcases::LIW_DATA_TYPES_013()

  1009     {

  1010         TBool flag = 0;    

  1011         CLiwList* pList = CLiwDefaultList::NewL();

  1012         

  1013         {

  1014             TLiwVariant intVairent;

  1015             for (TInt32 index = 100; index < 110; index++)

  1016                 {

  1017                 intVairent.Set(index);

  1018                 pList->AppendL(intVairent);    

  1019                 }   

  1020         }

  1021         

  1022         if(EFalse == (pList->operator==(*pList)))

  1023         {   

  1024             flag = 0;

  1025         }

  1026         

  1027         CLiwList* pAnotherList = CLiwDefaultList::NewL();

  1028         

  1029         {

  1030             TLiwVariant intVairent;

  1031             for (TInt32 index = 100; index < 110; index++)

  1032                 {

  1033                 intVairent.Set(index);

  1034                 pAnotherList->AppendL(intVairent);    

  1035                 }

  1036         }

  1037         

  1038         

  1039         if(EFalse == (pList->operator==(*pAnotherList)))

  1040         {

  1041              flag = 0;

  1042         }

  1043                 

  1044         pAnotherList->Remove(0);

  1045         

  1046         if(EFalse == (pList->operator==(*pAnotherList)))

  1047         {

  1048             flag = 1;

  1049         }

  1050         else

  1051         {

  1052             flag = 0;

  1053         }   

  1054     if(pList) pList->DecRef();

  1055     if(pAnotherList) pAnotherList->DecRef();

  1056     return !flag;

  1057    }

  1058     

  1059 TBool Cliwtestcases::LIW_DATA_TYPES_014()

  1060     {

  1061         TBool flag = 0; 

  1062         CLiwMap* pMap = CLiwDefaultMap::NewL();

  1063         

  1064         {

  1065             /*Create Map of 10 integer Varient Checks CLiwMap::InsertL*/

  1066             TLiwVariant contactNbr;

  1067             TBuf8<32> contactName;

  1068             for (TInt32 index = 100; index < 110; index++)

  1069                 {

  1070                 contactName.Format(KContact, index - 99);

  1071                 contactNbr.Set(index);

  1072                 pMap->InsertL(contactName, contactNbr);    

  1073                 }

  1074         }

  1075         

  1076         if(EFalse == (pMap->operator==(*pMap)))

  1077         {   

  1078             flag = 0;

  1079         }

  1080         

  1081         CLiwMap* pAnotherMap = CLiwDefaultMap::NewL();

  1082         TBuf8<32> keyToRem;

  1083         

  1084         {

  1085             /*Create Map of 10 integer Varient Checks CLiwMap::InsertL*/

  1086             TLiwVariant contactNbr;

  1087             TBuf8<32> contactName;

  1088             for (TInt32 index = 100; index < 110; index++)

  1089                 {

  1090                 contactName.Format(KContact, index - 99);

  1091                 contactNbr.Set(index);

  1092                 pAnotherMap->InsertL(contactName, contactNbr);  

  1093                 

  1094                 if(100==index)

  1095                     keyToRem.Copy(contactName);

  1096                 }

  1097         }

  1098         

  1099         if(EFalse == (pMap->operator==(*pAnotherMap)))

  1100         {

  1101              flag = 0;

  1102         }

  1103         

  1104         pAnotherMap->Remove(keyToRem);

  1105         

  1106         if(EFalse == (pMap->operator==(*pAnotherMap)))

  1107         {

  1108             flag = 1;

  1109         }

  1110         else

  1111         {

  1112             flag = 0;

  1113         }   

  1114         if(pMap) pMap->DecRef();

  1115         if(pAnotherMap) pAnotherMap->DecRef();

  1116         return !flag;

  1117     }

  1118     

  1119 TBool Cliwtestcases::LIW_DATA_TYPES_015()

  1120     {

  1121          

  1122          TBool flag = 1;

  1123          TInt32 intVal=10;

  1124          TLiwVariant intVar((TInt32)intVal);

  1125          

  1126          {//integer check

  1127             TInt32 intRet;

  1128             intVar.Get(intRet);

  1129             

  1130             Dump(intVar);

  1131             

  1132             if(intRet!=intVal)

  1133             {

  1134                 flag = 0;

  1135             }