diff -r 4697dfb2d7ad -r 238255e8b033 messagingappbase/smsmtm/test/src/t_smsdeliver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/smsmtm/test/src/t_smsdeliver.cpp Fri Apr 16 14:56:15 2010 +0300 @@ -0,0 +1,2380 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "t_smsdeliver.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + +_LIT(KFailed,"Failed to complete tests."); +_LIT(KRecipientOk, "+447747065438"); // has to be valid number and switched on +_LIT(KRecipientBad, "+442071541467"); +_LIT(KRecipientFail, "+34933753717"); +_LIT(KMessageData, "This is a simple text message"); +_LIT(KTestDeliverOneRecipientOk, "Single recipient, deliver ok"); +_LIT(KTestDeliverOneRecipientFail, "Single recipient, deliver fail"); +_LIT(KTestDeliverMultiRecipientsOk_1, "Multi (2) recipients, deliver ok"); +_LIT(KTestDeliverMultiRecipientsOk_2, "Multi (2) recipients, deliver ok, but 1 fails to send"); +_LIT(KTestDeliverMultiRecipientsOk_3, "Multi (3) recipients, deliver ok, but 1 fails to send"); +_LIT(KTestDeliverNoMatching, "Single recipient, no matching"); +_LIT(KTestDeliverNoStatusReports, "Single recipient, no status reports"); +_LIT(KTestDeliverNotSent, "Single recipient, not sent"); +_LIT(KTestDeliverMultiRecipientsFail_1, "Multi (2) recipients, deliver failure"); +_LIT(KTestDeliverMultiRecipientsMixed_1,"Multi (2) recipients, 1 deliver ok, 1 deliver failure"); +_LIT(KTestDeliverMultiRecipientsMixed_2,"Multi (2) recipients, 2 deliver failures"); + +#if defined (__WINS__) +_LIT(KPddName,"ECDRV"); +_LIT(KLddName,"ECOMM"); +#else //__WINS__ +_LIT(KPddSirName,"ESIR"); +_LIT(KPddUartName,"ECUART4"); +_LIT(KLddName,"ECOMM"); +#endif //__WINS__ + +RTest test(_L("T_SmsDeliver Test Harness")); + +const TTimeIntervalMicroSeconds32 KWaitForWatchersToStart = 20000000; +const TTimeIntervalMicroSeconds32 KWaitForWatchersToStartDisplayInterval = 5000000; + +LOCAL_C void DoTestsL() + { +#if defined (__WINS__) + User::LoadPhysicalDevice(KPddName); + User::LoadLogicalDevice(KLddName); +#else //__WINS__ + User::LoadPhysicalDevice(KPddSirName); + User::LoadPhysicalDevice(KPddUartName); + User::LoadLogicalDevice(KLddName); +#endif //__WINS__ + + TInt r = StartC32(); + if( (r != KErrNone) && (r != KErrAlreadyExists) ) + test.Printf(_L("Failed to start C32 %d\n"), r); + + // Create and install the active scheduler + CActiveScheduler* scheduler= new (ELeave) CActiveScheduler(); + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + // Create the test engine + CTestEngine* testEngine = CTestEngine::NewL(); + CleanupStack::PushL(testEngine); + + // Do tests... + testEngine->DoTestsL(); + + CleanupStack::PopAndDestroy(2, scheduler); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* tc=CTrapCleanup::New(); + TRAPD(err,DoTestsL()); + if (err!=KErrNone) + User::Panic(KFailed, err); + delete tc; + test.Close(); + __UHEAP_MARKEND; + return KErrNone; + } + +/* + * CTestEngine + */ + +CTestEngine* CTestEngine::NewL() + { + CTestEngine* self = new (ELeave) CTestEngine(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestEngine::~CTestEngine() + { + delete iTestUtils; + delete iWatchers; + + iSocket.Close(); + iSocketServ.Close(); + } + +CTestEngine::CTestEngine() +: CBase() + { + } + +void CTestEngine::DoTestsL() + { + + CTestDeliverBase* testCase = NULL; + + testCase = CTestDeliverOneRecipientOk::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsOk_1::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsOk_2::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsOk_3::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverNoMatching::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverNoStatusReports::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverNotSent::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverOneRecipientFail::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsFail_1::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsMixed_1::NewL(*iTestUtils); + RunTestCaseL(*testCase); + + testCase = CTestDeliverMultiRecipientsMixed_2::NewL(*iTestUtils); + RunTestCaseL(*testCase); + } + +void CTestEngine::RunTestCaseL(CTestDeliverBase& aTestCase) + { + CleanupStack::PushL(&aTestCase); + aTestCase.Start(); + CActiveScheduler::Start(); + CleanupStack::PopAndDestroy(&aTestCase); + } + +void CTestEngine::ConstructL() + { + // This should create the SMS service, including the service settings. + iTestUtils = CSmsTestUtils::NewL(test); + + // Notify the system agent that the phone is on. + iTestUtils->NotifySaPhoneOnL(); + + // Tell the tests utils to log to file + iTestUtils->SetLogToFile(); + + // Restore the service settings. + iTestUtils->SetEntryL(iTestUtils->iSmsServiceId); + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iTestUtils->iServiceSettings); + + // Remove the default service centres from the service settings + TInt count = iTestUtils->iServiceSettings->ServiceCenterCount(); + while( count-- ) + { + iTestUtils->iServiceSettings->RemoveServiceCenter(count); + } + + // Add the Vodafone service centre - store the settings. + iTestUtils->iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+447785016005")); + + // Set delivery options - do matching and make reports visible. + iTestUtils->iServiceSettings->SetDeliveryReport(ETrue); + iTestUtils->iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch); + + account->SaveSettingsL(*iTestUtils->iServiceSettings); + CleanupStack::PopAndDestroy(account); + + // Create a session with the SMS stack - note order of the next few things + // is important. + User::LeaveIfError(iSocketServ.Connect()); + TProtocolDesc protoinfo; + TProtocolName protocolname(KSmsDatagram); + User::LeaveIfError(iSocketServ.FindProtocol(protocolname,protoinfo)); + User::LeaveIfError(iSocket.Open(iSocketServ,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol)); + + TSmsAddr smsaddr; + smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly); + User::LeaveIfError(iSocket.Bind(smsaddr)); + + // Initialise phone... + iTestUtils->WaitForInitializeL(); + + // Start watchers... + StartWatcherL(); + } + +TBool CTestEngine::WatchersAlreadyRunningL() + { + RSocketServ server; + RSocket socket; + + User::LeaveIfError(server.Connect()); + CleanupClosePushL(server); + + // test if it's there... + TProtocolDesc protoInfo; + TProtocolName protocolname; + protocolname.Copy(KSmsDatagram); + User::LeaveIfError(server.FindProtocol(protocolname,protoInfo)); + + User::LeaveIfError(socket.Open(server, + protoInfo.iAddrFamily, + protoInfo.iSockType, + protoInfo.iProtocol)); + CleanupClosePushL(socket); + + TSmsAddr addr; + addr.SetSmsAddrFamily(ESmsAddrRecvAny); + TInt err = socket.Bind(addr); + + CleanupStack::Pop(2, &server); + socket.CancelAll(); + socket.Close(); + server.Close(); + return (err == KErrAlreadyExists); + } + +void CTestEngine::StartWatcherL() + { + iTestUtils->Printf(_L("Start the Watcher")); + + if( WatchersAlreadyRunningL() ) + { + iTestUtils->Printf(_L("Watchers are already running\n")); + return; + } + + iWatchers = CTestUtilsWatcherStarter::NewL(); + + TTimeIntervalMicroSeconds32 wait = KWaitForWatchersToStart; + TBool started = EFalse; + while( !started && wait.Int() > 0 ) + { + iTestUtils->Printf(_L("Waiting %d secs for watchers to start...\n"), wait.Int() / 1000000); + wait = wait.Int() - KWaitForWatchersToStartDisplayInterval.Int(); + User::After(KWaitForWatchersToStartDisplayInterval); + started = WatchersAlreadyRunningL(); + } + + if( !WatchersAlreadyRunningL() ) + { + iTestUtils->Printf(_L("WARNING: NBS Watcher has not started yet\n")); + } + } + +/* + * CTestDeliverBase + */ + +CTestDeliverBase::~CTestDeliverBase() + { + delete iEntryForObserver; + delete iOperation; + } + +void CTestDeliverBase::Start() + { + iTestUtils.Printf(_L("Starting %S\n"), &TestName()); + iState = EClearFolders; + CompleteSelf(); + } + +CTestDeliverBase::CTestDeliverBase(CSmsTestUtils& aTestUtils) +: CActive(CActive::EPriorityStandard), iTestUtils(aTestUtils) + { + CActiveScheduler::Add(this); + } + +void CTestDeliverBase::ConstructL() + { + iEntryForObserver = Session().GetEntryL(KMsvGlobalInBoxIndexEntryId); + } + +void CTestDeliverBase::CompleteSelf() + { + TRequestStatus* pStat = &iStatus; + User::RequestComplete(pStat, KErrNone); + SetActive(); + } + +CMsvSession& CTestDeliverBase::Session() + { + return *iTestUtils.iMsvSession; + } + +CMsvEntry& CTestDeliverBase::MsvEntry() + { + return *iTestUtils.iMsvEntry; + } + +CSmsClientMtm& CTestDeliverBase::Client() + { + return *iTestUtils.iSmsClientMtm; + } + +CSmsSettings& CTestDeliverBase::ServiceSettings() + { + return *iTestUtils.iServiceSettings; + } + +void CTestDeliverBase::ClearFoldersL() + { + iTestUtils.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId); + iTestUtils.DeleteSmsMessagesL(KMsvGlobalInBoxIndexEntryId); + iTestUtils.DeleteSmsMessagesL(KMsvSentEntryId); + } + +void CTestDeliverBase::TestComplete() + { + iTestUtils.Printf(_L("Test Complete\n")); + CActiveScheduler::Stop(); + } + +void CTestDeliverBase::CreateMessageL() + { + iTestUtils.Printf(_L("Creating message...\n")); + + TMsvEntry entry; + entry.SetVisible(ETrue); + entry.SetInPreparation(ETrue); + entry.iServiceId = iTestUtils.iSmsServiceId; + entry.iType = KUidMsvMessageEntry; + entry.iMtm = KUidMsgTypeSMS; + entry.iDate.HomeTime(); + entry.iSize = 0; + entry.iDescription.Set(KNullDesC); + entry.iDetails.Set(KNullDesC); + + // Check send options... + TUint sendState = KMsvSendStateWaiting; + switch( ServiceSettings().Delivery() ) + { + case ESmsDeliveryScheduled: + sendState = KMsvSendStateScheduled; + break; + case ESmsDeliveryUponRequest: + sendState = KMsvSendStateUponRequest; + break; + default: + sendState = KMsvSendStateWaiting; + break; + } + entry.SetSendingState(sendState); + + // Create the SMS header object... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + // Set the body text... + iTestUtils.iRichText->Reset(); + iTestUtils.iRichText->InsertL(0, KMessageData); + + // Copy the message settings... + header->SetSmsSettingsL(ServiceSettings()); + + // Set the service centre + TInt defaultIndex = ServiceSettings().DefaultServiceCenter(); + header->SetServiceCenterAddressL(ServiceSettings().GetServiceCenter(defaultIndex).Address()); + + // Set recipient - ask derived class + SetRecipientsL(*header); + + // Update entry description and details... + CArrayPtrFlat& recipient = header->Recipients(); + entry.iDetails.Set(recipient[0]->Address()); + entry.iDescription.Set(iTestUtils.iRichText->Read(0, ServiceSettings().DescriptionLength())); + entry.SetInPreparation(EFalse); + + // Create the entry - set context to the global outbox. + MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId); + MsvEntry().CreateL(entry); + + // Create new store and save header information + MsvEntry().SetEntryL(entry.Id()); + CMsvStore* store = MsvEntry().EditStoreL(); + CleanupStack::PushL(store); + header->StoreL(*store); + store->StoreBodyTextL(*iTestUtils.iRichText); + store->CommitL(); + CleanupStack::PopAndDestroy(2, header); + + iMessageId = entry.Id(); + } + +void CTestDeliverBase::SendMessageL() + { + iTestUtils.Printf(_L("Sending message %d\n"), iMessageId); + + delete iOperation; + iOperation = NULL; + + CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection(); + CleanupStack::PushL(sel); + sel->AppendL(iMessageId); + + iTestUtils.DisplayMessageL(iMessageId); + + MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId); + iOperation = MsvEntry().CopyL(*sel, iTestUtils.iSmsServiceId, iStatus); + CleanupStack::PopAndDestroy(sel); + + SetActive(); + } + +void CTestDeliverBase::ChangeServiceSettingsL() + { + // Restore the service settings. + iTestUtils.SetEntryL(iTestUtils.iSmsServiceId); + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iTestUtils.iServiceSettings); + + // Set the service settings + iTestUtils.iServiceSettings->SetValidityPeriod(TTimeIntervalMinutes(5)); + iTestUtils.iServiceSettings->SetDeliveryReport(ETrue); + iTestUtils.iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch); + + // Store the new service settings + account->SaveSettingsL(*iTestUtils.iServiceSettings); + CleanupStack::PopAndDestroy(account); + } + +void CTestDeliverBase::CheckCreatedMessageL() + { + // Need to check the following - + // 1. All recipients have correct delivery status - ENoAckRequested. + // 2. The index summary is correct - ENoAckSummary + // 3. The index message IS is invalid. + + iTestUtils.Printf(_L("Checking created message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + TInt rcptCount = header->Recipients().Count(); + for( TInt ii = 0; ii < rcptCount; ++ii ) + { + CSmsNumber* rcpt = header->Recipients()[ii]; + iTestUtils.Printf(_L("--Recipient %d - Delivery status -> %d - should be %d (ENoAckRequested)\n"), ii, rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + } + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (ENoAckSummary)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::ENoAckSummary); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::ENoAckSummary); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +TMsvId CTestDeliverBase::GetObserverEntry() + { + return iMessageId; + } + +// methods from CActive + +void CTestDeliverBase::RunL() + { + User::LeaveIfError(iStatus.Int()); + + switch( iState ) + { + case EClearFolders: + { + ClearFoldersL(); + iState = EChangeServiceSettings; + CompleteSelf(); + } break; + case EChangeServiceSettings: + { + ChangeServiceSettingsL(); + iState = ECreateMessage; + CompleteSelf(); + } break; + case ECreateMessage: + { + CreateMessageL(); + iState = ECheckCreatedMessage; + CompleteSelf(); + } break; + case ECheckCreatedMessage: + { + CheckCreatedMessageL(); + iState = ESendMessage; + CompleteSelf(); + } break; + case ESendMessage: + { + SendMessageL(); + iState = ECheckSentMessage; + } break; + case ECheckSentMessage: + { + CheckSentMessageL(); + + TMsvId entryId = GetObserverEntry(); + + if( entryId != KMsvNullIndexEntryId ) + { + // Need to observe something - move observer entry to specified entry + // and wait for it to be updated + iEntryForObserver->SetEntryL(entryId); + iEntryForObserver->AddObserverL(*this); + + iState = EPendingDeliveryReport; + } + else + { + // Not observing anything - end of test. + TestComplete(); + } + } break; + case EPendingDeliveryReport: + { + // End the test... + TestComplete(); + } break; + default: + User::Invariant(); + break; + } + } + +void CTestDeliverBase::DoCancel() + { + } + +TInt CTestDeliverBase::RunError(TInt /*aError*/) + { + return KErrNone; + } + +// methods from MMsvEntryObserver + +void CTestDeliverBase::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) + { + __ASSERT_DEBUG( iState == EPendingDeliveryReport, User::Invariant() ); + + if( aEvent == EMsvEntryChanged ) + { + iTestUtils.Printf(_L("Message entry has been updated\n")); + + // Check that the sent message has been updated. + CheckDeliveredMessageL(); + } + } + +/* + * CTestDeliverOneRecipientOk + */ + + CTestDeliverOneRecipientOk* CTestDeliverOneRecipientOk::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverOneRecipientOk* self = new (ELeave) CTestDeliverOneRecipientOk(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverOneRecipientOk::~CTestDeliverOneRecipientOk() + { + } + +CTestDeliverOneRecipientOk::CTestDeliverOneRecipientOk(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverOneRecipientOk::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting single recipient\n")); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt); + CleanupStack::Pop(rcpt); + } + +void CTestDeliverOneRecipientOk::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt->LogId()); + iTestUtils.Test()(logId == rcpt->LogId()); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverOneRecipientOk::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful); + + // Test is no ended - complete self to stop. + CompleteSelf(); + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverOneRecipientOk::TestName() + { + return KTestDeliverOneRecipientOk(); + } + +/* + * CTestDeliverOneRecipientFail + */ + + CTestDeliverOneRecipientFail* CTestDeliverOneRecipientFail::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverOneRecipientFail* self = new (ELeave) CTestDeliverOneRecipientFail(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverOneRecipientFail::~CTestDeliverOneRecipientFail() + { + } + +CTestDeliverOneRecipientFail::CTestDeliverOneRecipientFail(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverOneRecipientFail::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting single recipient\n")); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt); + CleanupStack::Pop(rcpt); + } + +void CTestDeliverOneRecipientFail::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt->LogId()); + iTestUtils.Test()(logId == rcpt->LogId()); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverOneRecipientFail::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EAckError)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("- Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("- Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllFailed)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllFailed); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllFailed); + + // Test is no ended - complete self to stop. + CompleteSelf(); + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverOneRecipientFail::TestName() + { + return KTestDeliverOneRecipientFail(); + } + +/* + * CTestDeliverMultiRecipientsOk_1 + */ + +CTestDeliverMultiRecipientsOk_1* CTestDeliverMultiRecipientsOk_1::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsOk_1* self = new (ELeave) CTestDeliverMultiRecipientsOk_1(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsOk_1::~CTestDeliverMultiRecipientsOk_1() + { + } + +CTestDeliverMultiRecipientsOk_1::CTestDeliverMultiRecipientsOk_1(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsOk_1::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (2) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + } + +void CTestDeliverMultiRecipientsOk_1::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsOk_1::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + + TMsvSmsEntry entry = MsvEntry().Entry(); + + if( iCheckCount == 1 ) + { + // At least one of the recipients has been delivered to ok - check the + // status of recipient 0 and make decisions based on that. + CSmsNumber* pendingRcpt = NULL; + + if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck ) + { + // Recipient 1 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + pendingRcpt = rcpt0; + } + else + { + // Recipient 0 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + pendingRcpt = rcpt1; + } + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId()); + iTestUtils.Test()(logId == pendingRcpt->LogId()); + } + else + { + // Both recipients has been delivered to ok - check the status of both + // recipients + iTestUtils.Printf(_L("--Second check of flags -> both recipients have been delivered to\n")); + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful); + + // Test is no ended - complete self to stop. + CompleteSelf(); + } + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsOk_1::TestName() + { + return KTestDeliverMultiRecipientsOk_1(); + } + +/* + * CTestDeliverMultiRecipientsOk_2 + */ + +CTestDeliverMultiRecipientsOk_2* CTestDeliverMultiRecipientsOk_2::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsOk_2* self = new (ELeave) CTestDeliverMultiRecipientsOk_2(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsOk_2::~CTestDeliverMultiRecipientsOk_2() + { + } + +CTestDeliverMultiRecipientsOk_2::CTestDeliverMultiRecipientsOk_2(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsOk_2::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (2) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientBad); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + } + +void CTestDeliverMultiRecipientsOk_2::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt0->LogId()); + iTestUtils.Test()(logId == rcpt0->LogId()); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsOk_2::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful); + + // Test is no ended - complete self to stop. + CompleteSelf(); + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsOk_2::TestName() + { + return KTestDeliverMultiRecipientsOk_2(); + } + +/* + * CTestDeliverMultiRecipientsOk_3 + */ + +CTestDeliverMultiRecipientsOk_3* CTestDeliverMultiRecipientsOk_3::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsOk_3* self = new (ELeave) CTestDeliverMultiRecipientsOk_3(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsOk_3::~CTestDeliverMultiRecipientsOk_3() + { + } + +CTestDeliverMultiRecipientsOk_3::CTestDeliverMultiRecipientsOk_3(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsOk_3::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (3) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + + CSmsNumber* rcpt2 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt2); + rcpt2->SetAddressL(KRecipientBad); + aHeader.Recipients().AppendL(rcpt2); + CleanupStack::Pop(rcpt2); + } + +void CTestDeliverMultiRecipientsOk_3::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 3); + iTestUtils.Test()(header->Recipients().Count() == 3); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt2 = header->Recipients()[2]; + + iTestUtils.Printf(_L("--Recipient 2 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt2->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt2->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsOk_3::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 3); + iTestUtils.Test()(header->Recipients().Count() == 3); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + CSmsNumber* rcpt2 = header->Recipients()[2]; + + TMsvSmsEntry entry = MsvEntry().Entry(); + + if( iCheckCount == 1 ) + { + // At least one of the recipients has been delivered to ok - check the + // status of recipient 0 and make decisions based on that. + CSmsNumber* pendingRcpt = NULL; + + if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck ) + { + // Recipient 2 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 2 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt2->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt2->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + pendingRcpt = rcpt0; + } + else + { + // Recipient 0 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 2 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt2->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt2->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + pendingRcpt = rcpt1; + } + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId()); + iTestUtils.Test()(logId == pendingRcpt->LogId()); + } + else + { + // Both recipients has been delivered to ok - check the status of both + // recipients + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Recipient 2 - Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt2->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt2->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllSuccessful)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllSuccessful); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllSuccessful); + + // Test is no ended - complete self to stop. + CompleteSelf(); + } + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsOk_3::TestName() + { + return KTestDeliverMultiRecipientsOk_3(); + } + +/* + * CTestDeliverNoMatching + */ + + CTestDeliverNoMatching* CTestDeliverNoMatching::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverNoMatching* self = new (ELeave) CTestDeliverNoMatching(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverNoMatching::~CTestDeliverNoMatching() + { + } + +CTestDeliverNoMatching::CTestDeliverNoMatching(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from MMsvEntryObserver + +void CTestDeliverNoMatching::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/) + { + if( aEvent == EMsvNewChildren ) + { + iTestUtils.Printf(_L("Received new message in Inbox - should be status report...\n")); + + CMsvEntrySelection* sel = static_cast(aArg1); + + // Check how many mesasges there are - should be just 1 + TInt count = sel->Count(); + + iTestUtils.Printf(_L("--Number of new messages -> %d - should be %d\n"), count, 1); + iTestUtils.Test()(count == 1); + + // Restore the message + + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL((*sel)[0]); + CMsvStore* store = MsvEntry().ReadStoreL(); + CleanupStack::PushL(store); + + header->RestoreL(*store); + iTestUtils.iRichText->Reset(); + store->RestoreBodyTextL(*iTestUtils.iRichText); + + CleanupStack::PopAndDestroy(store); + + // Check that it's a Status Report... + iTestUtils.Printf(_L("--Message type -> %d - should be %d\n"), header->Type(), CSmsPDU::ESmsStatusReport); + iTestUtils.Test()(header->Type() == CSmsPDU::ESmsStatusReport); + + // Check the message reference + TLogId logId = header->Message().LogServerId(); + iTestUtils.Printf(_L("--Log Server Id -> %d - should be %d\n"), logId, iLogId); + iTestUtils.Test()(logId == iLogId); + + // Check the deliver status + CSmsStatusReport& report = header->StatusReport(); + iTestUtils.Printf(_L("--Deliver status -> %d - should be %d (ESmsShortMessageReceivedBySME)\n"), report.Status(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(report.Status() == TSmsStatus::ESmsShortMessageReceivedBySME); + + CleanupStack::PopAndDestroy(header); + + // Check that the sent message has been updated. + CheckDeliveredMessageL(); + } + } + +// methods from CTestDeliverBase + +void CTestDeliverNoMatching::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting single recipient\n")); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt); + CleanupStack::Pop(rcpt); + } + +void CTestDeliverNoMatching::ChangeServiceSettingsL() + { + // Restore the service settings. + iTestUtils.SetEntryL(iTestUtils.iSmsServiceId); + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iTestUtils.iServiceSettings); + + // Set the service settings + iTestUtils.iServiceSettings->SetValidityPeriod(TTimeIntervalMinutes(5)); + iTestUtils.iServiceSettings->SetDeliveryReport(ETrue); + iTestUtils.iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible); + + // Store the new service settings + account->SaveSettingsL(*iTestUtils.iServiceSettings); + CleanupStack::PopAndDestroy(account); + } + +TMsvId CTestDeliverNoMatching::GetObserverEntry() + { + return KMsvGlobalInBoxIndexEntryId; + } + +void CTestDeliverNoMatching::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, rcpt->LogId()); + iTestUtils.Test()(logId == rcpt->LogId()); + + iLogId = rcpt->LogId(); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverNoMatching::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + // Test is no ended - complete self to stop. + CompleteSelf(); + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverNoMatching::TestName() + { + return KTestDeliverNoMatching(); + } + +/* + * CTestDeliverNoStatusReports + */ + + CTestDeliverNoStatusReports* CTestDeliverNoStatusReports::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverNoStatusReports* self = new (ELeave) CTestDeliverNoStatusReports(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverNoStatusReports::~CTestDeliverNoStatusReports() + { + } + +CTestDeliverNoStatusReports::CTestDeliverNoStatusReports(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverNoStatusReports::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting single recipient\n")); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt); + CleanupStack::Pop(rcpt); + } + +void CTestDeliverNoStatusReports::ChangeServiceSettingsL() + { + // Restore the service settings. + iTestUtils.SetEntryL(iTestUtils.iSmsServiceId); + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iTestUtils.iServiceSettings); + + // Set the service settings + iTestUtils.iServiceSettings->SetValidityPeriod(TTimeIntervalMinutes(5)); + iTestUtils.iServiceSettings->SetDeliveryReport(EFalse); + iTestUtils.iServiceSettings->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch); + + // Store the new service settings + account->SaveSettingsL(*iTestUtils.iServiceSettings); + CleanupStack::PopAndDestroy(account); + } + +TMsvId CTestDeliverNoStatusReports::GetObserverEntry() + { + return KMsvNullIndexEntryId; + } + +void CTestDeliverNoStatusReports::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (ENoAckSummary)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::ENoAckSummary); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::ENoAckSummary); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverNoStatusReports::CheckDeliveredMessageL() + { + User::Invariant(); + } + +const TDesC& CTestDeliverNoStatusReports::TestName() + { + return KTestDeliverNoStatusReports(); + } + +/* + * CTestDeliverNotSent + */ + + CTestDeliverNotSent* CTestDeliverNotSent::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverNotSent* self = new (ELeave) CTestDeliverNotSent(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverNotSent::~CTestDeliverNotSent() + { + } + +CTestDeliverNotSent::CTestDeliverNotSent(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverNotSent::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting single recipient\n")); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(KRecipientBad); + aHeader.Recipients().AppendL(rcpt); + CleanupStack::Pop(rcpt); + } + +TMsvId CTestDeliverNotSent::GetObserverEntry() + { + return KMsvNullIndexEntryId; + } + +void CTestDeliverNotSent::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 1); + iTestUtils.Test()(header->Recipients().Count() == 1); + + CSmsNumber* rcpt = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Delivery status -> %d - should be %d (ENoAckRequested)\n"), rcpt->AckStatus(ESmsAckTypeDelivery), CSmsNumber::ENoAckRequested); + iTestUtils.Test()(rcpt->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::ENoAckRequested); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (ENoAckSummary)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::ENoAckSummary); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::ENoAckSummary); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverNotSent::CheckDeliveredMessageL() + { + User::Invariant(); + } + +const TDesC& CTestDeliverNotSent::TestName() + { + return KTestDeliverNotSent(); + } + +/* + * CTestDeliverMultiRecipientsFail_1 + */ + +CTestDeliverMultiRecipientsFail_1* CTestDeliverMultiRecipientsFail_1::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsFail_1* self = new (ELeave) CTestDeliverMultiRecipientsFail_1(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsFail_1::~CTestDeliverMultiRecipientsFail_1() + { + } + +CTestDeliverMultiRecipientsFail_1::CTestDeliverMultiRecipientsFail_1(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsFail_1::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (3) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + } + +void CTestDeliverMultiRecipientsFail_1::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsFail_1::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + TMsvSmsEntry entry = MsvEntry().Entry(); + + if( iCheckCount == 1 ) + { + // At least one of the recipients has been delivered to ok - check the + // status of recipient 0 and make decisions based on that. + CSmsNumber* pendingRcpt = NULL; + + if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck ) + { + // Recipient 2 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 1 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt1->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt1->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 1 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt1->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt1->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + pendingRcpt = rcpt0; + } + else + { + // Recipient 0 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + pendingRcpt = rcpt1; + } + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId()); + iTestUtils.Test()(logId == pendingRcpt->LogId()); + } + else + { + // Both recipients has been delivered to ok - check the status of both + // recipients + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 1 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt1->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt1->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 1 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt1->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt1->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllFailed)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllFailed); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllFailed); + + // Test is no ended - complete self to stop. + CompleteSelf(); + } + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsFail_1::TestName() + { + return KTestDeliverMultiRecipientsFail_1(); + } + +/* + * CTestDeliverMultiRecipientsMixed_1 + */ + +CTestDeliverMultiRecipientsMixed_1* CTestDeliverMultiRecipientsMixed_1::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsMixed_1* self = new (ELeave) CTestDeliverMultiRecipientsMixed_1(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsMixed_1::~CTestDeliverMultiRecipientsMixed_1() + { + } + +CTestDeliverMultiRecipientsMixed_1::CTestDeliverMultiRecipientsMixed_1(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsMixed_1::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (3) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientOk); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + } + +void CTestDeliverMultiRecipientsMixed_1::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsMixed_1::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + + TMsvSmsEntry entry = MsvEntry().Entry(); + + if( iCheckCount == 1 ) + { + // At least one of the recipients has been delivered to ok - check the + // status of recipient 0 and make decisions based on that. + CSmsNumber* pendingRcpt = NULL; + + if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck ) + { + // Recipient 2 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + pendingRcpt = rcpt0; + } + else + { + // Recipient 0 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + pendingRcpt = rcpt1; + } + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId()); + iTestUtils.Test()(logId == pendingRcpt->LogId()); + } + else + { + // Status-reports for both recipients have been received - check the + // status of both recipients. + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckSuccessful)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckSuccessful); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckSuccessful); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EMixed)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EMixed); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EMixed); + + // Test is no ended - complete self to stop. + CompleteSelf(); + } + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsMixed_1::TestName() + { + return KTestDeliverMultiRecipientsMixed_1(); + } + +/* + * CTestDeliverMultiRecipientsMixed_2 + */ + +CTestDeliverMultiRecipientsMixed_2* CTestDeliverMultiRecipientsMixed_2::NewL(CSmsTestUtils& aTestUtils) + { + CTestDeliverMultiRecipientsMixed_2* self = new (ELeave) CTestDeliverMultiRecipientsMixed_2(aTestUtils); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CTestDeliverMultiRecipientsMixed_2::~CTestDeliverMultiRecipientsMixed_2() + { + } + +CTestDeliverMultiRecipientsMixed_2::CTestDeliverMultiRecipientsMixed_2(CSmsTestUtils& aTestUtils) +: CTestDeliverBase(aTestUtils) + { + } + +// methods from CTestDeliverBase + +void CTestDeliverMultiRecipientsMixed_2::SetRecipientsL(CSmsHeader& aHeader) + { + iTestUtils.Printf(_L("--Setting multiple (2) recipients\n")); + + CSmsNumber* rcpt0 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt0); + rcpt0->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt0); + CleanupStack::Pop(rcpt0); + + CSmsNumber* rcpt1 = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt1); + rcpt1->SetAddressL(KRecipientFail); + aHeader.Recipients().AppendL(rcpt1); + CleanupStack::Pop(rcpt1); + } + +void CTestDeliverMultiRecipientsMixed_2::CheckSentMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipients have delivery status correctly set + // 3. The index summary is correctly set + // 4. The index message ID is valid. + // 5. The index message ID matches that of the recipient + + iTestUtils.Printf(_L("Checking sent message %d has correct flags set...\n"), iMessageId); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + CSmsNumber* rcpt1 = header->Recipients()[1]; + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + TMsvSmsEntry entry = MsvEntry().Entry(); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EPendingAcks)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EPendingAcks); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EPendingAcks); + + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should be %d\n"), validId, EFalse); + iTestUtils.Test()(validId == EFalse); + + CleanupStack::PopAndDestroy(header); + } + +void CTestDeliverMultiRecipientsMixed_2::CheckDeliveredMessageL() + { + // Need to check the following - + // 1. Correct number of recipients + // 2. The recipient has delivery status is correctly set + // 3. The index summary is correctly set + + iTestUtils.Printf(_L("Checking delivered message %d has correct flags set - round %d...\n"), iMessageId, ++iCheckCount); + + // Restore the recipient... + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils.iRichText); + CleanupStack::PushL(header); + + MsvEntry().SetEntryL(KMsvGlobalInBoxIndexEntryId); + MsvEntry().SetEntryL(iMessageId); + CMsvStore* store = iTestUtils.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + iTestUtils.Printf(_L("--Number of recipients -> %d - should be %d\n"), header->Recipients().Count(), 2); + iTestUtils.Test()(header->Recipients().Count() == 2); + + CSmsNumber* rcpt0 = header->Recipients()[0]; + CSmsNumber* rcpt1 = header->Recipients()[1]; + + TMsvSmsEntry entry = MsvEntry().Entry(); + + if( iCheckCount == 1 ) + { + // At least one of the recipients has been delivered to ok - check the + // status of recipient 0 and make decisions based on that. + CSmsNumber* pendingRcpt = NULL; + + if( rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck ) + { + // Recipient 2 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 1 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt1->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt1->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 1 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt1->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt1->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + + pendingRcpt = rcpt0; + } + else + { + // Recipient 0 delivered to first... + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EPendingAck)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EPendingAck); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EPendingAck); + + pendingRcpt = rcpt1; + } + TLogId logId = 0; + TBool validId = entry.MessageId(logId); + + iTestUtils.Printf(_L("--Index message Id validity -> %d - should NOT be %d\n"), validId, EFalse); + iTestUtils.Test()(validId != EFalse); + + iTestUtils.Printf(_L("--Index message Id -> %d - should be %d\n"), logId, pendingRcpt->LogId()); + iTestUtils.Test()(logId == pendingRcpt->LogId()); + } + else + { + // Status-reports for both recipients have been received - check the + // status of both recipients. + iTestUtils.Printf(_L("--Recipient 0 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt0->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt0->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 0 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt0->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt0->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 0 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt0->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt0->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Recipient 1 - Delivery status -> %d - should be %d (EAckError)\n"), rcpt1->AckStatus(ESmsAckTypeDelivery), CSmsNumber::EAckError); + iTestUtils.Test()(rcpt1->AckStatus(ESmsAckTypeDelivery) == CSmsNumber::EAckError); + + iTestUtils.Printf(_L("--Recipient 1 - Recipient status -> %d - should be %d (EFailedToSend)\n"), rcpt1->Status(), CMsvRecipient::EFailedToSend); + iTestUtils.Test()(rcpt1->Status()==CMsvRecipient::EFailedToSend); + + iTestUtils.Printf(_L("--Recipient 1 - Error status -> %d - should not be %d (ESmsShortMessageReceivedBySME)\n"), rcpt1->Error(), TSmsStatus::ESmsShortMessageReceivedBySME); + iTestUtils.Test()(rcpt1->Error()!= TSmsStatus::ESmsShortMessageReceivedBySME); + + iTestUtils.Printf(_L("--Index summary -> %d - should be %d (EAllFailed)\n"), entry.AckSummary(ESmsAckTypeDelivery), TMsvSmsEntry::EAllFailed); + iTestUtils.Test()(entry.AckSummary(ESmsAckTypeDelivery) == TMsvSmsEntry::EAllFailed); + + // Test is no ended - complete self to stop. + CompleteSelf(); + } + + CleanupStack::PopAndDestroy(header); + } + +const TDesC& CTestDeliverMultiRecipientsMixed_2::TestName() + { + return KTestDeliverMultiRecipientsMixed_2(); + }