--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mobilemessaging/smsmtm/test/src/T_SmsSc.cpp	Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,1085 @@
+// 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 "T_SmsSc.h"
+#include <smutsimparam.h>
+#include <smsclnt.h>
+#include <smsuaddr.h>
+
+#include <testconfigfileparser.h>
+#include <e32std.h>
+
+// Autotest library header file
+#include "autotest.h"
+
+#include <simtsy.h>
+
+// Global pointer for use by the autogTest.h macro's
+CAutoTest* gAutoTest;
+
+
+RTest gTest(_L("T_SmsSc Testrig"));
+CTrapCleanup* theCleanup;
+
+
+#define LOCAL_CHECKPOINT_CODE(a,b) a.TestCheckPointCodeL((b), (__FILE__), (__LINE__))
+#define LOCAL_CHECKPOINT(a,b) a.TestCheckPointL((b), (__FILE__), (__LINE__))
+#define LOCAL_CHECKPOINT_COMPARE(a,b,c,d) a.TestCheckPointCompareL((b),(c),(d),(__FILE__),(__LINE__))
+
+_LIT(KTestScriptFile, "SimParameter.script");
+_LIT(KTestScriptComponent, "sms");
+
+_LIT8(KListSectionStart, "list");
+_LIT8(KSmsParamEntry, "SmsParamEntry");
+_LIT8(KSmsParamMaxEntries, "SmsParamMaxEntries");
+
+const TInt KSmsParamEntryDel = ',';
+
+enum TSmsParamEntry
+/**	@enum	TSmsParamEntry
+ *	Enum defining the SMS parameters
+ */
+	{
+	ESmsParamIndex,
+	ESmsParamName,
+	ESmsParamPID,
+	ESmsParamDCS,
+	ESmsParamVP,
+	ESmsParamDA,
+	ESmsParamSCA
+	};
+
+/*
+void SetTestNumberL(TInt aTestNumber)
+  	{
+  	gTest.Printf(_L("Changing the Test Number to %d\n"), aTestNumber);
+	RSAVarChangeNotify notify;
+	GLOBAL_CHECKPOINT_COMPARE(notify.Connect(), KErrNone, _L("Failed to connect to System Agent Notifier"));
+	CleanupClosePushL(notify);
+  	TRAPD(ret, notify.NotifySaVarChangeL(KUidSASimTsyTestNumber,aTestNumber));
+	GLOBAL_CHECKPOINT_COMPARE(ret, KErrNone, _L("Failed to set test number"));
+	CleanupStack::PopAndDestroy(&notify);
+  	}
+*/
+CSmsScTest* NewScTestLCC(TInt aTestNumber)
+/**
+	Constructs and returns CSmsScTest object. 
+	Notifies the system agent that the phone is on.
+
+	@return		CSmsScTest*		A pointer to SmsSc test.  
+ */
+	{
+	CSmsTestUtils* testUtils = CSmsTestUtils::NewL(gTest);
+	CleanupStack::PushL(testUtils);
+
+	testUtils->SetSimTsyTestNumberL(aTestNumber);
+
+	TInt nextTest = 0;
+
+	testUtils->NotifySaPhoneOnL();
+	testUtils->WaitForInitializeL();
+	return CSmsScTest::NewLC(*gAutoTest, *testUtils, KNullDesC, nextTest);
+	}
+
+RMobileSmsMessaging::TMobileSmspEntryV1 CreateEntry()
+/**
+	Creates and returns an entry. 
+
+	@return		TMobileSmspEntryV1		A SIM parameter entry. 
+ */
+	{
+	RMobileSmsMessaging::TMobileSmspEntryV1 entry;
+	
+	_LIT(KSmsServiceCenterNumber, "+44778501000000");
+	entry.iServiceCentre.iTelNumber = KSmsServiceCenterNumber();
+
+//	_LIT(KSmsNumber, "123456");
+//	entry.iDestination.iTelNumber = KSmsNumber();
+
+	_LIT(KSmsText, "Vodafone");
+	entry.iText = KSmsText();
+
+	entry.iValidParams = RMobileSmsMessaging::KSCAIncluded;
+
+//	TUint8 reservedFiller = 'a';
+//	entry.iReservedFiller = reservedFiller;
+
+//	TUint8 validityPeriod = 'b';
+//	entry.iValidityPeriod = validityPeriod;
+
+//	TUint8 dcs = 'c';
+//	entry.iDcs = dcs;
+
+//	TUint8 protocolID = 'd';
+//	entry.iProtocolId = protocolID;
+
+	return entry;
+	}
+
+CMobilePhoneSmspList* NewListLC(const RMobileSmsMessaging::TMobileSmspEntryV1& aEntry, TInt aCount)
+/**
+	Return a new list with aCount entries of aEntry
+
+	@param		aEntry						A SIM parameter entry.
+	@param		aCount						An integer.
+	@return		CMobilePhoneSmspList*		A list containing the SIM Parameters.
+ */
+	{
+	CMobilePhoneSmspList* list = CMobilePhoneSmspList::NewL();
+	CleanupStack::PushL(list);
+	RMobileSmsMessaging::TMobileSmspEntryV1 entry(aEntry);
+
+	for (TInt i = 0; i < aCount; ++i)
+		{
+		entry.iIndex = i;
+		list->AddEntryL(entry);
+		}
+
+	return list;
+	}
+
+void DoTest1L(CSmsScTest& aTest)
+/**
+	Reads and stores the initial SIM parameters
+
+	@param		aTest		A reference to the SmsSc test
+ */
+	{
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+	
+	aTest.ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("ReadInitialParamsL completed with error"));
+
+	CleanupStack::PopAndDestroy(waiter);
+	}
+
+void Test1L()
+/**
+	Tests Reading SMS parameters from SIM
+ */
+	{
+	CSmsScTest* scTest = NewScTestLCC(0);
+
+	DoTest1L(*scTest);
+
+	CleanupStack::PopAndDestroy(scTest);
+	CleanupStack::PopAndDestroy();
+	}
+
+void Test2L()
+/**
+	Tests Reading error
+ */
+	{
+	// todo Request the tester on screen to remove the phone from serial/IR link
+
+	CSmsScTest* scTest = NewScTestLCC(0);
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+	
+	scTest->ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	//GLOBAL_CHECKPOINT(waiter->iStatus != KErrNone);
+	//GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus != KErrNone, ETrue, _L("ReadInitialParamsL completed with error"));
+
+	CleanupStack::PopAndDestroy(3); //waiter, scTest*2
+	}
+
+void DoTest3L(CSmsScTest& aTest, CMsvOperationWait& aWaiter, TInt aMaxNumber)
+/**
+	Performs round trip tests
+
+	@param		aTest		A reference to SmsSc test
+	@param		aWaiter		A reference to MsvOperationWait
+ */
+	{
+	//const TInt maxNumber = aTest.OriginalOperation().SmspList().MaxNumberEntries();
+	const RMobileSmsMessaging::TMobileSmspEntryV1 entry(CreateEntry());
+	
+	for (TInt i = 1; i <= aMaxNumber; ++i)
+		{
+		CMobilePhoneSmspList* list = NewListLC(entry, i);
+		list->SetMaxNumberEntries(aMaxNumber);
+		aTest.RoundTripTestL(*list, aWaiter.iStatus);
+		aWaiter.Start();
+		CActiveScheduler::Start();
+		CleanupStack::PopAndDestroy(list);
+		User::LeaveIfError(aWaiter.iStatus.Int());
+		}
+	}
+
+void Test3L()
+/**
+	Tests Reading and Writing parameters (Round Trip Test)
+ */
+	{	
+	CSmsScTest* scTest = NewScTestLCC(1);
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+	scTest->ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("ReadInitialParamsL completed with error"));
+	
+	const TInt maxNumber = scTest->OriginalOperation().SmspList().MaxNumberEntries();
+	TRAPD(err, DoTest3L(*scTest, *waiter, maxNumber));
+
+	scTest->WriteOriginalParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("WriteOriginalParamsL completed with error"));
+	User::LeaveIfError(err);
+
+	CleanupStack::PopAndDestroy(3); //scTest*2, waiter
+	}
+
+void DoTest4L(CSmsScTest& aTest, CMsvOperationWait& aWaiter, TInt aMaxNumber)
+	{
+	const RMobileSmsMessaging::TMobileSmspEntryV1 entry(CreateEntry());
+
+	CMobilePhoneSmspList* list = NewListLC(entry, aMaxNumber);
+	list->SetMaxNumberEntries(aMaxNumber);
+	aTest.RoundTripTestL(*list, aWaiter.iStatus);
+	aWaiter.Start();
+	CActiveScheduler::Start();
+	CleanupStack::PopAndDestroy(list);
+	GLOBAL_CHECKPOINT(aWaiter.iStatus != KErrNone);
+	}
+
+void Test4L()
+/**
+	Tests Writing error
+ */
+	{
+	CSmsScTest* scTest = NewScTestLCC(0);
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+	
+	scTest->ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("ReadInitialParamsL completed with error"));
+
+	// Write too many parameters
+	const TInt maxNumber = scTest->OriginalOperation().SmspList().MaxNumberEntries() + 1;
+
+	TRAPD(err, DoTest4L(*scTest, *waiter, maxNumber));
+
+	scTest->WriteOriginalParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("WriteOriginalParamsL completed with error"));
+	User::LeaveIfError(err);
+
+	CleanupStack::PopAndDestroy(3); //waiter, scTest*2
+	}
+
+TInt CountListsInScriptL(RFs& aFs, const TDesC& aComponent, const TDesC& aScriptFile)
+/**
+	Returns the number of lists in the script file. 
+
+	@param		aFs							Handle to file server session 
+	@param		aComponent					A descriptor
+	@param		aScriptFile					Script file
+	@return		TInt						Number of lists in the script file
+ */
+	{
+	CTestConfig* file = CTestConfig::NewLC(aFs, aComponent, aScriptFile);
+
+	TInt count = 0;
+
+	FOREVER
+		{
+		TBuf8<32> sectionName(KListSectionStart);
+		sectionName.AppendNum(count+1);
+		const CTestConfigSection* section = file->Section(sectionName);
+
+		if (section != NULL)
+			count++;
+		else
+			break;
+		}
+
+	CleanupStack::PopAndDestroy(file);
+	return count;
+	}
+	
+
+CMobilePhoneSmspList* ReadFromScriptLC(RFs& aFs, const TDesC& aComponent, const TDesC& aScriptFile, TInt aListNumber, TInt aDefaultMaxNumber)
+/**
+	Reads and returns a list of parameters from the script file. 
+
+	@param		aFs							Handle to file server session 
+	@param		aComponent					A descriptor
+	@param		aScriptFile					Script file
+	@param		aListNumber					The list number in the script file 
+	@param		aDefaultMaxNumber			Maximum number of entries supported by the SIM 
+	@return		CMobilePhoneSmspList*		A list containing the parameters
+ */
+	{
+	gTest.Printf(_L("ReadFromScriptLC [aComponent=%S aScript=%S aListNumber=%d"), &aComponent, &aScriptFile, aListNumber);
+
+	CMobilePhoneSmspList* list = CMobilePhoneSmspList::NewL();
+	CleanupStack::PushL(list);
+
+	CTestConfig* file = CTestConfig::NewLC(aFs, aComponent, aScriptFile);
+
+	TBuf8<32> sectionName(KListSectionStart);
+	sectionName.AppendNum(aListNumber);
+
+	const CTestConfigSection* section = file->Section(sectionName);
+
+	if (section == NULL)
+		{
+		gTest.Printf(_L("\tSection %d Not Found"), aListNumber);
+		User::Leave(KErrNotFound);
+		}
+
+	const CTestConfigItem* item = section->Item(KSmsParamMaxEntries);
+
+	TInt maxNumber = aDefaultMaxNumber;
+
+	if (item == NULL)
+		{
+		gTest.Printf(_L("\tFailed to find KSmsParamMaxEntries in script section. Setting to %d\n"), aDefaultMaxNumber);
+		}
+	else
+		{
+		maxNumber = section->ItemValue(KSmsParamMaxEntries, aDefaultMaxNumber);
+		}
+
+	if (maxNumber > aDefaultMaxNumber)
+		maxNumber = aDefaultMaxNumber;
+
+	list->SetMaxNumberEntries(maxNumber);
+
+	const TInt count = section->ItemCount(KSmsParamEntry);
+
+	if (count == 0)
+		{
+		gTest.Printf(_L("\tFailed to find KSmsParamEntry in script section\n"));
+		User::Leave(KErrNotFound);
+		}
+	
+	for (TInt i = 0; i < count && i < aDefaultMaxNumber; ++i)
+		{
+		item = section->Item(KSmsParamEntry, i);
+		__ASSERT_ALWAYS(item != NULL, User::Invariant());
+
+		const TDesC8& value = item->Value();
+
+		RMobileSmsMessaging::TMobileSmspEntryV1 entry = RMobileSmsMessaging::TMobileSmspEntryV1();
+		TPtrC8 ptrOutput(KNullDesC8);
+		TInt intOutput;
+	
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamIndex, intOutput) == KErrNone)
+			entry.iIndex = intOutput;
+		else
+			entry.iIndex = i;
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamName, ptrOutput) == KErrNone)
+			{
+			entry.iText.Copy(ptrOutput);
+			}
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamPID, intOutput) == KErrNone)
+			{
+			entry.iProtocolId = (TUint8)intOutput;
+			entry.iValidParams |= RMobileSmsMessaging::KProtocolIdIncluded;
+			}
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamDCS, intOutput) == KErrNone)
+			{
+			entry.iDcs = (TUint8)intOutput;
+			entry.iValidParams |= RMobileSmsMessaging::KDcsIncluded;
+			}
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamVP, intOutput) == KErrNone)
+			{
+			entry.iValidityPeriod = (TUint8)intOutput;
+			entry.iValidParams |= RMobileSmsMessaging::KValidityPeriodIncluded;
+			}
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamDA, ptrOutput) == KErrNone)
+			{
+			entry.iDestination.iTelNumber.Copy(ptrOutput);
+			entry.iValidParams |= RMobileSmsMessaging::KDestinationIncluded;
+			}
+
+		if (CTestConfig::GetElement(value, KSmsParamEntryDel, ESmsParamSCA, ptrOutput) == KErrNone)
+			{
+			entry.iServiceCentre.iTelNumber.Copy(ptrOutput);
+			entry.iValidParams |= RMobileSmsMessaging::KSCAIncluded;
+			}
+
+		list->AddEntryL(entry);
+		}
+	
+	CleanupStack::PopAndDestroy(file);
+
+	return list;
+	}
+
+void Test5L()
+/**
+	Data test (Round Trip Test using script)
+ */
+	{
+	CSmsScTest* scTest = NewScTestLCC(0);
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+
+	scTest->ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("ReadInitialParamsL completed with error"));
+
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+
+	const TInt maxNumber = scTest->OriginalOperation().SmspList().MaxNumberEntries();
+	const TInt count = CountListsInScriptL(fs, KTestScriptComponent, KTestScriptFile);
+
+	TBool roundTripTests = ETrue;
+	for (TInt i = 1; i <= count; ++i)
+		{
+		CMobilePhoneSmspList* list = ReadFromScriptLC(fs, KTestScriptComponent, KTestScriptFile, i, maxNumber);
+
+		GLOBAL_CHECKPOINT(list->MaxNumberEntries() <= maxNumber);
+
+		scTest->RoundTripTestL(*list, waiter->iStatus);
+		waiter->Start();
+		CActiveScheduler::Start();
+
+		if(waiter->iStatus != KErrNone)
+			{
+			roundTripTests = EFalse;
+			break;
+			}
+
+		CleanupStack::PopAndDestroy(list);
+		}
+
+	scTest->WriteOriginalParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("WriteOriginalParamsL completed with error"));
+
+	//GLOBAL_CHECKPOINT(roundTripTests);
+	GLOBAL_CHECKPOINT_COMPARE(roundTripTests, ETrue, _L("RoundTripTestL failled"));
+
+	CleanupStack::PopAndDestroy(4); //waiter, scTest*2, fs
+	}
+
+void Test6L()
+/**
+	OOM Test of CSmsClientMtm::ReadSimParamsL
+ */
+	{
+	CSmsScTest* scTest = NewScTestLCC(0);
+
+	TInt failCount = 0;
+	TInt error = KErrNone;
+	_LIT(KFailCountDesc, "DoTest1L still failing, count = %d\n");
+
+	do
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, DoTest1L(*scTest));
+
+		__UHEAP_RESET;
+
+		if (error != KErrNone)
+			{
+			if (error != KErrNoMemory)
+				gTest.Printf(KFailCountDesc, failCount);
+
+			GLOBAL_CHECKPOINT_COMPARE(error, KErrNoMemory, _L("Error not KErrNoMemory"));
+
+			if (failCount % 100 == 0)
+				gTest.Printf(KFailCountDesc, failCount);
+			}
+		}
+	while (error != KErrNone);
+	
+	gTest.Printf(KFailCountDesc, failCount);
+
+	CleanupStack::PopAndDestroy(2); //scTest*2
+	}
+
+void Test7L()
+/**
+	OOM Test of CSmsClientMtm::WriteSimParamsL
+ */
+	{
+	CSmsScTest* scTest = NewScTestLCC(1);
+	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();
+	scTest->ReadInitialParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("ReadInitialParamsL completed with error"));
+
+	TInt failCount = 0;
+	TInt error = KErrNone;
+
+	do
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		const TInt maxNumber = 1;
+		TRAP(error, DoTest3L(*scTest, *waiter, maxNumber));
+
+		__UHEAP_RESET;
+
+		if (error != KErrNone)
+			{
+			gTest.Printf(_L("DoTest3L still failing, count = %d\n"), failCount);
+			GLOBAL_CHECKPOINT_COMPARE(error, KErrNoMemory, _L("Error not KErrNoMemory"));
+			}
+		}
+	while (error != KErrNone);
+	
+	gTest.Printf(_L("DoTest3L Fail Count %d\n"), failCount);
+
+	scTest->WriteOriginalParamsL(waiter->iStatus);
+	waiter->Start();
+	CActiveScheduler::Start();
+	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("WriteOriginalParamsL completed with error"));
+
+	CleanupStack::PopAndDestroy(3); //scTest*2, waiter
+	}
+
+LOCAL_C const TAutoTestCase SmsScTestCases[] =
+/**
+	Sets up an array of test functions
+ */
+	{
+	{Test1L,_S("GT83-T_MESSS-001 Test Reading")},
+	//{Test2L,_S("GT83-T_MESSS-002 Test Reading Error")},
+	{Test3L,_S("GT83-T_MESSS-003 Test Reading and Writing (Round Trip Test)")},
+	{Test4L,_S("GT83-T_MESSS-004 Test Writing Error")},
+	{Test5L,_S("GT83-T_MESSS-005 Data test (Round Trip Test using script)")},
+	{Test6L,_S("GT83-T_MESSS-006 OOM test of CSmsClientMtm::ReadSimParamsL")},
+	{Test7L,_S("GT83-T_MESSS-007 OOM test of CSmsClientMtm::WriteSimParamsL")}
+	};
+
+LOCAL_C void doMainL()
+/**
+	Constructs sctive scheduler and starts off the tests
+ */
+	{
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+	CleanupStack::PushL(scheduler);
+	CActiveScheduler::Install( scheduler );
+
+	// Copying the config file to the root directory
+
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	_LIT(KFileName2,"\\sms\\smssc_config.txt");
+	
+	CSmsTestUtils::CopyToSimTsyConfigFileL(fs, KFileName2);
+
+	CleanupStack::PopAndDestroy(&fs);
+
+	// Open the socket server
+
+	RSocketServ serv;
+	RSocket socket;
+
+	User::LeaveIfError(serv.Connect());
+	CleanupClosePushL(serv);
+	
+	TProtocolDesc protoinfo;
+	TProtocolName protocolname(KSmsDatagram);
+	User::LeaveIfError(serv.FindProtocol(protocolname,protoinfo));
+	User::LeaveIfError(socket.Open(serv,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol));
+
+	TSmsAddr smsaddr;
+	smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly);
+	User::LeaveIfError(socket.Bind(smsaddr));
+
+	CleanupClosePushL(socket);
+
+	_LIT(KTestOutput,"smssc_testreport.txt");
+	_LIT8(KComponentInfo,"smcm and smss");
+	// Library defined macro
+	// Uses a global pointer instance of CAutoTest
+	GLOBAL_AUTOTEST_EXECUTE(SmsScTestCases, KTestOutput, KComponentInfo, gTest);
+
+	CleanupStack::PopAndDestroy(&socket);
+	CleanupStack::PopAndDestroy(&serv);
+	CleanupStack::PopAndDestroy(scheduler);
+	}
+
+GLDEF_C TInt E32Main()
+/**
+	Calls doMainL and checks for error
+ */
+	{
+	__UHEAP_MARK;
+
+	gTest.Start(_L("Setup"));
+	theCleanup = CTrapCleanup::New();
+
+
+	TRAPD(ret,doMainL());
+
+	if (ret != KErrNone)
+		gTest.Printf(_L("Test completed with %d"), ret);
+
+	delete theCleanup;	
+	gTest.Console()->SetPos(0, 13);
+	gTest.End();
+	gTest.Close();
+	__UHEAP_MARKEND;
+	return(KErrNone);
+	}
+
+CSmsScTest::~CSmsScTest()
+/**
+	destructor
+ */
+	{
+	Cancel();
+	delete iOriginalParams;
+	}
+
+void CSmsScTest::ReadInitialParamsL(TRequestStatus& aStatus)
+/**
+	Starts off the read async operation.
+
+	@param		aStatus		A request status.
+ */
+	{
+	iState = EStateReadInitialParams;
+
+	delete iOperation;
+	iOperation = NULL;
+
+	iOperation = Client().ReadSimParamsL(iStatus);
+	SetActive();
+	Queue(aStatus);
+	}
+
+void CSmsScTest::RoundTripTestL(const CMobilePhoneSmspList& aListToWrite, TRequestStatus& aStatus)
+/**
+	Starts off the round trip test.
+
+	@param		aListToWrite	A list to write to the SIM.
+	@param		aStatus			Indicates the status of the operations.
+ */
+	{
+	iListToWrite = &aListToWrite;
+
+//	iSmsTest.Test().Printf(_L("Starting Round Trip Test\n"));
+
+	WriteSimParamsL();
+	Queue(aStatus);
+	}
+
+void CSmsScTest::WriteSimParamsL()
+/**
+	Starts off the write async operation.
+
+	@param		aList		A list to write to the SIM.
+ */
+	{
+	iState = EStateWriteSimParams;
+
+//	PrintList(iSmsTest.Test(), *iListToWrite);
+
+	delete iOperation;
+	iOperation = NULL;
+
+	iOperation = Client().WriteSimParamsL(*iListToWrite, iStatus);
+	SetActive();
+	}
+
+void CSmsScTest::ReadAfterWriteL()
+/**
+	Reading after writing to the SIM
+ */
+	{
+	iSmsTest.Test().Printf(_L("Reading after writing\n"));
+	iState = EStateReadAfterWrite;
+
+	delete iOperation;
+	iOperation = NULL;
+
+	iOperation = Client().ReadSimParamsL(iStatus);
+	SetActive();
+	}
+
+void CSmsScTest::WriteOriginalParamsL(TRequestStatus& aStatus)
+/**
+	Writes the default parameters back to the SIM
+
+	@param		aStatus		Indicates the status of the write operation.
+ */
+	{
+	Queue(aStatus);
+
+	iSmsTest.Test().Printf(_L("Writing original parameters back to Sim"));
+	iState = EStateWriteOriginalParams;
+
+	delete iOperation;
+	iOperation = NULL;
+
+	iOperation = Client().WriteSimParamsL(iOriginalParams->SmspList(), iStatus);
+	SetActive();
+	}
+
+CSmsScTest* CSmsScTest::NewLC(CAutoTest& aAutoTest, CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)
+	{
+	CSmsScTest* self = new (ELeave) CSmsScTest(aAutoTest, aSmsTest, aScriptFile, aNextTest);
+	CleanupStack::PushL(self);
+
+	self->ConstructL();
+	return self;
+	}
+
+CSmsScTest::CSmsScTest(CAutoTest& aAutoTest, CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)
+: CSmsTestBase(aSmsTest, aScriptFile, aNextTest), iState(EStateWaiting), iAutoTest(aAutoTest)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+void CSmsScTest::RunAutoL()
+/**
+	Required by CSmsTestBase.
+ */
+	{
+
+	}
+
+void CSmsScTest::ConstructL()
+	{
+	SetTestNameL(KSmsScTestName);
+	iSmsTest.InstantiateClientMtmsL();
+
+	iSmsTest.SetLogToFile();
+	}
+
+void CSmsScTest::ShowMenuL()
+/**
+	Required by CSmsTestBase.
+ */
+	{
+	}
+
+void CSmsScTest::RunL()
+/**
+	Handles completed async operations
+ */
+	{
+	iSmsTest.Test().Printf(_L("CSmsScTest::RunL [State=%d Status=%d]\n"), iState, iStatus.Int());
+
+	switch (iState)
+		{
+		case EStateReadInitialParams:
+			{
+			DoRunReadInitialParamsL();
+			break;
+			}
+		case EStateWriteSimParams:
+			{
+			DoRunWriteSimParamsL();
+			break;
+			}
+		case EStateReadAfterWrite:
+			{
+			DoRunReadAfterWriteL();
+			break;
+			}
+		case EStateWriteOriginalParams:
+			{
+			DoRunWriteOriginalParamsL();
+			break;
+			}
+		default:
+			{
+			break;
+			}
+		}
+
+	if (!IsActive())
+		Complete(iStatus.Int());
+	}
+
+void CSmsScTest::Complete(TInt aError)
+/**
+	Indicates that the operation is complete with aError.
+
+	@param		aError		error returned by the operation
+ */
+	{
+	iSmsTest.Test().Printf(_L("CSmsScTest::Complete [aError=%d]\n"), aError);
+
+	if (iReport != NULL)
+		User::RequestComplete(iReport, aError);
+	}
+
+TInt CSmsScTest::RunError(TInt aError)
+/**
+
+	@param		aError		error returned by the operation
+	@return		TInt		Returns the KErrNone. 
+ */
+	{
+	Complete(aError);
+	return KErrNone;
+	}
+
+void CSmsScTest::Queue(TRequestStatus& aStatus)
+/**
+
+	@param		aStatus		Indicates the status of the operation.
+ */
+	{
+	__ASSERT_DEBUG(iReport==NULL, User::Invariant());
+
+	aStatus=KRequestPending;
+	iReport=&aStatus;
+	}
+
+void CSmsScTest::PrintListL(RTest& aTest, const CMobilePhoneSmspList& aList)
+/**
+	Prints aList 
+
+	@param		aTest		
+	@param		aList		A list of SIM parameters	
+ */
+	{
+	//Print MaxNumber
+	aTest.Printf(_L("========= CMobilePhoneSmspList ========= \n"));
+
+	aTest.Printf(_L("MaxNumber=%d\n"), aList.MaxNumberEntries());
+
+	//Pirnt Num Entries
+	TInt count = aList.Enumerate();
+	aTest.Printf(_L("Number of entries: %d\n"), count);
+
+	//Print each entry in aList
+	for(TInt i = 0; i < count; ++i)
+		{
+		const RMobileSmsMessaging::TMobileSmspEntryV1& entry = aList.GetEntryL(i);
+		PrintEntry(aTest, entry);
+		}
+
+	aTest.Printf(_L("======= End CMobilePhoneSmspList ======= \n"));
+	}
+
+void CSmsScTest::PrintEntry(RTest& aTest, const RMobileSmsMessaging::TMobileSmspEntryV1& aEntry)
+/**
+	Prints aEntry 
+
+	@param		aTest		
+	@param		aEntry		A parameter entry.	
+ */
+	{
+	aTest.Printf(_L("\t========= TMobileSmspEntryV1 =========\n"));
+
+	aTest.Printf(_L("\tIndex= %d\n\tValid= 0x%X\n"), aEntry.iIndex, aEntry.iValidParams);
+
+	if (aEntry.iValidParams & RMobileSmsMessaging::KProtocolIdIncluded)
+		aTest.Printf(_L("\tProtocolId = %d\n"), aEntry.iProtocolId);
+
+	if (aEntry.iValidParams & RMobileSmsMessaging::KDcsIncluded)
+		aTest.Printf(_L("\tDcs = %d\n"), aEntry.iDcs);
+	
+	if (aEntry.iValidParams & RMobileSmsMessaging::KValidityPeriodIncluded)
+		aTest.Printf(_L("\tValidityPeriod= %d\n"), aEntry.iValidityPeriod);
+	
+	if (aEntry.iValidParams & RMobileSmsMessaging::KDestinationIncluded)
+		aTest.Printf(_L("\tDestination = %S\n"), &aEntry.iDestination.iTelNumber);
+	
+	if (aEntry.iValidParams & RMobileSmsMessaging::KSCAIncluded)
+		aTest.Printf(_L("\tSC = %S\n"), &aEntry.iServiceCentre.iTelNumber);
+	
+	if (aEntry.iValidParams & RMobileSmsMessaging::KSCAIncluded)
+		aTest.Printf(_L("\tText = %S\n"), &aEntry.iText);
+		
+	aTest.Printf(_L("\t======= End TMobileSmspEntryV1 =======\n"));
+	}
+
+void CSmsScTest::DoRunReadInitialParamsL()
+/**
+	Checks the status, saves the operation and prints the list read.
+ */
+	{
+	if (iStatus == KErrNone)
+		{
+		TIntBuf progressBuf;
+		progressBuf.Copy(iOperation->ProgressL());
+		iStatus = progressBuf();
+		}
+
+	if (iStatus == KErrNone)
+		{
+		delete iOriginalParams;
+		iOriginalParams = (CSmsSimParamOperation*) iOperation;
+		iOperation = NULL;
+
+	    PrintListL(iSmsTest.Test(), iOriginalParams->SmspList());
+		}
+
+	delete iOperation;
+	iOperation = NULL;
+	}
+
+void CSmsScTest::DoRunWriteSimParamsL()
+/**
+	Checks the status, saves the operation and calls ReadAfterWriteL.
+ */
+	{
+	if (iStatus == KErrNone)
+		{
+		TIntBuf progressBuf;
+		progressBuf.Copy(iOperation->ProgressL());
+		iStatus = progressBuf();
+		}
+
+	iSmsTest.Test().Printf(_L("WriteSimParams completed with error %d\n"), iStatus);
+
+	delete iOperation;
+	iOperation = NULL;
+
+	if (iStatus == KErrNone)
+		{
+		// Reading the new parameters from Sim
+		ReadAfterWriteL();
+		}
+	}
+
+void CSmsScTest::DoRunReadAfterWriteL()
+/**
+	Checks the status, parameter list and service center list.
+ */
+	{
+	if (iStatus == KErrNone)
+		{
+		TIntBuf progressBuf;
+		progressBuf.Copy(iOperation->ProgressL());
+		iStatus = progressBuf();
+		}
+
+	iSmsTest.Test().Printf(_L("ReadSimParams completed with error %d\n"), iStatus);
+	
+	if (iStatus == KErrNone)
+		{
+		CSmsSimParamOperation* op = (CSmsSimParamOperation*) iOperation;
+		
+		const CMobilePhoneSmspList& list = op->SmspList();
+		TInt count = list.Enumerate();
+
+		iSmsTest.Test().Printf(_L("ReadSimParams found:\n\t%d SMS params on SIM\n"), count);
+
+//		PrintList(iSmsTest.Test(), list);
+		LOCAL_CHECKPOINT(iAutoTest, CompareListsL(*iListToWrite, list));
+		}
+
+	delete iOperation;
+	iOperation = NULL;
+	}
+
+TBool CSmsScTest::CompareListsL(const CMobilePhoneSmspList& aWritten, const CMobilePhoneSmspList& aRead)
+/**
+	Compares two parameter lists 
+
+	@param		aWritten	A list of SIM parameters
+	@param		aRead		A list of SIM parameters	
+	@return		TBool		A boolean. 
+ */
+	{
+	const TInt count = aWritten.Enumerate();
+
+	TInt ret = ETrue;
+
+	if (count < aRead.Enumerate())
+		ret = EFalse;
+
+	for (TInt i=0; i<count && ret; ++i) 
+		{   
+		const RMobileSmsMessaging::TMobileSmspEntryV1& entry1 = aWritten.GetEntryL(i);
+		const RMobileSmsMessaging::TMobileSmspEntryV1& entry2 = aRead.GetEntryL(i);
+
+		ret = CompareEntries(entry1, entry2);
+		}
+	
+	return ret;
+	}
+
+TBool CSmsScTest::CompareEntries(const RMobileSmsMessaging::TMobileSmspEntryV1& aWritten, const RMobileSmsMessaging::TMobileSmspEntryV1& aRead)
+/**
+	Compares two parameter entries 
+
+	@param		aWritten	A parameter entry
+	@param		aRead		A parameter entry	
+	@return		TBool		A boolean. 
+ */
+	{
+	TBool ret = ETrue;
+
+	if ((aWritten.iValidParams & RMobileSmsMessaging::KProtocolIdIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KProtocolIdIncluded) && aRead.iProtocolId != aWritten.iProtocolId)
+		ret = EFalse;
+	else if ((aWritten.iValidParams & RMobileSmsMessaging::KDcsIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KDcsIncluded) && aWritten.iDcs != aRead.iDcs)
+		ret = EFalse;
+	else if ((aWritten.iValidParams & RMobileSmsMessaging::KValidityPeriodIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KValidityPeriodIncluded) && aWritten.iValidityPeriod != aRead.iValidityPeriod)
+		ret = EFalse;
+	else if ((aWritten.iValidParams & RMobileSmsMessaging::KDestinationIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KDestinationIncluded) && aWritten.iDestination.iTelNumber.CompareF(aRead.iDestination.iTelNumber) != 0)
+		ret = EFalse;
+	else if ((aWritten.iValidParams & RMobileSmsMessaging::KSCAIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KSCAIncluded) && aWritten.iServiceCentre.iTelNumber.CompareF(aRead.iServiceCentre.iTelNumber) != 0)
+		ret = EFalse;
+	else if ((aWritten.iValidParams & RMobileSmsMessaging::KSCAIncluded) && (aRead.iValidParams & RMobileSmsMessaging::KSCAIncluded) && aWritten.iText.CompareF(aRead.iText) != 0)
+		ret = EFalse;
+
+	return ret;
+	}
+
+void CSmsScTest::DoRunWriteOriginalParamsL()
+/**
+	Checks the status
+ */	
+	{
+	if (iStatus == KErrNone)
+		{
+		TIntBuf progressBuf;
+		progressBuf.Copy(iOperation->ProgressL());
+		iStatus = progressBuf();
+		}
+
+	iSmsTest.Test().Printf(_L("WriteSimParams completed with error %d\n"), iStatus);
+
+	delete iOperation;
+	iOperation = NULL;
+	}
+
+void CSmsScTest::DoCancel()
+/**
+	Cancels the async operation
+ */
+	{
+	if (iOperation)
+		{
+		iOperation->Cancel();
+		iSmsTest.Test().Printf(_L("Operation Cancelled!\n"));
+		}
+
+	delete iOperation;
+	iOperation = NULL;
+	}