--- /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 <e32std.h>
+#include <e32test.h>
+#include <msvstd.h>
+#include <msvids.h>
+#include <msvuids.h>
+#include <pushentry.h>
+#include <push/pushlog.h>
+#include <push/cwappushmsgutils.h>
+#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; loop<children->Count(); 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 <msgSel->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 <children->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("<wml>\n <card id= \"card1 \" title= \"Crystal Demo \" >\n <wml\\>"));
+ 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("<html> Some HTML for a web page <html>"));
+ 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("<XML> A little bit of XML <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);
+ }