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 	iDBSession->Close();

    44 	delete iDBSession;	

    45 	}

    46 

    47 void CSmutTest::ConstructL()

    48 	{

    49 	iSmsTest.SetLogToFile();

    50 

    51 	iSelection = new (ELeave) CMsvEntrySelection();

    52 	iTimer = CTestTimer::NewL();

    53 

    54 	iParaLayer =CParaFormatLayer::NewL();

    55 	iCharLayer = CCharFormatLayer::NewL();

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

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

    58 

    59 	CActiveScheduler::Add(this);

    60 	}

    61 

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

    63 	{

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

    65 	CleanupStack::PushL(self);

    66 

    67 	self->ConstructL();

    68 

    69 	return self;

    70 	}

    71 

    72 void CSmutTest::ShowMenuL()

    73 	{

    74 	}

    75 

    76 TVerdict CSmutTest::TestSettingsL()

    77 	{

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

    79 

    80 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

    81 

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

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

    84 

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

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

    87 		{

    88 		CleanupStack::PopAndDestroy(settings);

    89 		return EFail;	

    90 		}

    91 	if(!TestSettingsMembersL(*settings))

    92 		{

    93 		CleanupStack::PopAndDestroy(settings);

    94 		return EFail;	

    95 		}

    96 	TestMessageSettingsMembersL(*settings);

    97 

    98 	// Lets copy the values to a different instance

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

   100 	smsSettings->CopyL(*settings);

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

   102 		{

   103 		CleanupStack::PopAndDestroy(2,settings);

   104 		return EFail;	

   105 		}

   106 	CleanupStack::PopAndDestroy(smsSettings);

   107 	smsSettings = NULL;

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

   109 

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

   111 	TestStoreRestoreSettingsL(*settings);

   112 

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

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

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

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

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

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

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

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

   121 	set2->SetDefaultServiceCenter(1);

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

   123 	// Validity Period	

   124 	set2->SetValidityPeriod(ESmsVPSixHours);

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

   126 		{

   127 		CleanupStack::PopAndDestroy(2,settings);

   128 		return EFail;	

   129 		}

   130 	// Reply Quoted

   131 	set2->SetReplyQuoted(EFalse);

   132 	if(set2->ReplyQuoted())

   133 		{

   134 		CleanupStack::PopAndDestroy(2,settings);

   135 		return EFail;	

   136 		}

   137 	// Reject Duplicate 

   138 	set2->SetRejectDuplicate(ETrue);

   139 	if(!set2->RejectDuplicate())

   140 		{

   141 		CleanupStack::PopAndDestroy(2,settings);

   142 		return EFail;	

   143 		}

   144 	// Delivery Method

   145 	set2->SetDelivery(ESmsDeliveryUponRequest);

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

   147 		{

   148 		CleanupStack::PopAndDestroy(2,settings);

   149 		return EFail;	

   150 		}

   151 	// Delivery Report

   152 	set2->SetDeliveryReport(ETrue);

   153 	if(!set2->DeliveryReport())

   154 		{

   155 		CleanupStack::PopAndDestroy(2,settings);

   156 		return EFail;	

   157 		}

   158 	// Reply Path

   159 	set2->SetReplyPath(EFalse);

   160 	if(set2->ReplyPath())

   161 		{

   162 		CleanupStack::PopAndDestroy(2,settings);

   163 		return EFail;	

   164 		}

   165 	// Message Conversion

   166 	set2->SetMessageConversion(ESmsConvPIDNone);

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

   168 		{

   169 		CleanupStack::PopAndDestroy(2,settings);

   170 		return EFail;	

   171 		}

   172 	// Can Concatenate

   173 	set2->SetCanConcatenate(ETrue);

   174 	if(!set2->CanConcatenate())

   175 		{

   176 		CleanupStack::PopAndDestroy(2,settings);

   177 		return EFail;	

   178 		}

   179 	// Character Set

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

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

   182 		{

   183 		CleanupStack::PopAndDestroy(2,settings);

   184 		return EFail;	

   185 		}

   186 	// Validity period format

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

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

   189 		{

   190 		CleanupStack::PopAndDestroy(2,settings);

   191 		return EFail;	

   192 		}

   193 	// Status Report Handling

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

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

   196 		{

   197 		CleanupStack::PopAndDestroy(2,settings);

   198 		return EFail;	

   199 		}

   200 	// Special Message Handling

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

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

   203 		{

   204 		CleanupStack::PopAndDestroy(2,settings);

   205 		return EFail;	

   206 		}

   207 

   208 	if(!TestStoreRestoreSettingsL(*set2))

   209 		{

   210 		CleanupStack::PopAndDestroy(2,settings);

   211 		return EFail;	

   212 		}

   213 

   214 	set2->SetClass2Folder(123);

   215 	if(!TestStoreRestoreSettingsL(*set2))

   216 		{

   217 		CleanupStack::PopAndDestroy(2,settings);

   218 		return EFail;	

   219 		}

   220 

   221 	CleanupStack::PopAndDestroy(set2);

   222 

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

   224 

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

   226 		{

   227 		CleanupStack::PopAndDestroy(settings);

   228 		return EFail;	

   229 		}

   230 

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

   232 	CleanupStack::PopAndDestroy(settings);

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

   234 	TestSettingsStoreToCommDbL();

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

   236 	return EPass;

   237 	}

   238 

   239 

   240 TBool CSmutTest::CompareSettingsFiles(

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

   242 	)

   243 	{

   244 	TBool identical = ETrue;

   245 

   246 	RFileReadStream stream1;

   247 	RFileReadStream stream2;

   248 

   249 	// Open each stream for binary read.

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

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

   252 

   253 	TInt ret1 = KErrNone;

   254 	TInt ret2 = KErrNone;

   255 	TBool finished = EFalse;

   256 	TUint8 byte1 = 0;

   257 	TUint8 byte2 = 0;

   258 

   259 	while (!finished)

   260 		{

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

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

   263 

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

   265 			{

   266 			// Either file data or lengths differ.

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

   268 				identical = EFalse;

   269 			finished = ETrue;

   270 			}

   271 		}

   272 

   273 	stream1.Close();

   274 	stream2.Close();

   275 

   276 	return identical;

   277 	}

   278 

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

   280 	{

   281 	StoreSettingsL(aSettings);

   282 

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

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

   285 

   286 	RestoreSettingsL(*set1);

   287 

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

   289 		{

   290 		CleanupStack::PopAndDestroy(set1);

   291 		return EFalse;	

   292 		}

   293 

   294 	CleanupStack::PopAndDestroy(set1);

   295 	

   296 	return ETrue;

   297 	}

   298 

   299 TBool CSmutTest::TestSettingsMembersL(CSmsSettings& aSettings)

   300 	{

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

   302 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisible);

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

   304 		{

   305 		return EFalse;

   306 		}

   307 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   309 		{

   310 		return EFalse;	

   311 		}

   312 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReport);

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

   314 		{

   315 		return EFalse;

   316 		}

   317 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

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

   319 		{

   320 		return EFalse;	

   321 		}

   322 	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

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

   324 		{

   325 		return EFalse;	

   326 		}

   327 	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReportAndMatch);

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

   329 		{

   330 		return EFalse;	

   331 		}

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

   333 

   334 	// SC handling

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

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

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

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

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

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

   341 		{

   342 		return EFalse;	

   343 		}

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

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

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

   347 		{

   348 		return EFalse;	

   349 		}

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

   351 		{

   352 		return EFalse;	

   353 		}

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

   355 		{

   356 		return EFalse;	

   357 		}

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

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

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

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

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

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

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

   365 	aSettings.SetDefaultServiceCenter(1);

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

   367 		{

   368 		return EFalse;	

   369 		}

   370 	aSettings.SetDefaultServiceCenter(2);

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

   372 		{

   373 		return EFalse;	

   374 		}

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

   376 

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

   378 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisible);

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

   380 		{

   381 		return EFalse;	

   382 		}

   383 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible);

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

   385 		{

   386 		return EFalse;	

   387 		}

   388 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReport);

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

   390 		{

   391 		return EFalse;	

   392 		}

   393 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

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

   395 		{

   396 		return EFalse;	

   397 		}

   398 	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

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

   400 		{

   401 		return EFalse;	

   402 		}

   403 	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReportAndMatch);

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

   405 		{

   406 		return EFalse;	

   407 		}

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

   409 

   410 	//CommDbAction

   411 	aSettings.SetCommDbAction(CSmsSettings::ENone);

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

   413 		{

   414 		return EFalse;	

   415 		}

   416 	aSettings.SetCommDbAction(CSmsSettings::EStoreToCommDb);

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

   418 		{

   419 		return EFalse;	

   420 		}

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

   422 

   423 	//SmsBearerAction

   424 	aSettings.SetSmsBearerAction(CSmsSettings::ENone);

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

   426 		{

   427 		return EFalse;	

   428 		}

   429 	aSettings.SetSmsBearerAction(CSmsSettings::EStoreToCommDb);

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

   431 		{

   432 		return EFalse;	

   433 		}

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

   435 

   436 	//SmsBearer

   437 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

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

   439 		{

   440 		return EFalse;	

   441 		}

   442 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly);

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

   444 		{

   445 		return EFalse;	

   446 		}

   447 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly);

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

   449 		{

   450 		return EFalse;	

   451 		}

   452 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketPreferred);

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

   454 		{

   455 		return EFalse;	

   456 		}

   457 	aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred);

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

   459 		{

   460 		return EFalse;	

   461 		}

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

   463 

   464 	// Reply Quoted

   465 	aSettings.SetReplyQuoted(EFalse);

   466 	if(aSettings.ReplyQuoted())

   467 		{

   468 		return EFalse;	

   469 		}

   470 	aSettings.SetReplyQuoted(ETrue);

   471 	if(!aSettings.ReplyQuoted())

   472 		{

   473 		return EFalse;	

   474 		}

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

   476 

   477 	// Delivery Method

   478 	aSettings.SetDelivery(ESmsDeliveryUponRequest);

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

   480 		{

   481 		return EFalse;	

   482 		}

   483 	aSettings.SetDelivery(ESmsDeliveryScheduled);

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

   485 		{

   486 		return EFalse;

   487 		}

   488 	aSettings.SetDelivery(ESmsDeliveryImmediately);

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

   490 		{

   491 		return EFalse;	

   492 		}

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

   494 

   495 	// Class2Folder

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

   497 		{

   498 		return EFalse;	

   499 		}

   500 	aSettings.SetClass2Folder(1);

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

   502 		{

   503 		return EFalse;

   504 		}

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

   506 

   507 	// Description length

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

   509 		{

   510 		return EFalse;

   511 		}

   512 	aSettings.SetDescriptionLength(100);

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

   514 		{

   515 		return EFalse;

   516 		}

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

   518 	

   519 	return ETrue;

   520 	}

   521 

   522 TBool CSmutTest::TestMessageSettingsMembersL(CSmsMessageSettings& aSettings)

   523 	{

   524 

   525 	// Reject Duplicate 

   526 	aSettings.SetRejectDuplicate(ETrue);

   527 	if(!aSettings.RejectDuplicate())

   528 		{

   529 		return EFalse;	

   530 		}

   531 	aSettings.SetRejectDuplicate(EFalse);

   532 	if(aSettings.RejectDuplicate())

   533 		{

   534 		return EFalse;	

   535 		}

   536 	

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

   538 

   539 	// Delivery Report

   540 	aSettings.SetDeliveryReport(ETrue);

   541 	if(!aSettings.DeliveryReport())

   542 		{

   543 		return EFalse;	

   544 		}

   545 	aSettings.SetDeliveryReport(EFalse);

   546 	if(aSettings.DeliveryReport())

   547 		{

   548 		return EFalse;	

   549 		}

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

   551 

   552 	// Reply Path

   553 	aSettings.SetReplyPath(EFalse);

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

   555 		{

   556 		return EFalse;	

   557 		}

   558 	aSettings.SetReplyPath(ETrue);

   559 	if(!aSettings.ReplyPath())

   560 		{

   561 		return EFalse;	

   562 		}

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

   564 

   565 	// Validity period format

   566 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone);

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

   568 		{

   569 		return EFalse;	

   570 		}

   571 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFEnhanced);

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

   573 		{

   574 		return EFalse;	

   575 		}

   576 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger);

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

   578 		{

   579 		return EFalse;	

   580 		}

   581 	aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet);

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

   583 		{

   584 		return EFalse;	

   585 		}

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

   587 

   588 	// Message Conversion (following conversions are supported)

   589 	aSettings.SetMessageConversion(ESmsConvFax);

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

   591 		{

   592 		return EFalse;	

   593 		}

   594 	aSettings.SetMessageConversion(ESmsConvX400);

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

   596 		{

   597 		return EFalse;	

   598 		}

   599 	aSettings.SetMessageConversion(ESmsConvPaging);

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

   601 		{

   602 		return EFalse;	

   603 		}

   604 	aSettings.SetMessageConversion(ESmsConvMail);

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

   606 		{

   607 		return EFalse;	

   608 		}

   609 	aSettings.SetMessageConversion(ESmsConvErmes);

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

   611 		{

   612 		return EFalse;	

   613 		}

   614 	aSettings.SetMessageConversion(ESmsConvSpeech);

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

   616 		{

   617 		return EFalse;	

   618 		}

   619 	aSettings.SetMessageConversion(ESmsConvPIDNone);

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

   621 		{

   622 		return EFalse;	

   623 		}

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

   625 

   626 	// Validity Period	

   627 	aSettings.SetValidityPeriod(ESmsVPHour);

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

   629 		{

   630 		return EFalse;	

   631 		}

   632 	aSettings.SetValidityPeriod(ESmsVPSixHours);

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

   634 		{

   635 		return EFalse;	

   636 		}

   637 	aSettings.SetValidityPeriod(ESmsVP24Hours);

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

   639 		{

   640 		return EFalse;	

   641 		}

   642 	aSettings.SetValidityPeriod(ESmsVPMaximum);

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

   644 		{

   645 		return EFalse;	

   646 		}

   647 	aSettings.SetValidityPeriod(ESmsVPWeek);

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

   649 		{

   650 		return EFalse;	

   651 		}

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

   653 

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

   655 	aSettings.SetCanConcatenate(ETrue);

   656 	if(!aSettings.CanConcatenate())

   657 		{

   658 		return EFalse;	

   659 		}

   660 	aSettings.SetCanConcatenate(EFalse);

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

   662 		{

   663 		return EFalse;	

   664 		}

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

   666 

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

   668 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit);

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

   670 		{

   671 		return EFalse;	

   672 		}

   673 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2);

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

   675 		{

   676 		return EFalse;	

   677 		}

   678 	aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit);

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

   680 		{

   681 		return EFalse;	

   682 		}

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

   684 	

   685 	return ETrue;

   686 	}

   687 

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

   689 	{

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

   691 

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

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

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

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

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

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

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

   699 

   700 	if (aTestSC)

   701 		{

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

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

   704 

   705 		TInt count = aLeft.ServiceCenterCount();

   706 

   707 		while (count--)

   708 			{

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

   710 			}

   711 		}		

   712 

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

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

   715 

   716 	return compare;

   717 	}

   718 

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

   720 	{

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

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

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

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

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

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

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

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

   729 	return compare;

   730 	}

   731 

   732 void CSmutTest::TestSettingsRestoreDefectL()

   733 	{

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

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

   736 

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

   738 

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

   740 	const TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   741 	Session().CleanupEntryPushL(id);

   742 	iSmsTest.SetEntryL(id);

   743 

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

   745 

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

   747 

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

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

   750 	iSmsTest(err == KErrNotFound);

   751 

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

   753 	//	iSmsTest.SetEntryL(id);

   754 	StoreSettingsL(*settings);

   755 

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

   757 

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

   759 

   760 	RestoreSettingsL(*settings);

   761 

   762 	Session().CleanupEntryPop();

   763 	Session().RemoveEntry(id);

   764 

   765 	CleanupStack::PopAndDestroy(settings);

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

   767 	}

   768 

   769 

   770 TBool CSmutTest::TestSettingsStoreToCommDbL()

   771 	{

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

   773 	

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

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

   776 

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

   778 		{

   779 		CleanupStack::PopAndDestroy(2,settings1);

   780 		return EFalse;	

   781 		}

   782 

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

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

   785 	settings1->SetDeliveryReport(ETrue);

   786 	settings1->SetValidityPeriod(1000);

   787 

   788 	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

   789 

   790 	StoreSettingsL(*settings1);

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

   792 	if(!CompareSettingsAndCommDbL(*settings1))

   793 		{

   794 		CleanupStack::PopAndDestroy(2,settings1);

   795 		return EFalse;	

   796 		}

   797 

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

   799 

   800 	StoreSettingsL(*settings1);

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

   802 	if(!CompareSettingsAndCommDbL(*settings1))

   803 		{

   804 		CleanupStack::PopAndDestroy(2,settings1);

   805 		return EFalse;	

   806 		}

   807 	

   808 	settings1->SetDeliveryReport(EFalse);

   809 

   810 	StoreSettingsL(*settings1);

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

   812 	if(!CompareSettingsAndCommDbL(*settings1))

   813 		{

   814 		CleanupStack::PopAndDestroy(2,settings1);

   815 		return EFalse;	

   816 		}

   817 

   818 	settings1->SetValidityPeriod(2000);

   819 

   820 	StoreSettingsL(*settings1);

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

   822 	if(!CompareSettingsAndCommDbL(*settings1))

   823 		{

   824 		CleanupStack::PopAndDestroy(2,settings1);

   825 		return EFalse;	

   826 		}

   827 

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

   829 	settings1->SetDeliveryReport(ETrue);

   830 	settings1->SetValidityPeriod(3000);

   831 

   832 	StoreSettingsL(*settings1);

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

   834 	if(!CompareSettingsAndCommDbL(*settings1))

   835 		{

   836 		CleanupStack::PopAndDestroy(2,settings1);

   837 		return EFalse;	

   838 		}

   839 

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

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

   842 

   843 	StoreSettingsL(*settings1);

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

   845 	if(!CompareSettingsAndCommDbL(*settings1))

   846 		{

   847 		CleanupStack::PopAndDestroy(2,settings1);

   848 		return EFalse;	

   849 		}

   850 

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

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

   853 	settings1->SetDeliveryReport(EFalse);

   854 	settings1->SetValidityPeriod(4000);

   855 

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

   857 	if(CompareSettingsAndCommDbL(*settings1))

   858 		{

   859 		CleanupStack::PopAndDestroy(2,settings1);

   860 		return EFalse;	

   861 		}

   862 

   863 	TInt count = settings1->ServiceCenterCount();

   864 

   865 	while (count--)

   866 		{

   867 		settings1->RemoveServiceCenter(count);

   868 		}

   869 

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

   871 	if(CompareSettingsAndCommDbL(*settings1))

   872 		{

   873 		CleanupStack::PopAndDestroy(2,settings1);

   874 		return EFalse;	

   875 		}

   876 

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

   878 	RestoreSettingsL(*settings2);

   879 	if(!CompareSettingsAndCommDbL(*settings2))

   880 		{

   881 		CleanupStack::PopAndDestroy(2,settings1);

   882 		return EFalse;	

   883 		}

   884 

   885 	//Test SMS Bearer

   886 

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

   888 

   889 	//Test 1

   890 

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

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

   893 

   894 	StoreSettingsL(*settings1);

   895 	if(!CompareSettingsAndSmsBearerL(*settings1))

   896 		{

   897 		CleanupStack::PopAndDestroy(2,settings1);

   898 		return EFalse;	

   899 		}

   900 	

   901 	//Test 2

   902 

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

   904 	if(CompareSettingsAndSmsBearerL(*settings1))

   905 		{

   906 		CleanupStack::PopAndDestroy(2,settings1);

   907 		return EFalse;	

   908 		}

   909 

   910 	//Test 3

   911 

   912 	StoreSettingsL(*settings1);

   913 	if(!CompareSettingsAndSmsBearerL(*settings1))

   914 		{

   915 		CleanupStack::PopAndDestroy(2,settings1);

   916 		return EFalse;	

   917 		}

   918 

   919 	RestoreSettingsL(*settings2);

   920 	if(!CompareSettingsAndSmsBearerL(*settings2))

   921 		{

   922 		return EFalse;	

   923 		}

   924 

   925 	//Test 4

   926 

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

   928 	StoreSettingsL(*settings1);

   929 	if(!CompareSettingsAndSmsBearerL(*settings1))

   930 		{

   931 		CleanupStack::PopAndDestroy(2,settings1);

   932 		return EFalse;	

   933 		}

   934 

   935 	//Test 5

   936 

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

   938 	if(CompareSettingsAndSmsBearerL(*settings1))

   939 		{

   940 		CleanupStack::PopAndDestroy(2,settings1);

   941 		return EFalse;	

   942 		}

   943 	StoreSettingsL(*settings1);

   944 	if(CompareSettingsAndSmsBearerL(*settings1))

   945 		{

   946 		CleanupStack::PopAndDestroy(2,settings1);

   947 		return EFalse;	

   948 		}

   949 

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

   951 	

   952 	return ETrue;

   953 	}

   954 

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

   956 	{

   957 	TCompare compare = ETrue;

   958 	TBuf<256> scAddress;

   959 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

   960 	globalSettingsRecord.LoadL(*iDBSession);

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

   962 	CleanupStack::PushL(modemBearerRecord);

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

   964 	modemBearerRecord->LoadL(*iDBSession);

   965 	scAddress = modemBearerRecord->iMessageCentreNumber;

   966 

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

   968 		{

   969 		compare(!scAddress.Length());

   970 		}

   971 	else

   972 		{

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

   974 		}

   975 	

   976 	TUint32 valPeriod = 0;

   977 	valPeriod = modemBearerRecord->iMessageValidityPeriod;

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

   979 	

   980 	TBool delReport = EFalse;

   981 	delReport = modemBearerRecord->iMessageDeliveryReport;

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

   983 

   984 	CleanupStack::PopAndDestroy(modemBearerRecord);	

   985 

   986 	return compare;

   987 	}

   988 

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

   990 	{

   991 	TUint32 smsBearer=0;

   992 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

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

   994 	if(err == KErrNone)

   995 		{

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

   997 		}	

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

   999 	return compare;

  1000 	}

  1001 

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

  1003 	{

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

  1005 	CleanupStack::PushL(store);

  1006 

  1007 	RMsvWriteStream out;

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

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

  1010 	out.CommitL();

  1011 	store->CommitL();

  1012 

  1013 	CleanupStack::PopAndDestroy(2, store);

  1014 	}

  1015 

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

  1017 	{

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

  1019 	CleanupStack::PushL(store);

  1020 

  1021 	RMsvReadStream in;

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

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

  1024 

  1025 	CleanupStack::PopAndDestroy(2, store);

  1026 	}

  1027 

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

  1029 	{

  1030 	CMsvStore* store = iSmsTest.EditStoreL();

  1031 	CleanupStack::PushL(store);

  1032 

  1033 	aHeader.StoreL(*store);

  1034 	store->CommitL();

  1035 

  1036 	CleanupStack::PopAndDestroy(store);

  1037 	}

  1038 

  1039 void CSmutTest::RestoreHeaderL(CSmsHeader& aHeader)

  1040 	{

  1041 	CMsvStore* store = iSmsTest.ReadStoreL();

  1042 	CleanupStack::PushL(store);

  1043 

  1044 	aHeader.RestoreL(*store);

  1045 

  1046 	CleanupStack::PopAndDestroy(store);

  1047 	}

  1048 

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

  1050 	{

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

  1052 	account->SaveSettingsL(aSettings);

  1053 	CleanupStack::PopAndDestroy(account);    

  1054 	}

  1055 

  1056 void CSmutTest::RestoreSettingsL(CSmsSettings& aSettings)

  1057 	{

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

  1059 	account->LoadSettingsL(aSettings);

  1060 	CleanupStack::PopAndDestroy(account);    

  1061 	}

  1062 

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

  1064 	{

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

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

  1067 	return compare;	

  1068 	}

  1069 

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

  1071 	{

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

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

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

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

  1076 	return compare;

  1077 	}

  1078 

  1079 TVerdict CSmutTest::TestNumberL()

  1080 	{

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

  1082 

  1083 	TMsvId id=iSmsTest.CreateDummyMessageToSendL();

  1084 	Session().CleanupEntryPushL(id);

  1085 	iSmsTest.SetEntryL(id);

  1086 

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

  1088 	CleanupStack::PushL(number0);

  1089 

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

  1091 	CleanupStack::PushL(number);

  1092 

  1093 	// Testing the features of CSmsNumber

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

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

  1096 

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

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

  1099 

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

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

  1102 	number->SetLogId(KLogID1);	

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

  1104 

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

  1106 		{

  1107 		CleanupStack::PopAndDestroy(2, number0);

  1108 		Session().CleanupEntryPop();

  1109 		Session().RemoveEntry(id);

  1110 		return EFail;	

  1111 		}

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

  1113 		{

  1114 		CleanupStack::PopAndDestroy(2, number0);

  1115 		Session().CleanupEntryPop();

  1116 		Session().RemoveEntry(id);

  1117 		return EFail;	

  1118 		}

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

  1120 		{

  1121 		CleanupStack::PopAndDestroy(2, number0);

  1122 		Session().CleanupEntryPop();

  1123 		Session().RemoveEntry(id);

  1124 		return EFail;	

  1125 		}

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

  1127 		{

  1128 		CleanupStack::PopAndDestroy(2, number0);

  1129 		Session().CleanupEntryPop();

  1130 		Session().RemoveEntry(id);

  1131 		return EFail;	

  1132 		}

  1133 

  1134 	StoreNumberL(*number);

  1135 	RestoreNumberL(*number0);