// Copyright (c) 2004-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 "t_schedulesend.h"	

#include <e32test.h>

#include <msvuids.h>

#include "pigeonservermtm.h"

#include <msvsysagentaction.h>

#include <msvschedulesettings.h>

#include <tmsvschedulesettingsutils.h>

#include <centralrepository.h>

#include "t_schsendshare.h"

#include <e32property.h>

TBool definedPhonePwrValue = EFalse;

TBool definedSIMStatusValue = EFalse;

TBool definedNetworkStatusValue = EFalse;

_LIT(KPigeonDataComponentFileName, "z:\\resource\\messaging\\mtm\\pigeon.rsc");

_LIT(KFailed,"Failed to complete tests.");

_LIT(KScheduleSendTestPanic, "SchSendTst");

_LIT(KTestScheduleSendScheduleMultiple,			"Schedule multiple messages");

_LIT(KTestScheduleSendReScheduleTime_1,			"ReSechedule multiple messages, for same time");

_LIT(KTestScheduleSendReScheduleTime_2,			"ReSechedule multiple messages, for differnt times");

_LIT(KTestScheduleSendReScheduleConditions_1,	"ReSechedule multiple messages, for conditions, no timeout - conditions met");

_LIT(KTestScheduleSendReScheduleConditions_2,	"ReSechedule multiple messages, for conditions, with timeout - conditions met");

_LIT(KTestScheduleSendReScheduleConditions_3,	"ReSechedule multiple messages, for conditions, with timeout - timeout will occur");

_LIT(KTestScheduleSendReScheduleMixed_1,		"ReSechedule multiple messages, for time and conditions, with timeout - conditions met");

_LIT(KTestScheduleSendFailed_1,					"Fail multiple messages");

_LIT(KTestScheduleSendFailed_2,					"Fail multiple messages after second re-schedule");

_LIT(KStateUnknown,			"KMsvSendStateUnknown");

_LIT(KStateUponRequest, 	"KMsvSendStateUponRequest");

_LIT(KStateWaiting,			"KMsvSendStateWaiting");

_LIT(KStateSending,			"KMsvSendStateSending");

_LIT(KStateScheduled,		"KMsvSendStateScheduled");

_LIT(KStateResend,			"KMsvSendStateResend");

_LIT(KStateSuspended,		"KMsvSendStateSuspended");

_LIT(KStateFailed,			"KMsvSendStateFailed");

_LIT(KStateSent,			"KMsvSendStateSent");

_LIT(KStateNotApplicable,	"KMsvSendStateNotApplicable");

_LIT(KBoolTrue, 			"ETrue");

_LIT(KBoolFalse, 			"EFalse");

RTest test(_L("T_ScheduleSend Test Harness"));

LOCAL_C void CreateVariablesL()

	{

	TInt testState;

	if(KErrNone != RProperty::Get(KUidSystemCategory, KMsvTestUidPhonePwrValue, testState))

		{

		User::LeaveIfError(RProperty::Define(KUidSystemCategory, KMsvTestUidPhonePwrValue, RProperty::EInt));	// Qualified: No leavescan error

		definedPhonePwrValue = ETrue;

		}

	if(KErrNone != RProperty::Get(KUidSystemCategory, KMsvTestUidSIMStatusValue, testState))

		{

		User::LeaveIfError(RProperty::Define(KUidSystemCategory, KMsvTestUidSIMStatusValue, RProperty::EInt));	// Qualified: No leavescan error

		definedSIMStatusValue = ETrue;

		}

	if(KErrNone != RProperty::Get(KUidSystemCategory, KMsvTestUidNetworkStatusValue, testState))

		{

		User::LeaveIfError(RProperty::Define(KUidSystemCategory, KMsvTestUidNetworkStatusValue, RProperty::EInt));	// Qualified: No leavescan error

		definedNetworkStatusValue = ETrue;

		}

	}

LOCAL_C void DeleteVariablesL()

	{

	if(definedPhonePwrValue)

		{

		User::LeaveIfError(RProperty::Delete(KUidSystemCategory, KMsvTestUidPhonePwrValue));

		}

	if(definedSIMStatusValue)

		{

		User::LeaveIfError(RProperty::Delete(KUidSystemCategory, KMsvTestUidSIMStatusValue));

		}

	if(definedNetworkStatusValue)

		{

		User::LeaveIfError(RProperty::Delete(KUidSystemCategory, KMsvTestUidNetworkStatusValue));

		}

	}	

LOCAL_C void DoTestsL()

	{

	// Create and install the active scheduler

 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	// Create the test engine

	CTestEngine* testEngine = CTestEngine::NewL(test);

	CleanupStack::PushL(testEngine);

	CreateVariablesL();

	// Do tests...

	testEngine->DoTestsL();

	DeleteVariablesL();

	CleanupStack::PopAndDestroy(2, scheduler);

	}

GLDEF_C TInt E32Main()

	{	

	__UHEAP_MARK;

	CTrapCleanup* tc=CTrapCleanup::New();

	TRAPD(err,DoTestsL());

	if (err!=KErrNone)

		User::Panic(KFailed, err);

	delete tc;

	test.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}

/*

 * CScheduleSendTestUtils

 */

CScheduleSendTestUtils* CScheduleSendTestUtils::NewL(RTest& aTest, TUint aCreationFlags)

	{

	CScheduleSendTestUtils* self = new (ELeave) CScheduleSendTestUtils(aTest);

	CleanupStack::PushL(self);

	self->ConstructL(aCreationFlags);

	CleanupStack::Pop(self);

	return self;	

	}

CScheduleSendTestUtils::~CScheduleSendTestUtils()

	{

	CMsvTestUtils::Reset();

	}

CScheduleSendTestUtils::CScheduleSendTestUtils(RTest& aTest)

: CMsvTestUtils(aTest)

	{

	}

TMsvId CScheduleSendTestUtils::ServiceId()

	{

	return iServiceId;

	}

void CScheduleSendTestUtils::ConstructL(TUint aCreationFlags)

	{

	CMsvTestUtils::ConstructL(aCreationFlags);

	}

void CScheduleSendTestUtils::InstallPigeonMtmGroupL()

	{

	InstallMtmGroupL(KPigeonDataComponentFileName);

	}

void CScheduleSendTestUtils::CreatePigeonServerMtmRegL()

	{

	// Don't bother - use resource file!

	}

void CScheduleSendTestUtils::DeletePigeonMessagesL(TMsvId aFolder)

	{

	SetEntryL(aFolder);

	CMsvEntrySelection* sel = ChildrenWithMtmLC(KUidMsgTypePigeon);

	TInt count = sel->Count();

	while( count-- )

		{

		DeleteEntryL(sel->At(count));

		}

	CleanupStack::PopAndDestroy(sel);

	}

void CScheduleSendTestUtils::NotifySaPhoneOnL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOn));

	}

void CScheduleSendTestUtils::NotifySaPhoneOffL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOff));

	}

void CScheduleSendTestUtils::NotifySaSimOkL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidSIMStatusValue, EMsvTestSimOk));

	}

void CScheduleSendTestUtils::NotifySaSimNotPresentL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidSIMStatusValue, EMsvTestSimNotPresent));

	}

void CScheduleSendTestUtils::NotifySaNetworkAvailableL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidNetworkStatusValue, EMsvTestNetworkAvailable));

	}

void CScheduleSendTestUtils::NotifySaNetworkUnAvailableL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidNetworkStatusValue, EMsvTestNetworkUnAvailable));

	}

void CScheduleSendTestUtils::UpdateSysAgentConditionsL()

	{

	CMsvSysAgentActions* actions = new (ELeave) CMsvSysAgentActions();

	CleanupStack::PushL(actions);

	CRepository* repository = CRepository::NewLC(KUidMsgTypePigeon);

	// load existing settings

	TRAPD(error, TMsvScheduleSettingsUtils::LoadSysAgentSettingsL(*actions, *repository));

	if( error==KErrNone )

		{

		// Reset the conditions - leave the default action.

		actions->Reset();

		}

	// Add the conditions

	TMsvSysAgentConditionAction condAction;

	condAction.iUseDefaultSysAgentAction = ETrue;

	condAction.iCondition.iVariable = KMsvTestUidSIMStatus;

	condAction.iCondition.iState = EMsvTestSimOk;

	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;

	actions->AppendL(condAction);

	condAction.iCondition.iVariable = KMsvTestUidNetworkStatus;

	condAction.iCondition.iState = EMsvTestNetworkAvailable;

	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;

	actions->AppendL(condAction);

	// save these settings

	TMsvScheduleSettingsUtils::SaveSysAgentSettingsL(*actions, *repository);	

	CleanupStack::PopAndDestroy(2, actions); 

	}

void CScheduleSendTestUtils::UpdatePendingConditionsTimeoutL(TTimeIntervalMinutes aTimeout)

	{

	CMsvScheduleSettings* settings = CMsvScheduleSettings::NewL();

	CleanupStack::PushL(settings);

	// access sms account settings

	CRepository* repository = CRepository::NewLC(KUidMsgTypePigeon);

	TMsvScheduleSettingsUtils::LoadScheduleSettingsL(*settings, *repository);

	// Store the pending conditions timeout

	settings->SetPendingConditionsTimeout(aTimeout);

	// save these settings

	TMsvScheduleSettingsUtils::SaveScheduleSettingsL(*settings, *repository);

	CleanupStack::PopAndDestroy(2, settings);

	}

//	Methods from CMsvTestUtils

void CScheduleSendTestUtils::CreateServicesL()

	{

	iServiceId = CreateServiceL(KUidMsgTypePigeon, EFalse, ETrue);

	}

void CScheduleSendTestUtils::DeleteServicesL()

	{

	DeleteServiceL(KUidMsgTypePigeon);

	}

void CScheduleSendTestUtils::InstallMtmGroupsL()

	{

	InstallPigeonMtmGroupL();

	}

void CScheduleSendTestUtils::CreateServerMtmRegsL()

	{

	CreatePigeonServerMtmRegL();

	}

//	Methods from CTestUtils

void CScheduleSendTestUtils::Panic(TInt aPanic)

	{

	User::Panic(KScheduleSendTestPanic, aPanic);

	}

/*

 *	CTestEngine

 */

CTestEngine* CTestEngine::NewL(RTest& aTest)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTest);

	CleanupStack::Pop(self);

	return self;

	}

CTestEngine::~CTestEngine()

	{

	delete iTestUtils;

	}

CTestEngine::CTestEngine()

:CBase()

	{

	}

void CTestEngine::ConstructL(RTest& aTest)

	{

	iTestUtils = CScheduleSendTestUtils::NewL(aTest);

	// Install the pigeon MTM.

	iTestUtils->InstallMtmGroupsL();

	}

void CTestEngine::DoTestsL()

	{

	CTestScheduleSendBase* testCase = NULL;

	testCase = CTestSchedule::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;	

	testCase = CTestReScheduleTime_1::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;

	testCase = CTestReScheduleTime_2::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;	

	testCase = CTestRescheduleConditions_1::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;

	testCase = CTestRescheduleConditions_2::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;

	testCase = CTestRescheduleConditions_3::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;

	testCase = CTestRescheduleMixed_1::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;

	testCase = CTestFailed_1::NewL(*iTestUtils);

	testCase->Start();

	CActiveScheduler::Start();

	delete testCase;		

	iTestUtils->TestHarnessCompleted();	

	}

/*

 * CTestFolderObserver

 */

CTestFolderObserver* CTestFolderObserver::NewL(MTestFolderObserverCallback& aCallback, TMsvId aFolderId)

	{

	CTestFolderObserver* self = new (ELeave) CTestFolderObserver(aCallback, aFolderId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestFolderObserver::~CTestFolderObserver()

	{

	delete iEntryForObserver;

	}

CTestFolderObserver::CTestFolderObserver(MTestFolderObserverCallback& aCallback, TMsvId aFolderId)

: CBase(), iCallback(aCallback), iFolderId(aFolderId)

	{

	}

void CTestFolderObserver::ConstructL()

	{

	iEntryForObserver = iCallback.CreateEntryL(iFolderId);

	}

void CTestFolderObserver::StartObserverL()

	{

	iEntryForObserver->AddObserverL(*this);

	}

void CTestFolderObserver::StopObserver()

	{

	iEntryForObserver->RemoveObserver(*this);

	}	

// methods from MMsvEntryObserver

void CTestFolderObserver::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	CMsvEntrySelection* sel = (CMsvEntrySelection*)(aArg1);

	// The messages in the outbox have been updated - check them.

	if(  aEvent == EMsvNewChildren )

		{

		TInt count = sel->Count();

		for( TInt i=0; i < count; ++i )

			{

			// Notify the callback

			iCallback.UpdatedMessageL(iFolderId, sel->At(i));

			}

		}	

	}

/*

 * CTestScheduleSendBase

 */

CTestScheduleSendBase::~CTestScheduleSendBase()

	{

	delete iSelection;

	delete iPendingSent;

	delete iOutboxObserver;

	delete iSentFolderObserver;

	delete iOperation;

	}	

void CTestScheduleSendBase::Start()

	{

	iTestUtils.Printf(_L("Starting %S\n"), &TestName());

	iState = EClearFolders;

	CompleteSelf();

	}

CTestScheduleSendBase::CTestScheduleSendBase(CScheduleSendTestUtils& aTestUtils)

: CActive(CActive::EPriorityStandard), iTestUtils(aTestUtils)

	{

	CActiveScheduler::Add(this);

	}

void CTestScheduleSendBase::ConstructL()

	{

	iSelection = new (ELeave) CMsvEntrySelection();

	iPendingSent = new (ELeave) CMsvEntrySelection();

	iOutboxObserver = CTestFolderObserver::NewL(*this, KMsvGlobalOutBoxIndexEntryId);

	iSentFolderObserver = CTestFolderObserver::NewL(*this, KMsvSentEntryId);

	}

void CTestScheduleSendBase::CompleteSelf()

	{

	TRequestStatus* pStat = &iStatus;

	User::RequestComplete(pStat, KErrNone);

	SetActive();

	}

CMsvSession& CTestScheduleSendBase::Session()

	{

	return *iTestUtils.iMsvSession;

	}

CMsvEntry& CTestScheduleSendBase::MsvEntry()

	{

	return *iTestUtils.iMsvEntry;

	}

void CTestScheduleSendBase::ClearFoldersL()

	{

	iTestUtils.DeletePigeonMessagesL(KMsvGlobalOutBoxIndexEntryId);

	iTestUtils.DeletePigeonMessagesL(KMsvGlobalInBoxIndexEntryId);

	iTestUtils.DeletePigeonMessagesL(KMsvSentEntryId);		

	}

void CTestScheduleSendBase::TestComplete()

	{

	iTestUtils.Printf(_L("Test Complete\n"));

	CActiveScheduler::Stop();

	}

TMsvId CTestScheduleSendBase::CreateMessageL(TTime& aTime, TInt aError)

	{

	iTestUtils.Printf(_L("Creating message...\n"));

	TMsvEntry entry;

	entry.SetVisible(ETrue); 

	entry.SetInPreparation(EFalse); 

	entry.iServiceId = KMsvLocalServiceIndexEntryId; 

	entry.iType = KUidMsvMessageEntry; 

	entry.iMtm = KUidMsgTypePigeon; 

	entry.iDate = aTime; 

	entry.iSize = 0; 

	entry.iDescription.Set(KNullDesC); 

	entry.iDetails.Set(KNullDesC); 

	entry.iError = aError;

	entry.SetOffPeak(EFalse);

	entry.SetScheduled(EFalse);	

	entry.SetSendingState(KMsvSendStateWaiting);

	// Create the entry - set context to the global outbox.

	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	MsvEntry().CreateL(entry);

	return entry.Id();

	}

void CTestScheduleSendBase::TransferCommandL(TInt aCommand)

	{