1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "T_smut.h"

    17 #include <smss.rsg>

    18 #include <etelmm.h>

    19 #include <smutset.h>

    20 #include <csmsaccount.h>

    21 

    22 #include <csmsemailfields.h>

    23 

    24 #include <csmsgetdetdescinterface.h>

    25 

    26 

    27 const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};

    28 

    29 GLDEF_C TInt E32Main()

    30 	{	

    31 	__UHEAP_MARK;

    32 	test.Start(_L("Setup"));

    33 	theCleanup = CTrapCleanup::New();

    34 	TRAPD(ret,doMainL());		

    35 	test(ret==KErrNone);

    36 	delete theCleanup;	

    37 	test.Console()->SetPos(0, 13);

    38 	test.End();

    39 	test.Close();

    40 	__UHEAP_MARKEND;

    41 	return(KErrNone);

    42 	}

    43 

    44 LOCAL_C void doMainL()

    45 	{

    46 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    47 	CleanupStack::PushL(scheduler);

    48 	CActiveScheduler::Install(scheduler);

    49 

    50 	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);

    51 	CleanupStack::PushL(smsTest);

    52 	TInt nextTest = 0;

    53 	

    54 	CSmutTest* SmcmTest = CSmutTest::NewLC(*smsTest, KNullDesC, nextTest);

    55 

    56 	SmcmTest->StartL();

    57 

    58 	CleanupStack::PopAndDestroy(3, scheduler);

    59 	}

    60 

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

    62 : CSmsTestBase(aSmsTest, aScriptFile, aNextTest)

    63 	{

    64 	}

    65 

    66 void CSmutTest::RunAutoL()

    67 	{

    68 	iNextTest = 0;

    69 	

    70 	// Testing TMsvSmsEntry

    71 	iSmsTest.TestStart(++iNextTest, _L("TMsvSmsEntry"));

    72 	TestSmsEntryL();

    73 	iSmsTest.TestFinish(iNextTest);

    74 

    75 

    76 	// Testing settings (CSmsSettings)

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

    78 	TestSettingsL();

    79 	iSmsTest.TestFinish(iNextTest);

    80 

    81 	// Testing number class (CSmsNumber)

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

    83 	TestNumberL();

    84 	iSmsTest.TestFinish(iNextTest);

    85 	

    86 	// Testing email fields class (CSmsEmailFields)

    87 	iSmsTest.TestStart(++iNextTest, _L("CSmsEmailFields"));  

    88 	TestEmailFieldsL();

    89 	iSmsTest.TestFinish(iNextTest);

    90 

    91 	// Testing with header (CSmsHeader)

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

    93 	TestHeaderL();

    94 	iSmsTest.TestFinish(iNextTest);

    95 

    96 	// Testing with utility class (TSmsUtilities)

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

    98 	TestSmsUtilitiesL();

    99 

   100 	// Testing with ECOM Plugin class (CSmsGetDetDescInterface)

   101 	iSmsTest.TestStart(++iNextTest, _L("CSmsGetDetDescInterface"));

   102 	TestSmsUtilitiesBL();

   103 

   104 	iSmsTest.TestFinish(iNextTest);

   105 

   106 	iSmsTest.TestStart(++iNextTest, _L("EMS Extensions"));

   107 	TestSmsEmsExtensionsL();

   108 

   109 	iSmsTest.TestFinish(iNextTest);

   110 

   111 	}

   112 

   113 CSmutTest::~CSmutTest()

   114 	{

   115 	delete iSmsHeader;

   116 	delete iRichText;

   117 	delete iParaLayer;

   118 	delete iCharLayer;

   119 	delete iDBSession;

   120 	

   121 	}

   122 

   123 void CSmutTest::ConstructL()

   124 	{

   125 	iSmsTest.SetLogToFile();

   126 

   127 	iSelection = new (ELeave) CMsvEntrySelection();

   128 	iTimer = CTestTimer::NewL();

   129 

   130 	iParaLayer =CParaFormatLayer::NewL();

   131 	iCharLayer = CCharFormatLayer::NewL();

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

   133 	iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion());	

   134 

   135 	CActiveScheduler::Add(this);

   136 	}

   137 

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

   139 	{

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

   141 	CleanupStack::PushL(self);

   142 

   143 	self->ConstructL();

   144 

   145 	return self;

   146 	}

   147 

   148 void CSmutTest::ShowMenuL()

   149 	{

   150 	iSmsTest.ResetMenu();

   151 

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

   153 	iSmsTest.AppendToMenuL(_L("Sms Utilities"));

   154 	iSmsTest.AppendToMenuL(_L("Sms Settings"));

   155 

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

   157 

   158 	if (result <= 0)

   159 		return;

   160 

   161 	switch (result)

   162 		{

   163 		case 1:

   164 			RunAutoL();

   165 			break;

   166 		case 2:

   167 			TestSmsUtilitiesL();

   168 			break;

   169 		case 3:

   170 			TestSettingsL();

   171 			break;

   172 		default:

   173 			User::Leave(KErrArgument);

   174 			break;

   175 		}

   176 

   177 	if (!iSmsTest.RunAuto())

   178 		{

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

   180 		iSmsTest.Test().Getch();

   181 		}

   182 

   183 	ShowMenuL();

   184 	}

   185 

   186 void CSmutTest::TestSettingsL()

   187 	{

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

   189 

   190 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

   191 

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

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

   194 

   195 	CSmsSettings* settings = CSmsSettings::NewL();

   196 	CleanupStack::PushL(settings);

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

   198 	TestSettingsMembersL(*settings);

   199 	TestMessageSettingsMembersL(*settings);

   200 

   201 // Lets copy the values to a different instance

   202 	CSmsSettings* smsSettings=CSmsSettings::NewL();

   203 	CleanupStack::PushL(smsSettings);

   204 	smsSettings->CopyL(*settings);

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

   206 	CleanupStack::PopAndDestroy(smsSettings);

   207 	smsSettings = NULL;

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

   209 

   210 

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

   212 	TestStoreRestoreSettingsL(*settings);

   213 

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

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

   216 	CSmsSettings* set2=CSmsSettings::NewL();

   217 	CleanupStack::PushL(set2);

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

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

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

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

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

   223 	set2->SetDefaultServiceCenter(1);

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

   225 // Validity Period	

   226 	set2->SetValidityPeriod(ESmsVPSixHours);

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

   228 // Reply Quoted

   229 	set2->SetReplyQuoted(EFalse);

   230 	iSmsTest(!set2->ReplyQuoted());

   231 // Reject Duplicate 

   232 	set2->SetRejectDuplicate(ETrue);

   233 	iSmsTest(set2->RejectDuplicate());

   234 // Delivery Method

   235 	set2->SetDelivery(ESmsDeliveryUponRequest);

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

   237 // Delivery Report

   238 	set2->SetDeliveryReport(ETrue);

   239 	iSmsTest(set2->DeliveryReport());

   240 // Reply Path

   241 	set2->SetReplyPath(EFalse);

   242 	iSmsTest(!set2->ReplyPath());

   243 // Message Conversion

   244 	set2->SetMessageConversion(ESmsConvPIDNone);

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

   246 // Can Concatenate

   247 	set2->SetCanConcatenate(ETrue);

   248 	iSmsTest(set2->CanConcatenate());

   249 // Character Set

   250 	set2->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

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

   252 // Validity period format

   253 	set2->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

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

   255 // Status Report Handling

   256 	set2->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   258 // Special Message Handling

   259 	set2->SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   261 

   262 	TestStoreRestoreSettingsL(*set2);

   263 

   264 	set2->SetClass2Folder(123);

   265 	TestStoreRestoreSettingsL(*set2);

   266 

   267 	CleanupStack::PopAndDestroy(set2);

   268 

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

   270 

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

   272 

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

   274 

   275 	CleanupStack::PopAndDestroy(settings);

   276 

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

   278 

   279 	TestSettingsStoreToCommDbL();

   280 

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

   282 

   283 	}

   284 

   285 

   286 TBool CSmutTest::CompareSettingsFiles(

   287 	RFs& aFs, const TDesC& aCompare1, const TDesC& aCompare2

   288 	)

   289 	{

   290 	TBool identical = ETrue;

   291 

   292 	RFileReadStream stream1;

   293 	RFileReadStream stream2;

   294 

   295 	// Open each stream for binary read.

   296 	stream1.Open(aFs, aCompare1, EFileStream | EFileRead);

   297 	stream2.Open(aFs, aCompare2, EFileStream | EFileRead);

   298 

   299 	TInt ret1 = KErrNone;

   300 	TInt ret2 = KErrNone;

   301 	TBool finished = EFalse;

   302 	TUint8 byte1 = 0;

   303 	TUint8 byte2 = 0;

   304 

   305 	while (!finished)

   306 		{

   307 		TRAP(ret1, byte1 = stream1.ReadUint8L());

   308 		TRAP(ret2, byte2 = stream2.ReadUint8L());

   309 

   310 		if (byte1 != byte2 || ret1 == KErrEof || ret2 == KErrEof)

   311 			{

   312 			// Either file data or lengths differ.

   313 			if ((byte1 != byte2) || (ret1 != ret2))

   314 				identical = EFalse;

   315 			finished = ETrue;

   316 			}

   317 		}

   318 

   319 	stream1.Close();

   320 	stream2.Close();

   321 

   322 	return identical;

   323 	}

   324 

   325 void CSmutTest::TestStoreRestoreSettingsL(const CSmsSettings& aSettings)

   326 	{

   327 	StoreSettingsL(aSettings);

   328 

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

   330 	CSmsSettings* set1=CSmsSettings::NewL();

   331 	CleanupStack::PushL(set1);

   332 

   333 	RestoreSettingsL(*set1);

   334 

   335 	iSmsTest(CompareSettings(*set1, aSettings));

   336 

   337 	CleanupStack::PopAndDestroy(set1);

   338 	}

   339 

   340 void CSmutTest::TestSettingsMembersL(CSmsSettings& aSettings)

   341 	{

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

   343 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisible);

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

   345 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   347 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReport);

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

   349 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   350 	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   351 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   352 	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   353 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReportAndMatch);

   354 	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EDiscardReportAndMatch);

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

   356 

   357 // SC handling

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   376 	aSettings.SetDefaultServiceCenter(1);

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

   378 	aSettings.SetDefaultServiceCenter(2);

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

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

   381 

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

   383 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisible);

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

   385 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   387 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReport);

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

   389 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   390 	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   391 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   392 	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   393 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReportAndMatch);

   394 	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EDiscardReportAndMatch);

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

   396 

   397 //CommDbAction

   398 	aSettings.SetCommDbAction(CSmsSettings::ENone);

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

   400 	aSettings.SetCommDbAction(CSmsSettings::EStoreToCommDb);

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

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

   403 

   404 //SmsBearerAction

   405 	aSettings.SetSmsBearerAction(CSmsSettings::ENone);

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

   407 	aSettings.SetSmsBearerAction(CSmsSettings::EStoreToCommDb);

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

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

   410 

   411 //SmsBearer

   412 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

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

   414 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

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

   416 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly);

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

   418 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketPreferred);

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

   420 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred);

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

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

   423 

   424 // Reply Quoted

   425 	aSettings.SetReplyQuoted(EFalse);

   426 	iSmsTest(!aSettings.ReplyQuoted());

   427 	aSettings.SetReplyQuoted(ETrue);

   428 	iSmsTest(aSettings.ReplyQuoted());

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

   430 

   431 // Delivery Method

   432 	aSettings.SetDelivery(ESmsDeliveryUponRequest);

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

   434 	aSettings.SetDelivery(ESmsDeliveryScheduled);

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

   436 	aSettings.SetDelivery(ESmsDeliveryImmediately);

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

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

   439 

   440 // Class2Folder

   441 	iSmsTest(aSettings.Class2Folder() == KMsvGlobalInBoxIndexEntryId);

   442 	aSettings.SetClass2Folder(1);

   443 	iSmsTest(aSettings.Class2Folder() == 1);

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

   445 

   446 // Description length

   447 	iSmsTest(aSettings.DescriptionLength() == KSmsDescriptionLength);

   448 	aSettings.SetDescriptionLength(100);

   449 	iSmsTest(aSettings.DescriptionLength() == 100);

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

   451 	}

   452 

   453 void CSmutTest::TestMessageSettingsMembersL(CSmsMessageSettings& aSettings)

   454 	{

   455 

   456 // Reject Duplicate 

   457 	aSettings.SetRejectDuplicate(ETrue);

   458 	iSmsTest(aSettings.RejectDuplicate());

   459 	aSettings.SetRejectDuplicate(EFalse);

   460 	iSmsTest(!aSettings.RejectDuplicate());

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

   462 

   463 // Delivery Report

   464 	aSettings.SetDeliveryReport(ETrue);

   465 	iSmsTest(aSettings.DeliveryReport());

   466 	aSettings.SetDeliveryReport(EFalse);

   467 	iSmsTest(!aSettings.DeliveryReport());

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

   469 

   470 // Reply Path

   471 	aSettings.SetReplyPath(EFalse);

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

   473 	aSettings.SetReplyPath(ETrue);

   474 	iSmsTest(aSettings.ReplyPath());

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

   476 

   477 // Validity period format

   478 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone);

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

   480 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFEnhanced);

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

   482 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger);

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

   484 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

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

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

   487 

   488 // Message Conversion (following conversions are supported)

   489 	aSettings.SetMessageConversion(ESmsConvFax);

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

   491 	aSettings.SetMessageConversion(ESmsConvX400);

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

   493 	aSettings.SetMessageConversion(ESmsConvPaging);

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

   495 	aSettings.SetMessageConversion(ESmsConvMail);

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

   497 	aSettings.SetMessageConversion(ESmsConvErmes);

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

   499 	aSettings.SetMessageConversion(ESmsConvSpeech);

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

   501 	aSettings.SetMessageConversion(ESmsConvPIDNone);

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

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

   504 

   505 // Validity Period	

   506 	aSettings.SetValidityPeriod(ESmsVPHour);

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

   508 	aSettings.SetValidityPeriod(ESmsVPSixHours);

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

   510 	aSettings.SetValidityPeriod(ESmsVP24Hours);

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

   512 	aSettings.SetValidityPeriod(ESmsVPMaximum);

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

   514 	aSettings.SetValidityPeriod(ESmsVPWeek);

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

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

   517 

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

   519 	aSettings.SetCanConcatenate(ETrue);

   520 	iSmsTest(aSettings.CanConcatenate());

   521 	aSettings.SetCanConcatenate(EFalse);

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

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

   524 

   525 // Character Set (following character sets are supported)

   526 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit);

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

   528 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2);

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

   530 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

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

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

   533 	}

   534 

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

   536 	{

   537 	TCompare compare(CompareMessageSettings(aLeft, aRight));

   538 

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

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

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

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

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

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

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

   546 

   547 	if (aTestSC)

   548 		{

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

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

   551 

   552 		TInt count = aLeft.ServiceCenterCount();

   553 

   554 		while (count--)

   555 			{

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

   557 			}

   558 		}		

   559 

   560 	compare(aLeft.Class2Folder() == aRight.Class2Folder());

   561 	compare(aLeft.DescriptionLength() == aRight.DescriptionLength());

   562 

   563 	return compare;

   564 	}

   565 

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

   567 	{

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

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

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

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

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

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

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

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

   576 	return compare;

   577 	}

   578 

   579 void CSmutTest::TestSettingsRestoreDefectL()

   580 	{

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

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

   583 

   584 	CSmsSettings* settings = CSmsSettings::NewL();

   585 	CleanupStack::PushL(settings);

   586 

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

   588 	const TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   589 	Session().CleanupEntryPushL(id);

   590 	iSmsTest.SetEntryL(id);

   591 

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

   593 

   594 	TRAPD(err, RestoreSettingsL(*settings));

   595 

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

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

   598 	iSmsTest(err == KErrNotFound);

   599 

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

   601 //	iSmsTest.SetEntryL(id);

   602 	StoreSettingsL(*settings);

   603 

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

   605 

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

   607 

   608 	RestoreSettingsL(*settings);

   609 

   610 	Session().CleanupEntryPop();

   611 	Session().RemoveEntry(id);

   612 

   613 	CleanupStack::PopAndDestroy(settings);

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

   615 	}

   616 

   617 

   618 void CSmutTest::TestSettingsStoreToCommDbL()

   619 	{

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

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

   622 

   623 	CSmsSettings* settings1 = CSmsSettings::NewL();

   624 	CleanupStack::PushL(settings1);

   625 

   626 	CSmsSettings* settings2 = CSmsSettings::NewL();

   627 	CleanupStack::PushL(settings2);

   628 

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

   630 

   631 	settings1->SetCommDbAction(CSmsSettings::EStoreToCommDb);

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

   633 	settings1->SetDeliveryReport(ETrue);

   634 	settings1->SetValidityPeriod(1000);

   635 

   636 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

   637 

   638 	StoreSettingsL(*settings1);

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

   640 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   641 

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

   643 

   644 	StoreSettingsL(*settings1);

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

   646 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   647 	

   648 	settings1->SetDeliveryReport(EFalse);

   649 

   650 	StoreSettingsL(*settings1);

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

   652 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   653 

   654 	settings1->SetValidityPeriod(2000);

   655 

   656 	StoreSettingsL(*settings1);

   657 	iSmsTest.Printf(_L("\tValidity Period Changed...\n"));

   658 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   659 

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

   661 	settings1->SetDeliveryReport(ETrue);

   662 	settings1->SetValidityPeriod(3000);

   663 

   664 	StoreSettingsL(*settings1);

   665 	iSmsTest.Printf(_L("\tAll Settings Changed...\n"));

   666 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   667 

   668 	settings1->AddServiceCenterL(_L("Radio"), _L("+385669988"));

   669 	settings1->SetDefaultServiceCenter(settings1->ServiceCenterCount()-1);

   670 

   671 	StoreSettingsL(*settings1);

   672 	iSmsTest.Printf(_L("\tDefaultSC Changed...\n"));

   673 	iSmsTest(CompareSettingsAndCommDbL(*settings1));

   674 

   675 	settings1->SetCommDbAction(CSmsSettings::ENone);

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

   677 	settings1->SetDeliveryReport(EFalse);

   678 	settings1->SetValidityPeriod(4000);

   679 

   680 	iSmsTest.Printf(_L("\tTesting Setting Different from CommDb...\n"));

   681 	iSmsTest(!CompareSettingsAndCommDbL(*settings1));

   682 

   683 	TInt count = settings1->ServiceCenterCount();

   684 

   685 	while (count--)

   686 		{

   687 		settings1->RemoveServiceCenter(count);

   688 		}

   689 

   690 	iSmsTest.Printf(_L("\tTesting Setting Different from CommDb...\n"));

   691 	iSmsTest(!CompareSettingsAndCommDbL(*settings1));

   692 

   693 	iSmsTest.Printf(_L("\tRestore settings from store...\n"));

   694 	RestoreSettingsL(*settings2);

   695 	iSmsTest(CompareSettingsAndCommDbL(*settings2));

   696 

   697 //Test SMS Bearer

   698 

   699 	iSmsTest.Printf(_L("\tTest Store SMS Bearer...\n"));

   700 

   701 //Test 1

   702 

   703 	settings1->SetSmsBearerAction(CSmsSettings::EStoreToCommDb);

   704 	settings1->SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

   705 

   706 	StoreSettingsL(*settings1);

   707 	iSmsTest(CompareSettingsAndSmsBearerL(*settings1));

   708 	

   709 //Test 2

   710 

   711 	settings1->SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly);

   712 	iSmsTest(!CompareSettingsAndSmsBearerL(*settings1));

   713 

   714 //Test 3

   715 

   716 	StoreSettingsL(*settings1);

   717 	iSmsTest(CompareSettingsAndSmsBearerL(*settings1));

   718 

   719 	RestoreSettingsL(*settings2);

   720 	iSmsTest(CompareSettingsAndSmsBearerL(*settings2));

   721 

   722 //Test 4

   723 

   724 	settings1->SetSmsBearerAction(CSmsSettings::ENone);

   725 	StoreSettingsL(*settings1);

   726 	iSmsTest(CompareSettingsAndSmsBearerL(*settings1));

   727 

   728 //Test 5

   729 

   730 	settings1->SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred);

   731 	iSmsTest(!CompareSettingsAndSmsBearerL(*settings1));

   732 	StoreSettingsL(*settings1);

   733 	iSmsTest(!CompareSettingsAndSmsBearerL(*settings1));

   734 

   735 	CleanupStack::PopAndDestroy(2); //settings1, settings2

   736 	}

   737 

   738 TBool CSmutTest::CompareSettingsAndCommDbL(const CSmsSettings& aSettings) const

   739 	{

   740 	TCompare compare = ETrue;

   741 	TBuf<256> scAddress;

   742 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

   743 	TRAPD(err, globalSettingsRecord.LoadL(*iDBSession));

   744 	if(err != KErrNone)

   745 		{

   746 		User::Leave(KErrNotFound);	

   747 		}

   748 	CCDModemBearerRecord *modemBearerRecord = static_cast<CCDModemBearerRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));

   749 	CleanupStack::PushL(modemBearerRecord);

   750 	modemBearerRecord->SetRecordId(((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iModemForPhoneServicesAndSMS); 

   751 	modemBearerRecord->LoadL(*iDBSession);

   752 	scAddress = modemBearerRecord->iMessageCentreNumber;

   753 

   754 	if (aSettings.DefaultServiceCenter() < 0 || !aSettings.ServiceCenterCount())

   755 		{

   756 		compare(!scAddress.Length());

   757 		}

   758 	else

   759 		{

   760 		compare(scAddress == aSettings.GetServiceCenter(aSettings.DefaultServiceCenter()).Address());

   761 		}

   762 	

   763 	TUint32 valPeriod = 0;

   764 	valPeriod = modemBearerRecord->iMessageValidityPeriod;

   765 	compare(valPeriod == (TUint32) aSettings.ValidityPeriod().Int());

   766 	

   767 	TBool delReport = EFalse;

   768 	delReport = modemBearerRecord->iMessageDeliveryReport;

   769 	compare(delReport ? aSettings.DeliveryReport() : !aSettings.DeliveryReport());

   770 

   771 	CleanupStack::PopAndDestroy(modemBearerRecord);	

   772 

   773 	return compare;

   774 	}

   775 

   776 TBool CSmutTest::CompareSettingsAndSmsBearerL(const CSmsSettings& aSettings) const

   777 	{

   778 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

   779 	globalSettingsRecord.LoadL(*iDBSession);

   780 	TUint32 smsBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer;		

   781 	TCompare compare(smsBearer == (TUint32) aSettings.SmsBearer());

   782 	return compare;

   783 	}

   784 

   785 void CSmutTest::StoreNumberL(const CSmsNumber& aNumber, TUid aStreamId)

   786 	{

   787 	CMsvStore* store = iSmsTest.EditStoreL(); // lets edit the entry

   788 	CleanupStack::PushL(store);

   789 

   790 	RMsvWriteStream out;

   791 	out.AssignLC(*store, aStreamId);		// file stream id ok?

   792 	aNumber.ExternalizeL(out);				// lets extrenalise the instance

   793 	out.CommitL();

   794 	store->CommitL();

   795 

   796 	CleanupStack::PopAndDestroy(2, store);

   797 	}

   798 

   799 void CSmutTest::RestoreNumberL(CSmsNumber& rNumber, TUid aStreamId)

   800 	{

   801 	CMsvStore* store = iSmsTest.ReadStoreL(); // prepare the store for reading

   802 	CleanupStack::PushL(store);

   803 

   804 	RMsvReadStream in;

   805 	in.OpenLC(*store, aStreamId);		// lets open the store for 

   806 	rNumber.InternalizeL(in);				// internalising the address/name

   807 

   808 	CleanupStack::PopAndDestroy(2, store);

   809 	}

   810 

   811 void CSmutTest::StoreHeaderL(const CSmsHeader& aHeader)

   812 	{

   813 	CMsvStore* store = iSmsTest.EditStoreL();

   814 	CleanupStack::PushL(store);

   815 

   816 	aHeader.StoreL(*store);

   817 	store->CommitL();

   818 

   819 	CleanupStack::PopAndDestroy(store);

   820 	}

   821 

   822 void CSmutTest::RestoreHeaderL(CSmsHeader& aHeader)

   823 	{

   824 	CMsvStore* store = iSmsTest.ReadStoreL();

   825 	CleanupStack::PushL(store);

   826 

   827 	aHeader.RestoreL(*store);

   828 

   829 	CleanupStack::PopAndDestroy(store);

   830 	}

   831 

   832 void CSmutTest::StoreSettingsL(const CSmsSettings& aSettings)

   833 	{

   834 	CSmsAccount* account = CSmsAccount::NewLC();

   835 	account->SaveSettingsL(aSettings);

   836 	CleanupStack::PopAndDestroy(account);    

   837 	}

   838 

   839 void CSmutTest::RestoreSettingsL(CSmsSettings& aSettings)

   840 	{

   841 	CSmsAccount* account = CSmsAccount::NewLC();

   842 	account->LoadSettingsL(aSettings);

   843 	CleanupStack::PopAndDestroy(account);    

   844 	}

   845 

   846 TBool CSmutTest::CompareServiceCenters(const CSmsServiceCenter& aLeft, const CSmsServiceCenter& aRight)

   847 	{

   848 	TCompare compare(aLeft.Name() == aRight.Name());

   849 	compare(aLeft.Address() == aRight.Address());

   850 	return compare;	

   851 	}

   852 

   853 TBool CSmutTest::CompareNumbers(const CSmsNumber& aLeft, const CSmsNumber& aRight)

   854 	{

   855 	TCompare compare(aLeft.Name() == aRight.Name());

   856 	compare(aLeft.Address() == aRight.Address());

   857 	compare(aLeft.LogId() == aRight.LogId());

   858 	compare(aLeft.AckStatus(ESmsAckTypeDelivery) == aRight.AckStatus(ESmsAckTypeDelivery));	

   859 	return compare;

   860 	}

   861 

   862 void CSmutTest::TestNumberL()

   863 	{

   864 	iSmsTest.Test().Next(_L("Testing CSmsNumber"));

   865 	iSmsTest.Printf(_L("Preparing test CSmsNumber"));

   866 

   867 	TMsvId id=iSmsTest.CreateDummyMessageToSendL();

   868 	Session().CleanupEntryPushL(id);

   869 	iSmsTest.SetEntryL(id);

   870 

   871 	CSmsNumber* number0=CSmsNumber::NewL();  

   872 	CleanupStack::PushL(number0);

   873 

   874 	CSmsNumber* number=CSmsNumber::NewL();  // create the instance

   875 	CleanupStack::PushL(number);

   876 

   877 	// Testing the features of CSmsNumber

   878 	// The max length for a name is 256 characters

   879 	// The max length for a number is 20 characters

   880 

   881 // Lets take an ordinary number, test it, then store and restore it

   882 // and see if the values are still ok.

   883 

   884 	number->SetNameL(_L("Radiolinja1"));	

   885 	number->SetAddressL(_L("+358508771010")); 

   886 	number->SetLogId(123456789);	

   887 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EAckSuccessful);

   888 

   889 	iSmsTest(number->Name()==_L("Radiolinja1")); // name ok?

   890 	iSmsTest(number->Address()==_L("+358508771010")); // number ok?

   891 	iSmsTest(number->LogId() == 123456789);

   892 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

   893 

   894 	StoreNumberL(*number);

   895 	RestoreNumberL(*number0);

   896 	iSmsTest(CompareNumbers(*number0, *number));

   897 	

   898 // Lets try the max length of the telephone address, store and

   899 // restore it and see if it works

   900 

   901 	number->SetNameL(_L("Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?"));

   902 	number->SetAddressL(_L("+0123456789012345678"));

   903 	number->SetLogId(987654321);	

   904 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EAckError);

   905 

   906 	iSmsTest(number->Name()==_L("Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?"));

   907 	iSmsTest(number->Address()==_L("+0123456789012345678"));

   908 	iSmsTest(number->LogId() == 987654321);

   909 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError);

   910 

   911 	StoreNumberL(*number);

   912 	RestoreNumberL(*number0);

   913 	iSmsTest(CompareNumbers(*number, *number0));

   914 

   915 // Lets use special Scandinavian letters both in the name and

   916 // address, store and restore and see if they are ok

   917 	number->SetNameL(_L("ÖÄÅåöä"));

   918 	number->SetAddressL(_L("åäöÅÄÖ"));

   919 	number->SetLogId(123456789);	

   920 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EAckSuccessful);

   921 

   922 	iSmsTest(number->Name()==_L("ÖÄÅåöä"));

   923 	iSmsTest(number->Address()==_L("åäöÅÄÖ"));

   924 	iSmsTest(number->LogId() == 123456789);

   925 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

   926 

   927 	StoreNumberL(*number);

   928 	RestoreNumberL(*number0);

   929 	iSmsTest(CompareNumbers(*number, *number0));

   930 

   931 //  Lets try if both the number and the name can be empty,

   932 //	store and restore it and see if they still match

   933 	number->SetNameL(_L(""));

   934 	number->SetAddressL(_L(""));

   935 	number->SetLogId(987654321);	

   936 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EAckError);

   937 

   938 	iSmsTest(number->Name()==_L(""));

   939 	iSmsTest(number->Address()==_L(""));

   940 	iSmsTest(number->LogId() == 987654321);

   941 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError);

   942 

   943 	StoreNumberL(*number);

   944 	RestoreNumberL(*number0);

   945 	iSmsTest(CompareNumbers(*number, *number0));

   946 

   947 //  Lets try [alt+255] as both the name and number, store and	

   948 //  restore it and see if it works

   949 	number->SetNameL(_L(" ")); //alt+255

   950 	number->SetAddressL(_L(" "));

   951 	number->SetLogId(123456789);	

   952 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EAckSuccessful);

   953 

   954 	iSmsTest(number->Name()==_L(" "));

   955 	iSmsTest(number->Address()==_L(" "));

   956 	iSmsTest(number->LogId() == 123456789);

   957 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

   958 

   959 	StoreNumberL(*number);

   960 	RestoreNumberL(*number0);

   961 	iSmsTest(CompareNumbers(*number, *number0));

   962 

   963 // Test CSmsNumber::CopyL()

   964 

   965 	number->SetNameL(_L("DavidCuando"));	

   966 	number->SetAddressL(_L("+447747065627")); 

   967 	number->SetLogId(118888);	

   968 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EPendingAck);

   969 

   970 	iSmsTest(number->Name()==_L("DavidCuando")); 

   971 	iSmsTest(number->Address()==_L("+447747065627")); 

   972 	iSmsTest(number->LogId() == 118888);

   973 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   974 

   975 	number0->CopyL(*number);

   976 	iSmsTest(CompareNumbers(*number0, *number));

   977 

   978 	CleanupStack::PopAndDestroy(2, number0);

   979 

   980 // Test NewL(CSmsNumber&)

   981 

   982 	number=CSmsNumber::NewL();  // create the instance

   983 	CleanupStack::PushL(number);

   984 

   985 	number->SetNameL(_L("DavidCuando"));	

   986 	number->SetAddressL(_L("+447747065627")); 

   987 	number->SetLogId(118888);	

   988 	number->SetAckStatus(ESmsAckTypeDelivery, CSmsNumber::EPendingAck);

   989 

   990 	iSmsTest(number->Name()==_L("DavidCuando")); 

   991 	iSmsTest(number->Address()==_L("+447747065627")); 

   992 	iSmsTest(number->LogId() == 118888);

   993 	iSmsTest(number->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   994 

   995 	number0=CSmsNumber::NewL(*number);  

   996 	CleanupStack::PushL(number0);

   997 

   998 	iSmsTest(CompareNumbers(*number0, *number));

   999 	CleanupStack::PopAndDestroy(2, number);

  1000 

  1001 	//Test for defect EDNMOHN-4LDDK8

  1002 	number=CSmsNumber::NewL();  // create the instance

  1003 	CleanupStack::PushL(number);

  1004 

  1005 	StoreNumberL(*number);

  1006 	RestoreNumberL(*number);

  1007 

  1008 	number->SetAddressL(_L("+4477676545"));

  1009 	//End Test for defect  EDNMOHN-4LDDK8

  1010 

  1011 	CleanupStack::PopAndDestroy(number);

  1012 

  1013 	Session().CleanupEntryPop();

  1014 	Session().RemoveEntry(id);

  1015 	}

  1016 	

  1017 void CSmutTest::StoreEmailFieldsL(const CSmsEmailFields& aEmailFields)

  1018 	{

  1019 	CMsvStore* store = iSmsTest.EditStoreL(); 

  1020 	CleanupStack::PushL(store);

  1021 

  1022 	aEmailFields.StoreL(*store);

  1023 	store->CommitL();

  1024 

  1025 	CleanupStack::PopAndDestroy(store);

  1026 	}

  1027 

  1028 void CSmutTest::RestoreEmailFieldsL(CSmsEmailFields& aEmailFields)

  1029 	{

  1030 	CMsvStore* store = iSmsTest.ReadStoreL(); // prepare the store for reading

  1031 	CleanupStack::PushL(store);

  1032 	

  1033 	aEmailFields.RestoreL(*store);

  1034 

  1035 	CleanupStack::PopAndDestroy(store);

  1036 	}

  1037 	

  1038 TBool CSmutTest::CompareEmailFields(const CSmsEmailFields& aFields1, const CSmsEmailFields& aFields2)

  1039 	{

  1040 	TBool same = CompareEmailFieldsAddresses(aFields1.Addresses(), aFields2.Addresses());

  1041 	if( same )

  1042 		same = (aFields2.Subject().Compare(aFields1.Subject()) == 0);

  1043 	if( same )

  1044 		same = (!aFields2.HasAddress()&&!aFields1.HasAddress() || aFields2.HasAddress()&&aFields1.HasAddress());

  1045 	if( same )

  1046 		same = (aFields2.Length() == aFields1.Length());

  1047 	return same;

  1048 	}

  1049 	

  1050 TBool CSmutTest::CompareEmailFieldsAddresses(const MDesCArray& aAddresses1, const MDesCArray& aAddresses2)

  1051 	{

  1052 	TBool same = (aAddresses1.MdcaCount() == aAddresses2.MdcaCount());

  1053 	if( same )

  1054 		{

  1055 		TInt count = aAddresses1.MdcaCount();

  1056 		while( same && count-- > 0)

  1057 			{

  1058 			same = (aAddresses2.MdcaPoint(count).Compare(aAddresses1.MdcaPoint(count)) == 0);

  1059 			}

  1060 		}		

  1061 	return same;

  1062 	}

  1063 	

  1064 void CSmutTest::TestEmailFieldsL()

  1065 	{

  1066 	iSmsTest.Test().Next(_L("Testing CSmsEmailFields"));

  1067 	iSmsTest.Printf(_L("Preparing test CSmsEmailFields"));

  1068 

  1069 	TMsvId id=iSmsTest.CreateDummyMessageToSendL();

  1070 	Session().CleanupEntryPushL(id);

  1071 	iSmsTest.SetEntryL(id);

  1072 

  1073 	_LIT(KTestAddress, "support@symbian.com");

  1074 	_LIT(KTestSubject, "Happy Days!");

  1075 	

  1076 	// Test CSmsEmailFields::NewL()

  1077 	CSmsEmailFields* fields1 = CSmsEmailFields::NewL();

  1078 	CleanupStack::PushL(fields1);

  1079 	

  1080 	iSmsTest(fields1->Addresses().MdcaCount()==0);

  1081 	iSmsTest(fields1->Subject().Compare(KNullDesC()) == 0);

  1082 	iSmsTest(!fields1->HasAddress());

  1083 	iSmsTest(fields1->Length() == 0);

  1084 	

  1085 	// Test address and subject accessors, has-address, length and reset methods

  1086 	fields1->AddAddressL(KNullDesC);	// empty address - does nothing!

  1087 	iSmsTest(fields1->Addresses().MdcaCount()==0);

  1088 	iSmsTest(fields1->Subject().Compare(KNullDesC()) == 0);

  1089 	iSmsTest(!fields1->HasAddress());

  1090 	iSmsTest(fields1->Length() == 0);

  1091 	

  1092 	fields1->AddAddressL(KTestAddress);

  1093 	iSmsTest(fields1->Addresses().MdcaCount()==1);	

  1094 	iSmsTest(fields1->Addresses().MdcaPoint(0).Compare(KTestAddress) == 0);

  1095 	iSmsTest(fields1->HasAddress());

  1096 	iSmsTest(fields1->Length() == KTestAddress().Length() + 1);	

  1097 

  1098 	fields1->SetSubjectL(KTestSubject);

  1099 	iSmsTest(fields1->HasAddress());

  1100 	iSmsTest(fields1->Length() == KTestAddress().Length() + KTestSubject().Length() + 2);

  1101 	

  1102 	fields1->Reset();

  1103 	iSmsTest(fields1->Addresses().MdcaCount()==0);

  1104 	iSmsTest(fields1->Subject().Compare(KNullDesC()) == 0);

  1105 	iSmsTest(!fields1->HasAddress());

  1106 	iSmsTest(fields1->Length() == 0);

  1107 	

  1108 	fields1->SetSubjectL(KTestSubject);

  1109 	iSmsTest(fields1->Subject().Compare(KTestSubject) == 0);

  1110 	iSmsTest(!fields1->HasAddress());

  1111 	iSmsTest(fields1->Length() == KTestSubject().Length() + 2);

  1112 	

  1113 	fields1->AddAddressL(KTestAddress);

  1114 	iSmsTest(fields1->Addresses().MdcaCount()==1);	

  1115 	iSmsTest(fields1->Addresses().MdcaPoint(0).Compare(KTestAddress) == 0);

  1116 	iSmsTest(fields1->HasAddress());

  1117 	iSmsTest(fields1->Length() == KTestAddress().Length() + KTestSubject().Length() + 2);

  1118 

  1119 	// Test multiple addresses - add empty address -> not added	

  1120 	fields1->AddAddressL(KNullDesC);

  1121 	iSmsTest(fields1->Addresses().MdcaCount()==1);

  1122 	

  1123 	_LIT(KTestAddress2, "support2@symbian.com");

  1124 	fields1->AddAddressL(KTestAddress2);

  1125 	iSmsTest(fields1->Addresses().MdcaCount()==2);	

  1126 	iSmsTest(fields1->Addresses().MdcaPoint(1).Compare(KTestAddress2) == 0);

  1127 	iSmsTest(fields1->HasAddress());

  1128 	// NOTE - length check; 3 -> 2 for subject delimiters, 1 for address comma separtor.

  1129 	iSmsTest(fields1->Length() == KTestAddress().Length() + KTestAddress2().Length() + KTestSubject().Length() + 3);

  1130 	

  1131 	// Test copy factory c'tor

  1132 	CSmsEmailFields* fields2 = CSmsEmailFields::NewL(*fields1);

  1133 	CleanupStack::PushL(fields2);

  1134 

  1135 	iSmsTest(CompareEmailFields(*fields2, *fields1));