diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/wappushfw/PushMsgEntry/test/t_pushentry.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/wappushfw/PushMsgEntry/test/t_pushentry.cpp Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,2500 @@ +// Copyright (c) 2000-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 +#include +#include +#include +#include +#include +#include +#include +#include "testlog.h" +#include "t_serviceutils.h" +#include "t_pushentry.h" + + +_LIT(KPushEntryTestTitle,"T_PushEntry"); +_LIT(KFilename,"picture.jpg"); +_LIT(KFilename2,"image.gif"); + +// Uncomment the following define to switch on Heap Failure Testing +// #define __HEAP_FAILURE_TESTING + + + +// Global variables +RTest gTest(_L("t_PushMessage Test Harness")); + + + + + + +/** Active scheduler defined for this testcode to catch error */ +void CTestScheduler::Error(TInt aError) const + { + CActiveScheduler::Stop(); + gTest.Printf(_L("\nLeave signalled, reason=%d\n"),aError); + } + + + + + +CMessageDetails* CMessageDetails::NewL() + { + CMessageDetails* self = new (ELeave) CMessageDetails(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +void CMessageDetails::ConstructL() + { + iPushMsgType =0; //Uid of message type goes in iBioType + iStatusFlag = 0; + iActionFlag =0; + iSiId = HBufC::NewL(100); + iCreated = Time::NullTTime(); //.DateTime(); + iExpires = Time::NullTTime(); + iURL = HBufC::NewL(100); + iText = HBufC::NewL(100); + iFrom = HBufC8::NewL(100); + iHeader = HBufC8::NewL(100); + iContentType=HBufC::NewL(100); + iMessageBody =HBufC8::NewL(300); + iMsgDetails =HBufC::NewL(300); + iMsgDescription =HBufC::NewL(300); + iFilename = HBufC::NewL(100); + } + +CMessageDetails::CMessageDetails() + { + } + +CMessageDetails::~CMessageDetails() + { + delete iSiId; + delete iURL; + delete iText; + delete iFrom; + delete iHeader; + delete iContentType; + delete iMessageBody; + delete iMsgDetails; + delete iMsgDescription; + delete iFilename; + } + +void CMessageDetails::ResetL() + { + iPushMsgType =0; //Uid of message type goes in iBioType + iStatusFlag = 0; + iActionFlag =0; + delete iSiId; + iSiId = NULL; + iSiId = HBufC::NewL(100); + + iCreated= Time::NullTTime(); + iExpires = Time::NullTTime(); + + delete iURL; + iURL =NULL; + iURL = HBufC::NewL(100); + + delete iText; + iText = NULL; + iText = HBufC::NewL(100); + + delete iFrom; + iFrom = NULL; + iFrom = HBufC8::NewL(100); + + delete iHeader; + iHeader = NULL; + iHeader = HBufC8::NewL(100); + + delete iContentType; + iContentType =NULL; + iContentType = HBufC::NewL(100); + + delete iMessageBody; + iMessageBody=NULL; + iMessageBody = HBufC8::NewL(300); + } + + + +// Test Harness - Active Object with a lot of states. Tests Get/Set, Save/Retrieve & Update, +// for Push Entries. Also tests the Message Utilities. Use both together during the operations. +CPushEntryTester* CPushEntryTester::NewL(MWapPushLog& aLog) + { + CPushEntryTester* self = new (ELeave) CPushEntryTester(aLog); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +void CPushEntryTester::ConstructL() + { + __LOG_ALWAYS("Test Results"); + __LOG_ALWAYS(" "); + + iPushUtilities = CWapPushMsgUtils::NewL(); + iSISLPushUtilities = CSISLPushMsgUtils::NewL(); + iDetails = CMessageDetails::NewL(); + iMsvEntry = iPushUtilities->Session().GetEntryL(KMsvRootIndexEntryId); + CActiveScheduler::Add(this); + } + + +CPushEntryTester::CPushEntryTester(MWapPushLog& aLog) +:CActive(CActive::EPriorityIdle), iLog(aLog) + { + } + + +CPushEntryTester::~CPushEntryTester() + { + Cancel(); + delete iMsvEntry; + delete iDetails; + delete iPushEntry; + delete iPushUtilities; + delete iSISLPushUtilities; + } + +void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt) + { + iFormatBuffer.Format(aFormat, aInt); + iLog.WPLPrintf(iFormatBuffer); + } + +void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt1, TInt aInt2) + { + iFormatBuffer.Format(aFormat, aInt1, aInt2); + iLog.WPLPrintf(iFormatBuffer); + } + +void CPushEntryTester::LogFormatStr(const TDesC& aFormat, const TDesC& aDes) + { + iFormatBuffer.Format(aFormat, &aDes); + iLog.WPLPrintf(iFormatBuffer); + } + +void CPushEntryTester::LogStr(const TDesC& aDes) + { + iLog.WPLPrintf(aDes); + } + + + +void CPushEntryTester::RunL() + { + switch(iState) + { + case ETestInitialising: + __LOG_ALWAYS("========= TEST - SI GET/SET WITH PARAMETERS ========="); + CreateMsgDetailsL(EFalse); + SiGetSetTestL(); + iState =ETestSIGetSet;// Test the setters getters with Non Null fields + QueueOperationAsync(KErrNone); + break; + case ETestSIGetSet: + __LOG_ALWAYS("========= TEST - SI SAVE/RETRIEVE WITH PARAMETERS ========="); + SiSaveRetrieveTestL(); + iState = ETestSISaveRetrieveWithStringAppID;//Test Save Retrieve with Non Null fields + QueueOperationAsync(KErrNone); + break; + + case ETestSISaveRetrieveWithStringAppID: + __LOG_ALWAYS("========= TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND STRING APPID ========="); + SiSaveRetrieveTestL(); + iState = ETestSISaveRetrieveWithIntAppID; + QueueOperationAsync(KErrNone); + break; + + case ETestSISaveRetrieveWithIntAppID: + __LOG_ALWAYS("========= TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND INT APPID ========="); + iState = ETestSISaveRetrieve; + SiSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSISaveRetrieve: + __LOG_ALWAYS("========= TEST - SI GET/SET WITH NULL FIELDS ========="); + CreateMsgDetailsL(ETrue); + SiGetSetTestL(); + iState = ETestSIGetSetNull;// Test the setters getters with Null fields + QueueOperationAsync(KErrNone); + break; + + case ETestSIGetSetNull: + iState = ETestSISaveRetrieveNull; //Test Save/Retrieve with Empty fields + __LOG_ALWAYS("========= TEST - SI SAVE/RETRIEVE WITH NULL FIELDS ========="); + SiSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSISaveRetrieveNull: + __LOG_ALWAYS("========= TEST - UPDATING A EXISTING SI MESSAGE ========="); + iState = ETestSIChangeEntry; + ChangeSIEntryTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSIChangeEntry: + __LOG_ALWAYS("========= TEST - SL GET/SET WITH PARAMETERS ========="); + iState = ETestSLGetSet;//Test SL Set/Get functions with Empty fields + CreateMsgDetailsL(EFalse); + SlGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSLGetSet: + iState = ETestSLSaveRetrieve; + __LOG_ALWAYS("========= TEST - SL SAVE/RETRIEVE WITH PARAMETERS ========="); + SlSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSLSaveRetrieve: + __LOG_ALWAYS("========= TEST - SL GET/SET WITH EMPTY FIELDS ========="); + iState = ETestSLGetSetNull;//Test SL Set/Get functions with Empty fields + CreateMsgDetailsL(ETrue); + SlGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSLGetSetNull: + __LOG_ALWAYS("========= TEST - SL SAVE/RETRIEVE WITH EMPTY FIELDS ========="); + iState = ETestSLSaveRetrieveNull; + SlSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSLSaveRetrieveNull: + __LOG_ALWAYS("========= TEST - UPDATING A EXISTING SL MESSAGE ========="); + iState = ETestSLChangeEntry; + ChangeSLEntryTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestSLChangeEntry: + __LOG_ALWAYS("========= TEST - MULTI GET/SET WITH PARAMETERS ========="); + iState = ETestMultiGetSet; + CreateMsgDetailsL(EFalse); + MultiGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestMultiGetSet: + __LOG_ALWAYS("========= TEST - MULTI SAVE/RETRIEVE WITH PARAMETERS ========="); + iState = ETestMultiSaveRetrieve; + MultiSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestMultiSaveRetrieve: + __LOG_ALWAYS("========= TEST - MULTI SET/GET WITH EMPTY FIELDS ========="); + iState = ETestMultiGetSetNull; + CreateMsgDetailsL(ETrue); + MultiGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestMultiGetSetNull: + __LOG_ALWAYS("========= TEST - MULTI SAVE/RETRIEVE WITH EMPTY FIELDS ========="); + iState = ETestMultiSaveRetrieveNull; + MultiSaveRetrieveTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestMultiSaveRetrieveNull: + __LOG_ALWAYS("========= TEST - UNKNOWN GET/SET WITH PARAMETERS ========="); + iState = ETestUnknownGetSet; + CreateMsgDetailsL(EFalse); + UnknownGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownGetSet: + __LOG_ALWAYS("========= TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS =========="); + iState = ETestUnknownSaveRetrieve; + UnknownSaveRetrieveTestL(EFalse); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownSaveRetrieve: + __LOG_ALWAYS("========= TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS AND FILENAME ========="); + iState = ETestUnknownSaveRetrieveWithFilename; + UnknownSaveRetrieveTestL(ETrue); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownSaveRetrieveWithFilename: + __LOG_ALWAYS("========= TEST - UNKNOWN GET/SET WITH EMPTY FIELDS ========="); + iState = ETestUnknownGetSetNull; + CreateMsgDetailsL(ETrue); + UnknownGetSetTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownGetSetNull: + __LOG_ALWAYS("========= TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS ========="); + iState = ETestUnknownSaveRetrieveNull; + UnknownSaveRetrieveTestL(EFalse); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownSaveRetrieveNull: + __LOG_ALWAYS("========= TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS AND FILENAME ========="); + iState = ETestUnknownSaveRetrieveNullWithFilename; + UnknownSaveRetrieveTestL(ETrue); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownSaveRetrieveNullWithFilename: // Test updating an Unknown Msg + __LOG_ALWAYS("========= TEST - UPDATING A EXISTING UNKNOWN MESSAGE ========="); + iState = ETestUnknownChangeEntry; + ChangeUnknownEntryTestL(EFalse); + QueueOperationAsync(KErrNone); + break; + + case ETestUnknownChangeEntry: // Test updating an Unknown Msg with filename + __LOG_ALWAYS("========= TEST - UPDATING A EXISTING UNKNOWN MESSAGE WITH FILENAME ========="); + iState = ETestUnknownChangeEntryWithFilename; + ChangeUnknownEntryTestL(ETrue); + QueueOperationAsync(KErrNone); + break; + + + case ETestUnknownChangeEntryWithFilename: + __LOG_ALWAYS("========= TEST - SI FIND BY AN ID ========="); + iState = ETestSIFindSiId; + CreateMoreSiMessagesL(); + FindSiIdTestL(EFalse); // Not looking for a null ID string + QueueOperationAsync(KErrNone); + break; + + case ETestSIFindSiId: + iState = ETestSIFindSiIdNull; //Test Find Function with Empty fields + __LOG_ALWAYS("========= TEST - SI FIND A NULL ID ========="); + FindSiIdTestL(ETrue); // Looking for a null ID string + QueueOperationAsync(KErrNone); + break; + + case ETestSIFindSiIdNull: + iState = ETestSIFindSiUrl; //Test Find with Non Null URL field + __LOG_ALWAYS("========= TEST - SI FIND A URL ========="); + FindUrlTestL(EFalse, KUidWapPushMsgSI); + QueueOperationAsync(KErrNone); + break; + + case ETestSIFindSiUrl: + iState = ETestSIFindSiUrlNull; //Test Find with a Null URL field + __LOG_ALWAYS("========= TEST - SI FIND A NULL URL ========="); + FindUrlTestL(ETrue, KUidWapPushMsgSI); + QueueOperationAsync(KErrNone); + break; + + case ETestSIFindSiUrlNull: + __LOG_ALWAYS("========= TEST - SL FIND A URL ========="); + iState = ETestSLFindUrl; + CreateMoreSLMessagesL(); + FindUrlTestL(EFalse, KUidWapPushMsgSL); + QueueOperationAsync(KErrNone); + break; + + case ETestSLFindUrl : + __LOG_ALWAYS("========= TEST - SL FIND NULL URL ========="); + iState = ETestSLFindUrlNull; + FindUrlTestL(ETrue , KUidWapPushMsgSL); + QueueOperationAsync(KErrNone); + break; + + case ETestSLFindUrlNull: + __LOG_ALWAYS("========= TEST - GET HIGHEST SI ACTION ========="); + iState = ETestSIGetHiAction; + GetActionTestL(KUidWapPushMsgSI); + QueueOperationAsync(KErrNone); + break; + + + case ETestSIGetHiAction: + __LOG_ALWAYS("========= TEST - GET HIGHEST SL ACTION ========="); + iState = ETestSLGetHiAction ; + GetActionTestL(KUidWapPushMsgSL); + QueueOperationAsync(KErrNone); + break; + + + case ETestSLGetHiAction: + iState = ETestGetExpiry; + __LOG_ALWAYS("========= TEST - GET EARLIEST SI EXPIRY ========="); + //DumpPushMessageDetailsL(KUidWapPushMsgSI); + //DumpPushMessageDetailsL(KUidWapPushMsgSL); + //DumpPushMessageDetailsL(KUidWapPushMsgMultiPart); + //DumpPushMessageDetailsL(KUidWapPushMsgUnknown); + GetExpiryTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestGetExpiry: + iState = ETestGetNextExpiry; + __LOG_ALWAYS("========= TEST - GET NEXT SI EXPIRY ========="); + DeleteEarliestExpiryL(); + GetExpiryTestL(); + QueueOperationAsync(KErrNone); + break; + + case ETestGetNextExpiry: + iState = ETestComplete; + if (!iFailures) + { + __LOG_ALWAYS(" "); + __LOG_ALWAYS("Tests Completed"); + } + else + { + LogFormatInt(_L("========= TESTS FAILED !! TOTAL OF %d UNSUCESSFUL ========="), iFailures); + } + QueueOperationAsync(KErrNone); + break; + + case ETestComplete: //finished + User::After(10000); + Cancel(); + CActiveScheduler::Stop(); + break; + default: + break; + } + User::After(500); + } + + +void CPushEntryTester::QueueOperationAsync(TInt aErr) + { + TRequestStatus* pS = &iStatus; + iStatus = KRequestPending; + User::RequestComplete(pS, aErr); + SetActive(); + } + +void CPushEntryTester::DoCancel() + { + } + +void CPushEntryTester::StartL() + { + iFailures = 0; + CreateHeaders(); + iState = ETestInitialising; + QueueOperationAsync(KErrNone); + } + +// Halt the Scheduler & inform the user +TInt CPushEntryTester::RunError(TInt aError) + { + if (aError != KErrNone) + { + LogFormatInt(_L("Error %d occurred"), aError); + __LOG_DEBUG("Tests Failed!"); + iFailures++; + CActiveScheduler::Stop(); + } + return KErrNone; + } + + + + +// Tests use of get/set methods on a CSIPushMsgEntry +// Create new entry,set values on TMsvEntry,set Push Entry, display & set new values +void CPushEntryTester::SiGetSetTestL() + { + __LOG_ALWAYS("***** TESTING SI SETTER FUNCTIONS *****"); + + CSIPushMsgEntry* siEntry = NULL; + +#if defined (__HEAP_FAILURE_TESTING) + TInt error; + TBool finished = EFalse; + TInt failCount = 0; + + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,siEntry = DoSiCreateTestL()); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSiCreateTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + siEntry = DoSiCreateTestL(); +#endif + CleanupStack::PushL(siEntry); + OutputMessageDetailsL(*siEntry); // Tests our get functions - don't allocate memory + + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoSiSetTestL(*siEntry)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSiSetTestL()"), failCount); + finished = ETrue; + } + + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + DoSiSetTestL(*siEntry); +#endif + + OutputMessageDetailsL(*siEntry); + CleanupStack::PopAndDestroy(); + __LOG_ALWAYS("***** SI SET/GET - TEST SUCCESSFUL ******"); + } + +CSIPushMsgEntry* CPushEntryTester::DoSiCreateTestL() + { + TPtrC ptr; + TMsvEntry entry; + + entry.iServiceId = 0x0001234; + entry.iMtm.iUid = 0x0012345; // dummy value to check default gets set automatically! + entry.iBioType = 0x0054321; // ditto + entry.iType = KUidMsvMessageEntry; + entry.SetMtmData1(0x01FF); + ptr.Set(_L("123456@somewhere.com")); + + CSIPushMsgEntry* siEntry = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siEntry); + siEntry->SetEntry(entry); + + siEntry->SetExpires( TTime(_L("20020000:120000.0000")) ); + siEntry->SetHeaderL(iDummyHeader2); + siEntry->SetTextL(KUrl2); + + + siEntry->SetMsgDescriptionL(ptr); + siEntry->SetMsgDetailsL(_L("http;//www.garbage.com")); + + CleanupStack::Pop(); + return siEntry; + } + +void CPushEntryTester::DoSiSetTestL(CSIPushMsgEntry& aSiEntry) + { + aSiEntry.SetAction(iDetails->iActionFlag); + aSiEntry.SetCreated( iDetails->iCreated ); + aSiEntry.SetExpires( iDetails->iExpires); + aSiEntry.SetFromL(*iDetails->iFrom); + aSiEntry.SetHeaderL(*iDetails->iHeader); + aSiEntry.SetIdL(*iDetails->iSiId); + aSiEntry.SetStatus(iDetails->iStatusFlag); + aSiEntry.SetTextL(*iDetails->iText); + aSiEntry.SetUrlL(*iDetails->iURL); + + aSiEntry.SetMsgDetailsL(*iDetails->iMsgDetails); + aSiEntry.SetMsgDescriptionL(*iDetails->iMsgDescription); + } + + + +// Tests the Save and Retrieve functions - saves a message and then loads it +// - should remain unchanged +void CPushEntryTester::SiSaveRetrieveTestL() + { + __LOG_ALWAYS("***** TEST STORING NEW SI PUSH ENTRY DATA *****"); // Log details + TMsvId msgEntryId =0; + CSIPushMsgEntry* siSave =NULL; + +#if defined (__HEAP_FAILURE_TESTING) + TInt error; + TBool finished = EFalse; + TInt failCount = 0; + + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, siSave = DoSiSaveTestL()); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSiSaveTestL()"), failCount); + finished = ETrue; + } + + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + siSave = DoSiSaveTestL(); +#endif + + CleanupStack::PushL(siSave); + OutputMessageDetailsL(*siSave); + msgEntryId = siSave->Entry().Id(); + + __LOG_ALWAYS("***** TEST RESTORING DATA INTO NEW PUSH ENTRY *****"); + CSIPushMsgEntry* siLoad = NULL; + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; //reset loop variables + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,siLoad = DoSiRetrieveTestL(msgEntryId)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSiRetrieveTestL(msgEntryId)"), failCount); + finished = ETrue; + } + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + siLoad = DoSiRetrieveTestL(msgEntryId); +#endif + CleanupStack::PushL(siLoad); + + OutputMessageDetailsL(*siLoad); + CleanupStack::PopAndDestroy(2); //siLoad, siSave + __LOG_ALWAYS("***** SI SAVE/RETRIEVE - TEST SUCCESSFUL ******"); + if (iDetails->iNullEntries) + iSINullMsg = msgEntryId; // Hold the id of the null entry for a later test + else + iSIToChange = msgEntryId; //Hold the id of the non null entry for changing later + } + +CSIPushMsgEntry* CPushEntryTester::DoSiSaveTestL() + { + CSIPushMsgEntry* siSave=NULL; + if (iState==ETestSISaveRetrieveWithStringAppID) + { + siSave = CSIPushMsgEntry::NewL(); + } + else if (iState==ETestSISaveRetrieveWithIntAppID) + { + TInt tmp=5432; + siSave = CSIPushMsgEntry::NewL(tmp); + } + else + { + siSave = CSIPushMsgEntry::NewL(); + } + + CleanupStack::PushL(siSave); + siSave->SetIdL(*iDetails->iSiId); + siSave->SetHeaderL(*iDetails->iHeader); + siSave->SetAction(iDetails->iActionFlag); + siSave->SetStatus(iDetails->iStatusFlag); +// siSave->SetCreated(iDetails->iCreated); + + siSave->SetExpires(iDetails->iExpires); + siSave->SetUrlL(*iDetails->iURL); + siSave->SetTextL(*iDetails->iText); + siSave->SetFromL(*iDetails->iFrom); + + TTime now; + now.UniversalTime(); + siSave->SetCreated(now); + + if (iPushMsgFolderId ==KMsvNullIndexEntryId) + iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId); + siSave->SaveL(iPushUtilities->Session(),iPushMsgFolderId); + CleanupStack::Pop(); + return siSave; + } + +CSIPushMsgEntry* CPushEntryTester::DoSiRetrieveTestL(TMsvId aMsgId) + { + CSIPushMsgEntry* siLoad = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siLoad); + siLoad->RetrieveL(iPushUtilities->Session(), aMsgId); + CleanupStack::Pop(); + return siLoad; // for displaying data + } + + +// Tests use of get/set methods on a CSLPushMsgEntry +// Create new entry,set values on TMsvEntry,set Push Entry, display & set new values +void CPushEntryTester::SlGetSetTestL() + { + CSLPushMsgEntry* slEntry = NULL; + __LOG_ALWAYS("***** TESTING SL SETTER FUNCTIONS *****"); + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,slEntry = DoSlCreateTestL()); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSlCreateTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + slEntry = DoSlCreateTestL(); +#endif + CleanupStack::PushL(slEntry); + OutputMessageDetailsL(*slEntry); + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoSlSetTestL(*slEntry)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSlSetTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + DoSlSetTestL(*slEntry); +#endif + + OutputMessageDetailsL(*slEntry); + CleanupStack::PopAndDestroy(); //slEntry + __LOG_ALWAYS("***** SL PUSH ENTRY SET/GET - TEST SUCCESSFUL ******"); + } + +CSLPushMsgEntry* CPushEntryTester::DoSlCreateTestL() + { + TMsvEntry entry; + entry.iServiceId = 0x0999999; // Dummy value + entry.iMtm.iUid = 0x11111111; //Silly value + entry.iBioType = 0x44444444; //another silly value + entry.iType = KUidMsvMessageEntry; + entry.SetMtmData1(0x1FF); + + CSLPushMsgEntry* slEntry = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slEntry); + slEntry->SetEntry(entry); + slEntry->SetHeaderL(iDummyHeader2); + slEntry->SetUrlL(KUrl3); + + slEntry->SetMsgDescriptionL(_L("http://www.waffle.com")); + slEntry->SetTimeSent(KDateExpiry4); + slEntry->SetMsgDetailsL(_L("Henry Higgins")); + + CleanupStack::Pop(); + return slEntry; + } + +void CPushEntryTester::DoSlSetTestL(CSLPushMsgEntry& aSlEntry) + { + aSlEntry.SetAction(iDetails->iActionFlag); + aSlEntry.SetFromL(*iDetails->iFrom); + aSlEntry.SetStatus(iDetails->iStatusFlag); + aSlEntry.SetUrlL(*iDetails->iURL); + aSlEntry.SetTimeSent(iDetails->iCreated); + aSlEntry.SetHeaderL(*iDetails->iHeader); + } + + +// Tests the Save and Retrieve functions - saves a message and then loads it - should remain unchanged +void CPushEntryTester::SlSaveRetrieveTestL() + { + TMsvId msgEntryId; + CSLPushMsgEntry* slSave = NULL; + + __LOG_ALWAYS("***** TEST STORING NEW SL PUSH ENTRY DATA *****"); // Log details + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,slSave = DoSlSaveTestL()); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSlSaveTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + slSave = DoSlSaveTestL(); +#endif + + CleanupStack::PushL(slSave); + msgEntryId = slSave->Entry().Id(); + OutputMessageDetailsL(*slSave); + + CSLPushMsgEntry* slLoad = NULL; +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,slLoad = DoSlRetrieveTestL(msgEntryId)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoSlRetrieveTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + // Check if error is out of memory + gTest(error == KErrNoMemory); + __UHEAP_RESET; + } + } +#else + slLoad = DoSlRetrieveTestL(msgEntryId); +#endif + + CleanupStack::PushL(slLoad); + __LOG_ALWAYS("***** TEST RESTORING DATA INTO NEW PUSH ENTRY *****"); + OutputMessageDetailsL(*slLoad); + CleanupStack::PopAndDestroy(2); //slLoad, slSave + + if (iDetails->iNullEntries) + iSLNullMsg = msgEntryId; + else + iSLToChange = msgEntryId; //Hold the id of the non null entry for changing later + __LOG_ALWAYS("***** SL SAVE/RETRIEVE - TEST SUCCESSFUL ******"); + } + +CSLPushMsgEntry* CPushEntryTester::DoSlSaveTestL() + { + CSLPushMsgEntry* slSave = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slSave); + slSave->SetHeaderL(*iDetails->iHeader); + slSave->SetUrlL(*iDetails->iURL); + slSave->SetFromL(*iDetails->iFrom); + slSave->SetTimeSent(iDetails->iCreated); + slSave->SetAction(iDetails->iActionFlag); + slSave->SetStatus(iDetails->iStatusFlag); + if (iPushMsgFolderId==KMsvNullIndexEntryId) + iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId); + slSave->SaveL(iPushUtilities->Session(), iPushMsgFolderId); + CleanupStack::Pop(); + return slSave; + } + +CSLPushMsgEntry* CPushEntryTester::DoSlRetrieveTestL(TMsvId aId) + { + CSLPushMsgEntry* slLoad = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slLoad); //slEntry + slLoad->RetrieveL(iPushUtilities->Session(), aId); + CleanupStack::Pop(); + return slLoad; + } + + +// Tests use of get/set methods on a CMultiPushMsgEntry +// Create new entry,set values on TMsvEntry,set Push Entry, display & set new values +void CPushEntryTester::MultiGetSetTestL() + { + CMultiPartPushMsgEntry* multiEntry = NULL; + __LOG_ALWAYS("***** TESTING MULTIPART SETTER FUNCTIONS *****"); +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,multiEntry= DoMultiCreateTestL()); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoMultiCreateTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + multiEntry = DoMultiCreateTestL();; +#endif + CleanupStack::PushL(multiEntry); + OutputMessageDetailsL(*multiEntry); + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoMultiSetTestL(*multiEntry) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoMultiSetTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + DoMultiSetTestL(*multiEntry); +#endif + OutputMessageDetailsL(*multiEntry); + CleanupStack::PopAndDestroy(); //multiEntry + __LOG_ALWAYS("***** MULTIPART SET/GET - TEST SUCCESSFUL ******"); + } + + +CMultiPartPushMsgEntry* CPushEntryTester::DoMultiCreateTestL() + { + TMsvEntry entry; + entry.iServiceId = KMsvLocalServiceIndexEntryId; + entry.iMtm.iUid = 0x11111111; //Silly value + entry.iBioType = 0x44444444; //another silly value + entry.iType = KUidMsvMessageEntry; + entry.SetMtmData1(0x1FF); + + CMultiPartPushMsgEntry* multiEntry = CMultiPartPushMsgEntry::NewL(); + CleanupStack::PushL(multiEntry); + multiEntry->SetEntry(entry); + multiEntry->SetFromL(_L8("Eliza Dolittle")); + multiEntry->SetContentTypeL(KMultiContent); + multiEntry->SetStatus(6); + multiEntry->SetTimeSent(KDateExpiry3); + multiEntry->SetMsgDescriptionL(*iDetails->iText); + + CleanupStack::Pop(); + return multiEntry; + } + +void CPushEntryTester::DoMultiSetTestL(CMultiPartPushMsgEntry& aMultiEntry) + { + aMultiEntry.SetFromL(*iDetails->iFrom); + aMultiEntry.SetHeaderL(iDummyHeader1); + aMultiEntry.SetStatus(iDetails->iStatusFlag); + aMultiEntry.SetContentTypeL(*iDetails->iContentType); + aMultiEntry.SetTimeSent(iDetails->iCreated); + } + +void CPushEntryTester::MultiSaveRetrieveTestL() + { + TMsvId msgEntryId; + CMultiPartPushMsgEntry* multiSave = NULL; + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,multiSave = DoMultiSaveTestL() ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoMultiSaveTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + multiSave = DoMultiSaveTestL(); +#endif + CleanupStack::PushL(multiSave); + __LOG_ALWAYS("***** TEST STORING NEW MULTI PUSH ENTRY DATA *****"); // Log details + msgEntryId = multiSave->Entry().Id(); + CreateMultiChildrenL(msgEntryId); + OutputMessageDetailsL(*multiSave); + + __LOG_ALWAYS("***** TESTING RESTORING DATA INTO NEW PUSH ENTRY *****"); + CMultiPartPushMsgEntry* multiLoad = NULL; + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, multiLoad = DoMultiRetrieveTestL(msgEntryId) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoMultiRetrieveTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + multiLoad = DoMultiRetrieveTestL(msgEntryId); +#endif + + CleanupStack::PushL(multiLoad); + OutputMessageDetailsL(*multiLoad); + + // Get the child entries - don't bother with heap testing - tested with Unknown Entries + iMsvEntry->SetEntryL(msgEntryId); + CMsvEntrySelection* children = iMsvEntry->ChildrenL(); + CleanupStack::PushL(children); + CUnknownPushMsgEntry* unknownMsg = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unknownMsg); + + for (TInt loop=0; loopCount(); loop++) + { + __LOG_DEBUG("***** Details of MultiPart Child entry *****"); + unknownMsg->RetrieveL(iPushUtilities->Session(), children->At(loop)); + OutputMessageDetailsL(*unknownMsg); + } + + CleanupStack::PopAndDestroy(4); //unknownMsg, children, multiLoad, multiSave + __LOG_ALWAYS("***** MULTIPART SAVE/RETRIEVE - TEST SUCCESSFUL ******"); + } + + +CMultiPartPushMsgEntry* CPushEntryTester::DoMultiSaveTestL() + { + CMultiPartPushMsgEntry* multiSave = CMultiPartPushMsgEntry::NewL(); + CleanupStack::PushL(multiSave); + multiSave ->SetHeaderL(*iDetails->iHeader); + multiSave ->SetStatus(iDetails->iStatusFlag); + if (iDetails->iNullEntries) + multiSave ->SetContentTypeL(*iDetails->iContentType); + else + multiSave->SetContentTypeL(_L("multipart/related")); + multiSave ->SetFromL(*iDetails->iFrom); + multiSave ->SetTimeSent(iDetails->iCreated); + multiSave->SaveL(iPushUtilities->Session(),KMsvGlobalInBoxIndexEntryId); + CleanupStack::Pop(); + return multiSave; + } + +CMultiPartPushMsgEntry* CPushEntryTester::DoMultiRetrieveTestL(TMsvId aId) + { + CMultiPartPushMsgEntry* multiLoad = CMultiPartPushMsgEntry::NewL(); + CleanupStack::PushL(multiLoad); + multiLoad->RetrieveL(iPushUtilities->Session(), aId); + CleanupStack::Pop(); + return multiLoad; + } + +// Tests use of get/set methods on a CSLUnknownMsgEntry +// Create new entry,set values on TMsvEntry,set Push Entry, display & set new values +void CPushEntryTester::UnknownGetSetTestL() + { + __LOG_ALWAYS("***** TESTING UNKNOWN SETTER FUNCTIONS *****"); + CUnknownPushMsgEntry* unknownEntry= NULL; + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,unknownEntry = DoUnknownCreateTestL() ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoUnknownCreateTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + unknownEntry = DoUnknownCreateTestL(); +#endif + + CleanupStack::PushL(unknownEntry); + OutputMessageDetailsL(*unknownEntry); + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoUnknownSetTestL(*unknownEntry) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoUnknownSetTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + DoUnknownSetTestL(*unknownEntry); +#endif + OutputMessageDetailsL(*unknownEntry); + + __LOG_ALWAYS("***** UNKNOWN SET/GET - TEST SUCCESSFUL ******"); + CleanupStack::PopAndDestroy(); + } + +CUnknownPushMsgEntry* CPushEntryTester::DoUnknownCreateTestL() + { + TMsvEntry entry; + + entry.iServiceId = KMsvLocalServiceIndexEntryId; + entry.iMtm.iUid = 0x11111111; //Silly value + entry.iType = KUidMsvMessageEntry; + entry.SetMtmData1(0x1FF); //511 + + CUnknownPushMsgEntry* unknownEntry = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unknownEntry); unknownEntry->SetEntry(entry); + unknownEntry->SetContentTypeL(_L("multipart/unrelated")); + unknownEntry->SetStatus(3); + unknownEntry->SetTimeSent(KDateExpiry4); + unknownEntry->SetFromL(_L8("Henry Higgins")); + unknownEntry->SetHeaderL(iDummyHeader2); + unknownEntry->SetMessageDataL(_L8("A long long piece of text for the message body...........")); + unknownEntry->SetTimeSent(iDetails->iCreated); + unknownEntry->SetMsgDescriptionL(*iDetails->iText); + unknownEntry->SetContentFileNameL(KFilename); + + CleanupStack::Pop(); + return unknownEntry; + } + + +void CPushEntryTester::DoUnknownSetTestL(CUnknownPushMsgEntry& aUnknownEntry) + { + aUnknownEntry.SetStatus(iDetails->iStatusFlag); + aUnknownEntry.SetContentTypeL(*iDetails->iContentType); + aUnknownEntry.SetStatus(iDetails->iStatusFlag); + aUnknownEntry.SetFromL(*iDetails->iFrom); + aUnknownEntry.SetHeaderL(*iDetails->iHeader); + aUnknownEntry.SetTimeSent(iDetails->iCreated); + aUnknownEntry.SetMessageDataL(*iDetails->iMessageBody); + aUnknownEntry.SetContentFileNameL(*iDetails->iFilename); + } + +void CPushEntryTester::UnknownSaveRetrieveTestL(TBool aFilename) + { + TMsvId msgEntryId; + CUnknownPushMsgEntry* unknownSave= NULL; + CUnknownPushMsgEntry* unknownLoad = NULL; + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, unknownSave = DoUnknownSaveTestL(aFilename) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoUnknownSaveTestL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + unknownSave = DoUnknownSaveTestL(aFilename); +#endif + CleanupStack::PushL(unknownSave); + msgEntryId = unknownSave->Entry().Id(); + + __LOG_DEBUG("***** STORING NEW UNKNOWN PUSH ENTRY DATA *****"); + OutputMessageDetailsL(*unknownSave); + +#if defined (__HEAP_FAILURE_TESTING) + error = KErrNone; + finished = EFalse; + failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,unknownLoad = DoUnknownRetrieveTestL(msgEntryId) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoUnknownRetriveTestL()()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#else + unknownLoad = DoUnknownRetrieveTestL(msgEntryId); +#endif + CleanupStack::PushL(unknownLoad); + + __LOG_DEBUG("***** TESTING RESTORING DATA INTO NEW PUSH ENTRY *****"); + + if (!iDetails->iNullEntries) + iUnknownToChange = msgEntryId; + OutputMessageDetailsL(*unknownLoad); + CleanupStack::PopAndDestroy(2);// unknownLoad,unknownSave + __LOG_ALWAYS("***** UNKNOWN SAVE/RETRIEVE - TEST SUCCESSFUL ******"); + } + + +CUnknownPushMsgEntry* CPushEntryTester::DoUnknownSaveTestL(TBool aFilename) + { + CUnknownPushMsgEntry* unknownSave = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unknownSave); + unknownSave->SetHeaderL(*iDetails->iHeader); + unknownSave->SetContentTypeL(*iDetails->iContentType); + if (aFilename) + unknownSave->SetContentFileNameL(*iDetails->iFilename); + unknownSave->SetMessageDataL(*iDetails->iMessageBody); + unknownSave->SetStatus(iDetails->iStatusFlag); + unknownSave->SetFromL(*iDetails->iFrom); + unknownSave->SetTimeSent(iDetails->iCreated); + + unknownSave->SaveL(iPushUtilities->Session(), KMsvGlobalInBoxIndexEntryId); + CleanupStack::Pop(); + return unknownSave; + } + +CUnknownPushMsgEntry* CPushEntryTester::DoUnknownRetrieveTestL(TMsvId aId) + { + CUnknownPushMsgEntry* unknownLoad = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unknownLoad); + unknownLoad->RetrieveL(iPushUtilities->Session(), aId); + CleanupStack::Pop(); + return unknownLoad; + } + +void CPushEntryTester::ChangeSIEntryTestL() + { + // Retrieve has already been tested previously + CSIPushMsgEntry* siMsg = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siMsg); + siMsg->RetrieveL(iPushUtilities->Session(), iSIToChange); + __LOG_DEBUG("***** ORIGINAL SI ENTRY *****"); + OutputMessageDetailsL(*siMsg); + +#if defined (__HEAP_FAILURE_TESTING) +// Uncomment the following lines & check CommitL in UpdateL if you want to test +// if it leaves the message in an partially changed state. +// for (TInt loop = 0; loop<100; loop++) +// { + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoChangeSiEntryL(*siMsg) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoChangeSiEntryL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +// } + +#ifndef _DEBUG + failCount =1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else +// DoSiChangeEntryL(*siMsg); +#endif + + __LOG_DEBUG("***** UPDATED SI ENTRY *****"); + OutputMessageDetailsL(*siMsg); + __LOG_ALWAYS("***** CHANGING SI ENTRY - TEST SUCCESSFUL *****"); + CleanupStack::PopAndDestroy(); + + +} + + +void CPushEntryTester::DoChangeSiEntryL(CSIPushMsgEntry& aSiMsg) + { + aSiMsg.SetCreated(KDateExpiry4); + aSiMsg.SetExpires(KDateExpiry4); + aSiMsg.SetIdL(KSiID6); + aSiMsg.SetUrlL(KUrl2); + aSiMsg.SetHeaderL(iDummyHeader2); + aSiMsg.SetFromL(KFrom); + aSiMsg.SetAction(4); // Undefined value to test it + aSiMsg.SetStatus(4); + aSiMsg.SetTextL(KUrl5); + aSiMsg.UpdateL(iPushUtilities->Session()); + } + + +void CPushEntryTester::ChangeSLEntryTestL() + { + CSLPushMsgEntry* slMsg = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slMsg); + + slMsg->RetrieveL(iPushUtilities->Session(), iSLToChange); + __LOG_ALWAYS("***** RETRIEVING ORIGINAL SL ENTRY *****"); + OutputMessageDetailsL(*slMsg); + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoChangeSlEntryL(*slMsg) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoChangeSlEntryL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount =1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else +// DoSlChangeEntryL(*slMsg); +#endif + __LOG_ALWAYS("***** UPDATED SL ENTRY *****"); + OutputMessageDetailsL(*slMsg); + __LOG_ALWAYS("***** CHANGING SL ENTRY - TEST SUCCESSFUL *****"); + CleanupStack::PopAndDestroy(); + } + + +void CPushEntryTester::DoChangeSlEntryL(CSLPushMsgEntry& aSlMsg) + { + aSlMsg.SetHeaderL(iDummyHeader2); + aSlMsg.SetAction(3); // Undefined value to test it + aSlMsg.SetStatus(4); + aSlMsg.SetUrlL(KUrl6); + aSlMsg.SetTimeSent(KDateExpiry3); + aSlMsg.UpdateL(iPushUtilities->Session()); + } + + +void CPushEntryTester::ChangeUnknownEntryTestL(TBool aFilename) + { + CUnknownPushMsgEntry* unkMsg = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unkMsg); + + unkMsg->RetrieveL(iPushUtilities->Session(), iUnknownToChange); + __LOG_ALWAYS("***** RETRIEVING ORIGINAL SL ENTRY *****"); + OutputMessageDetailsL(*unkMsg); + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,DoChangeUnknownEntryL(*unkMsg, aFilename) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling DoChangeUnknownEntryL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount =1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else + DoChangeUnknownEntryL(*unkMsg, aFilename); +#endif + __LOG_ALWAYS("***** UPDATED UNKNOWN ENTRY *****"); + OutputMessageDetailsL(*unkMsg); + __LOG_ALWAYS("***** CHANGING UNKNOWN ENTRY - TEST SUCCESSFUL *****"); + CleanupStack::PopAndDestroy(); + } + + +void CPushEntryTester::DoChangeUnknownEntryL(CUnknownPushMsgEntry& aUnkMsg, TBool aFilename) + { + aUnkMsg.SetHeaderL(iDummyHeader2); + aUnkMsg.SetStatus(4); + aUnkMsg.SetTimeSent(KDateExpiry3); + if (aFilename) + aUnkMsg.SetContentFileNameL(KFilename2); + aUnkMsg.SetMessageDataL(KDummyBody2); + aUnkMsg.UpdateL(iPushUtilities->Session()); + } + + + +// Harded coded target Id string - we store the TMsvId during CreateMoreSiMessages. +void CPushEntryTester::FindSiIdTestL(TBool aSearchForNullStr) + { + __LOG_ALWAYS("***** TESTING FINDING SI ID *****"); + + TPtrC ptr; + TBuf<255> buffer; + if (aSearchForNullStr) + ptr.Set(KNullDesC); + else + ptr.Set(KSiID3); + + CMsvEntrySelection* msgSel = NULL; + + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, + msgSel = iSISLPushUtilities->FindSiIdLC(ptr); + CleanupStack::Pop(); + ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling msgSel = WapPushMsgUtils::FindSiIdLC(ptr)"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount =1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else + msgSel = iSISLPushUtilities->FindSiIdLC(ptr); + CleanupStack::Pop(); // make the cleanup calls match Heap Testing +#endif + CleanupStack::PushL(msgSel); + + buffer.Format(_L("Search for '%S' yielded %d msg "), &ptr, msgSel->Count()); + LogStr(buffer); + + for (TInt count =0; count Count(); count++) + { + TBuf<255> buffer; + buffer.Format(_L("Search for '%S' yielded msg %d with Id 0x%08X"), &ptr, count, msgSel->At(count)); +// __LOG_DEBUG(buffer); + } + + // Normally Should only be one entry in array and that should be equal to iSINullMsg + // With Heap Failure testing switched on, get lots of partially complete entries. + if ( (aSearchForNullStr && (msgSel->Find(iSINullMsg)!=KErrNotFound) ) + || (!aSearchForNullStr && (msgSel->Find(iTargetSiIDMsg)!=KErrNotFound) ) ) + + { + __LOG_ALWAYS("***** FIND SI ID - TEST SUCCESSFUL *****"); + } + else + { + iFailures++; + __LOG_ALWAYS("***** FIND SI ID - TEST FAILED *****"); + } + CleanupStack::PopAndDestroy(); //msgSel + } + + +void CPushEntryTester::FindUrlTestL(TBool aSearchForNullStr, TUid aUid) + { + TPtrC ptr; + TBuf<255> buffer; + TMsvId targetId =KMsvNullIndexEntryId; + TPtrC displayPtr; + + if (aUid ==KUidWapPushMsgSI) + { + displayPtr.Set(_L("SI ")); + targetId = aSearchForNullStr?iSINullMsg:iTargetSIUrlMsg; + ptr.Set(aSearchForNullStr ? TPtrC(KNullDesC) : TPtrC(KUrl3) ); + } + else if (aUid ==KUidWapPushMsgSL) + { + displayPtr.Set(_L("SL ")); + targetId = aSearchForNullStr ? iSLNullMsg:iTargetSLUrlMsg; + ptr.Set(aSearchForNullStr ? TPtrC(KNullDesC):TPtrC(KUrl3) ); + } + + LogFormatStr(_L("***** TESTING FINDING A %S MSG URL *****"), displayPtr); + + TMsvId msgId = KMsvNullIndexEntryId; +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error,msgId = iSISLPushUtilities->FindUrlL(ptr, aUid) ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling msgSel = WapPushMsgUtils::FindSiIdLC()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount =1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else + msgId = iSISLPushUtilities->FindUrlL(ptr, aUid); +#endif + + buffer.Format(_L("Searched messages of type 0x%08X with Url '%S'"),KUidWapPushMsgSI.iUid, &ptr); + LogStr(buffer); + LogFormatInt(_L("Find operation yielded Id 0x%08X"), msgId); + if ( msgId == targetId) + { + LogFormatStr(_L("***** FIND %S URL - TEST SUCCESSFUL *****"), displayPtr); + } + else + { + iFailures++; + LogFormatStr(_L("***** FIND %S URL - TEST FAILED *****"), displayPtr); + } + } + + +void CPushEntryTester::GetActionTestL(TUid aPushType) + { + TPtrC ptr; + TMsvId targetId; + TMsvId resultId = KMsvNullIndexEntryId; + + if (aPushType ==KUidWapPushMsgSI) + { + ptr.Set(_L("SI")); + targetId = iHighestSIActionID; + } + else + { + ptr.Set(_L("SL")); + targetId = iHighestSLActionID; + } + LogFormatStr(_L("***** TESTING FINDING HIGHEST %S ACTION *****"), ptr); + + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, resultId = iSISLPushUtilities->GetHighestActionL(aPushType)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling msgSel = WapPushMsgUtils::GetHighestActionL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } +#ifndef _DEBUG + failCount = 1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else // if no Heap Failure testing + resultId = iSISLPushUtilities->GetHighestActionL(aPushType); +#endif + + + LogFormatInt(_L("Get Action operation for Msg Type 0x%08X, yielded Id 0x%08X"), aPushType.iUid, resultId); + + if (targetId ==resultId) + { + LogFormatStr(_L("***** FIND HIGHEST %S ACTION - TEST SUCCESSFUL *****"), ptr); + } + else + { + iFailures++; + LogFormatStr(_L("***** FIND HIGHEST %S ACTION - TEST FAILED *****"), ptr); + } + } + +void CPushEntryTester::GetExpiryTestL() + { + __LOG_ALWAYS("***** TESTING FINDING EARLIEST EXPIRY *****"); + +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, iExpired = iSISLPushUtilities->GetNextExpiryL() ); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling msgSel = WapPushMsgUtils::GetNextExpiryL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount = 1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else + iExpired = iSISLPushUtilities->GetNextExpiryL(); +#endif + + CSIPushMsgEntry* siMsg = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siMsg); + if (iExpired != KMsvNullIndexEntryId) //Otherwise Retrieve panics!! + { + siMsg->RetrieveL(iPushUtilities->Session(), iExpired); + OutputMessageDetailsL(*siMsg); + TBuf<100> temp; + TTime expiryDate = siMsg->Expires().Int64(); + expiryDate.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + TPtrC ptr; + ptr.Set(temp); + LogFormatStr(_L("Next Expirys date := %S"), ptr); + __LOG_ALWAYS("***** FIND NEXT EXPIRY - TEST SUCCESSFUL *****"); + + } + else + { + __LOG_ALWAYS("***** FIND NEXT EXPIRY - TEST FAILED *****"); + } + CleanupStack::PopAndDestroy(); //siMsg + } + + +void CPushEntryTester::DeleteEarliestExpiryL() + { +#if defined (__HEAP_FAILURE_TESTING) + TInt error = KErrNone; + TBool finished = EFalse; + TInt failCount = 0; + while(!finished) + { + __UHEAP_FAILNEXT(failCount++); + TRAP(error, iSISLPushUtilities->DeleteEntryL(iExpired)); + if (error == KErrNone) + { + __UHEAP_RESET; + LogFormatInt(_L("Made %d attempts at calling msgSel = WapPushMsgUtils::DeleteEntryL()"), failCount); + finished = ETrue; + } + else // Handle error + { + gTest(error == KErrNoMemory);// Check if error is out of memory + __UHEAP_RESET; + } + } + +#ifndef _DEBUG + failCount = 1; // Bodge to stop compiler complaining on Non Debug builds +#endif + +#else + iSISLPushUtilities->DeleteEntryL(iExpired); +#endif + CMsvEntry* msvEntry = iPushUtilities->Session().GetEntryL(iExpired); + CleanupStack::PushL(msvEntry); + TMsvEntry entry = msvEntry->Entry(); + if (CWapPushMsgUtils::IsDeleted(entry)) + { + LogFormatInt(_L("Msg 0x%08X has been flagged for deletion"), iExpired); + } + else + { + LogFormatInt(_L("Msg 0x%08X has not been flagged for deletion"), iExpired); + } + + CleanupStack::PopAndDestroy();//msvEntry + } + + + +// Use if you want to see the contents of ALL the messages for a particular type +void CPushEntryTester::DumpPushMessageDetailsL(TUid aPushType) + { + TPtrC ptr; + TBuf<255> buffer; + if (aPushType== KUidWapPushMsgSI) + ptr.Set(_L("SI")); + else if (aPushType ==KUidWapPushMsgSL) + ptr.Set(_L("SL")); + else if (aPushType == KUidWapPushMsgMultiPart) + ptr.Set(_L("MULTI")); + else if (aPushType == KUidWapPushMsgUnknown) + ptr.Set(_L("UNKNOWN")); + else + ptr.Set(_L("Unrecognised type")); + + LogFormatStr(_L("***** Displaying details of all %S messages *****"),ptr); + + TMsvSelectionOrdering sort; + sort.SetShowInvisibleEntries(ETrue); + iMsvEntry->SetSortTypeL(sort); + + if (iPushMsgFolderId ==KMsvNullIndexEntryId) // Shouldn't be + iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId); + + iMsvEntry->SetEntryL(iPushMsgFolderId); + CMsvEntrySelection* children; + children = iMsvEntry->ChildrenWithMtmL(KUidMtmWapPush); + CleanupStack::PushL(children); + + CMsvEntrySelection* pushSel = new (ELeave) CMsvEntrySelection; + CleanupStack::PushL(pushSel); + + for (TInt count = 0; count Count(); count++) + { + iMsvEntry->SetEntryL(children->At(count)); + if (iMsvEntry->Entry().iBioType == aPushType.iUid) + pushSel->AppendL(children->At(count)); + } + + buffer.Format(_L("***** Have %d %S messages in folder ******"), pushSel->Count(), &ptr); + LogStr(buffer); + for (TInt out=0; out< pushSel->Count(); out++) + { + if (pushSel->At(out) != KMsvNullIndexEntryId) + { + TBool streamExists=EFalse; + iMsvEntry->SetEntryL(pushSel->At(out)); + + LogFormatInt(_L("Details for message %d"), out+1); + if (iMsvEntry->HasStoreL()) + { + CMsvStore* store = iMsvEntry->ReadStoreL(); + CleanupStack::PushL(store); + if (store->IsPresentL(aPushType) ) + streamExists =ETrue; + CleanupStack::PopAndDestroy(); + } + if (streamExists) + { + if (aPushType == KUidWapPushMsgSI) + { + CSIPushMsgEntry* siMsg = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siMsg); + siMsg->RetrieveL(iPushUtilities->Session(), pushSel->At(out)); + OutputMessageDetailsL(*siMsg); + CleanupStack::PopAndDestroy(); + } + else if (aPushType == KUidWapPushMsgSL) + { + CSLPushMsgEntry* slMsg = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slMsg); + slMsg->RetrieveL(iPushUtilities->Session(), pushSel->At(out)); + OutputMessageDetailsL(*slMsg); + CleanupStack::PopAndDestroy(); + } + else if (aPushType == KUidWapPushMsgMultiPart) + { + CMultiPartPushMsgEntry* multiMsg = CMultiPartPushMsgEntry::NewL(); + CleanupStack::PushL(multiMsg); + multiMsg->RetrieveL(iPushUtilities->Session(), pushSel->At(out)); + OutputMessageDetailsL(*multiMsg); + CleanupStack::PopAndDestroy(); + } + else if (aPushType == KUidWapPushMsgUnknown) + { + CUnknownPushMsgEntry* unknownMsg = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(unknownMsg); + unknownMsg->RetrieveL(iPushUtilities->Session(), pushSel->At(out)); + OutputMessageDetailsL(*unknownMsg); + CleanupStack::PopAndDestroy(); + } + + } + else + { + __LOG_DEBUG("No stream found!. Not a proper a Push Message."); + OutputTMsvEntryDetailsL(iMsvEntry->Entry()); + buffer.Format(_L("%S Msg 0x%08X Stream with %S Uid not found"),ptr, iMsvEntry->Entry().Id(), ptr); + } + } + } + CleanupStack::PopAndDestroy(2); //siSel, children + iMsvEntry->SetEntryL(KMsvRootIndexEntryId); + } + + + +void CPushEntryTester::CreateHeaders() + { + TUint8 value=0; + TInt i; + for (i=0; i<34; i++) + { + value = KMessageHeader2[i]; + iDummyHeader1.Append(value); + } + + for (i=0; i<9; i++) + { + value = KMessageHeader3[i]; + iDummyHeader2.Append(value); + } + } + + + + +void CPushEntryTester::CreateMsgDetailsL(TBool aNullFields) + { + iDetails->ResetL(); + if (aNullFields) // ==ETrue + { + iDetails->iNullEntries = ETrue; + return; + } + iDetails->iNullEntries =EFalse; + *iDetails->iSiId = KSiID1; + iDetails->iStatusFlag = 4; // Not a valid value, but tests that it's set okay + iDetails->iActionFlag = 1; // CSIPushMsgEntry::ESIPushMsgSignalNone & CSLPushMsgEntry::ESLPushMsgExecuteLow; + //iCreated leave as is 00.00.00 GMT 00-00-0000 + iDetails->iCreated=KDateExpiry1; + iDetails->iExpires=KDateExpiry1; // 12.00.00 GMT 26-07-2000 + *iDetails->iContentType =_L("image/jpeg"); + *iDetails->iURL=KUrl1; + *iDetails->iText=_L("Some Text"); + *iDetails->iFrom =_L8("Fred Smith"); + *iDetails->iHeader =iDummyHeader1; + *iDetails->iMessageBody=KDummyBody; + *iDetails->iFilename = KFilename; + } + +// Create another 4 SI Push Entries in the message folder. +void CPushEntryTester::CreateMoreSiMessagesL() + { + TMsvId msgEntryId =0; + TBuf<255> buffer; + + CreateMsgDetailsL(EFalse); + if (iPushMsgFolderId ==KMsvNullIndexEntryId) + iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId); + __LOG_DEBUG("Created additional SI Entries"); + for (TInt count =0; count<4; count++) + { + CSIPushMsgEntry* siMsg = CSIPushMsgEntry::NewL(); + CleanupStack::PushL(siMsg); + + siMsg->SetHeaderL(*iDetails->iHeader); + siMsg->SetStatus(iDetails->iStatusFlag); + siMsg->SetCreated(iDetails->iCreated); + siMsg->SetTextL(*iDetails->iText); + siMsg->SetFromL(*iDetails->iFrom); + switch (count) + { + case 0: + siMsg->SetIdL(KSiID2); + siMsg->SetUrlL(KUrl2); + siMsg->SetExpires(KDateExpiry2); + break; + case 1: + siMsg->SetIdL(KSiID3); + siMsg->SetUrlL(KUrl3); + siMsg->SetExpires(KDateExpiry3); + break; + case 2: + siMsg->SetIdL(KSiID4); + siMsg->SetUrlL(KUrl4); + siMsg->SetExpires(KDateExpiry4); + break; + case 3: + siMsg->SetIdL(KSiID5); + siMsg->SetUrlL(KUrl5); + siMsg->SetExpires(KDateExpiry5); + break; + } + siMsg->SetAction(count+2); + msgEntryId = siMsg->SaveL(iPushUtilities->Session(),iPushMsgFolderId); + TTime expiryDate = siMsg->Expires().Int64(); + expiryDate.FormatL(buffer, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + LogFormatStr(_L("Expires date := %S"), buffer); + + + buffer.Format(_L("Msg 0x%08X with ID=%S, URL=%S, Action=%d"), + msgEntryId, &(siMsg->Id()), &(siMsg->Url()),count+2); + LogStr(buffer); + + if (count == 1) + { + iTargetSiIDMsg = msgEntryId; + iTargetSIUrlMsg = msgEntryId; + } + CleanupStack::PopAndDestroy(); + } + iHighestSIActionID = msgEntryId; //Hold on to this for later check + } + + +void CPushEntryTester::CreateMoreSLMessagesL() + { + TMsvId msgEntryId =0; + TBuf<255> buffer; + + CreateMsgDetailsL(EFalse); + if (iPushMsgFolderId ==KMsvNullIndexEntryId) + iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId); + + for (TInt count =0; count<4; count++) + { + CSLPushMsgEntry* slMsg = CSLPushMsgEntry::NewL(); + CleanupStack::PushL(slMsg); + + slMsg->SetHeaderL(*iDetails->iHeader); + slMsg->SetStatus(iDetails->iStatusFlag); + slMsg->SetFromL(*iDetails->iFrom); + switch (count) + { + case 0: + slMsg->SetUrlL(KUrl2); + break; + case 1: + slMsg->SetUrlL(KUrl3); + break; + case 2: + slMsg->SetUrlL(KUrl4); + break; + case 3: + slMsg->SetUrlL(KUrl5); + break; + default: + slMsg->SetUrlL(*iDetails->iURL); + + } + slMsg->SetAction(count+2); + msgEntryId = slMsg->SaveL(iPushUtilities->Session(),iPushMsgFolderId); + buffer.Format(_L("Created SL message 0x%08X with URL = %S, Action = %d"), msgEntryId, &(slMsg->Url()), count+2); + LogStr(buffer); + if (count == 1) + iTargetSLUrlMsg = msgEntryId; + CleanupStack::PopAndDestroy();//slMsg + } + iHighestSLActionID = msgEntryId; //Hold on to this for later check + } + + + +void CPushEntryTester::CreateMultiChildrenL(TMsvId aParentEntry) + { + // Create and Save SI child entry + CUnknownPushMsgEntry* child = CUnknownPushMsgEntry::NewL(); + CleanupStack::PushL(child); + child->SetHeaderL(*iDetails->iHeader); + child->SetMessageDataL(*iDetails->iMessageBody); + child->SetContentTypeL(_L("text/vnd.wap.si")); + child->SetFromL(*iDetails->iFrom); + child->SaveL(iPushUtilities->Session(),aParentEntry); + + // Create and Save SL child entry + child->SetHeaderL(TPtrC8(KMessageHeader3)); + child->SetFromL(*iDetails->iFrom); + child->SetContentTypeL(_L("text/vnd.wap.sl")); + child->SetTimeSent(iDetails->iCreated); + child->SetMessageDataL(_L8("The body of a binary message - needs to be processed")); + child->SaveL(iPushUtilities->Session(), aParentEntry); + + // Create and Save WML child entry + child->SetHeaderL(TPtrC8(KMessageHeader3)); + child->SetFromL(*iDetails->iFrom); + child->SetContentTypeL(_L("text/vnd.wap.wml")); + child->SetTimeSent(iDetails->iCreated); + child->SetMessageDataL(_L8("\n \n ")); + child->SaveL(iPushUtilities->Session(), aParentEntry); + + // Create and Save HTML child entry + child->SetHeaderL(TPtrC8(KMessageHeader3)); + child->SetFromL(*iDetails->iFrom); + child->SetContentTypeL(_L("text/html")); + child->SetTimeSent(iDetails->iCreated); + child->SetMessageDataL(_L8(" Some HTML for a web page ")); + child->SaveL(iPushUtilities->Session(), aParentEntry); + + // Create and Save GIF child entry + child->SetHeaderL(TPtrC8(KMessageHeader3)); + child->SetFromL(*iDetails->iFrom); + child->SetContentTypeL(_L("image/gif")); + child->SetTimeSent(iDetails->iCreated); + child->SetMessageDataL(_L8("A binary GIF file qasdghgf92tkug;,b voif0r.,,ASFSrrf")); + child->SaveL(iPushUtilities->Session(), aParentEntry); + + // Create and Save XML child entry + child->SetHeaderL(TPtrC8(KMessageHeader3)); + child->SetFromL(*iDetails->iFrom); + child->SetContentTypeL(_L("application/xml")); + child->SetTimeSent(iDetails->iCreated); + child->SetMessageDataL(_L8(" A little bit of XML ")); + child->SaveL(iPushUtilities->Session(), aParentEntry); + + CleanupStack::PopAndDestroy(); + } + + + +// Prints & Logs the details of a TMsvEntry +void CPushEntryTester::OutputTMsvEntryDetailsL(const TMsvEntry& aEntry) + { + TPtrC truePtr; + TPtrC falsePtr; + + truePtr.Set(_L("ETrue")); + falsePtr.Set(_L("EFalse")); + + LogFormatInt(_L(" iID := 0x%08X"), aEntry.Id()); + LogFormatInt(_L(" Parent ID := 0x%08X"), aEntry.Parent()); + LogFormatInt(_L(" iService := 0x%08X"), aEntry.iServiceId); + LogFormatInt(_L(" iType := 0x%08X"), aEntry.iType.iUid); + LogFormatInt(_L(" iMtm := 0x%08X"), aEntry.iMtm.iUid); + LogFormatInt(_L(" iBioType := 0x%08X"), aEntry.iBioType); + LogFormatInt(_L(" iMtmData1 := %d"), aEntry.MtmData1()); + LogFormatInt(_L(" iMtmData2 := %d"), aEntry.MtmData2() ); + LogFormatInt(_L(" iMtmData3 := %d"), aEntry.MtmData3() ); + } + +void CPushEntryTester::OutputPushMsgDetailsL(const CPushMsgEntryBase& aEntry) + { + TBuf<100> temp; + TPtrC ptr; + + TTime date = aEntry.ReceivedDate(); + date.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + ptr.Set(temp); + LogFormatStr(_L(" Received Date := %S"),ptr); + + ptr.Set(aEntry.MsgDetails()); + LogFormatStr(_L(" iDetails(Url) := %S"),ptr); + ptr.Set(aEntry.MsgDescription()); + LogFormatStr(_L(" iDescription := %S"),ptr); + + TInt intID; + TBool isAnInt; + TPtrC8 ptr8; + if (aEntry.AppID(ptr8, intID, isAnInt)!=KErrNotFound) + { + if (isAnInt) + { + LogFormatInt(_L(" AppID := %d"), intID); + } + else + { + temp.Copy(ptr8); + LogFormatStr(_L(" AppID := %S"),temp); + } + } + } + +// Outputs the details of a SI Message - lists TMsvEntry first, +// then uses Push Entry functions - should be the same values where data's mapped to TMsvEntry +void CPushEntryTester::OutputMessageDetailsL(CSIPushMsgEntry& aSIEntry) + { + TMsvEntry entry = aSIEntry.Entry(); + TBuf<200> temp; + TBuf8<200> viewer; + TPtrC bufPtr; + + __LOG_DEBUG( " TMsvEntry values"); + OutputTMsvEntryDetailsL(entry); + OutputPushMsgDetailsL(aSIEntry); + + __LOG_DEBUG( " CSIPushMsgEntry values"); + LogFormatInt(_L(" Message Type := 0x%08X"), aSIEntry.Entry().iMtm.iUid); + LogFormatInt(_L(" Push Message Type := 0x%08X"), aSIEntry.PushMsgType()); + LogFormatInt(_L(" Status value := %d"), aSIEntry.Status()); + LogFormatInt(_L(" Action value := %d"), aSIEntry.Action()); + + viewer.Copy(aSIEntry.Id()); + bufPtr.Set(aSIEntry.Id()); + LogFormatStr(_L(" SI Id := %S"), bufPtr); + + TTime entryTime = aSIEntry.Created(); + temp.Zero(); + entryTime.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + bufPtr.Set(temp); + LogFormatStr(_L(" Created := %S"), bufPtr); + bufPtr.Set(aSIEntry.Url()); + LogFormatStr(_L(" Url := %S"), bufPtr); + bufPtr.Set( aSIEntry.Text()); + LogFormatStr(_L(" Text Info := %S"), bufPtr); + + entryTime = aSIEntry.Expires(); + entryTime.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + bufPtr.Set(temp); + LogFormatStr(_L(" Expires := %S"), bufPtr); + + temp.Copy(aSIEntry.Header()); + bufPtr.Set(temp); + LogFormatStr(_L(" Header := %S"), bufPtr); + + temp.Copy(aSIEntry.From()); + bufPtr.Set(temp); + LogFormatStr(_L(" From := %S"), bufPtr); + bufPtr.Set(aSIEntry.ContentType()); + LogFormatStr(_L(" Content Type := %S"), bufPtr); + } + + +// Outputs the details of a SL Message - lists TMsvEntry first, +// then uses Push Entry functions - should be the same values where data's mapped to TMsvEntry +void CPushEntryTester::OutputMessageDetailsL(CSLPushMsgEntry& aSLEntry) + { + TMsvEntry entry = aSLEntry.Entry(); + TBuf<200> temp; + TPtrC bufPtr; + + __LOG_DEBUG( " TMsvEntry values"); + OutputTMsvEntryDetailsL(entry); + OutputPushMsgDetailsL(aSLEntry); + + __LOG_DEBUG( " CSLPushMsgEntry values"); + LogFormatInt(_L(" Message Type := 0x%08X"), aSLEntry.Entry().iMtm.iUid); + LogFormatInt(_L(" Push Message Type := 0x%08X"), aSLEntry.PushMsgType()); + TTime entryTime = aSLEntry.TimeSent(); + temp.Zero(); + entryTime.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + bufPtr.Set(temp); + LogFormatStr(_L(" Message Date := %S"), bufPtr); + LogFormatInt(_L(" Status value := %d"), aSLEntry.Status()); + LogFormatInt(_L(" Action value := %d"), aSLEntry.Action()); + + bufPtr.Set(aSLEntry.Url()); + LogFormatStr(_L(" Url := %S"), bufPtr); + + temp.Copy(aSLEntry.Header()); + bufPtr.Set(temp); + LogFormatStr(_L(" Header := %S"), bufPtr); + + temp.Copy(aSLEntry.From()); + bufPtr.Set(temp); + LogFormatStr(_L(" From := %S"), bufPtr); + bufPtr.Set(aSLEntry.ContentType()); + LogFormatStr(_L(" Content Type := %S"), bufPtr); + } + +// Outputs the details of an Unknown Push Message - lists TMsvEntry first, +// then uses Push Entry functions - should be the same values where data's mapped to TMsvEntry +void CPushEntryTester::OutputMessageDetailsL(CUnknownPushMsgEntry& aUnknownEntry) + { + TMsvEntry entry = aUnknownEntry.Entry(); + TBuf<200> temp; + TPtrC bufPtr; + + __LOG_DEBUG("TMsvEntry values"); + OutputTMsvEntryDetailsL(entry); + OutputPushMsgDetailsL(aUnknownEntry); + + __LOG_DEBUG("CUnknownPushMsgEntry values"); + LogFormatInt(_L(" Message Type := 0x%08X"), aUnknownEntry.Entry().iMtm.iUid); + LogFormatInt(_L(" Push Message Type := 0x%08X"), aUnknownEntry.PushMsgType()); + LogFormatInt(_L(" Status value := %d"), aUnknownEntry.Status()); + + TTime entryTime = aUnknownEntry.TimeSent(); + temp.Zero(); + entryTime.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + bufPtr.Set(temp); + LogFormatStr(_L(" Message Date := %S"), bufPtr); + + bufPtr.Set(aUnknownEntry.ContentType()); + LogFormatStr(_L(" Content-Type := %S"), bufPtr ); + bufPtr.Set(aUnknownEntry.ContentFileNameL()); + LogFormatStr(_L(" Content-Filename := %S"), bufPtr ); + + temp.Copy(aUnknownEntry.Header()); + bufPtr.Set(temp); + LogFormatStr(_L(" Header := %S"), bufPtr); + temp.Copy(aUnknownEntry.From()); + bufPtr.Set(temp); + LogFormatStr(_L(" From := %S"), bufPtr); + + + HBufC* buffer = HBufC::NewL(aUnknownEntry.MessageData().Length()); + buffer->Des().Copy(aUnknownEntry.MessageData()); + bufPtr.Set(buffer->Des()); + LogFormatStr(_L(" Message Data := %S"), bufPtr); + delete buffer; + } + +// Outputs the details of a MultiPart Message - lists TMsvEntry first, +// then uses Push Entry functions - should be the same values where data's mapped to TMsvEntry +void CPushEntryTester::OutputMessageDetailsL(CMultiPartPushMsgEntry& aMultiEntry) + { + TMsvEntry entry = aMultiEntry.Entry(); + TBuf<200> temp; + TPtrC bufPtr; + + __LOG_DEBUG( " TMsvEntry values"); + OutputTMsvEntryDetailsL(entry); + OutputPushMsgDetailsL(aMultiEntry); + + __LOG_DEBUG( " CMultiPartPushMsgEntry values"); + LogFormatInt(_L(" Message Type := 0x%08X"), aMultiEntry.Entry().iMtm.iUid); + LogFormatInt(_L(" Push Message Type := 0x%08X"), aMultiEntry.PushMsgType()); + LogFormatInt(_L(" Status value := %d"), aMultiEntry.Status()); + + TTime entryTime = aMultiEntry.TimeSent(); + temp.Zero(); + entryTime.FormatL(temp, _L("%-B%:0%J%:1%T%:2%S%+B %D %N %Y %4 %5 %3" ) ); + bufPtr.Set(temp); + LogFormatStr(_L(" Message Date := %S"), bufPtr); + + + bufPtr.Set(aMultiEntry.ContentType()); + LogFormatStr(_L(" Content-Type := %S"), bufPtr); + temp.Copy(aMultiEntry.Header()); + bufPtr.Set(temp); + LogFormatStr(_L(" Header := %S"), bufPtr); + temp.Copy(aMultiEntry.From()); + bufPtr.Set(temp); + LogFormatStr(_L(" From := %S"), bufPtr); + } + + +/** Set up push folder in the message server */ +LOCAL_C TMsvId SetupPushServiceL() + { + gTest.Printf(_L("Getting Service Id")); + CWapPushTestMsgUtils* myTestUtils = CWapPushTestMsgUtils::NewL(); + CleanupStack::PushL(myTestUtils); + // Uncomment this if you want to remove existing service entries + //myTestUtils->ClearExistingServiceEntriesL(KUidMtmWapPush); + + CMsvEntrySelection* idArray = new (ELeave) CMsvEntrySelection(); + CleanupStack::PushL(idArray); + + TMsvId pushService =KMsvNullIndexEntryId; + myTestUtils->PushServiceIdL(pushService,idArray); + + if ((pushService == KMsvNullIndexEntryId) && (idArray->Count() ==0) ) // Found no service + { + gTest.Printf(_L("No Service found - creating new one")); + pushService = myTestUtils->CreateServiceL(); + gTest.Printf(_L("Created New Service Entry Id 0x%08X"), pushService); + } + else + { + gTest.Printf(_L("Found %d service entries\n"), idArray->Count()); + for (TInt count=0; count < idArray->Count(); count++) + { + gTest.Printf(_L("Entry %d - Service Id 0x%08X"), count, idArray->At(count)); + } + } + + idArray->Reset(); + + // Remove the message folder - test if the Msg Utils create if it's not there. + // myTestUtils->RemoveAllPushFolderEntriesL(); + + TMsvId pushFolder=KMsvNullIndexEntryId; + myTestUtils->PushFolderIdL(pushFolder, idArray); + + if ((pushFolder == KMsvNullIndexEntryId) && (idArray->Count() ==0) ) // Found no service + { + gTest.Printf(_L("No Push Msg Folder found - creating new one")); + pushFolder = myTestUtils->CreatePushMsgFolderL(); + gTest.Printf(_L("Created New Push Folder Entry Id 0x%08X"), pushFolder); + + } + else + { + gTest.Printf(_L("Found %d Push Folder entries\n"), idArray->Count()); + for (TInt count=0; count < idArray->Count(); count++) + { + gTest.Printf(_L("Entry %d - Folder Id 0x%08X"), count, idArray->At(count)); + } + } + + //Clean out all previous push entries from under the Push Service Entry + //myTestUtils->RemoveServiceEntryChildrenL(pushService); + + + // Clean the push msg folder of existing entries + myTestUtils->RemoveEntriesFromLocalServiceFolderL(pushFolder, KUidMtmWapPush); + myTestUtils->RemoveEntriesFromLocalServiceFolderL(KMsvGlobalInBoxIndexEntryIdValue, KUidMtmWapPush); + + CleanupStack::PopAndDestroy(2); //myTestUtils, idArray + return pushFolder; + } + + +/** setup test environment, create CPushEntryTester object and run tests */ +LOCAL_C void doMainL() + { + gTest.Start(KPushEntryTestTitle); + gTest.Printf(_L("@SYMTestCaseID IWS-WAPBROWSER-PUSHMSGENTRY-T_PUSHENTRY-0001 ")); + + CTestScheduler* activeScheduler = new CTestScheduler; + gTest(activeScheduler!=NULL); + CActiveScheduler::Install(activeScheduler); + CleanupStack::PushL(activeScheduler); + + CWapPushLog* log = CWapPushLog::NewL(*gTest.Console()); + log->SetLogFileName(_L("TPushEntry.txt")); + CleanupStack::PushL(log); + CPushEntryTester* myTester = CPushEntryTester::NewL(*log); + CleanupStack::PushL(myTester); + TMsvId pushFolder = SetupPushServiceL(); + myTester->SetPushFolderId(pushFolder); + myTester->StartL(); + + CActiveScheduler::Start(); + + CleanupStack::PopAndDestroy(3); //activeScheduler, log, myTester + gTest.End(); + gTest.Close(); + } + + +/** entry point for test executable */ +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + CTrapCleanup* theCleanup = CTrapCleanup::New(); + TRAPD(ret,doMainL()); + gTest(ret==KErrNone); + delete theCleanup; + + __UHEAP_MARKEND; + return(KErrNone); + }