/*

* 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 "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:  Ps Utils test suite source file

*

*/

// SYSTEM INCLUDES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <S32MEM.H>

#include <CPsClientData.h>

// USER INCLUDES

#include "PsUtilsTestSuite.h"

#include "psutilstestsuitedefs.h"

#include "TestSuiteInputData.h"

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

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

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

// Called from destructor. 

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

void CPsUtilsTestSuite::Delete() 

    {

    }

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

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

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

    {

        {  

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

        // Second is the actual implementation member function. 

        ENTRY( "PsQueryItem_SetAndGetL", CPsUtilsTestSuite::CPsQueryItem_SetAndGetL),

		ENTRY( "PsQuery_SetAndGetL", CPsUtilsTestSuite::CPsQuery_SetAndGetL),

		ENTRY( "PsClientData_SetAndGetL", CPsUtilsTestSuite::PsClientData_SetAndGetL),

		ENTRY( "PsData_SetAndGetL", CPsUtilsTestSuite::PsData_SetAndGetL),

		ENTRY( "PsSettings_SetAndGetL", CPsUtilsTestSuite::PsSettings_SetAndGetL),

		ENTRY( "PsPattern_SetAndGetL", CPsUtilsTestSuite::PsPattern_SetAndGetL),

        };

    const TInt count = sizeof( KFunctions ) / 

    return RunInternalL( KFunctions, count, aItem );

    }

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

// This test case performs all the  operations on the CPsQueryItem

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

TInt CPsUtilsTestSuite::CPsQueryItem_SetAndGetL( CStifItemParser& aItem )

{

	TInt errorStatus = KErrGeneral;

	RPointerArray<TDesC> inputParameterArray;

	Parse_StifItem(aItem,inputParameterArray);

	//Parse data for CPsQueryItem

    TKeyboardModes inputKeyboardMode = EModeUndefined;

    TChar inputCharacter = '=';

    ParseForCPsQueryItemL(inputParameterArray,inputKeyboardMode,inputCharacter);

    inputParameterArray.ResetAndDestroy();

	// Create the soure CPsQueryItem

	CPsQueryItem* itemSrc = NULL;

	itemSrc = CPsQueryItem::NewL(); 

	CleanupStack::PushL(itemSrc);

    //Set the mode and character

    itemSrc->SetMode(inputKeyboardMode);

    itemSrc->SetCharacter(inputCharacter);

    // Externalize to a stream of type RBufWriteStream

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen); 

    CleanupStack::PushL(buf);

    RBufWriteStream stream(*buf);

	stream.PushL();

	itemSrc->ExternalizeL(stream);

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

    // Create the destination CPsQueryItem

	CPsQueryItem* itemDest = NULL;

	itemDest = CPsQueryItem::NewL();

	CleanupStack::PushL(itemDest);

	// Internalize from the stream

	HBufC8* destBuf = HBufC8::NewLC(buf->Size()); 

    TPtr8 ptrdestBuf(destBuf->Des()); 

    buf->Read(0, ptrdestBuf, buf->Size()); 

	RDesReadStream rdStream(destBuf->Des()); 

	CleanupClosePushL(rdStream);

    itemDest->InternalizeL(rdStream);

    CleanupStack::PopAndDestroy(2);//rdStream, destBuf

    // Check if internalized and externalized values are same.

    if (   (itemDest->Mode() != itemSrc->Mode())

        || (itemDest->Character() != itemSrc->Character()) )

    {

    	errorStatus = KErrGeneral;

    }

    else

    {

    	errorStatus = KErrNone;

    }

	CleanupStack::PopAndDestroy(3); //itemDest,buf,itemSrc

	// return the errorStauts

	return errorStatus;

}

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

// This test case performs all the  operations on the CPsQuery

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

TInt CPsUtilsTestSuite::CPsQuery_SetAndGetL( CStifItemParser& aItem )

{

}

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

// This test case performs all the  operations on the CPsClientData

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

TInt CPsUtilsTestSuite::PsClientData_SetAndGetL( CStifItemParser& aItem )

{

	TInt errorStatus = KErrNone;

	CTestSuiteInputData* iInputParsedData = CTestSuiteInputData::NewL(aItem);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem) ;

  	// Create a new source PS Query object

    CPsClientData* psSrcData = CPsClientData::NewL();

    CleanupStack::PushL(psSrcData);

    // Set the unique Id

    psSrcData->SetId(iInputParsedData->Id());

    // Set the unique URI Id

	psSrcData->SetUriL( iInputParsedData->CacheUriAt(0));

    RPointerArray<TDesC> contactDataArray;

    iInputParsedData->Data(contactDataArray)  ; 

    // Set the data elements

    for (TInt i(0); i < contactDataArray.Count(); i++)

    {

    }

    //set data extension

    if(contactDataArray.Count() > 0)

    psSrcData->SetDataExtensionL(contactDataArray[0]);

    //set IsMarked

    psSrcData->SetMark();

    // Create the destination CPsQuery

	CPsClientData* destObject = NULL;

	destObject = CPsClientData::NewL();

	CleanupStack::PushL(destObject);

    // Externalize to a stream of type RBufWriteStream

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen); 

    CleanupStack::PushL(buf);

    RBufWriteStream stream(*buf);

	stream.PushL(); 

	psSrcData->ExternalizeL(stream);

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

    // Internalize from the stream

	HBufC8* destBuf = HBufC8::NewLC(buf->Size()); 

    TPtr8 ptrdestBuf(destBuf->Des()); 

    buf->Read(0, ptrdestBuf, buf->Size()); 

	RDesReadStream rdStream(destBuf->Des()); 

	CleanupClosePushL(rdStream);

    destObject->InternalizeL(rdStream);

    CleanupStack::PopAndDestroy(3);//rdStream, destBuf, buf

    //Compare the internalized and externalized object

    TInt ret1 = iInputParsedData->CompareByDataL(*psSrcData,*destObject);

    TBool ret2 = ComparePsClientDataL(*psSrcData,*destObject);

    if(ret1 !=0 && ret2)

    {

    	errorStatus = KErrGeneral;

    }

	CleanupStack::PopAndDestroy(2);

	return errorStatus;

}

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

// This test case performs all the  operations on the CPsData

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

TInt CPsUtilsTestSuite::PsData_SetAndGetL( CStifItemParser& aItem )

{

	TInt errorStatus = KErrNone;

	CTestSuiteInputData* iInputParsedData = CTestSuiteInputData::NewL(aItem);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem) ;

  	// Create a new source PS Query object

    CPsData* psSrcData = CPsData::NewL();

    CleanupStack::PushL(psSrcData);

    // Set the unique Id

    psSrcData->SetId(iInputParsedData->Id());

    if(iInputParsedData->Id())

    {

	    // Set the unique URI Id

	    psSrcData->SetUriId(iInputParsedData->Id());

	    //set data matches

	    psSrcData->SetDataMatch(iInputParsedData->Id());

	    //add Extended Data field of Integers

	    psSrcData->AddIntDataExtL(iInputParsedData->Id());

    }    

    RPointerArray<TDesC> contactDataArray;

    iInputParsedData->Data(contactDataArray)  ; 

    // Set the data elements

    for (TInt i(0); i < contactDataArray.Count(); i++)

    {

    }

     //set data extension

    if(contactDataArray.Count() > 0)

    psSrcData->SetDataExtension(contactDataArray[0]);

    // Create the destination CPsQuery

}

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

// This test case performs all the  operations on the CPsSettings

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

TInt CPsUtilsTestSuite::PsSettings_SetAndGetL(CStifItemParser& aItem )

{

	TInt errorStatus = KErrNone;

	TInt err1= KErrGeneral;

	TInt err2 = KErrGeneral;

	CTestSuiteInputData* inputParsedData = CTestSuiteInputData::NewL(aItem);

	// Parse the input data

  	inputParsedData->ParseInputL(aItem) ;

	RArray<TInt> displayFields;

	inputParsedData->DisplayFields(displayFields);

	RPointerArray<TDesC> uriArray;

    inputParsedData->CacheUris(uriArray)  ;    

    TInt maxResult = inputParsedData->Id();

    // Create a new source CPsSettings object

    CPsSettings* srcPsSettings = CPsSettings::NewL();

    CleanupStack::PushL(srcPsSettings);  

    // set the search uris

    srcPsSettings->SetSearchUrisL(uriArray);

    // set display fields

    srcPsSettings->SetDisplayFieldsL(displayFields);

    // set max results

    srcPsSettings->SetMaxResults(maxResult);

    // set sort type

    srcPsSettings->SetSortType(inputParsedData->SortType());

    // Create the destination CPsSettings

	CPsSettings* destPsSettings = NULL;

	destPsSettings = CPsSettings::NewL();

	CleanupStack::PushL(destPsSettings);  

    // Externalize to a stream of type RBufWriteStream

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen); 

    CleanupStack::PushL(buf);  

    RBufWriteStream stream(*buf);

	stream.PushL(); 

	srcPsSettings->ExternalizeL(stream);

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

    // Internalize from the stream

	HBufC8* destBuf = HBufC8::NewLC(buf->Size()); 

    TPtr8 ptrdestBuf(destBuf->Des()); 

    buf->Read(0, ptrdestBuf, buf->Size()); 

	RDesReadStream rdStream(destBuf->Des()); 

	CleanupClosePushL(rdStream);

    destPsSettings->InternalizeL(rdStream);

    CleanupStack::PopAndDestroy(3);//rdStream, destBuf, buf

    // Create a new settings instance use CloneL

    CPsSettings *tempSettings = srcPsSettings->CloneL();

    RArray<TInt> groupId;

    //check for group id

    srcPsSettings->GetGroupIdsL(groupId);

    RArray<TInt> expGroupId;

	inputParsedData->GroupIds(expGroupId);

    if(groupId.Count() == expGroupId.Count() )

    {

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

	    {

	    	if(groupId[i] == expGroupId[i])

	    	{

	    		err1 = KErrNone;

	    	}

	    	else

	    	{

	    		err1 = KErrGeneral;

	    		break;

	    	}

	    }

    }

    else

    {

    	err1 = KErrGeneral;

    }

    //Compare the internalized and externalized object    

    //Compare the clone object with original object

	if( ComparePsSettingsL(*srcPsSettings, *destPsSettings) && 

		ComparePsSettingsL(*srcPsSettings, *tempSettings) )

    {

    	err2 = KErrNone;

    }

    else

    {

    	err2 = KErrGeneral;

    }

    if(err1 == KErrNone && err2 == KErrNone)

    {

    	errorStatus = KErrNone;

    }

    else

    {

    	errorStatus = KErrGeneral;

    }

    CleanupStack::PopAndDestroy(2);  // destPsSettings, srcPsSettings

  	// clean up

  	delete inputParsedData;

  	// return error code

  	return errorStatus;

}

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

// This test case performs all the  operations on the CPsSettings

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

TInt CPsUtilsTestSuite::PsPattern_SetAndGetL(CStifItemParser& aItem )

{

	TInt errorStatus = KErrNone;

	CTestSuiteInputData* inputParsedData = CTestSuiteInputData::NewL(aItem);

	// Parse the input data

	RPointerArray<TDesC> dataArray;