1 // Copyright (c) 2003-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_smsdeliver.h"

    17 

    18 #include <e32test.h>

    19 #include <smutset.h>

    20 #include <smuthdr.h>

    21 #include <txtrich.h>

    22 #include <smstestutils.h>

    23 #include <msvuids.h>

    24 #include <smsuaddr.h>

    25 #include <csmsaccount.h>

    26 

    27 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

    28 #include <tmsvsmsentry.h>

    29 #endif

    30 

    31 _LIT(KFailed,"Failed to complete tests.");

    32 _LIT(KRecipientOk,		"+447747065438");  // has to be valid number and switched on

    33 _LIT(KRecipientBad,		"+442071541467");

    34 _LIT(KRecipientFail,	"+34933753717");

    35 _LIT(KMessageData, "This is a simple text message");

    36 _LIT(KTestDeliverOneRecipientOk,		"Single recipient, deliver ok");

    37 _LIT(KTestDeliverOneRecipientFail, 		"Single recipient, deliver fail");

    38 _LIT(KTestDeliverMultiRecipientsOk_1,	"Multi (2) recipients, deliver ok"); 

    39 _LIT(KTestDeliverMultiRecipientsOk_2,	"Multi (2) recipients, deliver ok, but 1 fails to send");

    40 _LIT(KTestDeliverMultiRecipientsOk_3,	"Multi (3) recipients, deliver ok, but 1 fails to send");

    41 _LIT(KTestDeliverNoMatching,			"Single recipient, no matching");

    42 _LIT(KTestDeliverNoStatusReports,		"Single recipient, no status reports");

    43 _LIT(KTestDeliverNotSent,				"Single recipient, not sent");

    44 _LIT(KTestDeliverMultiRecipientsFail_1,	"Multi (2) recipients, deliver failure");

    45 _LIT(KTestDeliverMultiRecipientsMixed_1,"Multi (2) recipients, 1 deliver ok, 1 deliver failure");

    46 _LIT(KTestDeliverMultiRecipientsMixed_2,"Multi (2) recipients, 2 deliver failures");

    47 

    48 #if defined (__WINS__)

    49 _LIT(KPddName,"ECDRV");

    50 _LIT(KLddName,"ECOMM");

    51 #else	//__WINS__

    52 _LIT(KPddSirName,"ESIR");

    53 _LIT(KPddUartName,"ECUART4");

    54 _LIT(KLddName,"ECOMM");

    55 #endif	//__WINS__

    56 

    57 RTest test(_L("T_SmsDeliver Test Harness"));

    58 

    59 const TTimeIntervalMicroSeconds32 KWaitForWatchersToStart = 20000000;

    60 const TTimeIntervalMicroSeconds32 KWaitForWatchersToStartDisplayInterval = 5000000;

    61 

    62 LOCAL_C void DoTestsL()

    63 	{

    64 #if defined (__WINS__)

    65 	User::LoadPhysicalDevice(KPddName);

    66 	User::LoadLogicalDevice(KLddName);

    67 #else	//__WINS__

    68 	User::LoadPhysicalDevice(KPddSirName);

    69 	User::LoadPhysicalDevice(KPddUartName);

    70     User::LoadLogicalDevice(KLddName);

    71 #endif	//__WINS__

    72 

    73 	TInt r = StartC32();

    74 	if( (r != KErrNone) && (r != KErrAlreadyExists) )

    75 		test.Printf(_L("Failed to start C32 %d\n"), r);

    76 	

    77 	// Create and install the active scheduler

    78  	CActiveScheduler* scheduler= new (ELeave) CActiveScheduler();

    79 	CleanupStack::PushL(scheduler);

    80 	CActiveScheduler::Install(scheduler);

    81 

    82 	// Create the test engine

    83 	CTestEngine* testEngine = CTestEngine::NewL();

    84 	CleanupStack::PushL(testEngine);

    85 

    86 	// Do tests...

    87 	testEngine->DoTestsL();

    88 	

    89 	CleanupStack::PopAndDestroy(2, scheduler);	

    90 	}

    91 

    92 GLDEF_C TInt E32Main()

    93 	{	

    94 	__UHEAP_MARK;

    95 	CTrapCleanup* tc=CTrapCleanup::New();

    96 	TRAPD(err,DoTestsL());

    97 	if (err!=KErrNone)

    98 		User::Panic(KFailed, err);

    99 	delete tc;

   100 	test.Close();

   101 	__UHEAP_MARKEND;

   102 	return KErrNone;

   103 	}

   104 	

   105 /*

   106  *	CTestEngine

   107  */

   108 	

   109 CTestEngine* CTestEngine::NewL()

   110 	{

   111 	CTestEngine* self = new (ELeave) CTestEngine();

   112 	CleanupStack::PushL(self);

   113 	self->ConstructL();

   114 	CleanupStack::Pop(self);

   115 	return self;

   116 	}

   117 

   118 CTestEngine::~CTestEngine()

   119 	{

   120 	delete iTestUtils;

   121 	delete iWatchers;

   122 

   123 	iSocket.Close();

   124 	iSocketServ.Close();

   125 	}

   126 

   127 CTestEngine::CTestEngine()

   128 : CBase()

   129 	{

   130 	}

   131 	

   132 void CTestEngine::DoTestsL()

   133 	{

   134 

   135 	CTestDeliverBase* testCase = NULL;

   136 	

   137 	testCase = CTestDeliverOneRecipientOk::NewL(*iTestUtils);

   138 	RunTestCaseL(*testCase);

   139 

   140 	testCase = CTestDeliverMultiRecipientsOk_1::NewL(*iTestUtils);

   141 	RunTestCaseL(*testCase);

   142 

   143 	testCase = CTestDeliverMultiRecipientsOk_2::NewL(*iTestUtils);

   144 	RunTestCaseL(*testCase);

   145 

   146 	testCase = CTestDeliverMultiRecipientsOk_3::NewL(*iTestUtils);

   147 	RunTestCaseL(*testCase);

   148 

   149 	testCase = CTestDeliverNoMatching::NewL(*iTestUtils);

   150 	RunTestCaseL(*testCase);

   151 	

   152 	testCase = CTestDeliverNoStatusReports::NewL(*iTestUtils);

   153 	RunTestCaseL(*testCase);

   154 

   155 	testCase = CTestDeliverNotSent::NewL(*iTestUtils);

   156 	RunTestCaseL(*testCase);

   157 

   158 	testCase = CTestDeliverOneRecipientFail::NewL(*iTestUtils);

   159 	RunTestCaseL(*testCase);

   160 	

   161 	testCase = 	CTestDeliverMultiRecipientsFail_1::NewL(*iTestUtils);

   162 	RunTestCaseL(*testCase);

   163 

   164 	testCase = 	CTestDeliverMultiRecipientsMixed_1::NewL(*iTestUtils);

   165 	RunTestCaseL(*testCase);

   166 

   167 	testCase = 	CTestDeliverMultiRecipientsMixed_2::NewL(*iTestUtils);

   168 	RunTestCaseL(*testCase);

   169 	}

   170 	

   171 void CTestEngine::RunTestCaseL(CTestDeliverBase& aTestCase)

   172 	{

   173 	CleanupStack::PushL(&aTestCase);

   174 	aTestCase.Start();

   175 	CActiveScheduler::Start();

   176 	CleanupStack::PopAndDestroy(&aTestCase);

   177 	}

   178 

   179 void CTestEngine::ConstructL()

   180 	{

   181 	// This should create the SMS service, including the service settings.

   182 	iTestUtils = CSmsTestUtils::NewL(test);

   183 	

   184 	// Notify the system agent that the phone is on.

   185 	iTestUtils->NotifySaPhoneOnL();

   186 	

   187 	// Tell the tests utils to log to file

   188 	iTestUtils->SetLogToFile();

   189 	

   190 	// Restore the service settings.

   191 	iTestUtils->SetEntryL(iTestUtils->iSmsServiceId);

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

   193 	account->LoadSettingsL(*iTestUtils->iServiceSettings);

   194 	

   195 	// Remove the default service centres from the service settings

   196 	TInt count = iTestUtils->iServiceSettings->ServiceCenterCount();

   197 	while( count-- )

   198 		{

   199 		iTestUtils->iServiceSettings->RemoveServiceCenter(count);

   200 		}

   201 		

   202 	// Add the Vodafone service centre - store the settings.

   203 	iTestUtils->iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+447785016005"));

   204 

   205 	// Set delivery options - do matching and make reports visible.	

   206 	iTestUtils->iServiceSettings->SetDeliveryReport(ETrue);

   207 	iTestUtils->iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   208 

   209 	account->SaveSettingsL(*iTestUtils->iServiceSettings);

   210 	CleanupStack::PopAndDestroy(account);

   211 	

   212 	// Create a session with the SMS stack - note order of the next few things

   213 	// is important.

   214 	User::LeaveIfError(iSocketServ.Connect());

   215 	TProtocolDesc protoinfo;

   216 	TProtocolName protocolname(KSmsDatagram);

   217 	User::LeaveIfError(iSocketServ.FindProtocol(protocolname,protoinfo));

   218 	User::LeaveIfError(iSocket.Open(iSocketServ,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol));

   219 	

   220 	TSmsAddr smsaddr;

   221 	smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly);

   222 	User::LeaveIfError(iSocket.Bind(smsaddr));

   223 	

   224 	// Initialise phone...

   225 	iTestUtils->WaitForInitializeL();

   226 	

   227 	// Start watchers...

   228 	StartWatcherL();

   229 	}

   230 	

   231 TBool CTestEngine::WatchersAlreadyRunningL()

   232 	{

   233 	RSocketServ server;

   234 	RSocket socket;

   235 

   236 	User::LeaveIfError(server.Connect());

   237 	CleanupClosePushL(server);

   238 

   239 		// test if it's there... 

   240 	TProtocolDesc protoInfo;

   241 	TProtocolName protocolname;

   242 	protocolname.Copy(KSmsDatagram);

   243 	User::LeaveIfError(server.FindProtocol(protocolname,protoInfo));

   244 

   245 	User::LeaveIfError(socket.Open(server,

   246 										protoInfo.iAddrFamily,

   247 										protoInfo.iSockType, 

   248 										protoInfo.iProtocol));

   249 	CleanupClosePushL(socket);

   250 

   251 	TSmsAddr addr;

   252 	addr.SetSmsAddrFamily(ESmsAddrRecvAny);

   253 	TInt err = socket.Bind(addr);

   254 

   255 	CleanupStack::Pop(2, &server);

   256 	socket.CancelAll();

   257 	socket.Close();

   258 	server.Close();

   259 	return (err == KErrAlreadyExists);

   260 	}

   261 	

   262 void CTestEngine::StartWatcherL()

   263 	{

   264 	iTestUtils->Printf(_L("Start the Watcher"));

   265 

   266 	if( WatchersAlreadyRunningL() )

   267 		{

   268 		iTestUtils->Printf(_L("Watchers are already running\n"));

   269 		return;

   270 		}

   271 

   272 	iWatchers = CTestUtilsWatcherStarter::NewL();

   273 

   274 	TTimeIntervalMicroSeconds32 wait = KWaitForWatchersToStart;

   275 	TBool started = EFalse;

   276 	while( !started && wait.Int() > 0 )

   277 		{

   278 		iTestUtils->Printf(_L("Waiting %d secs for watchers to start...\n"), wait.Int() / 1000000);

   279 		wait = wait.Int() - KWaitForWatchersToStartDisplayInterval.Int();

   280 		User::After(KWaitForWatchersToStartDisplayInterval);

   281 		started = WatchersAlreadyRunningL();

   282 		}

   283 

   284 	if( !WatchersAlreadyRunningL() )

   285 		{

   286 		iTestUtils->Printf(_L("WARNING: NBS Watcher has not started yet\n"));

   287 		}

   288 	}

   289 	

   290 /*

   291  * CTestDeliverBase

   292  */

   293  

   294 CTestDeliverBase::~CTestDeliverBase()

   295 	{

   296 	delete iEntryForObserver;

   297 	delete iOperation;

   298 	}	

   299 	

   300 void CTestDeliverBase::Start()

   301 	{

   302 	iTestUtils.Printf(_L("Starting %S\n"), &TestName());

   303 	iState = EClearFolders;

   304 	CompleteSelf();

   305 	}

   306 	

   307 CTestDeliverBase::CTestDeliverBase(CSmsTestUtils& aTestUtils)

   308 : CActive(CActive::EPriorityStandard), iTestUtils(aTestUtils)

   309 	{

   310 	CActiveScheduler::Add(this);

   311 	}

   312 	

   313 void CTestDeliverBase::ConstructL()

   314 	{

   315 	iEntryForObserver = Session().GetEntryL(KMsvGlobalInBoxIndexEntryId);

   316 	}

   317 	

   318 void CTestDeliverBase::CompleteSelf()

   319 	{

   320 	TRequestStatus* pStat = &iStatus;

   321 	User::RequestComplete(pStat, KErrNone);

   322 	SetActive();

   323 	}

   324 	

   325 CMsvSession& CTestDeliverBase::Session()

   326 	{

   327 	return *iTestUtils.iMsvSession;

   328 	}

   329 

   330 CMsvEntry& CTestDeliverBase::MsvEntry()

   331 	{

   332 	return *iTestUtils.iMsvEntry;

   333 	}

   334 

   335 CSmsClientMtm& CTestDeliverBase::Client()

   336 	{

   337 	return *iTestUtils.iSmsClientMtm;

   338 	}

   339 	

   340 CSmsSettings& CTestDeliverBase::ServiceSettings()

   341 	{

   342 	return *iTestUtils.iServiceSettings;

   343 	}

   344 		

   345 void CTestDeliverBase::ClearFoldersL()

   346 	{

   347 	iTestUtils.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

   348 	iTestUtils.DeleteSmsMessagesL(KMsvGlobalInBoxIndexEntryId);

   349 	iTestUtils.DeleteSmsMessagesL(KMsvSentEntryId);		

   350 	}

   351 	

   352 void CTestDeliverBase::TestComplete()

   353 	{

   354 	iTestUtils.Printf(_L("Test Complete\n"));

   355 	CActiveScheduler::Stop();

   356 	}

   357 	

   358 void CTestDeliverBase::CreateMessageL()

   359 	{

   360 	iTestUtils.Printf(_L("Creating message...\n"));

   361 	

   362 	TMsvEntry entry;

   363 	entry.SetVisible(ETrue); 

   364 	entry.SetInPreparation(ETrue); 

   365 	entry.iServiceId = iTestUtils.iSmsServiceId; 

   366 	entry.iType = KUidMsvMessageEntry; 

   367 	entry.iMtm = KUidMsgTypeSMS; 

   368 	entry.iDate.HomeTime(); 

   369 	entry.iSize = 0; 

   370 	entry.iDescription.Set(KNullDesC); 

   371 	entry.iDetails.Set(KNullDesC); 

   372 

   373 	// Check send options...

   374 	TUint sendState = KMsvSendStateWaiting; 

   375 	switch( ServiceSettings().Delivery() )  

   376 		{ 

   377 	case ESmsDeliveryScheduled: 

   378 		sendState = KMsvSendStateScheduled; 

   379 		break; 

   380 	case ESmsDeliveryUponRequest: 

   381 		sendState = KMsvSendStateUponRequest; 

   382 		break; 

   383 	default: 

   384 		sendState = KMsvSendStateWaiting; 

   385 		break;

   386 		}

   387 	entry.SetSendingState(sendState); 

   388 

   389 	// Create the SMS header object...

   390 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   391 	CleanupStack::PushL(header);

   392 	

   393 	// Set the body text...

   394 	iTestUtils.iRichText->Reset();

   395 	iTestUtils.iRichText->InsertL(0, KMessageData);

   396 	

   397 	// Copy the message settings...

   398 	header->SetSmsSettingsL(ServiceSettings()); 

   399 	

   400 	// Set the service centre

   401 	TInt defaultIndex = ServiceSettings().DefaultServiceCenter();

   402 	header->SetServiceCenterAddressL(ServiceSettings().GetServiceCenter(defaultIndex).Address());

   403 

   404 	// Set recipient - ask derived class

   405 	SetRecipientsL(*header);

   406 	

   407 	// Update entry description and details...

   408 	CArrayPtrFlat<CSmsNumber>& recipient = header->Recipients();

   409 	entry.iDetails.Set(recipient[0]->Address());

   410 	entry.iDescription.Set(iTestUtils.iRichText->Read(0, ServiceSettings().DescriptionLength()));

   411 	entry.SetInPreparation(EFalse);

   412 	

   413 	// Create the entry - set context to the global outbox.

   414 	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

   415 	MsvEntry().CreateL(entry);

   416 

   417 	// Create new store and save header information 

   418 	MsvEntry().SetEntryL(entry.Id()); 

   419 	CMsvStore* store = MsvEntry().EditStoreL(); 

   420 	CleanupStack::PushL(store); 

   421 	header->StoreL(*store);

   422 	store->StoreBodyTextL(*iTestUtils.iRichText);

   423 	store->CommitL(); 

   424 	CleanupStack::PopAndDestroy(2, header); 

   425 	

   426 	iMessageId = entry.Id();

   427 	}

   428 	

   429 void CTestDeliverBase::SendMessageL()

   430 	{

   431 	iTestUtils.Printf(_L("Sending message %d\n"), iMessageId);

   432 

   433 	delete iOperation;

   434 	iOperation = NULL;

   435 

   436 	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();

   437 	CleanupStack::PushL(sel);

   438 	sel->AppendL(iMessageId);

   439 

   440 	iTestUtils.DisplayMessageL(iMessageId);

   441 	

   442 	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

   443 	iOperation = MsvEntry().CopyL(*sel, iTestUtils.iSmsServiceId, iStatus);

   444 	CleanupStack::PopAndDestroy(sel);

   445 

   446 	SetActive();

   447 	}

   448 	

   449 void CTestDeliverBase::ChangeServiceSettingsL()

   450 	{

   451 	// Restore the service settings.

   452 	iTestUtils.SetEntryL(iTestUtils.iSmsServiceId);

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

   454 	account->LoadSettingsL(*iTestUtils.iServiceSettings);

   455 	

   456 	// Set the service settings 

   457 	iTestUtils.iServiceSettings->SetValidityPeriod(TTimeIntervalMinutes(5));

   458 	iTestUtils.iServiceSettings->SetDeliveryReport(ETrue);

   459 	iTestUtils.iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

   460 	

   461 	// Store the new service settings

   462 	account->SaveSettingsL(*iTestUtils.iServiceSettings);

   463 	CleanupStack::PopAndDestroy(account);

   464 	}

   465 	

   466 void CTestDeliverBase::CheckCreatedMessageL()

   467 	{

   468 	// Need to check the following - 

   469 	// 1. All recipients have correct delivery status - ENoAckRequested.

   470 	// 2. The index summary is correct - ENoAckSummary

   471 	// 3. The index message IS is invalid.

   472 	

   473 	iTestUtils.Printf(_L("Checking created message %d has correct flags set...\n"), iMessageId);

   474 		

   475 	// Restore the recipient...

   476 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   477 	CleanupStack::PushL(header);

   478 

   479 	MsvEntry().SetEntryL(iMessageId);

   480 	CMsvStore* store = iTestUtils.ReadStoreL();

   481 	CleanupStack::PushL(store);

   482 	header->RestoreL(*store);

   483 	CleanupStack::PopAndDestroy(store);

   484 	

   485 	TInt rcptCount = header->Recipients().Count();

   486 	for( TInt ii = 0; ii < rcptCount; ++ii )

   487 		{

   488 		CSmsNumber* rcpt = header->Recipients()[ii];

   489 		iTestUtils.Printf(_L("--Recipient %d - Delivery status -> %d - should be %d (ENoAckRequested)\n"), ii, rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested);

   490 		iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested);

   491 		}

   492 		

   493 	TMsvSmsEntry entry = MsvEntry().Entry();

   494 	

   495 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (ENoAckSummary)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::ENoAckSummary);

   496 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::ENoAckSummary);

   497 	

   498 	TLogId logId = 0;	

   499 	TBool validId = entry.MessageId(logId);

   500 	

   501 	iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse);

   502 	iTestUtils.Test()(validId == EFalse);

   503 	

   504 	CleanupStack::PopAndDestroy(header);

   505 	}

   506 	

   507 TMsvId CTestDeliverBase::GetObserverEntry()

   508 	{

   509 	return iMessageId;

   510 	}

   511 

   512 // methods from CActive

   513 

   514 void CTestDeliverBase::RunL()

   515 	{

   516 	User::LeaveIfError(iStatus.Int());

   517 	

   518 	switch( iState )

   519 		{

   520 	case EClearFolders:

   521 		{

   522 		ClearFoldersL();

   523 		iState = EChangeServiceSettings;

   524 		CompleteSelf();

   525 		} break;

   526 	case EChangeServiceSettings:

   527 		{

   528 		ChangeServiceSettingsL();

   529 		iState = ECreateMessage;

   530 		CompleteSelf();

   531 		} break;			

   532 	case ECreateMessage:

   533 		{

   534 		CreateMessageL();

   535 		iState = ECheckCreatedMessage;

   536 		CompleteSelf();

   537 		} break;

   538 	case ECheckCreatedMessage:

   539 		{

   540 		CheckCreatedMessageL();

   541 		iState = ESendMessage;

   542 		CompleteSelf();

   543 		} break;

   544 	case ESendMessage:

   545 		{

   546 		SendMessageL();

   547 		iState = ECheckSentMessage;

   548 		} break;

   549 	case ECheckSentMessage:

   550 		{

   551 		CheckSentMessageL();

   552 		

   553 		TMsvId entryId = GetObserverEntry();

   554 		

   555 		if( entryId != KMsvNullIndexEntryId )

   556 			{

   557 			// Need to observe something - move observer entry to specified entry 

   558 			// and wait for it to be updated

   559 			iEntryForObserver->SetEntryL(entryId);

   560 			iEntryForObserver->AddObserverL(*this);

   561 			

   562 			iState = EPendingDeliveryReport;

   563 			}

   564 		else

   565 			{

   566 			// Not observing anything - end of test.

   567 			TestComplete();

   568 			}

   569 		} break;

   570 	case EPendingDeliveryReport:

   571 		{

   572 		// End the test...

   573 		TestComplete();

   574 		} break;			

   575 	default:

   576 		User::Invariant();

   577 		break;

   578 		}

   579 	}

   580 	

   581 void CTestDeliverBase::DoCancel()

   582 	{

   583 	}

   584 	

   585 TInt CTestDeliverBase::RunError(TInt /*aError*/)

   586 	{

   587 	return KErrNone;

   588 	}

   589 	

   590 //	methods from MMsvEntryObserver	

   591 	

   592 void CTestDeliverBase::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

   593 	{

   594 	__ASSERT_DEBUG( iState == EPendingDeliveryReport, User::Invariant() );

   595 	

   596 	if( aEvent == EMsvEntryChanged )

   597 		{

   598 		iTestUtils.Printf(_L("Message entry has been updated\n"));

   599 

   600 		// Check that the sent message has been updated.

   601 		CheckDeliveredMessageL();

   602 		}

   603 	}

   604 	

   605 /*

   606  * CTestDeliverOneRecipientOk

   607  */

   608  

   609  CTestDeliverOneRecipientOk* CTestDeliverOneRecipientOk::NewL(CSmsTestUtils& aTestUtils)

   610 	{

   611 	CTestDeliverOneRecipientOk* self = new (ELeave) CTestDeliverOneRecipientOk(aTestUtils);

   612 	CleanupStack::PushL(self);

   613 	self->ConstructL();

   614 	CleanupStack::Pop(self);

   615 	return self;	

   616 	}

   617 		

   618 CTestDeliverOneRecipientOk::~CTestDeliverOneRecipientOk()

   619 	{

   620 	}

   621 	

   622 CTestDeliverOneRecipientOk::CTestDeliverOneRecipientOk(CSmsTestUtils& aTestUtils)

   623 : CTestDeliverBase(aTestUtils)

   624 	{

   625 	}

   626 		

   627 //	 methods from CTestDeliverBase

   628 

   629 void CTestDeliverOneRecipientOk::SetRecipientsL(CSmsHeader& aHeader)

   630 	{

   631 	iTestUtils.Printf(_L("--Setting single recipient\n"));

   632 	

   633 	CSmsNumber* rcpt = CSmsNumber::NewL();

   634 	CleanupStack::PushL(rcpt);

   635 	rcpt->SetAddressL(KRecipientOk);

   636 	aHeader.Recipients().AppendL(rcpt);

   637 	CleanupStack::Pop(rcpt);

   638 	}

   639 

   640 void CTestDeliverOneRecipientOk::CheckSentMessageL()

   641 	{

   642 	// Need to check the following - 

   643 	// 1. Correct number of recipients

   644 	// 2. The recipient has delivery status correctly set

   645 	// 3. The index summary is correctly set

   646 	// 4. The index message ID is valid.

   647 	// 5. The index message ID matches that of the recipient

   648 	

   649 	iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId);

   650 		

   651 	// Restore the recipient...

   652 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   653 	CleanupStack::PushL(header);

   654 

   655 	MsvEntry().SetEntryL(iMessageId);

   656 	CMsvStore* store = iTestUtils.ReadStoreL();

   657 	CleanupStack::PushL(store);

   658 	header->RestoreL(*store);

   659 	CleanupStack::PopAndDestroy(store);

   660 	

   661 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1);

   662 	iTestUtils.Test()(header->Recipients().Count() == 1);

   663 	

   664 	CSmsNumber* rcpt = header->Recipients()[0];

   665 	

   666 	iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

   667 	iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   668 	

   669 	TMsvSmsEntry entry = MsvEntry().Entry();

   670 	

   671 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks);

   672 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks);

   673 	

   674 	TLogId logId = 0;	

   675 	TBool validId = entry.MessageId(logId);

   676 	

   677 	iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse);

   678 	iTestUtils.Test()(validId != EFalse);

   679 		

   680 	iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt->LogId());

   681 	iTestUtils.Test()(logId == rcpt->LogId());

   682 	

   683 	CleanupStack::PopAndDestroy(header);

   684 	}

   685 	

   686 void CTestDeliverOneRecipientOk::CheckDeliveredMessageL()

   687 	{

   688 	// Need to check the following - 

   689 	// 1. Correct number of recipients

   690 	// 2. The recipient has delivery status correctly set

   691 	// 3. The index summary is correctly set

   692 	

   693 	iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId);

   694 		

   695 	// Restore the recipient...

   696 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   697 	CleanupStack::PushL(header);

   698 

   699 	MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId);

   700 	MsvEntry().SetEntryL(iMessageId);

   701 	CMsvStore* store = iTestUtils.ReadStoreL();

   702 	CleanupStack::PushL(store);

   703 	header->RestoreL(*store);

   704 	CleanupStack::PopAndDestroy(store);

   705 	

   706 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1);

   707 	iTestUtils.Test()(header->Recipients().Count() == 1);

   708 	

   709 	CSmsNumber* rcpt = header->Recipients()[0];

   710 	

   711 	iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful);

   712 	iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

   713 	

   714 	TMsvSmsEntry entry = MsvEntry().Entry();

   715 	

   716 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful);

   717 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful);

   718 	

   719 	// Test is no ended - complete self to stop.

   720 	CompleteSelf();		

   721 	

   722 	CleanupStack::PopAndDestroy(header);

   723 	}

   724 

   725 const TDesC& CTestDeliverOneRecipientOk::TestName()

   726 	{

   727 	return KTestDeliverOneRecipientOk();

   728 	}

   729 	

   730 /*

   731  * CTestDeliverOneRecipientFail

   732  */

   733  

   734  CTestDeliverOneRecipientFail* CTestDeliverOneRecipientFail::NewL(CSmsTestUtils& aTestUtils)

   735 	{

   736 	CTestDeliverOneRecipientFail* self = new (ELeave) CTestDeliverOneRecipientFail(aTestUtils);

   737 	CleanupStack::PushL(self);

   738 	self->ConstructL();

   739 	CleanupStack::Pop(self);

   740 	return self;	

   741 	}

   742 		

   743 CTestDeliverOneRecipientFail::~CTestDeliverOneRecipientFail()

   744 	{

   745 	}

   746 	

   747 CTestDeliverOneRecipientFail::CTestDeliverOneRecipientFail(CSmsTestUtils& aTestUtils)

   748 : CTestDeliverBase(aTestUtils)

   749 	{

   750 	}

   751 		

   752 //	 methods from CTestDeliverBase

   753 

   754 void CTestDeliverOneRecipientFail::SetRecipientsL(CSmsHeader& aHeader)

   755 	{

   756 	iTestUtils.Printf(_L("--Setting single recipient\n"));

   757 	

   758 	CSmsNumber* rcpt = CSmsNumber::NewL();

   759 	CleanupStack::PushL(rcpt);

   760 	rcpt->SetAddressL(KRecipientFail);

   761 	aHeader.Recipients().AppendL(rcpt);

   762 	CleanupStack::Pop(rcpt);

   763 	}

   764 	

   765 void CTestDeliverOneRecipientFail::CheckSentMessageL()

   766 	{

   767 	// Need to check the following - 

   768 	// 1. Correct number of recipients

   769 	// 2. The recipient has delivery status correctly set

   770 	// 3. The index summary is correctly set

   771 	// 4. The index message ID is valid.

   772 	// 5. The index message ID matches that of the recipient

   773 	

   774 	iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId);

   775 		

   776 	// Restore the recipient...

   777 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   778 	CleanupStack::PushL(header);

   779 

   780 	MsvEntry().SetEntryL(iMessageId);

   781 	CMsvStore* store = iTestUtils.ReadStoreL();

   782 	CleanupStack::PushL(store);

   783 	header->RestoreL(*store);

   784 	CleanupStack::PopAndDestroy(store);

   785 	

   786 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1);

   787 	iTestUtils.Test()(header->Recipients().Count() == 1);

   788 	

   789 	CSmsNumber* rcpt = header->Recipients()[0];

   790 	

   791 	iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

   792 	iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   793 	

   794 	TMsvSmsEntry entry = MsvEntry().Entry();

   795 	

   796 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks);

   797 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks);

   798 	

   799 	TLogId logId = 0;	

   800 	TBool validId = entry.MessageId(logId);

   801 	

   802 	iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse);

   803 	iTestUtils.Test()(validId != EFalse);

   804 		

   805 	iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt->LogId());

   806 	iTestUtils.Test()(logId == rcpt->LogId());

   807 	

   808 	CleanupStack::PopAndDestroy(header);

   809 	}

   810 	

   811 void CTestDeliverOneRecipientFail::CheckDeliveredMessageL()

   812 	{

   813 	// Need to check the following - 

   814 	// 1. Correct number of recipients

   815 	// 2. The recipient has delivery status correctly set

   816 	// 3. The index summary is correctly set

   817 	

   818  	iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId);

   819 		

   820 	// Restore the recipient...

   821 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   822 	CleanupStack::PushL(header);

   823 

   824 	MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId);

   825 	MsvEntry().SetEntryL(iMessageId);

   826 	CMsvStore* store = iTestUtils.ReadStoreL();

   827 	CleanupStack::PushL(store);

   828 	header->RestoreL(*store);

   829 	CleanupStack::PopAndDestroy(store);

   830 	

   831 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1);

   832 	iTestUtils.Test()(header->Recipients().Count() == 1);

   833 	

   834 	CSmsNumber* rcpt = header->Recipients()[0];

   835 	

   836 	iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EAckError)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError);

   837 	iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError);

   838 	

   839 	iTestUtils.Printf(_L("- Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt->Status(), CMsvRecipient::EFailedToSend);

   840 	iTestUtils.Test()(rcpt->Status()==CMsvRecipient::EFailedToSend);

   841 

   842 	iTestUtils.Printf(_L("- Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt->Error(), TSmsStatus::ESmsShortMessageReceivedBySME);

   843 	iTestUtils.Test()(rcpt->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME);

   844 	

   845 	TMsvSmsEntry entry = MsvEntry().Entry();

   846 	

   847 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllFailed)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllFailed);

   848 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllFailed);

   849 	

   850 	// Test is no ended - complete self to stop.

   851 	CompleteSelf();		

   852 	

   853 	CleanupStack::PopAndDestroy(header);

   854 	}

   855 

   856 const TDesC& CTestDeliverOneRecipientFail::TestName()

   857 	{

   858 	return KTestDeliverOneRecipientFail();

   859 	}

   860 	

   861 /*

   862  * CTestDeliverMultiRecipientsOk_1

   863  */

   864  

   865 CTestDeliverMultiRecipientsOk_1* CTestDeliverMultiRecipientsOk_1::NewL(CSmsTestUtils& aTestUtils)

   866 	{

   867 	CTestDeliverMultiRecipientsOk_1* self = new (ELeave) CTestDeliverMultiRecipientsOk_1(aTestUtils);

   868 	CleanupStack::PushL(self);

   869 	self->ConstructL();

   870 	CleanupStack::Pop(self);

   871 	return self;	

   872 	}

   873 		

   874 CTestDeliverMultiRecipientsOk_1::~CTestDeliverMultiRecipientsOk_1()

   875 	{

   876 	}

   877 	

   878 CTestDeliverMultiRecipientsOk_1::CTestDeliverMultiRecipientsOk_1(CSmsTestUtils& aTestUtils)

   879 : CTestDeliverBase(aTestUtils)

   880 	{

   881 	}

   882 	

   883 //	methods from CTestDeliverBase

   884 

   885 void CTestDeliverMultiRecipientsOk_1::SetRecipientsL(CSmsHeader& aHeader)

   886 	{

   887 	iTestUtils.Printf(_L("--Setting multiple (2) recipients\n"));

   888 	

   889 	CSmsNumber* rcpt0 = CSmsNumber::NewL();

   890 	CleanupStack::PushL(rcpt0);

   891 	rcpt0->SetAddressL(KRecipientOk);

   892 	aHeader.Recipients().AppendL(rcpt0);

   893 	CleanupStack::Pop(rcpt0);

   894 	

   895 	CSmsNumber* rcpt1 = CSmsNumber::NewL();

   896 	CleanupStack::PushL(rcpt1);

   897 	rcpt1->SetAddressL(KRecipientOk);

   898 	aHeader.Recipients().AppendL(rcpt1);

   899 	CleanupStack::Pop(rcpt1);

   900 	}

   901 	

   902 void CTestDeliverMultiRecipientsOk_1::CheckSentMessageL()

   903 	{

   904 	// Need to check the following - 

   905 	// 1. Correct number of recipients

   906 	// 2. The recipients have delivery status correctly set

   907 	// 3. The index summary is correctly set

   908 	// 4. The index message ID is valid.

   909 	// 5. The index message ID matches that of the recipient

   910 	

   911 	iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId);

   912 		

   913 	// Restore the recipient...

   914 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   915 	CleanupStack::PushL(header);

   916 

   917 	MsvEntry().SetEntryL(iMessageId);

   918 	CMsvStore* store = iTestUtils.ReadStoreL();

   919 	CleanupStack::PushL(store);

   920 	header->RestoreL(*store);

   921 	CleanupStack::PopAndDestroy(store);

   922 	

   923 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2);

   924 	iTestUtils.Test()(header->Recipients().Count() == 2);

   925 	

   926 	CSmsNumber* rcpt0 = header->Recipients()[0];

   927 	

   928 	iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

   929 	iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   930 	

   931 	CSmsNumber* rcpt1 = header->Recipients()[1];

   932 	

   933 	iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

   934 	iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);	

   935 	

   936 	TMsvSmsEntry entry = MsvEntry().Entry();

   937 	

   938 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks);

   939 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks);

   940 	

   941 	TLogId logId = 0;	

   942 	TBool validId = entry.MessageId(logId);

   943 	

   944 	iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse);

   945 	iTestUtils.Test()(validId == EFalse);

   946 		

   947 	CleanupStack::PopAndDestroy(header);

   948 	}

   949 	

   950 void CTestDeliverMultiRecipientsOk_1::CheckDeliveredMessageL()

   951 	{

   952 	// Need to check the following - 

   953 	// 1. Correct number of recipients

   954 	// 2. The recipient has delivery status is correctly set

   955 	// 3. The index summary is correctly set

   956 

   957 	iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount);

   958 		

   959 	// Restore the recipient...

   960 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

   961 	CleanupStack::PushL(header);

   962 

   963 	MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId);

   964 	MsvEntry().SetEntryL(iMessageId);

   965 	CMsvStore* store = iTestUtils.ReadStoreL();

   966 	CleanupStack::PushL(store);

   967 	header->RestoreL(*store);

   968 	CleanupStack::PopAndDestroy(store);

   969 	

   970 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2);

   971 	iTestUtils.Test()(header->Recipients().Count() == 2);

   972 	

   973 	CSmsNumber* rcpt0 = header->Recipients()[0];

   974 	CSmsNumber* rcpt1 = header->Recipients()[1];

   975 	

   976 	TMsvSmsEntry entry = MsvEntry().Entry();

   977 

   978 	if( iCheckCount == 1 )

   979 		{

   980 		// At least one of the recipients has been delivered to ok - check the 

   981 		// status of recipient 0 and make decisions based on that.

   982 		CSmsNumber* pendingRcpt = NULL;

   983 		

   984 		if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck )

   985 			{

   986 			// Recipient 1 delivered to first...

   987 			iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

   988 			iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

   989 			

   990 			iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful);

   991 			iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

   992 			

   993 			pendingRcpt = rcpt0;

   994 			}

   995 		else

   996 			{

   997 			// Recipient 0 delivered to first...

   998 			iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful);

   999 			iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

  1000 			

  1001 			iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

  1002 			iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

  1003 			

  1004 			pendingRcpt = rcpt1;

  1005 			}

  1006 		TLogId logId = 0;	

  1007 		TBool validId = entry.MessageId(logId);

  1008 		

  1009 		iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse);

  1010 		iTestUtils.Test()(validId != EFalse);

  1011 			

  1012 		iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId());

  1013 		iTestUtils.Test()(logId == pendingRcpt->LogId());

  1014 		}

  1015 	else

  1016 		{

  1017 		// Both recipients has been delivered to ok - check the status of both

  1018 		// recipients

  1019 		iTestUtils.Printf(_L("--Second check of flags -> both recipients have been delivered to\n"));

  1020 		

  1021 		iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful);

  1022 		iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

  1023 	

  1024 		iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful);

  1025 		iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful);

  1026 		

  1027 		iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful);

  1028 		iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful);

  1029 

  1030 		// Test is no ended - complete self to stop.

  1031 		CompleteSelf();		

  1032 		}

  1033 	CleanupStack::PopAndDestroy(header);

  1034 	}

  1035 

  1036 const TDesC& CTestDeliverMultiRecipientsOk_1::TestName()

  1037 	{

  1038 	return KTestDeliverMultiRecipientsOk_1();

  1039 	}

  1040 	

  1041 /*

  1042  * CTestDeliverMultiRecipientsOk_2

  1043  */

  1044  

  1045 CTestDeliverMultiRecipientsOk_2* CTestDeliverMultiRecipientsOk_2::NewL(CSmsTestUtils& aTestUtils)

  1046 	{

  1047 	CTestDeliverMultiRecipientsOk_2* self = new (ELeave) CTestDeliverMultiRecipientsOk_2(aTestUtils);

  1048 	CleanupStack::PushL(self);

  1049 	self->ConstructL();

  1050 	CleanupStack::Pop(self);

  1051 	return self;	

  1052 	}

  1053 		

  1054 CTestDeliverMultiRecipientsOk_2::~CTestDeliverMultiRecipientsOk_2()

  1055 	{

  1056 	}

  1057 	

  1058 CTestDeliverMultiRecipientsOk_2::CTestDeliverMultiRecipientsOk_2(CSmsTestUtils& aTestUtils)

  1059 : CTestDeliverBase(aTestUtils)

  1060 	{

  1061 	}

  1062 	

  1063 //	methods from CTestDeliverBase

  1064 

  1065 void CTestDeliverMultiRecipientsOk_2::SetRecipientsL(CSmsHeader& aHeader)

  1066 	{

  1067 	iTestUtils.Printf(_L("--Setting multiple (2) recipients\n"));

  1068 	

  1069 	CSmsNumber* rcpt0 = CSmsNumber::NewL();

  1070 	CleanupStack::PushL(rcpt0);

  1071 	rcpt0->SetAddressL(KRecipientOk);

  1072 	aHeader.Recipients().AppendL(rcpt0);

  1073 	CleanupStack::Pop(rcpt0);

  1074 	

  1075 	CSmsNumber* rcpt1 = CSmsNumber::NewL();

  1076 	CleanupStack::PushL(rcpt1);

  1077 	rcpt1->SetAddressL(KRecipientBad);

  1078 	aHeader.Recipients().AppendL(rcpt1);

  1079 	CleanupStack::Pop(rcpt1);

  1080 	}

  1081 

  1082 void CTestDeliverMultiRecipientsOk_2::CheckSentMessageL()

  1083 	{

  1084 	// Need to check the following - 

  1085 	// 1. Correct number of recipients

  1086 	// 2. The recipients have delivery status correctly set

  1087 	// 3. The index summary is correctly set

  1088 	// 4. The index message ID is valid.

  1089 	// 5. The index message ID matches that of the recipient

  1090 	

  1091 	iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId);

  1092 		

  1093 	// Restore the recipient...

  1094 	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText);

  1095 	CleanupStack::PushL(header);

  1096 

  1097 	MsvEntry().SetEntryL(iMessageId);

  1098 	CMsvStore* store = iTestUtils.ReadStoreL();

  1099 	CleanupStack::PushL(store);

  1100 	header->RestoreL(*store);

  1101 	CleanupStack::PopAndDestroy(store);

  1102 	

  1103 	iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2);

  1104 	iTestUtils.Test()(header->Recipients().Count() == 2);

  1105 	

  1106 	CSmsNumber* rcpt0 = header->Recipients()[0];

  1107 	

  1108 	iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck);

  1109 	iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck);

  1110 	

  1111 	CSmsNumber* rcpt1 = header->Recipients()[1];

  1112 	

  1113 	iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested);

  1114 	iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested);	

  1115 	

  1116 	TMsvSmsEntry entry = MsvEntry().Entry();

  1117 	

  1118 	iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks);

  1119 	iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks);

  1120 	

  1121 	TLogId logId = 0;	

  1122 	TBool validId = entry.MessageId(logId);

  1123 	

  1124 	iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse);

  1125 	iTestUtils.Test()(validId != EFalse);

  1126 		

  1127 	iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt0->LogId());

  1128 	iTestUtils.Test()(logId == rcpt0->LogId());

  1129 		

  1130 	CleanupStack::PopAndDestroy(header);

  1131 	}

  1132 	

  1133 void CTestDeliverMultiRecipientsOk_2::CheckDeliveredMessageL()