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

#include <e32test.h>

#include <smutset.h>

#include <smuthdr.h>

#include <txtrich.h>

#include "smstestutils.h"

#include <msvuids.h>

#include <smsuaddr.h>

#include <csmsaccount.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include <tmsvsmsentry.h>

#endif

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

_LIT(KRecipientOk,		"+447747065438");  // has to be valid number and switched on

_LIT(KRecipientBad,		"+442071541467");

_LIT(KRecipientFail,	"+34933753717");

_LIT(KMessageData, "This is a simple text message");

_LIT(KTestDeliverOneRecipientOk,		"Single recipient, deliver ok");

_LIT(KTestDeliverOneRecipientFail, 		"Single recipient, deliver fail");

_LIT(KTestDeliverMultiRecipientsOk_1,	"Multi (2) recipients, deliver ok"); 

_LIT(KTestDeliverMultiRecipientsOk_2,	"Multi (2) recipients, deliver ok, but 1 fails to send");

_LIT(KTestDeliverMultiRecipientsOk_3,	"Multi (3) recipients, deliver ok, but 1 fails to send");

_LIT(KTestDeliverNoMatching,			"Single recipient, no matching");

_LIT(KTestDeliverNoStatusReports,		"Single recipient, no status reports");

_LIT(KTestDeliverNotSent,				"Single recipient, not sent");

_LIT(KTestDeliverMultiRecipientsFail_1,	"Multi (2) recipients, deliver failure");

_LIT(KTestDeliverMultiRecipientsMixed_1,"Multi (2) recipients, 1 deliver ok, 1 deliver failure");

_LIT(KTestDeliverMultiRecipientsMixed_2,"Multi (2) recipients, 2 deliver failures");

#if defined (__WINS__)

_LIT(KPddName,"ECDRV");

_LIT(KLddName,"ECOMM");

#else	//__WINS__

_LIT(KPddSirName,"ESIR");

_LIT(KPddUartName,"ECUART4");

_LIT(KLddName,"ECOMM");

#endif	//__WINS__

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

const TTimeIntervalMicroSeconds32 KWaitForWatchersToStart = 20000000;

const TTimeIntervalMicroSeconds32 KWaitForWatchersToStartDisplayInterval = 5000000;

LOCAL_C void DoTestsL()

	{

#if defined (__WINS__)

	User::LoadPhysicalDevice(KPddName);

	User::LoadLogicalDevice(KLddName);

#else	//__WINS__

	User::LoadPhysicalDevice(KPddSirName);

	User::LoadPhysicalDevice(KPddUartName);

    User::LoadLogicalDevice(KLddName);

#endif	//__WINS__

	TInt r = StartC32();

	if( (r != KErrNone) && (r != KErrAlreadyExists) )

		test.Printf(_L("Failed to start C32 %d\n"), r);

	// 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();

	CleanupStack::PushL(testEngine);

	// Do tests...

	testEngine->DoTestsL();

	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;

	}

/*

 *	CTestEngine

 */

CTestEngine* CTestEngine::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestEngine::~CTestEngine()

	{

	delete iTestUtils;

	delete iWatchers;

	iSocket.Close();

	iSocketServ.Close();

	}

CTestEngine::CTestEngine()

: CBase()

	{

	}

void CTestEngine::DoTestsL()

	{

	CTestDeliverBase* testCase = NULL;

	testCase = CTestDeliverOneRecipientOk::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverMultiRecipientsOk_1::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverMultiRecipientsOk_2::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverMultiRecipientsOk_3::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverNoMatching::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverNoStatusReports::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverNotSent::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = CTestDeliverOneRecipientFail::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = 	CTestDeliverMultiRecipientsFail_1::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = 	CTestDeliverMultiRecipientsMixed_1::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	testCase = 	CTestDeliverMultiRecipientsMixed_2::NewL(*iTestUtils);

	RunTestCaseL(*testCase);

	}

void CTestEngine::RunTestCaseL(CTestDeliverBase& aTestCase)

	{

	CleanupStack::PushL(&aTestCase);

	aTestCase.Start();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(&aTestCase);

	}

void CTestEngine::ConstructL()

	{

	// This should create the SMS service, including the service settings.

	iTestUtils = CSmsTestUtils::NewL(test);

	// Notify the system agent that the phone is on.

	iTestUtils->NotifySaPhoneOnL();

	// Tell the tests utils to log to file

	iTestUtils->SetLogToFile();

	// Restore the service settings.

	iTestUtils->SetEntryL(iTestUtils->iSmsServiceId);

	CSmsAccount* account = CSmsAccount::NewLC();

	account->LoadSettingsL(*iTestUtils->iServiceSettings);

	// Remove the default service centres from the service settings

	TInt count = iTestUtils->iServiceSettings->ServiceCenterCount();

	while( count-- )

		{

		iTestUtils->iServiceSettings->RemoveServiceCenter(count);

		}

	// Add the Vodafone service centre - store the settings.

	iTestUtils->iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+447785016005"));

	// Set delivery options - do matching and make reports visible.	

	iTestUtils->iServiceSettings->SetDeliveryReport(ETrue);

	iTestUtils->iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	account->SaveSettingsL(*iTestUtils->iServiceSettings);

	CleanupStack::PopAndDestroy(account);

	// Create a session with the SMS stack - note order of the next few things

	// is important.

	User::LeaveIfError(iSocketServ.Connect());

	TProtocolDesc protoinfo;

	TProtocolName protocolname(KSmsDatagram);

	User::LeaveIfError(iSocketServ.FindProtocol(protocolname,protoinfo));

	User::LeaveIfError(iSocket.Open(iSocketServ,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol));

	TSmsAddr smsaddr;

	smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly);

	User::LeaveIfError(iSocket.Bind(smsaddr));

	// Initialise phone...

	iTestUtils->WaitForInitializeL();

	// Start watchers...

	StartWatcherL();

	}

TBool CTestEngine::WatchersAlreadyRunningL()

	{

	RSocketServ server;

	RSocket socket;

	User::LeaveIfError(server.Connect());

	CleanupClosePushL(server);

		// test if it's there... 

	TProtocolDesc protoInfo;

	TProtocolName protocolname;

	protocolname.Copy(KSmsDatagram);

	User::LeaveIfError(server.FindProtocol(protocolname,protoInfo));

	User::LeaveIfError(socket.Open(server,

										protoInfo.iAddrFamily,

										protoInfo.iSockType, 

										protoInfo.iProtocol));

	CleanupClosePushL(socket);

	TSmsAddr addr;

	addr.SetSmsAddrFamily(ESmsAddrRecvAny);

	TInt err = socket.Bind(addr);

	CleanupStack::Pop(2, &server);

	socket.CancelAll();

	socket.Close();

	server.Close();

	return (err == KErrAlreadyExists);

	}

void CTestEngine::StartWatcherL()

	{

	iTestUtils->Printf(_L("Start the Watcher"));

	if( WatchersAlreadyRunningL() )

		{

		iTestUtils->Printf(_L("Watchers are already running\n"));

		return;

		}

	iWatchers = CTestUtilsWatcherStarter::NewL();

	TTimeIntervalMicroSeconds32 wait = KWaitForWatchersToStart;

	TBool started = EFalse;

	while( !started && wait.Int() > 0 )

		{

		iTestUtils->Printf(_L("Waiting %d secs for watchers to start...\n"), wait.Int() / 1000000);

		wait = wait.Int() - KWaitForWatchersToStartDisplayInterval.Int();

		User::After(KWaitForWatchersToStartDisplayInterval);

		started = WatchersAlreadyRunningL();

		}

	if( !WatchersAlreadyRunningL() )

		{

		iTestUtils->Printf(_L("WARNING: NBS Watcher has not started yet\n"));

		}

	}

/*

 * CTestDeliverBase

 */

CTestDeliverBase::~CTestDeliverBase()

	{

	delete iEntryForObserver;

	delete iOperation;

	}	

void CTestDeliverBase::Start()

	{

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

	iState = EClearFolders;

	CompleteSelf();

	}

CTestDeliverBase::CTestDeliverBase(CSmsTestUtils& aTestUtils)

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

	{

	CActiveScheduler::Add(this);

	}

void CTestDeliverBase::ConstructL()

	{

	iEntryForObserver = Session().GetEntryL(KMsvGlobalInBoxIndexEntryId);

	}

void CTestDeliverBase::CompleteSelf()

	{

	TRequestStatus* pStat = &iStatus;

	User::RequestComplete(pStat, KErrNone);

	SetActive();

	}

CMsvSession& CTestDeliverBase::Session()

	{

	return *iTestUtils.iMsvSession;

	}

CMsvEntry& CTestDeliverBase::MsvEntry()

	{

	return *iTestUtils.iMsvEntry;

	}

CSmsClientMtm& CTestDeliverBase::Client()

	{

	return *iTestUtils.iSmsClientMtm;

	}

CSmsSettings& CTestDeliverBase::ServiceSettings()

	{

	return *iTestUtils.iServiceSettings;

	}

void CTestDeliverBase::ClearFoldersL()

	{

	iTestUtils.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	iTestUtils.DeleteSmsMessagesL(KMsvGlobalInBoxIndexEntryId);

	iTestUtils.DeleteSmsMessagesL(KMsvSentEntryId);		

	}

void CTestDeliverBase::TestComplete()

	{

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

	CActiveScheduler::Stop();

	}

void CTestDeliverBase::CreateMessageL()

	{

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

	TMsvEntry entry;

	entry.SetVisible(ETrue); 

	entry.SetInPreparation(ETrue); 

	entry.iServiceId = iTestUtils.iSmsServiceId; 

	entry.iType = KUidMsvMessageEntry; 

	entry.iMtm = KUidMsgTypeSMS; 

	entry.iDate.HomeTime(); 

	entry.iSize = 0; 

	entry.iDescription.Set(KNullDesC); 

	entry.iDetails.Set(KNullDesC); 

	// Check send options...

	TUint sendState = KMsvSendStateWaiting; 

	switch( ServiceSettings().Delivery() )  

		{ 

	case ESmsDeliveryScheduled: 

		sendState = KMsvSendStateScheduled; 

		break; 

	case ESmsDeliveryUponRequest: 

		sendState = KMsvSendStateUponRequest; 

		break; 

	default: 

		sendState = KMsvSendStateWaiting; 

		break;

		}

	entry.SetSendingState(sendState); 

	// Create the SMS header object...

	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

	CleanupStack::PushL(header);

	// Set the body text...

	iTestUtils.iRichText->Reset();

	iTestUtils.iRichText->InsertL(0, KMessageData);

	// Copy the message settings...

	header->SetSmsSettingsL(ServiceSettings()); 

	// Set the service centre

	TInt defaultIndex = ServiceSettings().DefaultServiceCenter();

	header->SetServiceCenterAddressL(ServiceSettings().GetServiceCenter(defaultIndex).Address());

	// Set recipient - ask derived class

	SetRecipientsL(*header);

	// Update entry description and details...

	CArrayPtrFlat<CSmsNumber>& recipient = header->Recipients();

	entry.iDetails.Set(recipient[0]->Address());

	entry.iDescription.Set(iTestUtils.iRichText->Read(0, ServiceSettings().DescriptionLength()));

	entry.SetInPreparation(EFalse);

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

	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	MsvEntry().CreateL(entry);

	// Create new store and save header information 

	MsvEntry().SetEntryL(entry.Id()); 

	CMsvStore* store = MsvEntry().EditStoreL(); 

	CleanupStack::PushL(store); 

	header->StoreL(*store);

	store->StoreBodyTextL(*iTestUtils.iRichText);

	store->CommitL(); 

	CleanupStack::PopAndDestroy(2, header); 

	iMessageId = entry.Id();

	}

void CTestDeliverBase::SendMessageL()

	{

	iTestUtils.Printf(_L("Sending message %d\n"), iMessageId);

	delete iOperation;

	iOperation = NULL;

	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();

	CleanupStack::PushL(sel);

	sel->AppendL(iMessageId);

	iTestUtils.DisplayMessageL(iMessageId);

	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	iOperation = MsvEntry().CopyL(*sel, iTestUtils.iSmsServiceId, iStatus);

	CleanupStack::PopAndDestroy(sel);

	SetActive();

	}

void CTestDeliverBase::ChangeServiceSettingsL()

	{

	// Restore the service settings.

	iTestUtils.SetEntryL(iTestUtils.iSmsServiceId);

	CSmsAccount* account = CSmsAccount::NewLC();

	account->LoadSettingsL(*iTestUtils.iServiceSettings);

	// Set the service settings 

	iTestUtils.iServiceSettings->SetValidityPeriod(TTimeIntervalMinutes(5));

	iTestUtils.iServiceSettings->SetDeliveryReport(ETrue);

	iTestUtils.iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	// Store the new service settings

	account->SaveSettingsL(*iTestUtils.iServiceSettings);

	CleanupStack::PopAndDestroy(account);

	}

void CTestDeliverBase::CheckCreatedMessageL()

	{

	// Need to check the following - 

	// 1. All recipients have correct delivery status - ENoAckRequested.

	// 2. The index summary is correct - ENoAckSummary

	// 3. The index message IS is invalid.

	iTestUtils.Printf(_L("Checking created message %d has correct flags set...\n"), iMessageId);

	// Restore the recipient...

	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

	CleanupStack::PushL(header);

	MsvEntry().SetEntryL(iMessageId);

	CMsvStore* store = iTestUtils.ReadStoreL();

	CleanupStack::PushL(store);

	header->RestoreL(*store);

	CleanupStack::PopAndDestroy(store);

	TInt rcptCount = header->Recipients().Count();

	for( TInt ii = 0; ii < rcptCount; ++ii )

		{

		CSmsNumber* rcpt = header->Recipients()[ii];

		iTestUtils.Printf(_L("--Recipient %d - Delivery status -> %d - should be %d (ENoAckRequested)\n"), ii, rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested);

		iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested);

		}

	TMsvSmsEntry entry = MsvEntry().Entry();

	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (ENoAckSummary)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::ENoAckSummary);

	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::ENoAckSummary);

	TLogId logId = 0;	

	TBool validId = entry.MessageId(logId);

	iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse);

	iTestUtils.Test()(validId == EFalse);

	CleanupStack::PopAndDestroy(header);

	}

TMsvId CTestDeliverBase::GetObserverEntry()

	{

	return iMessageId;

	}

// methods from CActive

void CTestDeliverBase::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch( iState )

		{

	case EClearFolders:

		{

		ClearFoldersL();

		iState = EChangeServiceSettings;

		CompleteSelf();

		} break;

	case EChangeServiceSettings:

		{

		ChangeServiceSettingsL();