1 // Copyright (c) 2005-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 <smss.rsg>

    17 #include <csmsaccount.h>

    18 #include <csmsemailfields.h>

    19 

    20 #include "T_smutTE.h"

    21 #include <gsmuieoperations.h>

    22 

    23 const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};

    24 const TInt KLogID1 = 123456789;

    25 const TInt KLogID2 = 987654321;

    26 const TInt KLogID3 = 118888;

    27 

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

    29 : CSmsTestBase(aSmsTest, aScriptFile, aNextTest), iTestStep(aTestStep)

    30 	{

    31 	}

    32 

    33 void CSmutTest::RunAutoL()

    34 	{

    35 	}

    36 	

    37 CSmutTest::~CSmutTest()

    38 	{

    39 	delete iSmsHeader;

    40 	delete iRichText;

    41 	delete iParaLayer;

    42 	delete iCharLayer;

    43 	if(iDBSession)

    44 	  {

    45 	  iDBSession->Close();

    46 	  }

    47 	delete iDBSession;	

    48 	}

    49 

    50 void CSmutTest::ConstructL()

    51 	{

    52 	iSmsTest.SetLogToFile();

    53 

    54 	iSelection = new (ELeave) CMsvEntrySelection();

    55 	iTimer = CTestTimer::NewL();

    56 

    57 	iParaLayer =CParaFormatLayer::NewL();

    58 	iCharLayer = CCharFormatLayer::NewL();

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

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

    61 

    62 	CActiveScheduler::Add(this);

    63 	}

    64 

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

    66 	{

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

    68 	CleanupStack::PushL(self);

    69 

    70 	self->ConstructL();

    71 

    72 	return self;

    73 	}

    74 

    75 void CSmutTest::ShowMenuL()

    76 	{

    77 	}

    78 

    79 TVerdict CSmutTest::TestSettingsL()

    80 	{

    81 	iTestStep.INFO_PRINTF1(_L("Testing Create Settings..."));

    82 

    83 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

    84 

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

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

    87 

    88 	CSmsSettings* settings = CSmsSettings::NewLC();

    89 	if(!CompareSettings(*settings, *settings))

    90 		{

    91 		CleanupStack::PopAndDestroy(settings);

    92 		return EFail;	

    93 		}

    94 	if(!TestSettingsMembersL(*settings))

    95 		{

    96 		CleanupStack::PopAndDestroy(settings);

    97 		return EFail;	

    98 		}

    99 	TestMessageSettingsMembersL(*settings);

   100 

   101 	// Lets copy the values to a different instance

   102 	CSmsSettings* smsSettings=CSmsSettings::NewLC();

   103 	smsSettings->CopyL(*settings);

   104 	if(!CompareSettings(*smsSettings, *settings))

   105 		{

   106 		CleanupStack::PopAndDestroy(2,settings);

   107 		return EFail;	

   108 		}

   109 	CleanupStack::PopAndDestroy(smsSettings);

   110 	smsSettings = NULL;

   111 	iTestStep.INFO_PRINTF1(_L("Test CSmsSettings::CopyL() passed"));

   112 

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

   114 	TestStoreRestoreSettingsL(*settings);

   115 

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

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

   118 	CSmsSettings* set2=CSmsSettings::NewLC();

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

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

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

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

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

   124 	set2->SetDefaultServiceCenter(1);

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

   126 	// Validity Period	

   127 	set2->SetValidityPeriod(ESmsVPSixHours);

   128 	if(set2->ValidityPeriod().Int()!=ESmsVPSixHours)

   129 		{

   130 		CleanupStack::PopAndDestroy(2,settings);

   131 		return EFail;	

   132 		}

   133 	// Reply Quoted

   134 	set2->SetReplyQuoted(EFalse);

   135 	if(set2->ReplyQuoted())

   136 		{

   137 		CleanupStack::PopAndDestroy(2,settings);

   138 		return EFail;	

   139 		}

   140 	// Reject Duplicate 

   141 	set2->SetRejectDuplicate(ETrue);

   142 	if(!set2->RejectDuplicate())

   143 		{

   144 		CleanupStack::PopAndDestroy(2,settings);

   145 		return EFail;	

   146 		}

   147 	// Delivery Method

   148 	set2->SetDelivery(ESmsDeliveryUponRequest);

   149 	if(set2->Delivery()!=ESmsDeliveryUponRequest)

   150 		{

   151 		CleanupStack::PopAndDestroy(2,settings);

   152 		return EFail;	

   153 		}

   154 	// Delivery Report

   155 	set2->SetDeliveryReport(ETrue);

   156 	if(!set2->DeliveryReport())

   157 		{

   158 		CleanupStack::PopAndDestroy(2,settings);

   159 		return EFail;	

   160 		}

   161 	// Reply Path

   162 	set2->SetReplyPath(EFalse);

   163 	if(set2->ReplyPath())

   164 		{

   165 		CleanupStack::PopAndDestroy(2,settings);

   166 		return EFail;	

   167 		}

   168 	// Message Conversion

   169 	set2->SetMessageConversion(ESmsConvPIDNone);

   170 	if(set2->MessageConversion()!=ESmsConvPIDNone)

   171 		{

   172 		CleanupStack::PopAndDestroy(2,settings);

   173 		return EFail;	

   174 		}

   175 	// Can Concatenate

   176 	set2->SetCanConcatenate(ETrue);

   177 	if(!set2->CanConcatenate())

   178 		{

   179 		CleanupStack::PopAndDestroy(2,settings);

   180 		return EFail;	

   181 		}

   182 	// Character Set

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

   184 	if(set2->CharacterSet()!=TSmsDataCodingScheme::ESmsAlphabet8Bit)

   185 		{

   186 		CleanupStack::PopAndDestroy(2,settings);

   187 		return EFail;	

   188 		}

   189 	// Validity period format

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

   191 	if(set2->ValidityPeriodFormat()!=TSmsFirstOctet::ESmsVPFSemiOctet)

   192 		{

   193 		CleanupStack::PopAndDestroy(2,settings);

   194 		return EFail;	

   195 		}

   196 	// Status Report Handling

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

   198 	if(set2->StatusReportHandling()!=CSmsSettings::EMoveReportToInboxVisible)

   199 		{

   200 		CleanupStack::PopAndDestroy(2,settings);

   201 		return EFail;	

   202 		}

   203 	// Special Message Handling

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

   205 	if(set2->SpecialMessageHandling()!=CSmsSettings::EMoveReportToInboxVisible)

   206 		{

   207 		CleanupStack::PopAndDestroy(2,settings);

   208 		return EFail;	

   209 		}

   210 

   211 	if(!TestStoreRestoreSettingsL(*set2))

   212 		{

   213 		CleanupStack::PopAndDestroy(2,settings);

   214 		return EFail;	

   215 		}

   216 

   217 	set2->SetClass2Folder(123);

   218 	if(!TestStoreRestoreSettingsL(*set2))

   219 		{

   220 		CleanupStack::PopAndDestroy(2,settings);

   221 		return EFail;	

   222 		}

   223 

   224 	CleanupStack::PopAndDestroy(set2);

   225 

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

   227 

   228 	if(!CompareSettings(*iSmsTest.iServiceSettings, *settings))

   229 		{

   230 		CleanupStack::PopAndDestroy(settings);

   231 		return EFail;	

   232 		}

   233 

   234 	iTestStep.INFO_PRINTF1(_L("CSmsSettings::CopyL() 2"));

   235 	CleanupStack::PopAndDestroy(settings);

   236 	iTestStep.INFO_PRINTF1(_L("Test Create Settings Passed"));

   237 	TestSettingsStoreToCommDbL();

   238 	iTestStep.INFO_PRINTF1(_L("Test Create Settings Passed"));

   239 	return EPass;

   240 	}

   241 

   242 

   243 TBool CSmutTest::CompareSettingsFiles(

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

   245 	)

   246 	{

   247 	TBool identical = ETrue;

   248 

   249 	RFileReadStream stream1;

   250 	RFileReadStream stream2;

   251 

   252 	// Open each stream for binary read.

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

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

   255 

   256 	TInt ret1 = KErrNone;

   257 	TInt ret2 = KErrNone;

   258 	TBool finished = EFalse;

   259 	TUint8 byte1 = 0;

   260 	TUint8 byte2 = 0;

   261 

   262 	while (!finished)

   263 		{

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

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

   266 

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

   268 			{

   269 			// Either file data or lengths differ.

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

   271 				identical = EFalse;

   272 			finished = ETrue;

   273 			}

   274 		}

   275 

   276 	stream1.Close();

   277 	stream2.Close();

   278 

   279 	return identical;

   280 	}

   281 

   282 TBool CSmutTest::TestStoreRestoreSettingsL(const CSmsSettings& aSettings)

   283 	{

   284 	StoreSettingsL(aSettings);

   285 

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

   287 	CSmsSettings* set1=CSmsSettings::NewLC();

   288 

   289 	RestoreSettingsL(*set1);

   290 

   291 	if(!CompareSettings(*set1, aSettings))

   292 		{

   293 		CleanupStack::PopAndDestroy(set1);

   294 		return EFalse;	

   295 		}

   296 

   297 	CleanupStack::PopAndDestroy(set1);

   298 	

   299 	return ETrue;

   300 	}

   301 

   302 TBool CSmutTest::TestSettingsMembersL(CSmsSettings& aSettings)

   303 	{

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

   305 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisible);

   306 	if(aSettings.StatusReportHandling()!=CSmsSettings::EMoveReportToInboxInvisible)

   307 		{

   308 		return EFalse;

   309 		}

   310 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

   311 	if(aSettings.StatusReportHandling()!=CSmsSettings::EMoveReportToInboxVisible)

   312 		{

   313 		return EFalse;	

   314 		}

   315 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReport);

   316 	if(aSettings.StatusReportHandling()!=CSmsSettings::EDiscardReport)

   317 		{

   318 		return EFalse;

   319 		}

   320 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   321 	if(aSettings.StatusReportHandling()!=CSmsSettings::EMoveReportToInboxInvisibleAndMatch)

   322 		{

   323 		return EFalse;	

   324 		}

   325 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   326 	if(aSettings.StatusReportHandling()!=CSmsSettings::EMoveReportToInboxVisibleAndMatch)

   327 		{

   328 		return EFalse;	

   329 		}

   330 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReportAndMatch);

   331 	if(aSettings.StatusReportHandling()!=CSmsSettings::EDiscardReportAndMatch)

   332 		{

   333 		return EFalse;	

   334 		}

   335 	iTestStep.INFO_PRINTF1(_L("Test Status Report Handling Passed"));

   336 

   337 	// SC handling

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

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

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

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

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

   343 	if(aSettings.GetServiceCenter(0).Name()!=_L("Radiolinja0"))

   344 		{

   345 		return EFalse;	

   346 		}

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

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

   349 	if(aSettings.GetServiceCenter(1).Name()!=_L("Radiolinja1"))

   350 		{

   351 		return EFalse;	

   352 		}

   353 	if(aSettings.GetServiceCenter(2).Name()!=_L("Radiolinja4"))

   354 		{

   355 		return EFalse;	

   356 		}

   357 	if(aSettings.GetServiceCenter(2).Address()!=_L("+358508771010"))

   358 		{

   359 		return EFalse;	

   360 		}

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

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

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

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

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

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

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

   368 	aSettings.SetDefaultServiceCenter(1);

   369 	if(aSettings.DefaultServiceCenter()!=1)

   370 		{

   371 		return EFalse;	

   372 		}

   373 	aSettings.SetDefaultServiceCenter(2);

   374 	if(aSettings.DefaultServiceCenter()!=2)

   375 		{

   376 		return EFalse;	

   377 		}

   378 	iTestStep.INFO_PRINTF1(_L("Test Default SC Passed"));

   379 

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

   381 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisible);

   382 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EMoveReportToInboxInvisible)

   383 		{

   384 		return EFalse;	

   385 		}

   386 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

   387 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EMoveReportToInboxVisible)

   388 		{

   389 		return EFalse;	

   390 		}

   391 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReport);

   392 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EDiscardReport)

   393 		{

   394 		return EFalse;	

   395 		}

   396 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

   397 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EMoveReportToInboxInvisibleAndMatch)

   398 		{

   399 		return EFalse;	

   400 		}

   401 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   402 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EMoveReportToInboxVisibleAndMatch)

   403 		{

   404 		return EFalse;	

   405 		}

   406 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReportAndMatch);

   407 	if(aSettings.SpecialMessageHandling()!=CSmsSettings::EDiscardReportAndMatch)

   408 		{

   409 		return EFalse;	

   410 		}

   411 	iTestStep.INFO_PRINTF1(_L("Test Special Message Handling Passed"));

   412 

   413 	//CommDbAction

   414 	aSettings.SetCommDbAction(CSmsSettings::ENone);

   415 	if(aSettings.CommDbAction() != CSmsSettings::ENone)

   416 		{

   417 		return EFalse;	

   418 		}

   419 	aSettings.SetCommDbAction(CSmsSettings::EStoreToCommDb);

   420 	if(aSettings.CommDbAction() != CSmsSettings::EStoreToCommDb)

   421 		{

   422 		return EFalse;	

   423 		}

   424 	iTestStep.INFO_PRINTF1(_L("Test CommDb Action Passed"));

   425 

   426 	//SmsBearerAction

   427 	aSettings.SetSmsBearerAction(CSmsSettings::ENone);

   428 	if(aSettings.SmsBearerAction() != CSmsSettings::ENone)

   429 		{

   430 		return EFalse;	

   431 		}

   432 	aSettings.SetSmsBearerAction(CSmsSettings::EStoreToCommDb);

   433 	if(aSettings.SmsBearerAction() != CSmsSettings::EStoreToCommDb)

   434 		{

   435 		return EFalse;	

   436 		}

   437 	iTestStep.INFO_PRINTF1(_L("Test SMS Bearer Action Passed"));

   438 

   439 	//SmsBearer

   440 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

   441 	if(aSettings.SmsBearer() != CSmsSettings::ESmsBearerPacketOnly)

   442 		{

   443 		return EFalse;	

   444 		}

   445 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

   446 	if(aSettings.SmsBearer() != CSmsSettings::ESmsBearerPacketOnly)

   447 		{

   448 		return EFalse;	

   449 		}

   450 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly);

   451 	if(aSettings.SmsBearer() != CSmsSettings::ESmsBearerCircuitOnly)

   452 		{

   453 		return EFalse;	

   454 		}

   455 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketPreferred);

   456 	if(aSettings.SmsBearer() != CSmsSettings::ESmsBearerPacketPreferred)

   457 		{

   458 		return EFalse;	

   459 		}

   460 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred);

   461 	if(aSettings.SmsBearer() != CSmsSettings::ESmsBearerCircuitPreferred)

   462 		{

   463 		return EFalse;	

   464 		}

   465 	iTestStep.INFO_PRINTF1(_L("Test SMS Bearer Passed"));

   466 

   467 	// Reply Quoted

   468 	aSettings.SetReplyQuoted(EFalse);

   469 	if(aSettings.ReplyQuoted())

   470 		{

   471 		return EFalse;	

   472 		}

   473 	aSettings.SetReplyQuoted(ETrue);

   474 	if(!aSettings.ReplyQuoted())

   475 		{

   476 		return EFalse;	

   477 		}

   478 	iTestStep.INFO_PRINTF1(_L("Test Reply Quoted Passed"));

   479 

   480 	// Delivery Method

   481 	aSettings.SetDelivery(ESmsDeliveryUponRequest);

   482 	if(aSettings.Delivery()!=ESmsDeliveryUponRequest)

   483 		{

   484 		return EFalse;	

   485 		}

   486 	aSettings.SetDelivery(ESmsDeliveryScheduled);

   487 	if(aSettings.Delivery()!=ESmsDeliveryScheduled)

   488 		{

   489 		return EFalse;

   490 		}

   491 	aSettings.SetDelivery(ESmsDeliveryImmediately);

   492 	if(aSettings.Delivery()!=ESmsDeliveryImmediately)

   493 		{

   494 		return EFalse;	

   495 		}

   496 	iTestStep.INFO_PRINTF1(_L("Test Delivery Passed"));

   497 

   498 	// Class2Folder

   499 	if(aSettings.Class2Folder() != KMsvGlobalInBoxIndexEntryId)

   500 		{

   501 		return EFalse;	

   502 		}

   503 	aSettings.SetClass2Folder(1);

   504 	if(aSettings.Class2Folder() != 1)

   505 		{

   506 		return EFalse;

   507 		}

   508 	iTestStep.INFO_PRINTF1(_L("Test Class2Folder Passed"));	

   509 

   510 	// Description length

   511 	if(aSettings.DescriptionLength() != KSmsDescriptionLength)

   512 		{

   513 		return EFalse;

   514 		}

   515 	aSettings.SetDescriptionLength(100);

   516 	if(aSettings.DescriptionLength() != 100)

   517 		{

   518 		return EFalse;

   519 		}

   520 	iTestStep.INFO_PRINTF1(_L("Test DescriptionLength Passed"));	

   521 	

   522 	return ETrue;

   523 	}

   524 

   525 TBool CSmutTest::TestMessageSettingsMembersL(CSmsMessageSettings& aSettings)

   526 	{

   527 

   528 	// Reject Duplicate 

   529 	aSettings.SetRejectDuplicate(ETrue);

   530 	if(!aSettings.RejectDuplicate())

   531 		{

   532 		return EFalse;	

   533 		}

   534 	aSettings.SetRejectDuplicate(EFalse);

   535 	if(aSettings.RejectDuplicate())

   536 		{

   537 		return EFalse;	

   538 		}

   539 	

   540 	iTestStep.INFO_PRINTF1(_L("Test Reject Duplicate Passed"));

   541 

   542 	// Delivery Report

   543 	aSettings.SetDeliveryReport(ETrue);

   544 	if(!aSettings.DeliveryReport())

   545 		{

   546 		return EFalse;	

   547 		}

   548 	aSettings.SetDeliveryReport(EFalse);

   549 	if(aSettings.DeliveryReport())

   550 		{

   551 		return EFalse;	

   552 		}

   553 	iTestStep.INFO_PRINTF1(_L("Test Delivery Report Passed"));

   554 

   555 	// Reply Path

   556 	aSettings.SetReplyPath(EFalse);

   557 	if(aSettings.ReplyPath()!=EFalse)

   558 		{

   559 		return EFalse;	

   560 		}

   561 	aSettings.SetReplyPath(ETrue);

   562 	if(!aSettings.ReplyPath())

   563 		{

   564 		return EFalse;	

   565 		}

   566 	iTestStep.INFO_PRINTF1(_L("Test Reply Path Passed"));

   567 

   568 	// Validity period format

   569 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone);

   570 	if(aSettings.ValidityPeriodFormat()!=TSmsFirstOctet::ESmsVPFNone)

   571 		{

   572 		return EFalse;	

   573 		}

   574 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFEnhanced);

   575 	if(aSettings.ValidityPeriodFormat()!=TSmsFirstOctet::ESmsVPFEnhanced)

   576 		{

   577 		return EFalse;	

   578 		}

   579 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger);

   580 	if(aSettings.ValidityPeriodFormat()!=TSmsFirstOctet::ESmsVPFInteger)

   581 		{

   582 		return EFalse;	

   583 		}

   584 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

   585 	if(aSettings.ValidityPeriodFormat()!=TSmsFirstOctet::ESmsVPFSemiOctet)

   586 		{

   587 		return EFalse;	

   588 		}

   589 	iTestStep.INFO_PRINTF1(_L("Test Validity Period Format Passed"));

   590 

   591 	// Message Conversion (following conversions are supported)

   592 	aSettings.SetMessageConversion(ESmsConvFax);

   593 	if(aSettings.MessageConversion()!=ESmsConvFax)

   594 		{

   595 		return EFalse;	

   596 		}

   597 	aSettings.SetMessageConversion(ESmsConvX400);

   598 	if(aSettings.MessageConversion()!=ESmsConvX400)

   599 		{

   600 		return EFalse;	

   601 		}

   602 	aSettings.SetMessageConversion(ESmsConvPaging);

   603 	if(aSettings.MessageConversion()!=ESmsConvPaging)

   604 		{

   605 		return EFalse;	

   606 		}

   607 	aSettings.SetMessageConversion(ESmsConvMail);

   608 	if(aSettings.MessageConversion()!=ESmsConvMail)

   609 		{

   610 		return EFalse;	

   611 		}

   612 	aSettings.SetMessageConversion(ESmsConvErmes);

   613 	if(aSettings.MessageConversion()!=ESmsConvErmes)

   614 		{

   615 		return EFalse;	

   616 		}

   617 	aSettings.SetMessageConversion(ESmsConvSpeech);

   618 	if(aSettings.MessageConversion()!=ESmsConvSpeech)

   619 		{

   620 		return EFalse;	

   621 		}

   622 	aSettings.SetMessageConversion(ESmsConvPIDNone);

   623 	if(aSettings.MessageConversion()!=ESmsConvPIDNone)

   624 		{

   625 		return EFalse;	

   626 		}

   627 	iTestStep.INFO_PRINTF1(_L("Test Message Conversion Passed"));

   628 

   629 	// Validity Period	

   630 	aSettings.SetValidityPeriod(ESmsVPHour);

   631 	if(aSettings.ValidityPeriod().Int()!=ESmsVPHour)

   632 		{

   633 		return EFalse;	

   634 		}

   635 	aSettings.SetValidityPeriod(ESmsVPSixHours);

   636 	if(aSettings.ValidityPeriod().Int()!=ESmsVPSixHours)

   637 		{

   638 		return EFalse;	

   639 		}

   640 	aSettings.SetValidityPeriod(ESmsVP24Hours);

   641 	if(aSettings.ValidityPeriod().Int()!=ESmsVP24Hours)

   642 		{

   643 		return EFalse;	

   644 		}

   645 	aSettings.SetValidityPeriod(ESmsVPMaximum);

   646 	if(aSettings.ValidityPeriod().Int()!=ESmsVPMaximum)

   647 		{

   648 		return EFalse;	

   649 		}

   650 	aSettings.SetValidityPeriod(ESmsVPWeek);

   651 	if(aSettings.ValidityPeriod().Int()!=ESmsVPWeek)

   652 		{

   653 		return EFalse;	

   654 		}

   655 	iTestStep.INFO_PRINTF1(_L("Test Validity Period Passed"));

   656 

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

   658 	aSettings.SetCanConcatenate(ETrue);

   659 	if(!aSettings.CanConcatenate())

   660 		{

   661 		return EFalse;	

   662 		}

   663 	aSettings.SetCanConcatenate(EFalse);

   664 	if(aSettings.CanConcatenate()!=EFalse)

   665 		{

   666 		return EFalse;	

   667 		}

   668 	iTestStep.INFO_PRINTF1(_L("Test Can Concatenate Passed"));

   669 

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

   671 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit);

   672 	if(aSettings.CharacterSet()!=TSmsDataCodingScheme::ESmsAlphabet7Bit)

   673 		{

   674 		return EFalse;	

   675 		}

   676 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2);

   677 	if(aSettings.CharacterSet()!=TSmsDataCodingScheme::ESmsAlphabetUCS2)

   678 		{

   679 		return EFalse;	

   680 		}

   681 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

   682 	if(aSettings.CharacterSet()!=TSmsDataCodingScheme::ESmsAlphabet8Bit)

   683 		{

   684 		return EFalse;	

   685 		}

   686 	iTestStep.INFO_PRINTF1(_L("Test Character Set Passed"));

   687 	

   688 	return ETrue;

   689 	}

   690 

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

   692 	{

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

   694 

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

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

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

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

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

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

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

   702 

   703 	if (aTestSC)

   704 		{

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

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

   707 

   708 		TInt count = aLeft.ServiceCenterCount();

   709 

   710 		while (count--)

   711 			{

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

   713 			}

   714 		}		

   715 

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

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

   718 

   719 	return compare;

   720 	}

   721 

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

   723 	{

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

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

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

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

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

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

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

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

   732 	return compare;

   733 	}

   734 

   735 void CSmutTest::TestSettingsRestoreDefectL()

   736 	{

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

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

   739 

   740 	CSmsSettings* settings = CSmsSettings::NewLC();

   741 

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

   743 	const TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   744 	Session().CleanupEntryPushL(id);

   745 	iSmsTest.SetEntryL(id);

   746 

   747 	iTestStep.INFO_PRINTF1(_L("TestSettingsRestoreDefectL Created dummy message"));

   748 

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

   750 

   751 	iTestStep.INFO_PRINTF2(_L("TestSettingsRestoreDefectL RestoreL 1 with error %d"), err);

   752 	iTestStep.INFO_PRINTF2(_L("Expected %d"), KErrNotFound);

   753 	iSmsTest(err == KErrNotFound);

   754 

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

   756 	//	iSmsTest.SetEntryL(id);

   757 	StoreSettingsL(*settings);

   758 

   759 	iTestStep.INFO_PRINTF1(_L("TestSettingsRestoreDefectL StoreL 1"));

   760 

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

   762 

   763 	RestoreSettingsL(*settings);

   764 

   765 	Session().CleanupEntryPop();

   766 	Session().RemoveEntry(id);

   767 

   768 	CleanupStack::PopAndDestroy(settings);

   769 	iTestStep.INFO_PRINTF1(_L("TestSettingsRestoreDefectL RestoreL 2"));

   770 	}

   771 

   772 

   773 TBool CSmutTest::TestSettingsStoreToCommDbL()

   774 	{

   775 	iTestStep.INFO_PRINTF1(_L("Test Store Settings to CommDb"));

   776 	

   777 	CSmsSettings* settings1 = CSmsSettings::NewLC();

   778 	CSmsSettings* settings2 = CSmsSettings::NewLC();

   779 

   780 	if(!CompareSettings(*settings1, *settings2))

   781 		{

   782 		CleanupStack::PopAndDestroy(2,settings1);

   783 		return EFalse;	

   784 		}

   785 

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

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

   788 	settings1->SetDeliveryReport(ETrue);

   789 	settings1->SetValidityPeriod(1000);

   790 

   791 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

   792 

   793 	StoreSettingsL(*settings1);

   794 	iTestStep.INFO_PRINTF1(_L("\tNew Settings..."));

   795 	if(!CompareSettingsAndCommDbL(*settings1))

   796 		{

   797 		CleanupStack::PopAndDestroy(2,settings1);

   798 		return EFalse;	

   799 		}

   800 

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

   802 

   803 	StoreSettingsL(*settings1);

   804 	iTestStep.INFO_PRINTF1(_L("\tSC Address Changed..."));

   805 	if(!CompareSettingsAndCommDbL(*settings1))

   806 		{

   807 		CleanupStack::PopAndDestroy(2,settings1);

   808 		return EFalse;	

   809 		}

   810 	

   811 	settings1->SetDeliveryReport(EFalse);

   812 

   813 	StoreSettingsL(*settings1);

   814 	iTestStep.INFO_PRINTF1(_L("\tDelivery Report Changed..."));

   815 	if(!CompareSettingsAndCommDbL(*settings1))

   816 		{

   817 		CleanupStack::PopAndDestroy(2,settings1);

   818 		return EFalse;	

   819 		}

   820 

   821 	settings1->SetValidityPeriod(2000);

   822 

   823 	StoreSettingsL(*settings1);

   824 	iTestStep.INFO_PRINTF1(_L("\tValidity Period Changed..."));

   825 	if(!CompareSettingsAndCommDbL(*settings1))

   826 		{

   827 		CleanupStack::PopAndDestroy(2,settings1);

   828 		return EFalse;	

   829 		}

   830 

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

   832 	settings1->SetDeliveryReport(ETrue);

   833 	settings1->SetValidityPeriod(3000);

   834 

   835 	StoreSettingsL(*settings1);

   836 	iTestStep.INFO_PRINTF1(_L("\tAll Settings Changed..."));

   837 	if(!CompareSettingsAndCommDbL(*settings1))

   838 		{

   839 		CleanupStack::PopAndDestroy(2,settings1);

   840 		return EFalse;	

   841 		}

   842 

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

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

   845 

   846 	StoreSettingsL(*settings1);

   847 	iTestStep.INFO_PRINTF1(_L("\tDefaultSC Changed..."));

   848 	if(!CompareSettingsAndCommDbL(*settings1))

   849 		{

   850 		CleanupStack::PopAndDestroy(2,settings1);

   851 		return EFalse;	

   852 		}

   853 

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

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

   856 	settings1->SetDeliveryReport(EFalse);

   857 	settings1->SetValidityPeriod(4000);

   858 

   859 	iTestStep.INFO_PRINTF1(_L("\tTesting Setting Different from CommDb..."));

   860 	if(CompareSettingsAndCommDbL(*settings1))

   861 		{

   862 		CleanupStack::PopAndDestroy(2,settings1);

   863 		return EFalse;	

   864 		}

   865 

   866 	TInt count = settings1->ServiceCenterCount();

   867 

   868 	while (count--)

   869 		{

   870 		settings1->RemoveServiceCenter(count);

   871 		}

   872 

   873 	iTestStep.INFO_PRINTF1(_L("\tTesting Setting Different from CommDb..."));

   874 	if(CompareSettingsAndCommDbL(*settings1))

   875 		{

   876 		CleanupStack::PopAndDestroy(2,settings1);

   877 		return EFalse;	

   878 		}

   879 

   880 	iTestStep.INFO_PRINTF1(_L("\tRestore settings from store..."));

   881 	RestoreSettingsL(*settings2);

   882 	if(!CompareSettingsAndCommDbL(*settings2))

   883 		{

   884 		CleanupStack::PopAndDestroy(2,settings1);

   885 		return EFalse;	

   886 		}

   887 

   888 	//Test SMS Bearer

   889 

   890 	iTestStep.INFO_PRINTF1(_L("\tTest Store SMS Bearer..."));

   891 

   892 	//Test 1

   893 

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

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

   896 

   897 	StoreSettingsL(*settings1);

   898 	if(!CompareSettingsAndSmsBearerL(*settings1))

   899 		{

   900 		CleanupStack::PopAndDestroy(2,settings1);

   901 		return EFalse;	

   902 		}

   903 	

   904 	//Test 2

   905 

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

   907 	if(CompareSettingsAndSmsBearerL(*settings1))

   908 		{

   909 		CleanupStack::PopAndDestroy(2,settings1);

   910 		return EFalse;	

   911 		}

   912 

   913 	//Test 3

   914 

   915 	StoreSettingsL(*settings1);

   916 	if(!CompareSettingsAndSmsBearerL(*settings1))

   917 		{

   918 		CleanupStack::PopAndDestroy(2,settings1);

   919 		return EFalse;	

   920 		}

   921 

   922 	RestoreSettingsL(*settings2);

   923 	if(!CompareSettingsAndSmsBearerL(*settings2))

   924 		{

   925 		return EFalse;	

   926 		}

   927 

   928 	//Test 4

   929 

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

   931 	StoreSettingsL(*settings1);

   932 	if(!CompareSettingsAndSmsBearerL(*settings1))

   933 		{

   934 		CleanupStack::PopAndDestroy(2,settings1);

   935 		return EFalse;	

   936 		}

   937 

   938 	//Test 5

   939 

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

   941 	if(CompareSettingsAndSmsBearerL(*settings1))

   942 		{

   943 		CleanupStack::PopAndDestroy(2,settings1);

   944 		return EFalse;	

   945 		}

   946 	StoreSettingsL(*settings1);

   947 	if(CompareSettingsAndSmsBearerL(*settings1))

   948 		{

   949 		CleanupStack::PopAndDestroy(2,settings1);

   950 		return EFalse;	

   951 		}

   952 

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

   954 	

   955 	return ETrue;

   956 	}

   957 

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

   959 	{

   960 	TCompare compare = ETrue;

   961 	TBuf<256> scAddress;

   962 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

   963 	globalSettingsRecord.LoadL(*iDBSession);

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

   965 	CleanupStack::PushL(modemBearerRecord);

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

   967 	modemBearerRecord->LoadL(*iDBSession);

   968 	scAddress = modemBearerRecord->iMessageCentreNumber;

   969 

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

   971 		{

   972 		compare(!scAddress.Length());

   973 		}

   974 	else

   975 		{

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

   977 		}

   978 	

   979 	TUint32 valPeriod = 0;

   980 	valPeriod = modemBearerRecord->iMessageValidityPeriod;

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

   982 	

   983 	TBool delReport = EFalse;

   984 	delReport = modemBearerRecord->iMessageDeliveryReport;

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

   986 

   987 	CleanupStack::PopAndDestroy(modemBearerRecord);	

   988 

   989 	return compare;

   990 	}

   991 

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

   993 	{

   994 	TUint32 smsBearer=0;

   995 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

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

   997 	if(err == KErrNone)

   998 		{

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

  1000 		}	

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

  1002 	return compare;

  1003 	}

  1004 

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

  1006 	{

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

  1008 	CleanupStack::PushL(store);

  1009 

  1010 	RMsvWriteStream out;

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

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

  1013 	out.CommitL();

  1014 	store->CommitL();

  1015 

  1016 	CleanupStack::PopAndDestroy(2, store);

  1017 	}

  1018 

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

  1020 	{

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

  1022 	CleanupStack::PushL(store);

  1023 

  1024 	RMsvReadStream in;

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

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

  1027 

  1028 	CleanupStack::PopAndDestroy(2, store);

  1029 	}

  1030 

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

  1032 	{

  1033 	CMsvStore* store = iSmsTest.EditStoreL();

  1034 	CleanupStack::PushL(store);

  1035 

  1036 	aHeader.StoreL(*store);

  1037 	store->CommitL();

  1038 

  1039 	CleanupStack::PopAndDestroy(store);

  1040 	}

  1041 

  1042 void CSmutTest::RestoreHeaderL(CSmsHeader& aHeader)

  1043 	{

  1044 	CMsvStore* store = iSmsTest.ReadStoreL();

  1045 	CleanupStack::PushL(store);

  1046 

  1047 	aHeader.RestoreL(*store);

  1048 

  1049 	CleanupStack::PopAndDestroy(store);

  1050 	}

  1051 

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

  1053 	{

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

  1055 	account->SaveSettingsL(aSettings);

  1056 	CleanupStack::PopAndDestroy(account);    

  1057 	}

  1058 

  1059 void CSmutTest::RestoreSettingsL(CSmsSettings& aSettings)

  1060 	{

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

  1062 	account->LoadSettingsL(aSettings);

  1063 	CleanupStack::PopAndDestroy(account);    

  1064 	}

  1065 

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

  1067 	{

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

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

  1070 	return compare;	

  1071 	}

  1072 

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

  1074 	{

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

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

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

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

  1079 	return compare;

  1080 	}

  1081 

  1082 TVerdict CSmutTest::TestNumberL()

  1083 	{

  1084 	iTestStep.INFO_PRINTF1(_L("Testing Preparing test CSmsNumber..."));

  1085 

  1086 	TMsvId id=iSmsTest.CreateDummyMessageToSendL();

  1087 	Session().CleanupEntryPushL(id);

  1088 	iSmsTest.SetEntryL(id);

  1089 

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

  1091 	CleanupStack::PushL(number0);

  1092 

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

  1094 	CleanupStack::PushL(number);

  1095 

  1096 	// Testing the features of CSmsNumber

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

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

  1099 

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

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

  1102 

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

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

  1105 	number->SetLogId(KLogID1);	

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

  1107 

  1108 	if(number->Name()!=_L("Radiolinja1")) // name ok?

  1109 		{

  1110 		CleanupStack::PopAndDestroy(2, number0);

  1111 		Session().CleanupEntryPop();

  1112 		Session().RemoveEntry(id);

  1113 		return EFail;	

  1114 		}

  1115 	if(number->Address()!=_L("+358508771010")) // number ok?

  1116 		{

  1117 		CleanupStack::PopAndDestroy(2, number0);

  1118 		Session().CleanupEntryPop();

  1119 		Session().RemoveEntry(id);

  1120 		return EFail;	

  1121 		}

  1122 	if(number->LogId() != KLogID1)

  1123 		{

  1124 		CleanupStack::PopAndDestroy(2, number0);

  1125 		Session().CleanupEntryPop();

  1126 		Session().RemoveEntry(id);

  1127 		return EFail;	

  1128 		}

  1129 	if(number->AckStatus(ESmsAckTypeDelivery) != CSmsNumber::EAckSuccessful)

  1130 		{

  1131 		CleanupStack::PopAndDestroy(2, number0);

  1132 		Session().CleanupEntryPop();

  1133 		Session().RemoveEntry(id);