/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:       ?Description

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "liwtestcases.h"

#include  <aknViewAppUi.h>

#include  <liwservicehandler.h>

//#include  "liwTC1.h"

//#include  "liwtestapp.hrh"

//#include  <liwtestapp.rsg>

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

#include <rtsecmanager.h>

#include <rtsecmgrutility.h>

#include <rtsecmgrscriptsession.h>

#include <rtsecmgrcommondef.h>

#include "liwtestapplit.h"

#include  "liw_async_testcase.h"

using namespace LIW;

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

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

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

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

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

// -----------------------------------------------------------------------------

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

// -----------------------------------------------------------------------------

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

// -----------------------------------------------------------------------------

// Cliwtestcases::Delete

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

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void Cliwtestcases::Delete() 

    {

		if(iServiceHandler)

		{

    	iServiceHandler->Reset();

    	delete iServiceHandler;	

    	iServiceHandler = NULL;

		}

    }

// ---------------------------------------------------------

// CLiwtcbase::HandleNotifyL

// From - MLiwNotifyCallback

// ---------------------------------------------------------

TInt Cliwtestcases::HandleNotifyL

    (

    TInt /*aCmdId*/,

    TInt /*aEventId*/,

    CLiwGenericParamList& /*aEventParamList*/,

    const CLiwGenericParamList& /*aInParamList*/)

    {

    return KErrNone;    

    }

TInt Cliwtestcases::LoadL( )

    {

    RCriteriaArray interest;

    CleanupClosePushL(interest);

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

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

    interest.AppendL(criteria);

    // Attach the MyServiceName provider to the LIW framework.

    TInt status = iServiceHandler->AttachL(interest);

    // Detach The MyServiceName Provider

    //iServiceHandler->DetachL(interest);    

    CleanupStack::PopAndDestroy(criteria);

    CleanupStack::PopAndDestroy(&interest);   

    return status;

    }   

// -----------------------------------------------------------------------------

// Cliwtestcases::RunMethodL

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

// -----------------------------------------------------------------------------

//

TInt Cliwtestcases::RunMethodL( 

    CStifItemParser& aItem ) 

    {

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

        static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

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

        // Second is the actual implementation member function. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        ENTRY( "LIW_DATA_NewLOverLoad", Cliwtestcases::LIW_DATA_NewLOverLoad )

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// Cliwtestcases::ExampleL

// Example test method function.

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

// -----------------------------------------------------------------------------

//

TInt Cliwtestcases::ExampleL( CStifItemParser& aItem )

    {

    // Print to UI

    _LIT( Kliwtestcases, "liwtestcases" );

    _LIT( KExample, "In Example" );

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

    // Print to log file

    iLog->Log( KExample );

    TInt i = 0;

    TPtrC string;

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

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

        {

        TestModuleIf().Printf( i, Kliwtestcases, 

                                KParam, i, &string );

        i++;

        }

    return KErrNone;

    }

// ---------------------------------------------------------

// Test Case Deffinition for LIW Data Types

// 

// ---------------------------------------------------------

TBool Cliwtestcases::LIW_DATA_TYPES_001()

    {

	    TBool flag = 0;

	    /*Testing String Based Command*/

	    //LoadL();

	    TLiwGenericParam param;

	    param.Value().Set(KLIW_DATA_TYPES_001);

	    param.SetNameL(KTestPARAMNanmeTC1);

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

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

	    inps->AppendL(param);

	    param.Reset();

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

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

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

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

	    CleanupStack::PopAndDestroy(crit); // crit

	    TInt pos = 0;

	    outps->FindFirst(pos, EGenericParamError);

	    if(pos != KErrNotFound)

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

	        {

	            flag = 1;

	        }

	        else

	        {

	            flag = 0;

	        }

		else

		{

	        flag = 0;

		}

        // Detach The MyServiceName Provider

	    //iServiceHandler->DetachL(interest);    

    	//CleanupStack::PopAndDestroy(criteria);

    	//CleanupStack::PopAndDestroy(&interest);   

		return !flag;

    }

TBool Cliwtestcases::LIW_DATA_TYPES_002()

    {

        TBool flag = 0;

        /*Testing Boolean data Type*/

        //LoadL();

        TLiwGenericParam param;

        param.Value().Set(KLIW_DATA_TYPES_002);

        param.SetNameL(KTestPARAMNanmeTC1);

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

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

        inps->AppendL(param);

        param.Reset();

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

        // One Argument constructer 

        TLiwVariant boolVarient(ETrue);

        // Test TLiwVariant::SetL(TLiwVariant&)

        TLiwGenericParam boolParam(EGenericParamError);

        boolParam.Value().SetL(boolVarient);

        inps->AppendL(boolParam);

        boolVarient.Reset();

        boolParam.Reset();

        // Call ExecuteServiceCmdL TO GET THE RESULT

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

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

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

        CleanupStack::PopAndDestroy(crit); // crit

        // CHECK RESULT 

        TInt pos = 0;

        outps->FindFirst(pos, EGenericParamError);

        if(pos != KErrNotFound)

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

                flag = 1;

            else

                flag = 0;

         else

            flag = 0;

        return !flag;

    }

TBool Cliwtestcases::LIW_DATA_TYPES_003( )

    {

        TBool flag = 0;

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

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

        //LoadL();

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

        TLiwGenericParam param;

        param.Value().Set(KLIW_DATA_TYPES_003);

        param.SetNameL(KTestPARAMNanmeTC1);

        inps->AppendL(param);

        param.Reset();

        /*Checks Default constructer "CLiwDefaultList" Creation*/

        CLiwList* listType = CLiwDefaultList::NewL();

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

        TLiwVariant intVairent;

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

            {

            intVairent.Set(index);

            listType->AppendL(intVairent);    

            }

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

        param.Value().Set(listType);

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

        inps->AppendL(param);

        intVairent.Reset();

        param.Reset();

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

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

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

        CleanupStack::PopAndDestroy(crit); // crit

        TInt pos = 0;

        TBool result = FALSE;

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

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

        if(pos != KErrNotFound)

            {

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

               if(resultList != NULL )

               {

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

                   {

                   result = TRUE;

                   } 

               }

            }

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

        if (listType) listType->DecRef();

        pos = 0;

        outps->FindFirst(pos, EGenericParamError);

        if(pos != KErrNotFound)

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

                flag = 1;

            else

                flag = 0;

        else

            flag = 0;

        // Detach The MyServiceName Provider

        //iServiceHandler->DetachL(interest);    

        //CleanupStack::PopAndDestroy(criteria);

        //CleanupStack::PopAndDestroy(&interest);   

        return !flag;

    }

TBool Cliwtestcases::LIW_DATA_TYPES_004( )

    {

        TBool flag = 0;

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

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

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

        TLiwGenericParam param;

        param.Value().Set(KLIW_DATA_TYPES_004);

        param.SetNameL(KTestPARAMNanmeTC1);

        inps->AppendL(param);

        param.Reset();

        /*Checks Default constructer "CLiwDefaultMap" Creation*/

        CLiwMap* mapType = CLiwDefaultMap::NewL();

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

        TLiwVariant contactNbr;

        TBuf8<32> contactName;

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

            {

            contactName.Format(KContact, index - 99);

            contactNbr.Set(index);

            mapType->InsertL(contactName, contactNbr);    

            }

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

        param.Value().Set(mapType);

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

        inps->AppendL(param);

        contactNbr.Reset();

        param.Reset();

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

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

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

        CleanupStack::PopAndDestroy(crit); // crit

        TInt pos = 0;

        TBool result = FALSE;

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

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

        if(pos != KErrNotFound)

            {

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

               if(resultMap != NULL )

                   {

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

                       {

                       result = TRUE;

                       } 

                   }

            }

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

        if (mapType) mapType->DecRef();

        pos = 0;

        outps->FindFirst(pos, EGenericParamError);

        if(pos != KErrNotFound)

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

                flag = 1;

            else

                flag = 0;

        else

            flag = 0;

        return !flag;

    }

TBool Cliwtestcases::LIW_DATA_TYPES_005( )

    {

    TBool flag = 0;

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

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

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

    TLiwGenericParam param;

    param.Value().Set(KLIW_DATA_TYPES_005);

    param.SetNameL(KTestPARAMNanmeTC1);

    inps->AppendL(param);

    param.Reset();

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