/*

* 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 <hal.h>

#include "tserviceregistrytest.h"

#include "serviceerrno.h"

// Other generated constants

_LIT8(KService, "IService");

_LIT8(KCmdCancel, "Cancel");

_LIT8( KParamFilter, "Filter" );

_LIT8( KServiceName, "ServiceName" );

_LIT8( KInterfaceName, "InterfaceName" );

_LIT8( KVersionList, "VersionList" );

// Constants for supported Operations

_LIT8(KGetList, "GetList");

_LIT8(KBadCmd, "BadCmd");

// Constants for error messages

_LIT8(KErrorMessage, "ErrorMessage");

_LIT(KMessageSeparator, ": ");

_LIT(KInterfaceErrorMessage, "Invalid Interface"); 

_LIT(KMissingArgument, "Input argument was not found.");

_LIT(KBadArgumentType, "Input argument type was wrong.");

_LIT(KInvalidCMD, "Command not supported.");

_LIT(KInvalidCMDOptions, "Invalid command options.");

_LIT(KCallbackNotFound, "Callback was not found for asynchronous method.");

_LIT(KSyncRequestNotSupported, "Synchronous request not supported.");

_LIT(KAsyncRequestNotSupported, "Asynchronous request not supported.");

_LIT(KGeneralErrorMessage, "Error occured during runtime.");

_LIT(KTransactionCancelFailed, "Canceling transaction failed.");

_LIT(KMissingCancelOption, "Cancel option was not set.");

_LIT8(KWild, "*");

_LIT8(KErrorCode , "ErrorCode"); 

/*

 * Return Value Identifier in output parameter list.

 */

_LIT8(KReturnValue , "ReturnValue");

/**

 * Command identifier in input parameter list

 */

_LIT8(KCommand, "cmd");

/**

 * Transaction id in output parameter list needed for asynchronous request

 */

_LIT8(KTransactionId, "TransactionID");

_LIT(KInputStart, "InputStart");

_LIT(KInputEnd, "InputEnd");

_LIT(KExpectedStart,"ExpectedStart");

_LIT(KExpectedEnd,"ExpectedEnd");

_LIT(KMapStart,"StartMap");

_LIT(KMapEnd,"EndMap");

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

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

// CIServiceTestModule::Delete

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

// Called from destructor. 

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

//

void CIServiceTestModule::Delete() 

    {

    iIface->Close();

    iCriteriaArray.Close();

    delete iServiceHandler;        

    delete iCriteria;    

    for(TInt i=0; i<iExpectedOutPutArray.Count(); i++)

        {

        iExpectedOutPutArray[i]->DecRef();    

        } 

    iExpectedOutPutArray.Reset();       

    }

TInt CIServiceTestModule :: HandleNotifyL(TInt /*aCmdId*/,

                            	          TInt /*aEventId*/,

                            	          CLiwGenericParamList& aEventParamList,

                            	          const CLiwGenericParamList& /*aInParamList*/)

    {

    TInt pos = 0 ;

    const TLiwGenericParam* param =  NULL;

    const TLiwGenericParam* paramIter =  NULL;

    const CLiwList* pList = NULL;

    CLiwIterable* iter = NULL;

    CActiveScheduler::Stop();

    param = aEventParamList.FindFirst(pos, KErrorCode);

    if(param)

        {         

        TLiwVariant err = param->Value();

        TInt code = err.AsTInt32(); 

        err.Reset();

        if(code != iExpectedError)

            {                        

            iResult =  KErrGeneral;

            }

        } 

    pos = 0;         

    paramIter = aEventParamList.FindFirst(pos, KReturnValue);    

	iter = paramIter->Value().AsIterable();

	if(iter)

    	{

    	if(IsExpectedResult(iter))

            {

            iResult = KErrNone;    

            }     

    	}                      

    }

TInt CIServiceTestModule::LoadProviderTest(CStifItemParser& aItem)

    {    

    __UHEAP_MARK;  

    if(iIface)

        {

        iResult = KErrNone;

        }

    else

        {

        iResult = KErrNotFound;

        }   

    iInparams->Reset();    

    iOutparams->Reset();        

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidServiceValue(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;

    TReal serviceName = 1.0;

    CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();

    pMap->InsertL(KServiceName,TLiwVariant(serviceName));

    iInparams->AppendL(TLiwGenericParam(KParamFilter, TLiwVariant(pMap)));                        

    pMap->DecRef(); 

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

      {

      TLiwVariant err = param->Value();    

      code = err.AsTInt32();

      err.Reset();     

      }

    if(SErrInvalidServiceArgument == code)

      {

      iResult = KErrNone;

      }

    else

      {

      iResult = KErrGeneral;

      }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidInterfaceValue(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;

    TReal interfacename = 1.0;

    CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();

    pMap->InsertL(KInterfaceName,TLiwVariant(interfacename));

    iInparams->AppendL(TLiwGenericParam(KParamFilter, TLiwVariant(pMap)));                        

    pMap->DecRef(); 

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

      {

      TLiwVariant err = param->Value();    

      code = err.AsTInt32();

      err.Reset();     

      }

    if(SErrInvalidServiceArgument == code)

      {

      iResult = KErrNone;

      }

    else

      {

      iResult = KErrGeneral;

      }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidMinVerValue(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;

    TBuf<25> Minver(_L("InvalidVer"));

    CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();

    pMap->InsertL(_L8("MinimumVersion"),TLiwVariant(Minver));

    iInparams->AppendL(TLiwGenericParam(KParamFilter, TLiwVariant(pMap)));                        

    pMap->DecRef(); 

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

      {

      TLiwVariant err = param->Value();    

      code = err.AsTInt32();

      err.Reset();     

      }

    if(SErrInvalidServiceArgument == code)

      {

      iResult = KErrNone;

      }

    else

      {

      iResult = KErrGeneral;

      }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidMaxVerValue(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;

    TBuf<25> Maxver(_L("InvalidVer"));

    CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();

    pMap->InsertL(_L8("MaximumVersion"),TLiwVariant(Maxver));

    iInparams->AppendL(TLiwGenericParam(KParamFilter, TLiwVariant(pMap)));                        

    pMap->DecRef(); 

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

      {

      TLiwVariant err = param->Value();    

      code = err.AsTInt32();

      err.Reset();     

      }

    if(SErrInvalidServiceArgument == code)

      {

      iResult = KErrNone;

      }

    else

      {

      iResult = KErrGeneral;

      }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidFilterValue(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;    

    CLiwDefaultList* pList= CLiwDefaultList::NewL();   

    iInparams->AppendL(TLiwGenericParam(KParamFilter, TLiwVariant(pList)));                        

    pList->DecRef(); 

    iIface->ExecuteCmdL(KGetList, 

                       *iInparams, 

                       *iOutparams, 

                       KLiwOptASyncronous, 

                       this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

     {

     TLiwVariant err = param->Value();    

     code = err.AsTInt32();

     err.Reset();     

     }

    if(SErrInvalidServiceArgument == code)

     {

     iResult = KErrNone;

     }

    else

     {

     iResult = KErrGeneral;

     }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::GetListTwice(CStifItemParser& aItem)

    {

    __UHEAP_MARK; 

    TInt pos =0;

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

        {

        TLiwVariant err = param->Value();    

        code = err.AsTInt32();

        err.Reset();     

        }

    if(code == KErrNone)

        {

        iInparams->Reset();    

        iOutparams->Reset();

        iIface->ExecuteCmdL(KGetList, 

                            *iInparams, 

                            *iOutparams, 

                            KLiwOptASyncronous, 

                            this);

        }    

    pos =0;

    const TLiwGenericParam* param1 = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code1 = KErrGeneral;

    if(param1)

        {

        TLiwVariant err1 = param1->Value();    

        code1 = err1.AsTInt32();

        err1.Reset();     

        }

    if(code1 == SErrServiceInUse)

        {

        iResult = KErrNone;

        }

    else

        {

        iResult = KErrGeneral;

        }

    iInparams->Reset();    

    iOutparams->Reset();

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::InvalidCommand(CStifItemParser& aItem)

    {

    __UHEAP_MARK;

    TInt pos = 0;

    iIface->ExecuteCmdL(_L8("Dummy"), 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);    

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

        {

        TLiwVariant err = param->Value();    

        code = err.AsTInt32();

        err.Reset();     

        }

    if(SErrServiceNotSupported == code)

        {

        iResult = KErrNone;

        }

    else

        {

        iResult = KErrNotFound;

            }

    iInparams->Reset();    

    iOutparams->Reset();            

    Delete();

    __UHEAP_MARKEND;

    return iResult;

    }

TInt CIServiceTestModule::CancelInvalidTransID(CStifItemParser& aItem)

    {

    __UHEAP_MARK; 

    TInt pos =0 ;

    iIface->ExecuteCmdL(KGetList, 

                        *iInparams, 

                        *iOutparams, 

                        KLiwOptASyncronous, 

                        this);

    const TLiwGenericParam* param = iOutparams->FindFirst(pos, KErrorCode); 

    TInt code = KErrGeneral;

    if(param)

        {

        TLiwVariant err = param->Value();    

        code = err.AsTInt32();

        err.Reset();     

        }

    if(code == KErrNone)

        {            

        pos = 0;            

        iInparams->Reset();

        iOutparams->Reset();

        iInparams->AppendL(TLiwGenericParam(KTransactionId, TLiwVariant(TInt32(12345))));

        iIface->ExecuteCmdL(KCmdCancel, 

                            *iInparams, 

                            *iOutparams, 

                            KLiwOptCancel, 

                            this);                

        pos =0;

        const TLiwGenericParam* paramerr = iOutparams->FindFirst(pos, KErrorCode);

        TLiwVariant error = paramerr->Value();    

        code = error.AsTInt32();

        error.Reset();

        if(code == SErrNotFound)

            {

            iResult = KErrNone;

            }

        else

            {

            iResult = KErrGeneral;

            } 

        } 

    iInparams->Reset();    

    iOutparams->Reset();

    Delete();

    __UHEAP_MARKEND;               

    }

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

// CIServiceTestModule::GetListL

// Test method function.

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

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

//

TInt CIServiceTestModule::GetMetaDataListL(CStifItemParser& aItem)

    {