// Copyright (c) 2000-2009 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:

//

#include <e32std.h>

#include <e32test.h>

#include <msvstd.h>

#include <msvids.h>

#include <msvuids.h>

#include <pushentry.h>

#include <push/pushlog.h>

#include <push/cwappushmsgutils.h>

#include "testlog.h"

#include "t_serviceutils.h"

#include "t_pushentry.h"

_LIT(KPushEntryTestTitle,"T_PushEntry");

_LIT(KFilename,"picture.jpg");

_LIT(KFilename2,"image.gif");

// Uncomment the following define to switch on Heap Failure Testing

// #define __HEAP_FAILURE_TESTING

// Global variables

RTest gTest(_L("t_PushMessage Test Harness"));

/** Active scheduler defined for this testcode to catch error */

void CTestScheduler::Error(TInt aError) const

    {

    CActiveScheduler::Stop();

    gTest.Printf(_L("\nLeave signalled, reason=%d\n"),aError);

    }

CMessageDetails* CMessageDetails::NewL()

	{

	CMessageDetails* self = new (ELeave) CMessageDetails();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CMessageDetails::ConstructL()

	{

	iPushMsgType =0;   //Uid of message type goes in iBioType

	iStatusFlag = 0;

	iActionFlag =0;

	iSiId = HBufC::NewL(100);

	iCreated = Time::NullTTime(); //.DateTime();

	iExpires = Time::NullTTime();

	iURL =  HBufC::NewL(100);

	iText = HBufC::NewL(100);

	iFrom = HBufC8::NewL(100);

	iHeader = HBufC8::NewL(100);

	iContentType=HBufC::NewL(100);

	iMessageBody =HBufC8::NewL(300);

	iMsgDetails =HBufC::NewL(300);

	iMsgDescription =HBufC::NewL(300);

	iFilename = HBufC::NewL(100);

	}

CMessageDetails::CMessageDetails()

	{

	}

CMessageDetails::~CMessageDetails()

	{

	delete iSiId;

	delete iURL;

	delete iText;

	delete iFrom;	

	delete iHeader;

	delete iContentType;

	delete iMessageBody;

	delete iMsgDetails;

	delete iMsgDescription;

	delete iFilename;

	}

void CMessageDetails::ResetL()

	{

	iPushMsgType =0;   //Uid of message type goes in iBioType

	iStatusFlag = 0;

	iActionFlag =0;

	delete iSiId;

	iSiId = NULL;

	iSiId = HBufC::NewL(100);

	iCreated= Time::NullTTime();

	iExpires = Time::NullTTime();

	delete iURL; 

	iURL =NULL;

	iURL = HBufC::NewL(100);

	delete iText;

	iText = NULL;

	iText = HBufC::NewL(100);

	delete iFrom;

	iFrom = NULL;

	iFrom = HBufC8::NewL(100);

	delete iHeader;

	iHeader = NULL;

	iHeader = HBufC8::NewL(100);

	delete iContentType;

	iContentType =NULL;

	iContentType = HBufC::NewL(100);

	delete iMessageBody;

	iMessageBody=NULL;

	iMessageBody = HBufC8::NewL(300);

	}

// Test Harness - Active Object with a lot of states. Tests Get/Set, Save/Retrieve & Update,

// for Push Entries. Also tests the Message Utilities.  Use both together during the operations.

CPushEntryTester* CPushEntryTester::NewL(MWapPushLog& aLog)

	{

	CPushEntryTester* self = new (ELeave) CPushEntryTester(aLog);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CPushEntryTester::ConstructL()

	{

	__LOG_ALWAYS("Test Results");

	__LOG_ALWAYS(" ");

	iPushUtilities = CWapPushMsgUtils::NewL();

	iSISLPushUtilities = CSISLPushMsgUtils::NewL();

	iDetails = CMessageDetails::NewL();

	iMsvEntry = iPushUtilities->Session().GetEntryL(KMsvRootIndexEntryId);

    CActiveScheduler::Add(this);	

	}

CPushEntryTester::CPushEntryTester(MWapPushLog& aLog)

:CActive(CActive::EPriorityIdle), iLog(aLog)

	{

	}

CPushEntryTester::~CPushEntryTester()

	{

	Cancel();

	delete iMsvEntry;

	delete iDetails;

	delete iPushEntry;

	delete iPushUtilities;

	delete iSISLPushUtilities;

	}

void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt)

	{

	iFormatBuffer.Format(aFormat, aInt);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt1, TInt aInt2)

	{

	iFormatBuffer.Format(aFormat, aInt1, aInt2);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CPushEntryTester::LogFormatStr(const TDesC& aFormat, const TDesC& aDes)

	{

	iFormatBuffer.Format(aFormat, &aDes);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CPushEntryTester::LogStr(const TDesC& aDes)

	{

	iLog.WPLPrintf(aDes);

	}

void CPushEntryTester::RunL()

	{

	switch(iState)

		{

		case ETestInitialising:  

			__LOG_ALWAYS("=========    TEST - SI GET/SET WITH PARAMETERS              =========");

			CreateMsgDetailsL(EFalse);

			SiGetSetTestL();

			iState =ETestSIGetSet;// Test the setters getters with Non Null fields

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIGetSet:

			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS        =========");

			SiSaveRetrieveTestL();

			iState = ETestSISaveRetrieveWithStringAppID;//Test Save Retrieve with Non Null fields

			QueueOperationAsync(KErrNone);

			break;

		case ETestSISaveRetrieveWithStringAppID:

			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND STRING APPID  =========");

			SiSaveRetrieveTestL();

			iState = ETestSISaveRetrieveWithIntAppID;

			QueueOperationAsync(KErrNone);

			break;

		case ETestSISaveRetrieveWithIntAppID:

			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND INT APPID  =========");

			iState = ETestSISaveRetrieve;

			SiSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSISaveRetrieve:

			__LOG_ALWAYS("=========    TEST - SI GET/SET WITH NULL FIELDS             =========");

			CreateMsgDetailsL(ETrue);

			SiGetSetTestL();

			iState = ETestSIGetSetNull;// Test the setters getters with Null fields

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIGetSetNull:

			iState =  ETestSISaveRetrieveNull; //Test Save/Retrieve with Empty fields

			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH NULL FIELDS       =========");

			SiSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSISaveRetrieveNull:

			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING SI MESSAGE          =========");

			iState = ETestSIChangeEntry;

			ChangeSIEntryTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIChangeEntry:

			__LOG_ALWAYS("=========    TEST - SL GET/SET WITH PARAMETERS              =========");

			iState = ETestSLGetSet;//Test SL Set/Get functions with Empty fields

			CreateMsgDetailsL(EFalse);

			SlGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLGetSet:

			iState = ETestSLSaveRetrieve;

			__LOG_ALWAYS("=========    TEST - SL SAVE/RETRIEVE WITH PARAMETERS        =========");

			SlSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLSaveRetrieve:

			__LOG_ALWAYS("=========    TEST - SL GET/SET WITH EMPTY FIELDS            =========");

			iState = ETestSLGetSetNull;//Test SL Set/Get functions with Empty fields

			CreateMsgDetailsL(ETrue);

			SlGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLGetSetNull:

			__LOG_ALWAYS("=========    TEST - SL SAVE/RETRIEVE WITH EMPTY FIELDS      =========");

			iState = ETestSLSaveRetrieveNull;

			SlSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLSaveRetrieveNull:

			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING SL MESSAGE          =========");

			iState = ETestSLChangeEntry;

			ChangeSLEntryTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLChangeEntry:

			__LOG_ALWAYS("=========    TEST - MULTI GET/SET WITH PARAMETERS           =========");

			iState = ETestMultiGetSet;

			CreateMsgDetailsL(EFalse);

			MultiGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestMultiGetSet:

			__LOG_ALWAYS("=========    TEST - MULTI SAVE/RETRIEVE WITH PARAMETERS      =========");

			iState = ETestMultiSaveRetrieve;

			MultiSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestMultiSaveRetrieve: 

			__LOG_ALWAYS("=========    TEST - MULTI SET/GET WITH EMPTY FIELDS         =========");

			iState = ETestMultiGetSetNull;

			CreateMsgDetailsL(ETrue);

			MultiGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestMultiGetSetNull:

			__LOG_ALWAYS("=========   TEST - MULTI SAVE/RETRIEVE WITH EMPTY FIELDS    =========");

			iState = ETestMultiSaveRetrieveNull;

			MultiSaveRetrieveTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestMultiSaveRetrieveNull:

			__LOG_ALWAYS("=========    TEST - UNKNOWN GET/SET WITH PARAMETERS          =========");

			iState = ETestUnknownGetSet;

			CreateMsgDetailsL(EFalse);		

			UnknownGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownGetSet:

			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS    ==========");

			iState = ETestUnknownSaveRetrieve;

			UnknownSaveRetrieveTestL(EFalse);

			QueueOperationAsync(KErrNone);

			break;	

		case ETestUnknownSaveRetrieve:

			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS AND FILENAME     =========");

			iState = ETestUnknownSaveRetrieveWithFilename;

			UnknownSaveRetrieveTestL(ETrue);

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownSaveRetrieveWithFilename:

			__LOG_ALWAYS("=========    TEST - UNKNOWN GET/SET WITH EMPTY FIELDS        =========");

			iState = ETestUnknownGetSetNull;

			CreateMsgDetailsL(ETrue);

			UnknownGetSetTestL();

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownGetSetNull:

			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS   =========");

			iState = ETestUnknownSaveRetrieveNull;

			UnknownSaveRetrieveTestL(EFalse);

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownSaveRetrieveNull:  

			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS AND FILENAME     =========");

			iState = ETestUnknownSaveRetrieveNullWithFilename;

			UnknownSaveRetrieveTestL(ETrue);

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownSaveRetrieveNullWithFilename: 	// Test updating an Unknown Msg

			__LOG_ALWAYS("=========     TEST - UPDATING A EXISTING UNKNOWN MESSAGE     =========");

			iState = ETestUnknownChangeEntry;

			ChangeUnknownEntryTestL(EFalse);

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownChangeEntry:	// Test updating an Unknown Msg with filename

			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING UNKNOWN MESSAGE  WITH FILENAME     =========");

			iState = ETestUnknownChangeEntryWithFilename;  

			ChangeUnknownEntryTestL(ETrue);

			QueueOperationAsync(KErrNone);

			break;

		case ETestUnknownChangeEntryWithFilename:

			__LOG_ALWAYS("=========    TEST - SI FIND BY AN ID                          =========");

			iState = ETestSIFindSiId;  

			CreateMoreSiMessagesL();

			FindSiIdTestL(EFalse); // Not looking for a null ID string

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIFindSiId:

			iState =  ETestSIFindSiIdNull; //Test Find Function  with Empty fields

			__LOG_ALWAYS("=========    TEST - SI FIND A NULL ID                         =========");

			FindSiIdTestL(ETrue);  // Looking for a null ID string

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIFindSiIdNull:

			iState =  ETestSIFindSiUrl; //Test Find with Non Null URL field

			__LOG_ALWAYS("=========    TEST - SI FIND A URL                             =========");

			FindUrlTestL(EFalse, KUidWapPushMsgSI);

			QueueOperationAsync(KErrNone);

			break;

		case ETestSIFindSiUrl:

			iState = ETestSIFindSiUrlNull;  //Test Find with a Null URL field

			__LOG_ALWAYS("=========    TEST - SI FIND A NULL URL                        =========");

			FindUrlTestL(ETrue, KUidWapPushMsgSI);

			QueueOperationAsync(KErrNone); 

			break;

		case ETestSIFindSiUrlNull:

			__LOG_ALWAYS("=========    TEST - SL FIND A URL                             =========");

			iState = ETestSLFindUrl;

			CreateMoreSLMessagesL();

			FindUrlTestL(EFalse, KUidWapPushMsgSL);

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLFindUrl :

			__LOG_ALWAYS("=========    TEST - SL FIND NULL URL                          =========");

			iState = ETestSLFindUrlNull;

			FindUrlTestL(ETrue , KUidWapPushMsgSL);

			QueueOperationAsync(KErrNone);

			break;

		case ETestSLFindUrlNull:

			__LOG_ALWAYS("=========    TEST - GET HIGHEST SI ACTION                     =========");

			iState = ETestSIGetHiAction;

			GetActionTestL(KUidWapPushMsgSI);

			QueueOperationAsync(KErrNone); 

			break;

		case ETestSIGetHiAction:

			__LOG_ALWAYS("=========    TEST - GET HIGHEST SL ACTION                     =========");

			iState = ETestSLGetHiAction ;

			GetActionTestL(KUidWapPushMsgSL);

			QueueOperationAsync(KErrNone); 

			break;

		case ETestSLGetHiAction:

			iState = ETestGetExpiry;

			__LOG_ALWAYS("=========    TEST - GET EARLIEST SI EXPIRY                    =========");

			//DumpPushMessageDetailsL(KUidWapPushMsgSI);

			//DumpPushMessageDetailsL(KUidWapPushMsgSL);

			//DumpPushMessageDetailsL(KUidWapPushMsgMultiPart);

			//DumpPushMessageDetailsL(KUidWapPushMsgUnknown);

			GetExpiryTestL();

 			QueueOperationAsync(KErrNone); 

			break;

		case ETestGetExpiry:

			iState = ETestGetNextExpiry;

			__LOG_ALWAYS("=========    TEST - GET NEXT     SI EXPIRY                    =========");

			DeleteEarliestExpiryL();

			GetExpiryTestL();

			QueueOperationAsync(KErrNone); 

			break;

		case ETestGetNextExpiry:

			iState = ETestComplete;

			if (!iFailures)

				{

				__LOG_ALWAYS(" ");

				__LOG_ALWAYS("Tests Completed");

				}

			else 

				{

				LogFormatInt(_L("=========      TESTS FAILED !! TOTAL OF %d UNSUCESSFUL        ========="), iFailures);

				}

			QueueOperationAsync(KErrNone);

			break;

		case ETestComplete: //finished

			User::After(10000);

			Cancel();

			CActiveScheduler::Stop();

			break;

		default:

			break;

		}

	User::After(500);

	}

void CPushEntryTester::QueueOperationAsync(TInt aErr)

    {

    TRequestStatus*  pS = &iStatus;

	iStatus = KRequestPending;

    User::RequestComplete(pS, aErr);

	SetActive();

    }

void CPushEntryTester::DoCancel()

	{

	}

void CPushEntryTester::StartL()

	{

	iFailures = 0;

	CreateHeaders();

	iState = ETestInitialising;

	QueueOperationAsync(KErrNone);

	}

// Halt the Scheduler & inform the user

TInt CPushEntryTester::RunError(TInt aError)

	{

	if (aError != KErrNone)

		{

		LogFormatInt(_L("Error %d  occurred"), aError);

		__LOG_DEBUG("Tests Failed!");

		iFailures++;

		CActiveScheduler::Stop();

		}

	return KErrNone;

	}

// Tests use of get/set methods on a CSIPushMsgEntry