--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgtest/integration/email/src/sms.cpp	Wed Nov 03 22:41:46 2010 +0530
@@ -0,0 +1,636 @@
+// Copyright (c) 1999-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 "sms.h"
+
+//
+CSmsBaseUtils::CSmsBaseUtils()
+	:iSession(NULL), iEntry(NULL), iOrder(KMsvGroupByType|KMsvGroupByStandardFolders,EMsvSortById,ETrue)
+	{
+	}
+
+
+CSmsBaseUtils::~CSmsBaseUtils()
+	{
+	delete iEntry;
+	iEntry=NULL;
+	delete iSession;
+	iSession=NULL;
+	}
+
+
+void CSmsBaseUtils::StartL()
+	{
+	iSession=CMsvSession::OpenSyncL(*this);
+	}
+
+
+CMsvEntry& CSmsBaseUtils::EntryL()
+	{
+	if ( iEntry == NULL )
+		{
+		User::Leave(KErrGeneral);
+		}
+	return *iEntry;
+	}
+
+
+void CSmsBaseUtils::SetEntryL(TMsvId aId)
+	{
+	delete iEntry;
+	iEntry=NULL;
+	iEntry=iSession->GetEntryL(aId);
+	}
+
+
+void CSmsBaseUtils::SetDefaultServiceL(TUid aMtm,TMsvId aService) const
+	{
+	CMsvEntry* rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);
+	CleanupStack::PushL(rootEntry);
+	CMsvStore* store = rootEntry->EditStoreL();
+	CleanupStack::PushL(store);
+	CMsvDefaultServices* services = new(ELeave)CMsvDefaultServices;
+	CleanupStack::PushL(services);
+	services->RestoreL(*store);
+
+	TMsvDefaultService	defaultService;
+	defaultService.iMtm=aMtm;
+	defaultService.iService=aService;
+	services->ChangeDefaultServiceL(defaultService);
+	services->StoreL(*store);
+	store->CommitL();
+
+	CleanupStack::PopAndDestroy(3, rootEntry);
+	}
+
+
+TInt CSmsBaseUtils::DefaultServiceL(TUid aMtm,TMsvId& aService) const
+	{
+	CMsvEntry*				rootEntry=iSession->GetEntryL(KMsvRootIndexEntryIdValue);
+	CleanupStack::PushL(rootEntry);
+	CMsvStore*				store=rootEntry->ReadStoreL();
+	CleanupStack::PushL(store);
+	CMsvDefaultServices*	services=new(ELeave)CMsvDefaultServices;
+	CleanupStack::PushL(services);
+	services->RestoreL(*store);
+
+	TInt					ret=services->DefaultService(aMtm, aService);
+
+	CleanupStack::PopAndDestroy(3, rootEntry);
+
+	return ret;
+	}
+
+
+//
+void CSmsTestUtils::StartL()
+	{
+	_LIT(KSmsAccountName,	"Short Message");
+	
+	CSmsBaseUtils::StartL();
+
+	CSmsSettings* smsSettings = CSmsSettings::NewL();
+	CleanupStack::PushL(smsSettings);
+	SetEntryL(KMsvRootIndexEntryId);
+
+	EntryL().SetSortTypeL(SelectionOrdering());
+	CMsvEntrySelection*	selection=EntryL().ChildrenWithTypeL(KUidMsvServiceEntry);
+	CleanupStack::PushL(selection);
+	TInt   count=selection->Count();
+	TBool  found=EFalse;
+	TPtrC  accountName(KSmsAccountName);
+	TMsvId idSms=0;
+	for (TInt i=count; i>0 && !found; )
+		{
+		SetEntryL(selection->At(--i));
+		if	(EntryL().Entry().iMtm == KUidMsgTypeSMS && EntryL().Entry().iType == KUidMsvServiceEntry)
+			{
+			idSms=EntryL().EntryId();
+			found=ETrue;
+			}
+		}
+
+	if (!found)
+		{
+		TMsvEntry entry;
+		entry.iMtm = KUidMsgTypeSMS;
+		entry.iType = KUidMsvServiceEntry;
+		entry.SetReadOnly(EFalse);
+		entry.SetVisible(EFalse);
+		entry.SetOperation(ETrue);
+		entry.iDetails.Set(accountName);
+	
+		SetEntryL(KMsvRootIndexEntryId);
+		EntryL().CreateL(entry);
+		idSms=entry.Id();
+
+		smsSettings->SetValidityPeriod(ESmsVPWeek);
+		smsSettings->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger);
+		smsSettings->SetReplyQuoted(EFalse);
+		smsSettings->SetRejectDuplicate(ETrue);
+		smsSettings->SetDelivery(ESmsDeliveryImmediately);
+		smsSettings->SetDeliveryReport(ETrue);
+		smsSettings->SetReplyPath(EFalse);
+		smsSettings->SetMessageConversion(ESmsConvPIDNone);
+		smsSettings->SetCanConcatenate(ETrue);
+
+		SetEntryL(idSms);
+		
+		CMsvStore*	msvstore=EntryL().EditStoreL();
+		CleanupStack::PushL(msvstore);
+		smsSettings->StoreL(*msvstore);
+		msvstore->CommitL();
+		CleanupStack::PopAndDestroy(msvstore);
+		}
+
+		SetEntryL(idSms);
+		
+ 		CMsvStore*	smsStore = EntryL().EditStoreL();
+		CleanupStack::PushL(smsStore);
+
+		smsSettings->RestoreL(*smsStore);
+
+		TPtrC	ptrSCName;
+		TPtrC	ptrSCNumber;
+
+		smsSettings->AddSCAddressL(ptrSCName, ptrSCNumber);
+		
+		smsSettings->StoreL(*smsStore);
+		smsStore->CommitL();
+
+		CleanupStack::PopAndDestroy(smsStore);
+
+		SetDefaultServiceL(KUidMsgTypeSMS, idSms);
+		CleanupStack::PopAndDestroy(2);
+	}
+
+
+//
+CSmsBaseClientTest* CSmsBaseClientTest::NewL(CSmsTestUtils& aSmsUtils,RTest& aTest)
+	{
+	CSmsBaseClientTest* self = new (ELeave) CSmsBaseClientTest(aSmsUtils,aTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CSmsBaseClientTest* CSmsBaseClientTest::NewL(CSmsTestUtils* aSmsUtils, RTest& aTest)
+	{
+	CSmsBaseClientTest* self = new (ELeave) CSmsBaseClientTest(aSmsUtils, aTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CSmsBaseClientTest::~CSmsBaseClientTest()
+	{
+	Cancel();
+	delete iCurrentSelection;
+	delete iOperation;
+	delete iOwnedSmsUtils;
+	}
+
+void CSmsBaseClientTest::DoCancel()
+	{
+	if (iOperation)
+		{
+		iOperation->Cancel();
+		}
+	}
+
+void CSmsBaseClientTest::SetCurrentOperation(CMsvOperation* aOperation)
+	{
+	delete iOperation;
+	iOperation = aOperation;
+	}
+
+
+CMsvOperation& CSmsBaseClientTest::CurrentOperation()
+	{
+	return *iOperation;
+	}
+
+void CSmsBaseClientTest::ConstructL()
+	{
+	CBaseTestHarness::ConstructL();
+	iCurrentSelection = new (ELeave) CMsvEntrySelection;
+	}
+
+CSmsBaseClientTest::CSmsBaseClientTest(CSmsTestUtils& aSmsUtils, RTest& aTest) 
+: CBaseTestHarness(aTest), 
+  iSmsUtils(aSmsUtils)
+	{
+	iOperation = NULL;
+	}
+
+CSmsBaseClientTest::CSmsBaseClientTest(CSmsTestUtils* aSmsUtils, RTest& aTest) 
+: CBaseTestHarness(aTest), 
+  iSmsUtils(*aSmsUtils),
+  iOwnedSmsUtils(aSmsUtils)
+	{
+	iOperation = NULL;
+	}
+
+CSmsTestUtils& CSmsBaseClientTest::SmsTestUtils()
+	{
+	return iSmsUtils;
+	}
+
+
+//
+CSmsBaseClientSectionParser* CSmsBaseClientSectionParser::NewL(CSmsBaseClientTest& aSmsTest, CTestScript& aScript, const TDesC& aNewSectionName)
+	{
+	CSmsBaseClientSectionParser* self = new (ELeave) CSmsBaseClientSectionParser(aSmsTest, aScript);
+	CleanupStack::PushL(self);
+	self->ConstructL(aNewSectionName);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CSmsBaseClientSectionParser::LogCommentL(const TDesC& /*aComment*/)
+	{
+//	iEmailTest.EmailTestUtils().WriteComment(aComment);
+	}
+
+void CSmsBaseClientSectionParser::ConstructL(const TDesC& aNewSectionName)
+	{
+	CBaseSectionParser::ConstructL(aNewSectionName);
+	TTestDebugInfo debugInfo = iSmsTest.GetDebugInfo();
+	debugInfo.SetTestHarnessName(iSection->SectionPosition());
+	iSmsTest.SetDebugInfo(debugInfo);
+	iCommandParsers->AppendL(CNewSmsTestCommandParser::NewL(iScript,iSmsTest));
+	iCommandParsers->AppendL(CSmsBaseUtilitiesParser::NewL(iSmsTest));
+	}
+
+CSmsBaseClientSectionParser::CSmsBaseClientSectionParser(CSmsBaseClientTest& aSmsTest, CTestScript& aScript) : CBaseSectionParser(aScript), iSmsTest(aSmsTest)
+	{
+	}
+
+
+//
+CNewSmsBaseTestCommandParser* CNewSmsBaseTestCommandParser::NewL(CTestScript& aScript, CMainTestHarness& aMainTest, TBool aKeepLogFile)
+	{
+	CNewSmsBaseTestCommandParser* self = new (ELeave) CNewSmsBaseTestCommandParser(aScript, aMainTest, aKeepLogFile);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CNewSmsBaseTestCommandParser::ProcessL()
+	{
+	// Create sms stuff
+	CSmsTestUtils* smsUtils = new(ELeave) CSmsTestUtils();
+	CleanupStack::PushL(smsUtils);
+	
+	// Create an Sms test, give it the test utilities
+	CSmsBaseClientTest* smsTest = CSmsBaseClientTest::NewL(smsUtils,iMainTest.TestConsole());
+	CleanupStack::Pop(smsUtils); // smsTest has taken ownership
+	CleanupStack::PushL(smsTest);
+
+	// Attach the Sms test to the main test
+	iMainTest.AddStateL(smsTest, iDebugInfo);
+	CleanupStack::Pop(smsTest); // SmsTest is now owned by the iMainTest
+
+	// Check that there is one argument, the Sms test section name
+	CheckNumberOfArgumentsL(1);
+
+	// Create an Sms section parser
+	CSmsBaseClientSectionParser* sectionParser = CSmsBaseClientSectionParser::NewL(*smsTest, iScript, (*iArgumentList)[0]);
+	CleanupStack::PushL(sectionParser);
+	sectionParser->ParseL();
+	CleanupStack::PopAndDestroy(sectionParser);
+	}
+
+void CNewSmsBaseTestCommandParser::ConstructL()
+	{
+	CBaseCommandParser::ConstructL();
+	AddCommandL(CCommandSmsBaseClientTest);
+	}
+
+CNewSmsBaseTestCommandParser::CNewSmsBaseTestCommandParser(CTestScript& aScript, CMainTestHarness& aMainTest, TBool aKeepLogFile) : iMainTest(aMainTest), iScript(aScript), iKeepLogFile(aKeepLogFile)
+	{
+	}
+
+
+//
+CSmsClientTest* CSmsClientTest::NewL(CSmsTestUtils& aSmsUtils, RTest& aTest)
+	{
+	CSmsClientTest* self = new (ELeave) CSmsClientTest(aSmsUtils, aTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CSmsClientTest::~CSmsClientTest()
+	{
+	}
+
+void CSmsClientTest::ConstructL()
+	{
+	CSmsBaseClientTest::ConstructL();
+	}
+
+CSmsClientTest::CSmsClientTest(CSmsTestUtils& aSmsUtils, RTest& aTest) : CSmsBaseClientTest(aSmsUtils, aTest)
+	{
+	}
+
+
+//
+CSmsClientSectionParser* CSmsClientSectionParser::NewL(CSmsClientTest& aSmsTest, CTestScript& aScript, const TDesC& aNewSectionName)
+	{
+	CSmsClientSectionParser* self = new (ELeave) CSmsClientSectionParser(aSmsTest, aScript);
+	CleanupStack::PushL(self);
+	self->ConstructL(aNewSectionName);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CSmsClientSectionParser::ConstructL(const TDesC& aNewSectionName)
+	{
+	CSmsBaseClientSectionParser::ConstructL(aNewSectionName);
+	}
+
+CSmsClientSectionParser::CSmsClientSectionParser(CSmsClientTest& aSmsTest, CTestScript& aScript) : CSmsBaseClientSectionParser(aSmsTest, aScript), iSmsTest(aSmsTest)
+	{
+	}
+
+
+
+//
+CNewSmsTestCommandParser* CNewSmsTestCommandParser::NewL(CTestScript& aScript, CSmsBaseClientTest& aSmsTest)
+	{
+	CNewSmsTestCommandParser* self = new (ELeave) CNewSmsTestCommandParser(aScript, aSmsTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	};
+
+void CNewSmsTestCommandParser::ProcessL()
+	{
+	// Create an sms test, give it the test utilities
+	CSmsClientTest* smsTest = CSmsClientTest::NewL(iSmsTest.SmsTestUtils(), iSmsTest.TestConsole());
+	CleanupStack::PushL(smsTest);
+
+	// Attach the sms test to the main test
+	iSmsTest.AddStateL(smsTest, iDebugInfo);
+	CleanupStack::Pop(smsTest); // smsTest is now owned by the iMainTest
+
+	// Check that there is one argument, the sms test section name
+	CheckNumberOfArgumentsL(1);
+
+	// Create an sms section parser
+	CSmsClientSectionParser* sectionParser = CSmsClientSectionParser::NewL(*smsTest, iScript, (*iArgumentList)[0]);
+	CleanupStack::PushL(sectionParser);
+	sectionParser->ParseL();
+	CleanupStack::PopAndDestroy(sectionParser);
+	}
+
+void CNewSmsTestCommandParser::ConstructL()
+	{
+	CBaseCommandParser::ConstructL();
+	AddCommandL(CCommandSmsClientTest);
+	}
+
+CNewSmsTestCommandParser::CNewSmsTestCommandParser(CTestScript& aScript, CSmsBaseClientTest& aSmsTest) : iSmsTest(aSmsTest), iScript(aScript)
+	{
+	}
+
+
+
+//
+CSmsBaseUtilitiesParser* CSmsBaseUtilitiesParser::NewL(CSmsBaseClientTest& aSmsTest)
+	{
+	CSmsBaseUtilitiesParser* self = new (ELeave) CSmsBaseUtilitiesParser(aSmsTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CSmsBaseUtilitiesParser::ProcessL()
+	{
+	TInt howMany;
+
+	if ((*iCurrentCommand) == KCommandSmsBegin)
+		{
+		iSmsTest.AddStateL(new(ELeave) CSmsBegin(iSmsTest.SmsTestUtils()),iDebugInfo);
+		}
+	else if ((*iCurrentCommand) == KCommandSmsCreateMessage)
+		{
+		if (iArgumentList->Count() == 4) // If optional howmany is specified
+			{
+			TPtrC param = (*iArgumentList)[3];
+			TLex lex(param);
+			if (lex.Val(howMany)!=KErrNone)
+				howMany=1;
+			}
+		else
+			{
+			howMany = 1;
+			CheckNumberOfArgumentsL(3);
+			}
+		RFs fs;
+		fs.Connect();
+		TParse fileName;
+		ResolveFile(fs, (*iArgumentList)[0], (*iArgumentList)[1], fileName);
+		fs.Close();
+		TMsvId folder;
+		TPtrC folderName = (*iArgumentList)[2];
+		if (folderName == _L("inbox"))
+			folder = KMsvGlobalInBoxIndexEntryId;
+		else if (folderName == _L("outbox"))
+			folder = KMsvGlobalOutBoxIndexEntryId;
+		else if (folderName == _L("sent"))
+			folder = KMsvSentEntryId;
+		else 
+			folder = KMsvDraftEntryId;
+		iSmsTest.AddStateL(new (ELeave) CCreateSmsMessage(folder, iSmsTest.iCurrentServiceId, fileName.FullName(), iSmsTest.SmsTestUtils(),howMany), iDebugInfo);
+		}
+	else if ((*iCurrentCommand) == KCommandSmsEnd)
+		{
+		iSmsTest.AddStateL(new(ELeave) CSmsEnd(iSmsTest.SmsTestUtils()),iDebugInfo);
+		}
+	else
+		{
+		User::Leave(KErrNotFound);
+		}
+	}
+
+void CSmsBaseUtilitiesParser::ConstructL()
+	{
+	CBaseCommandParser::ConstructL();
+	AddCommandL(KCommandSmsBegin);
+	AddCommandL(KCommandSmsCreateMessage);
+	AddCommandL(KCommandSmsEnd);
+	}
+
+CSmsBaseUtilitiesParser::CSmsBaseUtilitiesParser(CSmsBaseClientTest& aSmsTest) : iSmsTest(aSmsTest)
+	{
+	}
+
+
+//
+void CSmsBegin::StartL(TRequestStatus& aStatus)
+	{
+	iSmsUtils.StartL();
+	TRequestStatus* status = &aStatus;
+	User::RequestComplete(status, KErrNone);
+	}
+
+CSmsBegin::CSmsBegin(CSmsTestUtils& aSmsUtils) : iSmsUtils(aSmsUtils)
+	{}
+
+
+//
+void CSmsEnd::StartL(TRequestStatus& aStatus)
+	{
+//	iSmsUtils.StartL();
+	TRequestStatus* status = &aStatus;
+	User::RequestComplete(status, KErrNone);
+	}
+
+CSmsEnd::CSmsEnd(CSmsTestUtils& aSmsUtils) : iSmsUtils(aSmsUtils)
+	{}
+
+
+//
+CCreateSmsMessage::CCreateSmsMessage(TMsvId aFolderId, const TMsvId& aServiceId, const TDesC& aFileName, CSmsTestUtils& aSmsUtils,TInt aHowMany) : CActive(EPriorityNormal), iCurrentFolderId(aFolderId), iServiceId(aServiceId), iSmsUtils(aSmsUtils), iHowMany(aHowMany)
+	{
+	CActiveScheduler::Add(this);
+	iFileName = aFileName;
+	}
+
+void CCreateSmsMessage::StartL(TRequestStatus& aStatus)
+	{
+	delete iTimer;
+	iTimer = 0;
+	iTimer = CTestTimer::NewL();
+	iReportStatus = &aStatus;
+	iTimer->AfterReq(5000000, iStatus);
+	aStatus = KRequestPending;
+	iState = ECreateSmsWait1;
+	SetActive();
+	}
+
+void CCreateSmsMessage::RunL()
+	{
+	TInt i;
+	switch (iState)
+		{
+		case ECreateSmsWait1:
+			for (i=0; i<iHowMany; i++)
+				 CreateMessageL();
+			iTimer->AfterReq(5000000, iStatus);
+
+			iState = ECreateSmsWait2;
+			SetActive();
+			break;
+
+		case ECreateSmsWait2:
+			// We should be safely back on the client side so we can continue.
+			User::RequestComplete(iReportStatus, iStatus.Int());
+			break;
+		};
+	}
+
+void CCreateSmsMessage::CreateMessageL()
+	{
+	CParaFormatLayer*	paraFormatLayer=CParaFormatLayer::NewL();
+	CleanupStack::PushL(paraFormatLayer);
+
+	CCharFormatLayer*	charFormatLayer=CCharFormatLayer::NewL();
+	CleanupStack::PushL(charFormatLayer);
+
+	CRichText*			bodyText=CRichText::NewL(paraFormatLayer, charFormatLayer, CEditableText::EFlatStorage, 256);
+	CleanupStack::PushL(bodyText);
+
+
+		CSendAs* sendAs=CSendAs::NewL(*this);
+		CleanupStack::PushL(sendAs);
+
+		sendAs->SetMtmL(KUidMsgTypeSMS);
+
+	    if (sendAs->AvailableServices().Count() < 1)
+		    {
+			User::Leave(KErrNotFound);
+			}
+		sendAs->SetService(0);
+
+		sendAs->CreateMessageL(iCurrentFolderId);
+
+		TRAPD(err, sendAs->SaveMessageL(ETrue));
+		if (err != KErrNone)
+			{
+			sendAs->AbandonMessage();
+			}
+		else
+			{
+			TMsvId	messageId=sendAs->MessageId();
+			iSmsUtils.SetEntryL(messageId);
+
+			//Get the new message
+			CSmsHeader* smsHeader = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *bodyText);
+			CleanupStack::PushL(smsHeader);
+			CMsvStore*	store = iSmsUtils.EntryL().EditStoreL();
+			CleanupStack::PushL(store);
+
+			smsHeader->RestoreL(*store);
+
+			TMsvEntry	entry=iSmsUtils.EntryL().Entry();
+
+			entry.SetSendingState(KMsvSendStateSuspended);
+
+			TBuf<KSmsDetailsLength>	details;	
+			if ( TSmsUtilities::GetDetails(iSmsUtils.EntryL().Session().FileSession(), smsHeader->Message(), details) == KErrNone )
+				{
+				entry.iDetails.Set(details);
+				}
+				
+			TBuf<KSmsDescriptionLength>	desc;
+			if ( TSmsUtilities::GetDescription(smsHeader->Message(), desc) == KErrNone )
+				{
+				entry.iDescription.Set(desc);
+				}
+			entry.SetInPreparation(EFalse);
+
+			//	Update entry with data set from .ini file
+			iSmsUtils.EntryL().ChangeL(entry);
+			smsHeader->StoreL(*store);
+
+			CleanupStack::PopAndDestroy(2, smsHeader);
+		}
+		CleanupStack::PopAndDestroy(sendAs);
+	CleanupStack::PopAndDestroy(3); // bodyText, paraFormatLayer, charFormatLayer
+	}
+
+void CCreateSmsMessage::DoCancel()
+	{
+	}
+
+CCreateSmsMessage::~CCreateSmsMessage()
+	{
+	if (iTimer)
+		{
+		iTimer->Cancel();
+		}
+	delete iTimer;
+	}
+
+