void CMtfTestActionDeleteEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeleteEntry);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramEntryId);
entry->SetEntryL(entry->Entry().Parent());
if (entry->OwningService() == KMsvLocalServiceIndexEntryId)
{
entry->DeleteL(paramEntryId);
DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TestCase().ActionCompletedL(*this);
}
else
{
iOperation = entry->DeleteL(paramEntryId,iStatus);
SetActive();
}
CleanupStack::PopAndDestroy(entry);
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeleteEntry);
}
/**
doTestStepL()
Performs the comparison of POP messages
@return
Returns the teststep result.
*/
TVerdict CT_MsgComparePopEmailMsgs::doTestStepL()
{
INFO_PRINTF1(_L("Test Step: Compare Pop Email Msgs"));
if(LoadParametersL())
{
User::LeaveIfError(iFs.Connect());
CleanupClosePushL(iFs);
// Normally do not push an object that is a data member of another object.
// But in this case we want to close early if we get a leave.
// Otherwise the iFs would be open till the thread had begun to die.
if(TestStepResult() == EPass)
{
CMsvEntry* recvMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(recvMsvEntry);
CMsvEntry* sentMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(sentMsvEntry);
for(TInt i = 0;i < iInboxSelectionList->Count();i++)
{
recvMsvEntry->SetEntryL(iInboxSelectionList->At(i));
TMsvEntry recvEntry = recvMsvEntry->Entry();
for(TInt j = 0;j < iSentSelectionList->Count();j++)
{
sentMsvEntry->SetEntryL(iSentSelectionList->At(j));
TMsvEntry sentEntry = sentMsvEntry->Entry();
if(recvEntry.iDescription.Compare(sentEntry.iDescription) == 0)
{
CExpPop3MailInfo* pExpMailInfo = NULL;
for(int k = 0;k < iExpResults.Count();k++)
{
if(iExpResults[k]->GetDescription().Compare(recvEntry.iDescription) == 0)
{
pExpMailInfo = iExpResults[k];
break;
}
}
if(! pExpMailInfo)
{
ERR_PRINTF2(_L("Test %d failed could not retrieve expected mail info"), j+1);
SetTestStepResult(EFail);
break;
}
if(! DoCompareL(recvEntry, *pExpMailInfo, sentEntry))
{
INFO_PRINTF2(_L("Test %d failed"), j + 1);
SetTestStepResult(EFail);
}
}
}
}
CleanupStack::PopAndDestroy(2, recvMsvEntry); // recvMsvEntry, sentMsvEntry
}
CleanupStack::PopAndDestroy();
}
INFO_PRINTF1(_L("T_ComparePopEmailMsgs Completed"));
return TestStepResult();
}
TInt CMtfTestActionCheckChildrenCountWithFlagBase::CountChildrenL(TMsvId aParent, CMsvSession& aSession)
{
TInt children = 0;
// Get children at this level
CMsvEntry* entryContext = CMsvEntry::NewL(aSession, aParent,
TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
CleanupStack::PushL(entryContext);
entryContext->SetEntryL(aParent);
TMsvSelectionOrdering order;
order.SetShowInvisibleEntries(ETrue);
entryContext->SetSortTypeL(order);
CMsvEntrySelection* selection = entryContext->ChildrenL();
CleanupStack::PushL(selection);
// for each child
TInt count=selection->Count();
for(TInt child=0;child<count;child++)
{
entryContext->SetEntryL((*selection)[child]);
TMsvEntry entry=entryContext->Entry();
if (entry.iType==KUidMsvMessageEntry && FlagIsSet(entry) )
{
++children;
}
// if this is a folder then recurse
if (entry.iType==KUidMsvFolderEntry)
children +=CountChildrenL((*selection)[child], aSession);
}
CleanupStack::PopAndDestroy(2); // selection,entryContext
return children;
}
LOCAL_C void TestReadOnlyDeletionL()
{
CDummyObserver* ob = new(ELeave)CDummyObserver;
CleanupStack::PushL(ob);
CMsvSession* session = CMsvSession::OpenSyncL(*ob);
CleanupStack::PushL(session);
CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
// Create an entry
TMsvEntry entry;
entry.iType = KUidMsvMessageEntry;
entry.iMtm = KUidMsvLocalServiceMtm;
entry.iServiceId = KMsvLocalServiceIndexEntryId;
cEntry->CreateL(entry);
// Generate name of attachment
cEntry->SetEntryL(entry.Id());
TFileName fileName;
fileName.Append(_L("Test"));
CMsvStore* store = cEntry->EditStoreL();
CleanupStack::PushL(store);
CAsyncWaiter* waiter = CAsyncWaiter::NewL();
CleanupStack::PushL(waiter);
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachment);
fileName.Append(_L("Test"));
attachment->SetAttachmentNameL(fileName);
RFile file;
store->AttachmentManagerL().CreateAttachmentL(fileName, file, attachment, waiter->iStatus);
CleanupStack::Pop(attachment); // ownership passed
waiter->StartAndWait();
User::LeaveIfError(waiter->Result());
CleanupStack::PopAndDestroy(waiter);
CleanupClosePushL(file);
User::LeaveIfError(file.Write(_L8("some text")));
User::LeaveIfError(file.SetAtt(KEntryAttReadOnly, KEntryAttNormal));
CleanupStack::PopAndDestroy(2, store); // file, store
// Now try and delete the file
cEntry->SetEntryL(entry.Parent());
cEntry->DeleteL(entry.Id());
CleanupStack::PopAndDestroy(3); // cEntry, session, ob
}
/**
Delete Existing Service
@param aSession Current Session reference
@internalTechnology
*/
void CentralRepoUtils::DeleteServiceL(CMsvSession* aSession)
{
TMsvId serviceId;
TRAPD(err,TSmsUtilities::ServiceIdL(*aSession,serviceId));
if(err !=KErrNotFound)
{
CMsvEntry* entry = CMsvEntry::NewL(*aSession,serviceId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(serviceId);
entry->SetEntryL(entry->Entry().Parent());
entry->DeleteL(serviceId);
CleanupStack::PopAndDestroy(entry);
}
}
/**
GetMessagePartIndexL()
Retrieves the part index id for the email identified by aEntry
@param aEntry
A valid email identifier
@param aUid
An identifier tfor the type of message part to be retrieved
@return
TMsvId - message part identifier
*/
TMsvId CT_MsgComparePopEmailMsgs::GetMessagePartIndexL(TMsvEntry& aEntry, TUid aUid)
{
static TBool msgPartFound = EFalse;
TMsvId msgPartId = 0;
CMsvEntry* baseEntry = iSharedDataPOP.iSession->GetEntryL(aEntry.Id());
CleanupStack::PushL(baseEntry);
CMsvEntrySelection* selection = baseEntry->ChildrenL();
CleanupStack::PushL(selection);
TInt count = selection->Count();
TInt ind1;
CMsvEntry* entry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(entry);
for (ind1=0, msgPartFound=EFalse; ind1 < count; ind1++)
{
if(msgPartFound)
{
break;
}
TMsvId childId = selection->At(ind1);
entry->SetEntryL(childId);
if (entry->Entry().iType == aUid)
{
msgPartId = childId;
break;
}
else if (entry->Entry().iType == KUidMsvFolderEntry)
{
TMsvEntry ent = entry->Entry();
msgPartId = GetMessagePartIndexL(ent, aUid);
}
}
CleanupStack::PopAndDestroy(3, baseEntry); // entry,selection,baseEntry
return msgPartId;
}
void CScheduleTestActive::HandleSessionEventL(TMsvSessionEvent eventType, TAny* p1, TAny*, TAny*)
{
if (iStopAtRunL) return;
if (eventType != EMsvEntriesCreated) return;
CMsvEntrySelection* entries = STATIC_CAST(CMsvEntrySelection*, p1);
CMsvEntry* cEntry = iSession.GetEntryL((*entries)[0]);
CleanupStack::PushL(cEntry);
TMsvEntry entry(cEntry->Entry());
if(entry.iDetails == KSchSendTestDetails)
{
iTest.Printf(_L("Scheduled message has been sent\n"));
//We found the right message!
CActiveScheduler::Stop();
//Delete the new message
CMsvOperationWait* wait = CMsvOperationWait::NewLC();
wait->Start();
cEntry->SetEntryL(entry.Parent());
CMsvOperation* op = cEntry->DeleteL(entry.Id(), wait->iStatus);
CActiveScheduler::Start();
delete op;
CleanupStack::PopAndDestroy(wait);
}
CleanupStack::PopAndDestroy(cEntry);
}
void CT_CMsvSession::TestIncPcSyncCountL()
{
TInt error = KErrGeneral;
INFO_PRINTF1(_L("Testing: Increment PC Sync Count -- started"));
TRAP(error, iSession = CMsvSession::OpenSyncL(*this));
TEST(error == KErrNone);
CMsvOperationWait* active = CMsvOperationWait::NewLC();
CMsvEntry* cEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
CleanupStack::PushL(selection);
TInt ret = iSession->InstallMtmGroup(KDataComponentFilename);
TEST(ret==KErrNone|| ret==KErrAlreadyExists);
cEntry->SetEntryL(KMsvRootIndexEntryId);
TMsvEntry service;
service.iType=KUidMsvServiceEntry;
service.iMtm = KUidTestServerMtmType;
cEntry->CreateL(service);
selection->AppendL(service.Id());
TBuf8<256> progress;
TBuf8<32> param;
TRAP(error, iSession->IncPcSyncCountL(*selection);)
void CMtfTestActionSetUserResponse::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSetUserResponse);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession> (TestCase(),ActionParameters().Parameter(0));
TInt paramUserResponse = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(1),EFalse);
CMsvEntry* cEntry = CMsvEntry::NewL(*paramSession, KMsvDraftEntryId,
TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = cEntry->ChildrenL();
CleanupStack::PushL(selection);
TestCase().INFO_PRINTF2(_L("Count of Draft Folder's selection is %d"),selection->Count());
if (selection->Count() == 0)
{
User::Leave(KErrNotFound);
}
cEntry->SetEntryL((*selection)[0]);
if (!paramUserResponse)
{
TMsvEntry entry = cEntry->Entry();
entry.iError = KErrCancel;
cEntry->ChangeL(entry);
}
CleanupStack::PopAndDestroy(2);
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSetUserResponse);
TestCase().ActionCompletedL(*this);
}
void CheckNoAttachmentsL()
{
CDummyObserver* ob1 = new(ELeave) CDummyObserver;
CleanupStack::PushL(ob1);
CMsvSession* session = CMsvSession::OpenSyncL(*ob1);
CleanupStack::PushL(session);
CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId,
TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = cEntry->ChildrenL();
CleanupStack::PushL(selection);
test(selection->Count() == 1);
cEntry->SetEntryL((*selection)[0]);
if (cEntry->HasStoreL())
{
CMsvStore* store = cEntry->ReadStoreL();
CleanupStack::PushL(store);
MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
test(attachmentMgr.AttachmentCount() == 0);
CleanupStack::PopAndDestroy(store);
}
CleanupStack::PopAndDestroy(4, ob1); // selection, cEntry, session, ob1
}
void CMtfTestActionCopyEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCopyEntry);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TMsvId paramTargetId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramEntryId);
entry->SetEntryL(entry->Entry().Parent());
iOperation = entry->CopyL(paramEntryId,paramTargetId,iStatus);
CleanupStack::PopAndDestroy(entry);
CActiveScheduler::Add(this);
SetActive();
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCopyEntry);
}
void CMtfTestActionDeletePop3Service::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeletePop3Service);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramServiceId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramServiceId);
entry->SetEntryL(entry->Entry().Parent());
entry->DeleteL(paramServiceId);
CleanupStack::PopAndDestroy(entry);
DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeletePop3Service);
TestCase().ActionCompletedL(*this);
}
CMsvOperation* CTextMtmClient::ForwardL(TMsvId aForwardEntryId, TMsvPartList aPartList,
TRequestStatus& aCompletionStatus)
// Create forwarded message
// Destination folder is aForwardEntryL
//
{
__ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(ETxtcNoCMsvEntrySet));
__ASSERT_DEBUG(iMsvEntry->Entry().iType.iUid == KUidMsvMessageEntryValue, gPanic(ETxtcEntryTypeNotSupported));
__ASSERT_DEBUG(iMsvEntry->Entry().iServiceId == KMsvLocalServiceIndexEntryId, gPanic(ETxtcInvalidServiceId));
// Create the forwarded index entry
TMsvEntry forwardEntry;
forwardEntry.iMtm = KUidMsgTypeText;
forwardEntry.iServiceId = Entry().Entry().iServiceId;
forwardEntry.iType = KUidMsvMessageEntry;
forwardEntry.iDetails.Set(iMsvEntry->Entry().iDetails);
forwardEntry.iSize = iMsvEntry->Entry().iSize;
if(aPartList&KMsvMessagePartDate)
forwardEntry.iDate.HomeTime();
if(aPartList&KMsvMessagePartDescription)
forwardEntry.iDescription.Set(iMsvEntry->Entry().iDescription);
// Get CMsvEntry for destination (parent)
CMsvEntry* cEntry = CMsvEntry::NewL(Session(), aForwardEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
// Synchronously create new child
CMsvOperationActiveSchedulerWait* wait = CMsvOperationActiveSchedulerWait::NewLC();
CMsvOperation* opert = cEntry->CreateL(forwardEntry, wait->iStatus);
CleanupStack::PushL(opert);
wait->Start();
User::LeaveIfError(opert->iStatus.Int());
// Check result
TPckgBuf<TMsvLocalOperationProgress> progressPack;
progressPack.Copy(opert->ProgressL());
TMsvLocalOperationProgress progress = progressPack();
User::LeaveIfError(progress.iError);
CleanupStack::PopAndDestroy(2); // opert, wait
// Get CMsvEntry for new entry
TMsvId forwardId=progress.iId;
cEntry->SetEntryL(forwardId);
// Populate new forwarded message with Body text
if(aPartList&KMsvMessagePartBody)
{
CMsvStore* store=cEntry->EditStoreL();
CleanupStack::PushL(store);
StoreBodyL(*store); // Current context is original message
store->CommitL();
CleanupStack::PopAndDestroy(); // store
}
CleanupStack::PopAndDestroy(); // cEntry
// Request was performed synchronously, so return a completed operation object
return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeText, progressPack,
KMsvNullIndexEntryId, aCompletionStatus);
}
// -----------------------------------------------------------------------------
// CWPMessage::StoreMsgL
// -----------------------------------------------------------------------------
//
void CWPMessage::StoreMsgL()
{
FLOG( _L( "CWPMessage::StoreMsgL" ) );
// create an invisible blank entry
TMsvEntry entry;
PrepareEntryLC( entry ); // details on cleanup stack
entry.iBioType = iBioUID.iUid;
entry.iMtm = KUidBIOMessageTypeMtm;
// Look up and set the description
FLOG( _L( "CWPMessage::StoreMsgL 1" ) );
TInt index;
CBIODatabase* bioDB = CBIODatabase::NewLC( iSession->FileSession() );
FLOG( _L( "CWPMessage::StoreMsgL 2" ) );
TRAPD( err, bioDB->GetBioIndexWithMsgIDL( iBioUID, index ) );
if (err ==KErrNone)
{
FLOG( _L( "CWPMessage::StoreMsgL 3" ) );
HBufC* description = bioDB->BifReader(index).Description().AllocL();
FLOG( _L( "CWPMessage::StoreMsgL 4" ) );
entry.iDescription.Set(*description);
FLOG( _L( "CWPMessage::StoreMsgL 5" ) );
CleanupStack::PopAndDestroy(); // bioDB
CleanupStack::PushL( description );
}
else
{
FTRACE(RDebug::Print(_L(" CWPMessage::StoreMsgL err (%d)"), err));
CleanupStack::PopAndDestroy(); // bioDB
}
FLOG( _L( "CWPMessage::StoreMsgL 6" ) );
// Store entry in inbox
CMsvEntry* msvEntry = iSession->GetEntryL( KMsvGlobalInBoxIndexEntryId );
FLOG( _L( "CWPMessage::StoreMsgL 7" ) );
CleanupStack::PushL(msvEntry);
msvEntry->CreateL(entry);
msvEntry->Session().CleanupEntryPushL(entry.Id());
msvEntry->SetEntryL(entry.Id());
FLOG( _L( "CWPMessage::StoreMsgL 8" ) );
// Save the message
CMsvStore* store = msvEntry->EditStoreL();
CleanupStack::PushL(store);
FLOG( _L( "CWPMessage::StoreMsgL 9" ) );
iMessage->StoreL( *store );
store->CommitL();
// Complete processing the message
PostprocessEntryL( *msvEntry, entry );
CleanupStack::PopAndDestroy(); //store
msvEntry->Session().CleanupEntryPop(); //entry
CleanupStack::PopAndDestroy(3); //description, details, msvEntry
FLOG( _L( "CWPMessage::StoreMsgL Done" ) );
}
// -----------------------------------------------------------------------------
// CWPMessage::StoreMsgL
// -----------------------------------------------------------------------------
//
void CWPMessage::StoreMsgL( TInt aResource )
{
FLOG( _L( "CWPMessage::StoreMsgL(aResource)" ) );
// create an invisible blank entry
TMsvEntry entry;
PrepareEntryLC( entry ); // details on cleanup stack
entry.iMtm = KUidMsgTypeSMS;
// Store entry in inbox
CMsvEntry* msvEntry = iSession->GetEntryL(KMsvGlobalInBoxIndexEntryId);
CleanupStack::PushL(msvEntry);
msvEntry->CreateL(entry);
msvEntry->Session().CleanupEntryPushL(entry.Id());
msvEntry->SetEntryL(entry.Id());
// Save the message body
CMsvStore* store = msvEntry->EditStoreL();
CleanupStack::PushL(store);
CParaFormatLayer* paraFormat = CParaFormatLayer::NewL();
CleanupStack::PushL( paraFormat );
CCharFormatLayer* charFormat = CCharFormatLayer::NewL();
CleanupStack::PushL( charFormat );
CRichText* body = CRichText::NewL( paraFormat, charFormat );
CleanupStack::PushL( body );
HBufC* text = LoadStringLC( aResource );
body->InsertL( body->DocumentLength(), *text );
store->StoreBodyTextL( *body );
// Store the actual message for post-mortem analysis
iMessage->StoreL( *store );
// Save the SMS header and create a description field
CSmsHeader* header = CSmsHeader::NewL( CSmsPDU::ESmsDeliver, *body );
CleanupStack::PushL( header );
TBuf<KSmsDescriptionLength> description;
CSmsGetDetDescInterface* smsPlugin = CSmsGetDetDescInterface::NewL();
CleanupStack::PushL( smsPlugin );
smsPlugin->GetDescription( header->Message(), description );
CleanupStack::PopAndDestroy( smsPlugin );
entry.iDescription.Set( description );
header->StoreL( *store );
store->CommitL();
CleanupStack::PopAndDestroy( 5 ); // header, text, body, charformat, paraFormat
// Complete processing the message
PostprocessEntryL( *msvEntry, entry );
CleanupStack::PopAndDestroy(); //store
msvEntry->Session().CleanupEntryPop(); //entry
CleanupStack::PopAndDestroy(2); //details, msvEntry
}
LOCAL_C void TestSetSendingStateAttributeL()
{
CDummyObserver* ob = new(ELeave)CDummyObserver;
CleanupStack::PushL(ob);
CMsvSession* session = CMsvSession::OpenSyncL(*ob);
CleanupStack::PushL(session);
CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
CleanupStack::PushL(selection);
TMsvEntry entry1;
entry1.iType = KUidMsvMessageEntry;
entry1.iMtm = KUidMsvLocalServiceMtm;
entry1.iServiceId = KMsvLocalServiceIndexEntryId;
entry1.SetSendingState(12);
cEntry->CreateL(entry1);
selection->AppendL(entry1.Id());
TMsvEntry entry2;
entry2.iType = KUidMsvMessageEntry;
entry2.iMtm = KUidMsvLocalServiceMtm;
entry2.iServiceId = KMsvLocalServiceIndexEntryId;
entry2.SetSendingState(3);
cEntry->CreateL(entry2);
selection->AppendL(entry2.Id());
session->ChangeAttributesL(*selection, 6<<KMsvSendingStateShift, 0);
cEntry->SetEntryL(entry1.Id());
test(cEntry->Entry().SendingState() == 6);
cEntry->SetEntryL(entry2.Id());
test(cEntry->Entry().SendingState() == 6);
CleanupStack::PopAndDestroy(4); // selection, cEntry, session, ob
}
/*
-----------------------------------------------------------------------------
RFile GetAttachmentFileL(TMsvAttachmentId aId)
----------------------------------------------------------------------------
*/
void CMailBoxContainer::OpenFileL(TBool /*aOpenWith*/)
{
if(iSession && iSelectionBox)
{
TInt CurrItmIndex = iSelectionBox->CurrentItemIndex();
TMsvSelectionOrdering sort;
sort.SetShowInvisibleEntries(ETrue);
sort.SetSorting(EMsvSortByDate);
// Take a handle to the folder entry
CMsvEntry* parentEntry = CMsvEntry::NewL(*iSession,iCurrentMailBox,sort);
CleanupStack::PushL(parentEntry);
// A selection of all BT entries
CMsvEntrySelection* entries = parentEntry->ChildrenL();//ChildrenWithMtmL(KUidMsgTypeBt);
CleanupStack::PushL(entries);
//Process all entries
if(CurrItmIndex >= 0 && CurrItmIndex < iIDArray->Count())
{
//Get entry
CMsvEntry* btEntry = iSession->GetEntryL(iIDArray->At(CurrItmIndex).iEnt);
CleanupStack::PushL(btEntry);
//Then get entrys child
CMsvEntrySelection* btChildren = btEntry->ChildrenL();
CleanupStack::PushL(btChildren);
btEntry->SetEntryL(iIDArray->At(CurrItmIndex).iMsg);
if (btEntry->HasStoreL())
{
CMsvStore* store = btEntry->ReadStoreL();
CleanupStack::PushL(store);
MMsvAttachmentManager& attMngr = store->AttachmentManagerL();
CMsvAttachment* attachment = attMngr.GetAttachmentInfoL(iIDArray->At(CurrItmIndex).iAtt);
if(attachment)
{
RFile SourceFil(attMngr.GetAttachmentFileL(iIDArray->At(CurrItmIndex).iAtt));
iUtils.GetFileUtils().OpenFileWithHandler(SourceFil);
SourceFil.Close();
}
CleanupStack::PopAndDestroy(store);
}
CleanupStack::PopAndDestroy(2);
}
CleanupStack::PopAndDestroy(2);
}
}
void CMtfTestActionCreateEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCreateEntry);
CActiveScheduler::Add(this);
iBlank = KNullDesC().AllocL();
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TUid paramEntryTypeUid = ObtainValueParameterL<TUid>(TestCase(),ActionParameters().Parameter(1));
TMsvId paramParentId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2));
TUid paramMtmUid = ObtainValueParameterL<TUid>(TestCase(),ActionParameters().Parameter(3), KUidMsvLocalServiceMtm);
TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(4), KMsvLocalServiceIndexEntryId);
TMsvPriority paramPriority = ObtainValueParameterL<TMsvPriority>(TestCase(),ActionParameters().Parameter(5),EMsvMediumPriority);
TInt paramReadOnlyFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(6),EFalse);
TInt paramVisibleFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(7),ETrue);
HBufC* paramDescription = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(8),iBlank);
HBufC* paramDetails = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(9),iBlank);
iIndexEntry.iType = paramEntryTypeUid;
iIndexEntry.iMtm = paramMtmUid;
iIndexEntry.iServiceId = paramServiceId;
iIndexEntry.SetPriority(paramPriority);
iIndexEntry.SetReadOnly(paramReadOnlyFlag);
iIndexEntry.SetVisible(paramVisibleFlag);
iIndexEntry.iDescription.Set(paramDescription->Des());
iIndexEntry.iDetails.Set(paramDetails->Des());
iIndexEntry.iDate.HomeTime();
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramParentId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramParentId);
if (entry->OwningService() == KMsvLocalServiceIndexEntryId)
{
entry->CreateL(iIndexEntry);
CleanupStack::PopAndDestroy(entry);
TMsvId paramEntryId;
paramEntryId = iIndexEntry.Id();
StoreParameterL<TMsvId>(TestCase(),paramEntryId,ActionParameters().Parameter(10));
TestCase().ActionCompletedL(*this);
}
else
{
iOperation = entry->CreateL(iIndexEntry,iStatus);
SetActive();
}
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCreateEntry);
}
/**
CountLinesOfBodyTextL()
Counts the lines of body text in the email aEntry
@param aEntry
A reference to an object representing the email
@param aFooterExists
Reference to a boolean variable - set to ETrue if the footer string is found in the body text
@param aFooterSize
Expected KB left on server inserted into footer string if present
@return
Number of lines in the body text
*/
TInt CT_MsgComparePopEmailMsgs::CountLinesOfBodyTextL(CMsvEntry& aEntry, TBool& aFooterExists, TInt& aFooterSize)
{
TInt lines = 0;
aFooterExists=EFalse;
aFooterSize=0;
aEntry.SetEntryL(aEntry.EntryId());
if(aEntry.HasStoreL())
{
CMsvStore* msvStore1= aEntry.ReadStoreL();
CleanupStack::PushL(msvStore1);
CParaFormatLayer* paraFormatLayer1 = CParaFormatLayer::NewL();
CleanupStack::PushL(paraFormatLayer1);
CCharFormatLayer* charFormatLayer1 = CCharFormatLayer::NewL();
CleanupStack::PushL(charFormatLayer1);
CRichText* bodyText1=CRichText::NewL(paraFormatLayer1, charFormatLayer1, CEditableText::EFlatStorage, 256);
CleanupStack::PushL(bodyText1);
bodyText1->Reset();
if (msvStore1->HasBodyTextL())
{
msvStore1->RestoreBodyTextL(*bodyText1);
TUint16 val = CEditableText::ELineBreak;
TInt n = 0;
TInt pos = 0;
for(;;)
{
TPtrC bodyText = bodyText1->Read(pos);
n = bodyText.Find(&val, 1);
if(n < 0)
break;
lines++;
pos += n+1;
//This Check is needed to delete the extra line introduced by communigate Pro Server
TInt fpos = CheckIfServerMessageExists(bodyText);
if (fpos != KErrNotFound)
{
lines--;
}
}
TPtrC pBt = bodyText1->Read(0);
aFooterExists = CheckIfFooterMessageExistsL(pBt , aFooterSize);
}
CleanupStack::PopAndDestroy(4, msvStore1); //bodyText1,charFormatLayer1,paraFormatLayer1,msvStore1.
}
return lines;
}
LOCAL_C void TestEntryStream(CMsvEntry& aEntry, TMsvId aId, TMsvId aService, TBool aAllDescendents)
{
// get the store
aEntry.SetEntryL(aId);
CMsvStore* store=NULL;
if(aEntry.HasStoreL()) store = aEntry.ReadStoreL();
test(store==NULL || store->IsPresentL(KUidMsvHiddenEntryStream)==EFalse);
delete store;
// recurse into the children
if (aAllDescendents)
{
CMsvEntrySelection* selection = aEntry.ChildrenL();
TInt count=selection->Count();
while (count--)
TestEntryStream(aEntry, selection->At(count), aService, EFalse);
delete selection;
}
}
TBool CSmsReplyToStep::CheckMessageL()
{
INFO_PRINTF1(_L("Received new message in Inbox - should be status report..."));
TMsvSelectionOrdering ordering;
ordering.ShowInvisibleEntries();
CMsvEntry* entry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId,ordering);
CleanupStack::PushL(entry);
CMsvEntrySelection* msvEntrySelection;
msvEntrySelection=entry->ChildrenL();
CleanupStack::PushL(msvEntrySelection);
// Check how many mesasges there are - should be just 1
TInt count = msvEntrySelection->Count();
INFO_PRINTF3(_L("Number of new messages: %d, should be: %d"), count, 1);
// Restore the message
CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iTestUtils->iRichText);
CleanupStack::PushL(header);
entry->SetEntryL((*msvEntrySelection)[0]);
CMsvStore* store = entry->ReadStoreL();
CleanupStack::PushL(store);
header->RestoreL(*store);
if(store->HasBodyTextL())
{
store->RestoreBodyTextL(*iTestUtils->iRichText);
}
TBuf<KSmsDescriptionLength> desc;
User::LeaveIfError(TSmsUtilities::GetDescription(header->Message(), desc));
//Check for a reply address field
CSmsReplyAddressOperations& operations = STATIC_CAST(CSmsReplyAddressOperations&,header->Message().GetOperationsForIEL(CSmsInformationElement::ESmsReplyAddressFormat));
TBool result=operations.ContainsReplyAddressIEL();
CleanupStack::PopAndDestroy(4,entry);
return result;
}
/**
Stores the Unknown Push message in the message store.
Saves the message data in a new attachment file. This makes it more efficient for the UI
to read the data.
@param aSession
Message server session
@param aParent
ID of the parent for the new entry. It is the caller's responsibility to ensure
that the parent ID is correct.
@return
ID of the new message server entry.
@see CPushMsgEntryBase::SaveL()
*/
EXPORT_C TMsvId CUnknownPushMsgEntry::SaveL(CMsvSession& aSession, TMsvId aParent)
{
CMsvEntry* entryPtr = aSession.GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(entryPtr);
// This tidies itself up
TMsvId newEntry = CPushMsgEntryBase::SaveL(aSession, aParent);
#ifdef __MESSAGING_API_V2__
TRAPD(
saveError,
TFileName fileName = ContentFileNameL();
entryPtr->SetEntryL(newEntry);
CMsvStore* store = entryPtr->EditStoreL();
CleanupStack::PushL(store);
SaveMessageBodyL(store->AttachmentManagerL(), fileName);
store->CommitL();
CleanupStack::PopAndDestroy(store);
)
void CMtfTestActionGetEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionAddGetEntry);
if(TestCase().TestStepResult() == EPass)
{
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
CMsvEntry* entry = paramSession->GetEntryL(messageEntry);
CleanupStack::PushL(entry);
entry->SetEntryL(messageEntry);
StoreParameterL<CMsvEntry>(TestCase(),*entry,ActionParameters().Parameter(2));
CleanupStack::Pop(entry);
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionAddGetEntry);
}
TestCase().ActionCompletedL(*this);
}
void CT_CMsvSession::TestTransferCommandL()
{
TInt error = KErrGeneral;
INFO_PRINTF1(_L("Testing: Transfer Commands -- started"));
TRAP(error, iSession = CMsvSession::OpenSyncL(*this));
TEST(error == KErrNone);
CMsvOperationWait* active = CMsvOperationWait::NewLC();
CMsvEntry* cEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
CleanupStack::PushL(selection);
TInt ret = iSession->InstallMtmGroup(KDataComponentFilename);
TEST(ret==KErrNone|| ret==KErrAlreadyExists);
cEntry->SetEntryL(KMsvRootIndexEntryId);
TMsvEntry service;
service.iType=KUidMsvServiceEntry;
service.iMtm = KUidTestServerMtmType;
cEntry->CreateL(service);
selection->AppendL(service.Id());
TBuf8<256> progress;
TBuf8<32> param;
CMsvOperation* operation = NULL;
active->Start();
operation = iSession->TransferCommandL(*selection, 1, param, active->iStatus);
CActiveScheduler::Start();
TEST(operation->iStatus.Int()==KErrNone);
cEntry->DeleteL(service.Id());
delete operation;
CleanupStack::PopAndDestroy(selection);
CleanupStack::PopAndDestroy(cEntry);
CleanupStack::PopAndDestroy(active);
delete iSession;
INFO_PRINTF1(_L("Testing: Transfer Commands -- ended"));
}
// -----------------------------------------------------------------------------
// CMmsAdapterMsvApi::DeleteUserFolderL
// -----------------------------------------------------------------------------
//
TInt CMmsAdapterMsvApi::DeleteUserFolderL( TMsvId aUid )
{
TRACE_FUNC_ENTRY;
CMsvEntry* entry = iSession.GetEntryL(aUid);
CleanupStack::PushL(entry);
TMsvEntry tEntry = entry->Entry();
TMsvId parent = tEntry.Parent();
if ( tEntry.iType != KUidMsvFolderEntry || parent != KMsvMyFoldersEntryIdValue )
{
LOGGER_WRITE( "Not correct folder" );
CleanupStack::PopAndDestroy(entry);
LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" );
return KErrNotSupported;
}
CMsvEntrySelection* children = entry->ChildrenL();
TInt count = children->Count();
delete children;
if ( count > 0 )
{
LOGGER_WRITE( "Folder not empty" );
CleanupStack::PopAndDestroy( entry );
LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" );
return KErrInUse;
}
tEntry.SetReadOnly( EFalse );
entry->ChangeL( tEntry );
entry->SetEntryL( parent );
entry->DeleteL( aUid );
CleanupStack::PopAndDestroy( entry );
TRACE_FUNC_EXIT;
return KErrNone;
}
/**
CountLinesOfHtmlL()
Counts the number of lines of HTML
@param aEntry
A reference to an object representing the email
@return
Number of lines of HTML
*/
TInt CT_MsgComparePopEmailMsgs::CountLinesOfHtmlL(CMsvEntry& aEntry)
{
TInt lines = 0;
aEntry.SetEntryL(aEntry.EntryId());
CMsvStore* store = aEntry.ReadStoreL();
CleanupStack::PushL(store);
MMsvAttachmentManager& attManager = store->AttachmentManagerL();
RFile htmlFile = attManager.GetAttachmentFileL(0);
CleanupClosePushL(htmlFile);
_LIT8(KFindData, "\r\n");
TInt htmlSize = 0;
User::LeaveIfError(htmlFile.Size(htmlSize));
HBufC8* fBuf = HBufC8::NewLC(htmlSize);
TPtr8 p = fBuf->Des();
htmlFile.Read(p);
TInt pos = 0;
for(;;)
{
pos = p.Find(KFindData);
if(pos < 0)
{
break;
}
p = p.Mid(pos+2);
lines++;
}
CleanupStack::PopAndDestroy(fBuf);
CleanupStack::PopAndDestroy(); // htmlFile
CleanupStack::PopAndDestroy(store);
return lines;
}
/**
GetMessageLinesL()
Counts the number of lines in a message's HTML or body text
@param aEntry
Email message identifier
@param aUid
Request identifier KUidMsvEmailHtmlEntry or KUidMsvEmailTextEntry at present
@param aFooterExists
Reference to a boolean variable only used when aUid == KUidMsvEmailTextEntry
@param aFooterSize
Expected KB left on server inserted into footer string if present
@return
Returns the number of lines in the requested message part
*/
TInt CT_MsgComparePopEmailMsgs::GetMessageLinesL(TMsvEntry& aEntry, TUid aUid, TBool& aFooterExists, TInt &aFooterSize)
{
TInt lines = 0;
TMsvId msgPartIndex = GetMessagePartIndexL(aEntry,aUid);
if(msgPartIndex)
{
CMsvEntry* msvEntry = iSharedDataPOP.iSession->GetEntryL(msgPartIndex);
CleanupStack::PushL(msvEntry);
msvEntry->SetEntryL(msgPartIndex);
if(aUid == KUidMsvEmailTextEntry)
{
lines = CountLinesOfBodyTextL(*msvEntry, aFooterExists, aFooterSize);
}
else if(aUid == KUidMsvEmailHtmlEntry)
{
lines = CountLinesOfHtmlL(*msvEntry);
}
CleanupStack::PopAndDestroy(msvEntry);
}
return lines;
}
//---------------------------------------------------------------
// TestUniDataModelPlugin::createMMS
//---------------------------------------------------------------
void TestUniDataModelMMSPlugin::createMMS(TMsvId pId, TBool subjectField)
{
TMsvEntry indexEntry;
indexEntry.iType = KUidMsvMessageEntry;
indexEntry.iMtm = KUidMsgTypeMultimedia;
indexEntry.iServiceId = iServiceId;
indexEntry.iDate.HomeTime();
// Convert TTime to QDateTime , this will be used for comparing the time of mesage
// when fetched from datamodel
TTime unixEpoch(KUnixEpoch);
TTimeIntervalSeconds seconds;
TTime timeStamp = indexEntry.iDate;
timeStamp.SecondsFrom(unixEpoch, seconds);
retTimeStamp.setTime_t(seconds.Int());
TMsvId parentId = pId;
CMsvEntry* entry = CMsvEntry::NewL(*iMSession,parentId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(parentId);
entry->CreateL(indexEntry);
entry->SetEntryL(indexEntry.Id());
iMmsClientMtm->SwitchCurrentEntryL(entry->EntryId());
CMsvStore* store = iMmsClientMtm->Entry().EditStoreL();
CleanupStack::PushL(store);
//MMS Message ID Saved
iMessageId = indexEntry.Id();
//Adding Subject
if(subjectField)
{
QString subject(TEST_MSG_SUBJECT);
HBufC* subj = XQConversions::qStringToS60Desc(subject);
iMmsClientMtm->SetSubjectL(*subj);
}
//Adding Sender
QString sender(TEST_MSG_FROM1);
HBufC* addr = XQConversions::qStringToS60Desc(sender);
if (addr)
{
CleanupStack::PushL(addr);
TBuf<32> name;
name.Copy(addr->Left(32));
indexEntry.iDetails.Set(name);
iMmsClientMtm->SetSenderL(*addr);
CleanupStack::PopAndDestroy(addr);
}
//Adding Recipient
QString recipient(TEST_MSG_RECIEPIENT1);
HBufC* addr2 = XQConversions::qStringToS60Desc(recipient);
if (addr2)
{
CleanupStack::PushL(addr2);
iMmsClientMtm->AddAddresseeL(EMsvRecipientTo,*addr2);
CleanupStack::PopAndDestroy(addr2);
}
//Adding cCRecipient
QString recipient2(TEST_MSG_RECIEPIENT2);
HBufC* addr3 = XQConversions::qStringToS60Desc(recipient2);
if (addr3)
{
CleanupStack::PushL(addr3);
iMmsClientMtm->AddAddresseeL(EMsvRecipientCc,*addr3);
CleanupStack::PopAndDestroy(addr3);
}
//Adding bCCRecipient
QString recipient3(TEST_MSG_RECIEPIENT3);
HBufC* addr4 = XQConversions::qStringToS60Desc(recipient3);
if (addr4)
{
CleanupStack::PushL(addr4);
iMmsClientMtm->AddAddresseeL(EMsvRecipientBcc,*addr4);
CleanupStack::PopAndDestroy(addr4);
}
//Create Text Attachment
TMsvAttachmentId attaId = 0;
TFileName attachmentFile( _L("story.txt") );
TBufC<12> story = _L( "Hello world!" );
iMmsClientMtm->CreateTextAttachmentL(*store, attaId, story, attachmentFile, ETrue );
qDebug() << "Text Attachment id" << attaId;
//Image Attachment added to the message entry
RFile attaFile;
// Set filename of attachment
TFileName name( KPictureFileName );
CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
CleanupStack::PushL( mimeHeaders );
// Set values to mime headers
mimeHeaders->SetContentTypeL( _L8( "image") );
mimeHeaders->SetContentSubTypeL( _L8( "jpeg" ) );
_LIT8(KMimeType, "image/jpeg");
TBufC8<10> mimeType(KMimeType);
// CreateAttachment2L will set the content type to attachment Info
// Open the attachment file for reading
attaFile.Open( iFs, name, EFileShareReadersOnly | EFileRead );
CleanupClosePushL(attaFile);
CMsvAttachment* attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
// attaInfo ownerhip will be transferred to Attachment Manager.
// It must not be pushed onto the cleanupStack before calling
// CreateAttachment2L.
iMmsClientMtm->CreateAttachment2L(*store, attaFile,mimeType,*mimeHeaders,attaInfo,attaId);
qDebug() << "Image Attachment id" << attaId;
// Now Attachment Manager owns the attaInfo
CleanupStack::Pop(); // attaFile.Close()
CleanupStack::PopAndDestroy(); // mimeHeaders
store->CommitL();
CleanupStack::PopAndDestroy(store); // store
iMmsClientMtm->SaveMessageL();
//Saving the message size for future checking
msgSize = iMmsClientMtm->MessageSize();
CleanupStack::Pop(entry); // entry
}
/**
LoadParametersL()
Loads the test parameters
@leave KErrNotReady
@return
ETrue if parameters loaded, Efalse on failure.
*/
TBool CT_MsgComparePopEmailMsgs::LoadParametersL()
{
TPtrC sentFolder;
_LIT(KSentFolder, "SentFolder");
if(!GetStringFromConfig(ConfigSection(), KSentFolder, sentFolder))
{
ERR_PRINTF1(_L("No Input for Sent Folder"));
User::Leave(KErrNotReady);
}
iSentSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, CT_MsgUtilsEnumConverter::FindFolderIdByName(sentFolder));
if(! iSentSelectionList)
{
ERR_PRINTF1(_L("Invalid sentSelectionList"));
SetTestStepResult(EFail);
return EFalse;
}
TPtrC inboxFolder;
_LIT(KInboxFolder, "InboxFolder");
if(!GetStringFromConfig(ConfigSection(), KInboxFolder, inboxFolder))
{
ERR_PRINTF1(_L("No Input for Inbox Folder"));
User::Leave(KErrNotReady);
}
TPtrC popAccountName;
if(!GetStringFromConfig(ConfigSection(), KPopAccountName, popAccountName))
{
ERR_PRINTF1(_L("Account name not specified"));
SetTestStepResult(EFail);
}
if (CT_MsgUtilsEnumConverter::FindFolderIdByName(inboxFolder) == KMsvLocalServiceIndexEntryId)
{
// We are expecting to get a selection of remote Folder(which is the serviceId)
TMsvId popServiceId = CT_MsgUtilsCentralRepository::GetPopServiceIdL((TDes&)popAccountName);
CMsvEntry* entry = iSharedDataPOP.iSession->GetEntryL(popServiceId);
CleanupStack::PushL(entry);
entry->SetEntryL(popServiceId); // Setting the context to remote folder.
iInboxSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, popServiceId);
CleanupStack::PopAndDestroy(entry);
}
else
{
iInboxSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, CT_MsgUtilsEnumConverter::FindFolderIdByName(inboxFolder));
}
if(! iInboxSelectionList)
{
ERR_PRINTF1(_L("Invalid inboxSelectionList"));
SetTestStepResult(EFail);
return EFalse;
}
//Starting the comparision
if(iInboxSelectionList->Count() != iSentSelectionList->Count())
{
ERR_PRINTF3(_L("iInboxSelectionList->Count(%d) != iSentSelectionList->Count(%d)"),
iInboxSelectionList->Count(), iSentSelectionList->Count());
SetTestStepResult(EFail);
return EFalse;
}
TInt comInt = -1;
_LIT(KNumTest, "NumTest");
if (!GetIntFromConfig(ConfigSection(), KNumTest, comInt))
{
ERR_PRINTF1(_L("No Input for NumTests"));
User::Leave(KErrNotReady);
}
TInt numTests = comInt;
if(numTests != iInboxSelectionList->Count())
{
ERR_PRINTF1(_L("iNumTests != iInboxSelectionList"));
SetTestStepResult(EFail);
return EFalse;
}
iExpResults.Reset();
for(TInt i = 0;i < numTests; i++)
{
CExpPop3MailInfo* pExp = GetExpPop3MailInfoLC(i);
if(! pExp)
{
ERR_PRINTF1(_L("Invalid expected mail Info"));
SetTestStepResult(EFail);
return EFalse;
}
else
{
CleanupStack::Pop(pExp); // pExp
iExpResults.Append(pExp);
}
}
return ETrue;
}
/**
CountLinesOfBodyTextL()
Counts the lines of body text in the email aEntry
@param aEntry
A reference to an object representing the email
@param aFooterExists
Reference to a boolean variable - set to ETrue if the footer string is found in the body text
@param aFooterSize
Expected KB left on server inserted into footer string if present
@return
Number of lines in the body text
*/
TInt CT_MsgComparePopEmailMsgs::CountLinesOfBodyTextL(CMsvEntry& aEntry, TBool& aFooterExists, TInt& aFooterSize)
{
TInt lines = 0;
TInt count =0;
aFooterExists=EFalse;
aFooterSize=0;
aEntry.SetEntryL(aEntry.EntryId());
if(aEntry.HasStoreL())
{
CMsvStore* msvStore1= aEntry.ReadStoreL();
CleanupStack::PushL(msvStore1);
CParaFormatLayer* paraFormatLayer1 = CParaFormatLayer::NewL();
CleanupStack::PushL(paraFormatLayer1);
CCharFormatLayer* charFormatLayer1 = CCharFormatLayer::NewL();
CleanupStack::PushL(charFormatLayer1);
CRichText* bodyText1=CRichText::NewL(paraFormatLayer1, charFormatLayer1, CEditableText::EFlatStorage, 256);
CleanupStack::PushL(bodyText1);
bodyText1->Reset();
if (msvStore1->HasBodyTextL())
{
msvStore1->RestoreBodyTextL(*bodyText1);
TUint16 val = CEditableText::ELineBreak;
TUint16 val1 = CEditableText::EParagraphDelimiter;
TUint16 val2 = KUnicodeValue;
TInt n = 0;
TInt pos = 0;
for(;;)
{
TPtrC bodyText = bodyText1->Read(pos);
n = bodyText.Find(&val, 1);
// if iStore8BitData flag is set, the line is terminated by "CEditableText::EParagraphDelimiter"
if(msvStore1->IsPresentL(KMsvPlainBodyText8))
{
if ( 0 == count )
{
TPtrC buffer = bodyText.Mid(0,n+2);
// eg for 8bit the body look as : This is a simple email message.\x2028\x2029\x2029
// eg for 16bit the body look as: This is a simple email message.\x2028\x2028\x2029
if((bodyText.Right(2).Compare(KParagraphDelimiter)==KErrNone) && \
buffer.Find(&val2,1) != 75)
{
lines++;
count++;
}
// Increment the line if EParagraphDelimiter or 0x0046 is found sequence as eg:1. \x2028\x2029
// 2. \x2028\x2029\x2028\x2029\x0046 3. \x2028\x2029\x2028\x2029\x2028\x2029
else if ( (buffer.Find(&val1,1)==0 && n==-1) || (buffer.Find(&val2,1)==1) \
|| (buffer.Find(&val1,1)>0) )
{
lines++;
}
}
}
if(n < 0)
break;
lines++;
pos += n+1;
//This Check is needed to delete the extra line introduced by communigate Pro Server
TInt fpos = CheckIfServerMessageExists(bodyText);
if (fpos != KErrNotFound)
{
lines--;
}
}
TPtrC pBt = bodyText1->Read(0);
aFooterExists = CheckIfFooterMessageExistsL(pBt , aFooterSize);
}
CleanupStack::PopAndDestroy(4, msvStore1); //bodyText1,charFormatLayer1,paraFormatLayer1,msvStore1.
}
return lines;
}
