// 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 "T_smcm.h"

#include <commsdattypesv1_1.h>

#include <commsdat.h>

#include <etelmm.h>

#include <smutset.h>

using namespace CommsDat;

	#include <csmsaccount.h>

CSmutTest::CSmutTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

: CSmsTestBase(aSmsTest, aScriptFile, aNextTest)

	{

	}

void CSmutTest::RunAutoL()

	{

	// Testing settings (CSmsSettings)

	iSmsTest.TestStart(++iNextTest, _L("CSmsSettings"));  

	TestSettingsL();

	iSmsTest.TestFinish(iNextTest);

	// Testing number class (CSmsNumber)

	iSmsTest.TestStart(++iNextTest, _L("CSmsNumber"));  

	TestNumberL();

	iSmsTest.TestFinish(iNextTest);

	// Testing with header (CSmsHeader)

	iSmsTest.TestStart(++iNextTest, _L("CSmsHeader"));

	TestHeaderL();

	iSmsTest.TestFinish(iNextTest);

	// Testing with utility class (TSmsUtilities)

	iSmsTest.TestStart(++iNextTest, _L("TSmsUtilities"));

	TestSmsUtilitiesL();

	iSmsTest.TestFinish(iNextTest);

	}

CSmutTest::~CSmutTest()

	{

	delete iSmsHeader;

	delete iRichText;

	delete iParaLayer;

	delete iCharLayer;

	}

void CSmutTest::ConstructL()

	{

	SetTestNameL(KSmsUtilitiesTestName);

	iSmsTest.SetLogToFile();

	iSelection = new (ELeave) CMsvEntrySelection();

	iTimer = CTestTimer::NewL();

	iParaLayer =CParaFormatLayer::NewL();

	iCharLayer = CCharFormatLayer::NewL();

	iRichText = CRichText::NewL(iParaLayer, iCharLayer, CEditableText::EFlatStorage,256);

	CActiveScheduler::Add(this);

	}

CSmutTest* CSmutTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

	{

	CSmutTest* self = new (ELeave) CSmutTest(aSmsTest, aScriptFile, aNextTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CSmutTest::ShowMenuL()

	{

	iSmsTest.ResetMenu();

	iSmsTest.AppendToMenuL(_L("Start"));

	TInt result = iSmsTest.DisplayMenu(_L("SMS Client MTM Test"));

	if (result <= 0)

		return;

	switch (result)

		{

		case 1:

			RunAutoL();

			break;

		default:

			User::Leave(KErrArgument);

			break;

		}

	if (!iSmsTest.RunAuto())

		{

		iSmsTest.Printf(_L("Press any key to continue...\n"));

		iSmsTest.Test().Getch();

		}

	ShowMenuL();

	}

void CSmutTest::TestSettingsL()

	{

	iSmsTest.Printf(_L("Testing Create Settings...\n"));

	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

// First we test all the features of the class CSmsSettings

// We give them different values and compare if it works

	CSmsSettings* settings = CSmsSettings::NewL();

	CleanupStack::PushL(settings);

	iSmsTest(CompareSettings(*settings, *settings));

	TestSettingsMembersL(*settings);

	TestMessageSettingsMembersL(*settings);

// Lets copy the values to a different instance

	CSmsSettings* smsSettings=CSmsSettings::NewL();

	CleanupStack::PushL(smsSettings);

	smsSettings->CopyL(*settings);

	iSmsTest(CompareSettings(*smsSettings, *settings));

	CleanupStack::PopAndDestroy(smsSettings);

	smsSettings = NULL;

	iSmsTest.Printf(_L("Test CSmsSettings::CopyL() passed\n"));

//	Lets create a sms service in the file system with these values

	StoreSettingsL(*settings);

	iSmsTest.Printf(_L("Stored CSmsSettings against the service\n"));

// Lets read the service and see it the values are still ok

	CSmsSettings* set1=CSmsSettings::NewL();

	CleanupStack::PushL(set1);

	RestoreSettingsL(*set1);

	iSmsTest.Printf(_L("Restored CSmsSettings\n"));

	iSmsTest(CompareSettings(*set1, *settings));

	CleanupStack::PopAndDestroy(set1);

// Lets make the previous test again; Lets give a settings instance some

// values, store it, restore it and see that the values are still the same

	CSmsSettings* set2=CSmsSettings::NewL();

	CleanupStack::PushL(set2);

	set2->AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010"));

	set2->AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010"));

	set2->AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010"));

	set2->AddServiceCenterL(_L("Radiolinja3"),_L("+358508771010"));

	set2->AddServiceCenterL(_L("Radiolinja4"),_L("+358508771010"));

	set2->SetDefaultServiceCenter(1);

	iSmsTest(set2->DefaultServiceCenter()==1);

// Validity Period	

	set2->SetValidityPeriod(ESmsVPSixHours);

	iSmsTest(set2->ValidityPeriod().Int()==ESmsVPSixHours);

// Reply Quoted

	set2->SetReplyQuoted(EFalse);

	iSmsTest(!set2->ReplyQuoted());

// Reject Duplicate 

	set2->SetRejectDuplicate(ETrue);

	iSmsTest(set2->RejectDuplicate());

// Delivery Method

	set2->SetDelivery(ESmsDeliveryUponRequest);

	iSmsTest(set2->Delivery()==ESmsDeliveryUponRequest);

// Delivery Report

	set2->SetDeliveryReport(ETrue);

	iSmsTest(set2->DeliveryReport());

// Reply Path

	set2->SetReplyPath(EFalse);

	iSmsTest(!set2->ReplyPath());

// Message Conversion

	set2->SetMessageConversion(ESmsConvPIDNone);

	iSmsTest(set2->MessageConversion()==ESmsConvPIDNone);

// Can Concatenate

	set2->SetCanConcatenate(ETrue);

	iSmsTest(set2->CanConcatenate());

// Character Set

	set2->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

	iSmsTest(set2->CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet8Bit);

// Validity period format

	set2->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

	iSmsTest(set2->ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet);

// Status Report Handling

	set2->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

	iSmsTest(set2->StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisible);

// Special Message Handling

	set2->SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

	iSmsTest(set2->SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisible);

	StoreSettingsL(*set2);

	iSmsTest.Printf(_L("Stored CSmsSettings 2\n"));

	CSmsSettings* set3=CSmsSettings::NewL();

	CleanupStack::PushL(set3);

	RestoreSettingsL(*set3);

	iSmsTest.Printf(_L("Restored CSmsSettings 2\n"));

	iSmsTest(CompareSettings(*set2, *set3));

	CleanupStack::PopAndDestroy(set3);

	CleanupStack::PopAndDestroy(set2);

	iSmsTest.iServiceSettings->CopyL(*settings);  // Lets copy the current setting to the service settings

	iSmsTest(CompareSettings(*iSmsTest.iServiceSettings, *settings));

	iSmsTest.Printf(_L("CSmsSettings::CopyL() 2\n"));

	CleanupStack::PopAndDestroy(settings);

	iSmsTest.Printf(_L("Test Create Settings Passed\n"));

	TestSettingsStoreToCommDbL();

	iSmsTest.Printf(_L("TestSettingsStoreToCommDbL Passed\n"));

	TestSettingsRestoreDefectL();

	iSmsTest.Printf(_L("TestSettingsRestoreDefectL Passed\n"));

	}

void CSmutTest::TestSettingsMembersL(CSmsSettings& aSettings)

	{

// Status Report Handling (what should be done to report messages)

	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisible);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxInvisible);

	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisible);

	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReport);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EDiscardReport);

	iSmsTest.Printf(_L("Test Status Report Handling Passed\n"));

// SC handling

	aSettings.AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja3"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja4"),_L("+358508771010"));

	iSmsTest(aSettings.GetServiceCenter(0).Name()==_L("Radiolinja0"));

	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-3);

	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-2);

	iSmsTest(aSettings.GetServiceCenter(1).Name()==_L("Radiolinja1"));

	iSmsTest(aSettings.GetServiceCenter(2).Name()==_L("Radiolinja4"));

	iSmsTest(aSettings.GetServiceCenter(2).Address()==_L("+358508771010"));

	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1);

	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1);

	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1);

//	aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1); // this would be -1

	aSettings.AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010"));

	aSettings.AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010"));

	aSettings.SetDefaultServiceCenter(1);

	iSmsTest(aSettings.DefaultServiceCenter()==1);

	aSettings.SetDefaultServiceCenter(2);

	iSmsTest(aSettings.DefaultServiceCenter()==2);

	iSmsTest.Printf(_L("Test Default SC Passed\n"));

// Special Message Handling (what should be done to special messages)

	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisible);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxInvisible);

	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisible);

	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReport);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EDiscardReport);

	iSmsTest.Printf(_L("Test Special Message Handling Passed\n"));

//CommDbAction

	aSettings.SetCommDbAction(CSmsSettings::ENone);

	iSmsTest(aSettings.CommDbAction() == CSmsSettings::ENone);

	aSettings.SetCommDbAction(CSmsSettings::EStoreToCommDb);

	iSmsTest(aSettings.CommDbAction() == CSmsSettings::EStoreToCommDb);

	iSmsTest.Printf(_L("Test CommDb Action Passed\n"));

//SmsBearerAction

	aSettings.SetSmsBearerAction(CSmsSettings::ENone);

	iSmsTest(aSettings.SmsBearerAction() == CSmsSettings::ENone);

	aSettings.SetSmsBearerAction(CSmsSettings::EStoreToCommDb);

	iSmsTest(aSettings.SmsBearerAction() == CSmsSettings::EStoreToCommDb);

	iSmsTest.Printf(_L("Test SMS Bearer Action Passed\n"));

//SmsBearer

	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

	iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketOnly);

	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

	iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketOnly);

	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly);

	iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerCircuitOnly);

	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketPreferred);

	iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketPreferred);

	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred);

	iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerCircuitPreferred);

	iSmsTest.Printf(_L("Test SMS Bearer Passed\n"));

// Reply Quoted

	aSettings.SetReplyQuoted(EFalse);

	iSmsTest(!aSettings.ReplyQuoted());

	aSettings.SetReplyQuoted(ETrue);

	iSmsTest(aSettings.ReplyQuoted());

	iSmsTest.Printf(_L("Test Reply Quoted Passed\n"));

// Delivery Method

	aSettings.SetDelivery(ESmsDeliveryUponRequest);

	iSmsTest(aSettings.Delivery()==ESmsDeliveryUponRequest);

	aSettings.SetDelivery(ESmsDeliveryScheduled);

	iSmsTest(aSettings.Delivery()==ESmsDeliveryScheduled);

	aSettings.SetDelivery(ESmsDeliveryImmediately);

	iSmsTest(aSettings.Delivery()==ESmsDeliveryImmediately);

	iSmsTest.Printf(_L("Test Delivery Passed\n"));

	}

void CSmutTest::TestMessageSettingsMembersL(CSmsMessageSettings& aSettings)

	{

// Reject Duplicate 

	aSettings.SetRejectDuplicate(ETrue);

	iSmsTest(aSettings.RejectDuplicate());

	aSettings.SetRejectDuplicate(EFalse);

	iSmsTest(!aSettings.RejectDuplicate());

	iSmsTest.Printf(_L("Test Reject Duplicate Passed\n"));

// Delivery Report

	aSettings.SetDeliveryReport(ETrue);

	iSmsTest(aSettings.DeliveryReport());

	aSettings.SetDeliveryReport(EFalse);

	iSmsTest(!aSettings.DeliveryReport());

	iSmsTest.Printf(_L("Test Delivery Report Passed\n"));

// Reply Path

	aSettings.SetReplyPath(EFalse);

	iSmsTest(aSettings.ReplyPath()==EFalse);

	aSettings.SetReplyPath(ETrue);

	iSmsTest(aSettings.ReplyPath());

	iSmsTest.Printf(_L("Test Reply Path Passed\n"));

// Validity period format

	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone);

	iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFNone);

	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFEnhanced);

	iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFEnhanced);

	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger);

	iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFInteger);

	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

	iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet);

	iSmsTest.Printf(_L("Test Validity Period Format Passed\n"));

// Message Conversion (following conversions are supported)

	aSettings.SetMessageConversion(ESmsConvFax);

	iSmsTest(aSettings.MessageConversion()==ESmsConvFax);

	aSettings.SetMessageConversion(ESmsConvX400);

	iSmsTest(aSettings.MessageConversion()==ESmsConvX400);

	aSettings.SetMessageConversion(ESmsConvPaging);

	iSmsTest(aSettings.MessageConversion()==ESmsConvPaging);

	aSettings.SetMessageConversion(ESmsConvMail);

	iSmsTest(aSettings.MessageConversion()==ESmsConvMail);

	aSettings.SetMessageConversion(ESmsConvErmes);

	iSmsTest(aSettings.MessageConversion()==ESmsConvErmes);

	aSettings.SetMessageConversion(ESmsConvSpeech);

	iSmsTest(aSettings.MessageConversion()==ESmsConvSpeech);

	aSettings.SetMessageConversion(ESmsConvPIDNone);

	iSmsTest(aSettings.MessageConversion()==ESmsConvPIDNone);

	iSmsTest.Printf(_L("Test Message Conversion Passed\n"));

// Validity Period	

	aSettings.SetValidityPeriod(ESmsVPHour);

	iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPHour);

	aSettings.SetValidityPeriod(ESmsVPSixHours);

	iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPSixHours);

	aSettings.SetValidityPeriod(ESmsVP24Hours);

	iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVP24Hours);

	aSettings.SetValidityPeriod(ESmsVPMaximum);

	iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPMaximum);

	aSettings.SetValidityPeriod(ESmsVPWeek);

	iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPWeek);

	iSmsTest.Printf(_L("Test Validity Period Passed\n"));

// Can Concatenate (write messages with more than 160 characters)

	aSettings.SetCanConcatenate(ETrue);

	iSmsTest(aSettings.CanConcatenate());

	aSettings.SetCanConcatenate(EFalse);

	iSmsTest(aSettings.CanConcatenate()==EFalse);

	iSmsTest.Printf(_L("Test Can Concatenate Passed\n"));

// Character Set (following character sets are supported)

	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit);

	iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet7Bit);

	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2);

	iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabetUCS2);

	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

	iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet8Bit);

	iSmsTest.Printf(_L("Test Character Set Passed\n"));

	}

TBool CSmutTest::CompareSettings(const CSmsSettings& aLeft, const CSmsSettings& aRight, TBool aTestSC)

	{

	TCompare compare(CompareMessageSettings(aLeft, aRight));

	compare(aLeft.CommDbAction() == aRight.CommDbAction());

	compare(aLeft.SmsBearerAction() == aRight.SmsBearerAction());

	compare(aLeft.SmsBearer() == aRight.SmsBearer());

	compare(aLeft.Delivery() == aRight.Delivery());

	compare(CompareBools(aLeft.ReplyQuoted(), aRight.ReplyQuoted()));

	compare(aLeft.SpecialMessageHandling() == aRight.SpecialMessageHandling());

	compare(aLeft.StatusReportHandling() == aRight.StatusReportHandling());

	if (aTestSC)

		{

		compare(aLeft.DefaultServiceCenter() == aRight.DefaultServiceCenter());

		compare(aLeft.ServiceCenterCount() == aRight.ServiceCenterCount());

		TInt count = aLeft.ServiceCenterCount();

		while (count--)

			{

			compare(CompareServiceCenters(aLeft.GetServiceCenter(count), aRight.GetServiceCenter(count)));

			}

		}		

	return compare;

	}

TBool CSmutTest::CompareMessageSettings(const CSmsMessageSettings& aLeft, const CSmsMessageSettings& aRight)

	{

	TCompare compare(CompareBools(aLeft.CanConcatenate(), aRight.CanConcatenate()));

	compare(aLeft.CharacterSet() == aRight.CharacterSet());

	compare(CompareBools(aLeft.DeliveryReport(), aRight.DeliveryReport()));

	compare(aLeft.MessageConversion() == aRight.MessageConversion());

	compare(CompareBools(aLeft.RejectDuplicate(), aRight.RejectDuplicate()));

	compare(CompareBools(aLeft.ReplyPath(), aRight.ReplyPath()));

	compare(aLeft.ValidityPeriod() == aRight.ValidityPeriod());

	compare(aLeft.ValidityPeriodFormat() == aRight.ValidityPeriodFormat());

	return compare;

	}

void CSmutTest::TestSettingsRestoreDefectL()

	{

	//Test fix for defects EDNAALR-4KTKTD (CSmsSettings::RestoreL() should leave if stream not present)

	//and EDNAALR-4KTKLP (CSmsSettings::InternalizeL() causes memory leak)

	CSmsSettings* settings = CSmsSettings::NewL();

	CleanupStack::PushL(settings);

	//Test defect fix for EDNAALR-4KTKTD (CSmsSettings::RestoreL() should leave if stream not present)

	const TMsvId id = iSmsTest.CreateDummyMessageToSendL();

	Session().CleanupEntryPushL(id);

	iSmsTest.SetEntryL(id);

	iSmsTest.Printf(_L("TestSettingsRestoreDefectL Created dummy message\n"));

	TRAPD(err, RestoreSettingsL(*settings));

	iSmsTest.Printf(_L("TestSettingsRestoreDefectL RestoreL 1 with error %d\n"), err);

	iSmsTest.Printf(_L("Expected %d\n"), KErrNotFound);

	iSmsTest(err == KErrNotFound);

	//Test defect fix for EDNAALR-4KTKLP (CSmsSettings::InternalizeL() causes memory leak)

//	iSmsTest.SetEntryL(id);

	StoreSettingsL(*settings);

	iSmsTest.Printf(_L("TestSettingsRestoreDefectL StoreL 1\n"));

	settings->AddServiceCenterL(_L("Unknown"), _L("447785016005"));

	RestoreSettingsL(*settings);

	CleanupStack::PopAndDestroy(); //id

	CleanupStack::PopAndDestroy(settings);

	iSmsTest.Printf(_L("TestSettingsRestoreDefectL RestoreL 2\n"));

	}

void CSmutTest::TestSettingsStoreToCommDbL()

	{

	iSmsTest.Test().Next(_L("Storing CSmsSettings to CommDb\n"));

	iSmsTest.Printf(_L("Test Store Settings to CommDb\n"));

	CSmsSettings* settings1 = CSmsSettings::NewL();

	CleanupStack::PushL(settings1);

	CSmsSettings* settings2 = CSmsSettings::NewL();

	CleanupStack::PushL(settings2);

	iSmsTest(CompareSettings(*settings1, *settings2));

	settings1->SetCommDbAction(CSmsSettings::EStoreToCommDb);

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

	settings1->SetDeliveryReport(ETrue);

	settings1->SetValidityPeriod(1000);

	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

	StoreSettingsL(*settings1);

	iSmsTest.Printf(_L("\tNew Settings...\n"));

	iSmsTest(CompareSettingsAndCommDbL(*settings1));

	settings1->GetServiceCenter(settings1->DefaultServiceCenter()).SetAddressL(_L("+3854354433"));

	StoreSettingsL(*settings1);

	iSmsTest.Printf(_L("\tSC Address Changed...\n"));

	iSmsTest(CompareSettingsAndCommDbL(*settings1));

	settings1->SetDeliveryReport(EFalse);

	StoreSettingsL(*settings1);

	iSmsTest.Printf(_L("\tDelivery Report Changed...\n"));

	iSmsTest(CompareSettingsAndCommDbL(*settings1));

	settings1->SetValidityPeriod(2000);