1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <e32std.h>

    17 #include <e32test.h>

    18 #include <msvstd.h>

    19 #include <msvids.h>

    20 #include <msvuids.h>

    21 #include <pushentry.h>

    22 #include <push/pushlog.h>

    23 #include <push/cwappushmsgutils.h>

    24 #include "testlog.h"

    25 #include "t_serviceutils.h"

    26 #include "t_pushentry.h"

    27 

    28 

    29 _LIT(KPushEntryTestTitle,"T_PushEntry");

    30 _LIT(KFilename,"picture.jpg");

    31 _LIT(KFilename2,"image.gif");

    32 

    33 // Uncomment the following define to switch on Heap Failure Testing

    34 // #define __HEAP_FAILURE_TESTING

    35 

    36 

    37 

    38 // Global variables

    39 RTest gTest(_L("t_PushMessage Test Harness"));

    40 

    41 

    42 

    43 

    44 

    45 

    46 /** Active scheduler defined for this testcode to catch error */

    47 void CTestScheduler::Error(TInt aError) const

    48     {

    49     CActiveScheduler::Stop();

    50     gTest.Printf(_L("\nLeave signalled, reason=%d\n"),aError);

    51     }

    52 

    53 

    54 

    55 

    56 

    57 CMessageDetails* CMessageDetails::NewL()

    58 	{

    59 	CMessageDetails* self = new (ELeave) CMessageDetails();

    60 	CleanupStack::PushL(self);

    61 	self->ConstructL();

    62 	CleanupStack::Pop();

    63 	return self;

    64 	}

    65 

    66 void CMessageDetails::ConstructL()

    67 	{

    68 	iPushMsgType =0;   //Uid of message type goes in iBioType

    69 	iStatusFlag = 0;

    70 	iActionFlag =0;

    71 	iSiId = HBufC::NewL(100);

    72 	iCreated = Time::NullTTime(); //.DateTime();

    73 	iExpires = Time::NullTTime();

    74 	iURL =  HBufC::NewL(100);

    75 	iText = HBufC::NewL(100);

    76 	iFrom = HBufC8::NewL(100);

    77 	iHeader = HBufC8::NewL(100);

    78 	iContentType=HBufC::NewL(100);

    79 	iMessageBody =HBufC8::NewL(300);

    80 	iMsgDetails =HBufC::NewL(300);

    81 	iMsgDescription =HBufC::NewL(300);

    82 	iFilename = HBufC::NewL(100);

    83 	}

    84 

    85 CMessageDetails::CMessageDetails()

    86 	{

    87 	}

    88 

    89 CMessageDetails::~CMessageDetails()

    90 	{

    91 	delete iSiId;

    92 	delete iURL;

    93 	delete iText;

    94 	delete iFrom;	

    95 	delete iHeader;

    96 	delete iContentType;

    97 	delete iMessageBody;

    98 	delete iMsgDetails;

    99 	delete iMsgDescription;

   100 	delete iFilename;

   101 	}

   102 

   103 void CMessageDetails::ResetL()

   104 	{

   105 	iPushMsgType =0;   //Uid of message type goes in iBioType

   106 	iStatusFlag = 0;

   107 	iActionFlag =0;

   108 	delete iSiId;

   109 	iSiId = NULL;

   110 	iSiId = HBufC::NewL(100);

   111 

   112 	iCreated= Time::NullTTime();

   113 	iExpires = Time::NullTTime();

   114 

   115 	delete iURL; 

   116 	iURL =NULL;

   117 	iURL = HBufC::NewL(100);

   118 

   119 	delete iText;

   120 	iText = NULL;

   121 	iText = HBufC::NewL(100);

   122 

   123 	delete iFrom;

   124 	iFrom = NULL;

   125 	iFrom = HBufC8::NewL(100);

   126 

   127 	delete iHeader;

   128 	iHeader = NULL;

   129 	iHeader = HBufC8::NewL(100);

   130 

   131 	delete iContentType;

   132 	iContentType =NULL;

   133 	iContentType = HBufC::NewL(100);

   134 	

   135 	delete iMessageBody;

   136 	iMessageBody=NULL;

   137 	iMessageBody = HBufC8::NewL(300);

   138 	}

   139 

   140 

   141 

   142 // Test Harness - Active Object with a lot of states. Tests Get/Set, Save/Retrieve & Update,

   143 // for Push Entries. Also tests the Message Utilities.  Use both together during the operations.

   144 CPushEntryTester* CPushEntryTester::NewL(MWapPushLog& aLog)

   145 	{

   146 	CPushEntryTester* self = new (ELeave) CPushEntryTester(aLog);

   147 	CleanupStack::PushL(self);

   148 	self->ConstructL();

   149 	CleanupStack::Pop();

   150 	return self;

   151 	}

   152 

   153 void CPushEntryTester::ConstructL()

   154 	{

   155 	__LOG_ALWAYS("Test Results");

   156 	__LOG_ALWAYS(" ");

   157 

   158 	iPushUtilities = CWapPushMsgUtils::NewL();

   159 	iSISLPushUtilities = CSISLPushMsgUtils::NewL();

   160 	iDetails = CMessageDetails::NewL();

   161 	iMsvEntry = iPushUtilities->Session().GetEntryL(KMsvRootIndexEntryId);

   162     CActiveScheduler::Add(this);	

   163 	}

   164 

   165 

   166 CPushEntryTester::CPushEntryTester(MWapPushLog& aLog)

   167 :CActive(CActive::EPriorityIdle), iLog(aLog)

   168 	{

   169 	}

   170 

   171 

   172 CPushEntryTester::~CPushEntryTester()

   173 	{

   174 	Cancel();

   175 	delete iMsvEntry;

   176 	delete iDetails;

   177 	delete iPushEntry;

   178 	delete iPushUtilities;

   179 	delete iSISLPushUtilities;

   180 	}

   181 

   182 void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt)

   183 	{

   184 	iFormatBuffer.Format(aFormat, aInt);

   185 	iLog.WPLPrintf(iFormatBuffer);

   186 	}

   187 

   188 void CPushEntryTester::LogFormatInt(const TDesC& aFormat, TInt aInt1, TInt aInt2)

   189 	{

   190 	iFormatBuffer.Format(aFormat, aInt1, aInt2);

   191 	iLog.WPLPrintf(iFormatBuffer);

   192 	}

   193 

   194 void CPushEntryTester::LogFormatStr(const TDesC& aFormat, const TDesC& aDes)

   195 	{

   196 	iFormatBuffer.Format(aFormat, &aDes);

   197 	iLog.WPLPrintf(iFormatBuffer);

   198 	}

   199 

   200 void CPushEntryTester::LogStr(const TDesC& aDes)

   201 	{

   202 	iLog.WPLPrintf(aDes);

   203 	}

   204 

   205 

   206 

   207 void CPushEntryTester::RunL()

   208 	{

   209 	switch(iState)

   210 		{

   211 		case ETestInitialising:  

   212 			__LOG_ALWAYS("=========    TEST - SI GET/SET WITH PARAMETERS              =========");

   213 			CreateMsgDetailsL(EFalse);

   214 			SiGetSetTestL();

   215 			iState =ETestSIGetSet;// Test the setters getters with Non Null fields

   216 			QueueOperationAsync(KErrNone);

   217 			break;

   218 		case ETestSIGetSet:

   219 			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS        =========");

   220 			SiSaveRetrieveTestL();

   221 			iState = ETestSISaveRetrieveWithStringAppID;//Test Save Retrieve with Non Null fields

   222 			QueueOperationAsync(KErrNone);

   223 			break;

   224 

   225 		case ETestSISaveRetrieveWithStringAppID:

   226 			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND STRING APPID  =========");

   227 			SiSaveRetrieveTestL();

   228 			iState = ETestSISaveRetrieveWithIntAppID;

   229 			QueueOperationAsync(KErrNone);

   230 			break;

   231 

   232 		case ETestSISaveRetrieveWithIntAppID:

   233 			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH PARAMETERS AND INT APPID  =========");

   234 			iState = ETestSISaveRetrieve;

   235 			SiSaveRetrieveTestL();

   236 			QueueOperationAsync(KErrNone);

   237 			break;

   238 

   239 		case ETestSISaveRetrieve:

   240 			__LOG_ALWAYS("=========    TEST - SI GET/SET WITH NULL FIELDS             =========");

   241 			CreateMsgDetailsL(ETrue);

   242 			SiGetSetTestL();

   243 			iState = ETestSIGetSetNull;// Test the setters getters with Null fields

   244 			QueueOperationAsync(KErrNone);

   245 			break;

   246 

   247 		case ETestSIGetSetNull:

   248 			iState =  ETestSISaveRetrieveNull; //Test Save/Retrieve with Empty fields

   249 			__LOG_ALWAYS("=========    TEST - SI SAVE/RETRIEVE WITH NULL FIELDS       =========");

   250 			SiSaveRetrieveTestL();

   251 			QueueOperationAsync(KErrNone);

   252 			break;

   253 

   254 		case ETestSISaveRetrieveNull:

   255 			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING SI MESSAGE          =========");

   256 			iState = ETestSIChangeEntry;

   257 			ChangeSIEntryTestL();

   258 			QueueOperationAsync(KErrNone);

   259 			break;

   260 

   261 		case ETestSIChangeEntry:

   262 			__LOG_ALWAYS("=========    TEST - SL GET/SET WITH PARAMETERS              =========");

   263 			iState = ETestSLGetSet;//Test SL Set/Get functions with Empty fields

   264 			CreateMsgDetailsL(EFalse);

   265 			SlGetSetTestL();

   266 			QueueOperationAsync(KErrNone);

   267 			break;

   268 

   269 		case ETestSLGetSet:

   270 			iState = ETestSLSaveRetrieve;

   271 			__LOG_ALWAYS("=========    TEST - SL SAVE/RETRIEVE WITH PARAMETERS        =========");

   272 			SlSaveRetrieveTestL();

   273 			QueueOperationAsync(KErrNone);

   274 			break;

   275 

   276 		case ETestSLSaveRetrieve:

   277 			__LOG_ALWAYS("=========    TEST - SL GET/SET WITH EMPTY FIELDS            =========");

   278 			iState = ETestSLGetSetNull;//Test SL Set/Get functions with Empty fields

   279 			CreateMsgDetailsL(ETrue);

   280 			SlGetSetTestL();

   281 			QueueOperationAsync(KErrNone);

   282 			break;

   283 

   284 		case ETestSLGetSetNull:

   285 			__LOG_ALWAYS("=========    TEST - SL SAVE/RETRIEVE WITH EMPTY FIELDS      =========");

   286 			iState = ETestSLSaveRetrieveNull;

   287 			SlSaveRetrieveTestL();

   288 			QueueOperationAsync(KErrNone);

   289 			break;

   290 

   291 		case ETestSLSaveRetrieveNull:

   292 			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING SL MESSAGE          =========");

   293 			iState = ETestSLChangeEntry;

   294 			ChangeSLEntryTestL();

   295 			QueueOperationAsync(KErrNone);

   296 			break;

   297 

   298 		case ETestSLChangeEntry:

   299 			__LOG_ALWAYS("=========    TEST - MULTI GET/SET WITH PARAMETERS           =========");

   300 			iState = ETestMultiGetSet;

   301 			CreateMsgDetailsL(EFalse);

   302 			MultiGetSetTestL();

   303 			QueueOperationAsync(KErrNone);

   304 			break;

   305 

   306 		case ETestMultiGetSet:

   307 			__LOG_ALWAYS("=========    TEST - MULTI SAVE/RETRIEVE WITH PARAMETERS      =========");

   308 			iState = ETestMultiSaveRetrieve;

   309 			MultiSaveRetrieveTestL();

   310 			QueueOperationAsync(KErrNone);

   311 			break;

   312 

   313 		case ETestMultiSaveRetrieve: 

   314 			__LOG_ALWAYS("=========    TEST - MULTI SET/GET WITH EMPTY FIELDS         =========");

   315 			iState = ETestMultiGetSetNull;

   316 			CreateMsgDetailsL(ETrue);

   317 			MultiGetSetTestL();

   318 			QueueOperationAsync(KErrNone);

   319 			break;

   320 		

   321 		case ETestMultiGetSetNull:

   322 			__LOG_ALWAYS("=========   TEST - MULTI SAVE/RETRIEVE WITH EMPTY FIELDS    =========");

   323 			iState = ETestMultiSaveRetrieveNull;

   324 			MultiSaveRetrieveTestL();

   325 			QueueOperationAsync(KErrNone);

   326 			break;

   327 

   328 		case ETestMultiSaveRetrieveNull:

   329 			__LOG_ALWAYS("=========    TEST - UNKNOWN GET/SET WITH PARAMETERS          =========");

   330 			iState = ETestUnknownGetSet;

   331 			CreateMsgDetailsL(EFalse);		

   332 			UnknownGetSetTestL();

   333 			QueueOperationAsync(KErrNone);

   334 			break;

   335 

   336 		case ETestUnknownGetSet:

   337 			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS    ==========");

   338 			iState = ETestUnknownSaveRetrieve;

   339 			UnknownSaveRetrieveTestL(EFalse);

   340 			QueueOperationAsync(KErrNone);

   341 			break;	

   342 

   343 		case ETestUnknownSaveRetrieve:

   344 			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH PARAMETERS AND FILENAME     =========");

   345 			iState = ETestUnknownSaveRetrieveWithFilename;

   346 			UnknownSaveRetrieveTestL(ETrue);

   347 			QueueOperationAsync(KErrNone);

   348 			break;

   349 

   350 		case ETestUnknownSaveRetrieveWithFilename:

   351 			__LOG_ALWAYS("=========    TEST - UNKNOWN GET/SET WITH EMPTY FIELDS        =========");

   352 			iState = ETestUnknownGetSetNull;

   353 			CreateMsgDetailsL(ETrue);

   354 			UnknownGetSetTestL();

   355 			QueueOperationAsync(KErrNone);

   356 			break;

   357 

   358 		case ETestUnknownGetSetNull:

   359 			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS   =========");

   360 			iState = ETestUnknownSaveRetrieveNull;

   361 			UnknownSaveRetrieveTestL(EFalse);

   362 			QueueOperationAsync(KErrNone);

   363 			break;

   364 

   365 		case ETestUnknownSaveRetrieveNull:  

   366 			__LOG_ALWAYS("=========    TEST - UNKNOWN SAVE/RETRIEVE WITH EMPTY FIELDS AND FILENAME     =========");

   367 			iState = ETestUnknownSaveRetrieveNullWithFilename;

   368 			UnknownSaveRetrieveTestL(ETrue);

   369 			QueueOperationAsync(KErrNone);

   370 			break;

   371 

   372 		case ETestUnknownSaveRetrieveNullWithFilename: 	// Test updating an Unknown Msg

   373 			__LOG_ALWAYS("=========     TEST - UPDATING A EXISTING UNKNOWN MESSAGE     =========");

   374 			iState = ETestUnknownChangeEntry;

   375 			ChangeUnknownEntryTestL(EFalse);

   376 			QueueOperationAsync(KErrNone);

   377 			break;

   378 

   379 		case ETestUnknownChangeEntry:	// Test updating an Unknown Msg with filename

   380 			__LOG_ALWAYS("=========    TEST - UPDATING A EXISTING UNKNOWN MESSAGE  WITH FILENAME     =========");

   381 			iState = ETestUnknownChangeEntryWithFilename;  

   382 			ChangeUnknownEntryTestL(ETrue);

   383 			QueueOperationAsync(KErrNone);

   384 			break;

   385 

   386 

   387 		case ETestUnknownChangeEntryWithFilename:

   388 			__LOG_ALWAYS("=========    TEST - SI FIND BY AN ID                          =========");

   389 			iState = ETestSIFindSiId;  

   390 			CreateMoreSiMessagesL();

   391 			FindSiIdTestL(EFalse); // Not looking for a null ID string

   392 			QueueOperationAsync(KErrNone);

   393 			break;

   394 

   395 		case ETestSIFindSiId:

   396 			iState =  ETestSIFindSiIdNull; //Test Find Function  with Empty fields

   397 			__LOG_ALWAYS("=========    TEST - SI FIND A NULL ID                         =========");

   398 			FindSiIdTestL(ETrue);  // Looking for a null ID string

   399 			QueueOperationAsync(KErrNone);

   400 			break;

   401 

   402 		case ETestSIFindSiIdNull:

   403 			iState =  ETestSIFindSiUrl; //Test Find with Non Null URL field

   404 			__LOG_ALWAYS("=========    TEST - SI FIND A URL                             =========");

   405 			FindUrlTestL(EFalse, KUidWapPushMsgSI);

   406 			QueueOperationAsync(KErrNone);

   407 			break;

   408 

   409 		case ETestSIFindSiUrl:

   410 			iState = ETestSIFindSiUrlNull;  //Test Find with a Null URL field

   411 			__LOG_ALWAYS("=========    TEST - SI FIND A NULL URL                        =========");

   412 			FindUrlTestL(ETrue, KUidWapPushMsgSI);

   413 			QueueOperationAsync(KErrNone); 

   414 			break;

   415 

   416 		case ETestSIFindSiUrlNull:

   417 			__LOG_ALWAYS("=========    TEST - SL FIND A URL                             =========");

   418 			iState = ETestSLFindUrl;

   419 			CreateMoreSLMessagesL();

   420 			FindUrlTestL(EFalse, KUidWapPushMsgSL);

   421 			QueueOperationAsync(KErrNone);

   422 			break;

   423 		

   424 		case ETestSLFindUrl :

   425 			__LOG_ALWAYS("=========    TEST - SL FIND NULL URL                          =========");

   426 			iState = ETestSLFindUrlNull;

   427 			FindUrlTestL(ETrue , KUidWapPushMsgSL);

   428 			QueueOperationAsync(KErrNone);

   429 			break;

   430 

   431 		case ETestSLFindUrlNull:

   432 			__LOG_ALWAYS("=========    TEST - GET HIGHEST SI ACTION                     =========");

   433 			iState = ETestSIGetHiAction;

   434 			GetActionTestL(KUidWapPushMsgSI);

   435 			QueueOperationAsync(KErrNone); 

   436 			break;

   437 

   438 

   439 		case ETestSIGetHiAction:

   440 			__LOG_ALWAYS("=========    TEST - GET HIGHEST SL ACTION                     =========");

   441 			iState = ETestSLGetHiAction ;

   442 			GetActionTestL(KUidWapPushMsgSL);

   443 			QueueOperationAsync(KErrNone); 

   444 			break;

   445 

   446 

   447 		case ETestSLGetHiAction:

   448 			iState = ETestGetExpiry;

   449 			__LOG_ALWAYS("=========    TEST - GET EARLIEST SI EXPIRY                    =========");

   450 			//DumpPushMessageDetailsL(KUidWapPushMsgSI);

   451 			//DumpPushMessageDetailsL(KUidWapPushMsgSL);

   452 			//DumpPushMessageDetailsL(KUidWapPushMsgMultiPart);

   453 			//DumpPushMessageDetailsL(KUidWapPushMsgUnknown);

   454 			GetExpiryTestL();

   455  			QueueOperationAsync(KErrNone); 

   456 			break;

   457 

   458 		case ETestGetExpiry:

   459 			iState = ETestGetNextExpiry;

   460 			__LOG_ALWAYS("=========    TEST - GET NEXT     SI EXPIRY                    =========");

   461 			DeleteEarliestExpiryL();

   462 			GetExpiryTestL();

   463 			QueueOperationAsync(KErrNone); 

   464 			break;

   465 

   466 		case ETestGetNextExpiry:

   467 			iState = ETestComplete;

   468 			if (!iFailures)

   469 				{

   470 				__LOG_ALWAYS(" ");

   471 				__LOG_ALWAYS("Tests Completed");

   472 				}

   473 			else 

   474 				{

   475 				LogFormatInt(_L("=========      TESTS FAILED !! TOTAL OF %d UNSUCESSFUL        ========="), iFailures);

   476 				}

   477 			QueueOperationAsync(KErrNone);

   478 			break;

   479 

   480 		case ETestComplete: //finished

   481 			User::After(10000);

   482 			Cancel();

   483 			CActiveScheduler::Stop();

   484 			break;

   485 		default:

   486 			break;

   487 		}

   488 	User::After(500);

   489 	}

   490 

   491 

   492 void CPushEntryTester::QueueOperationAsync(TInt aErr)

   493     {

   494     TRequestStatus*  pS = &iStatus;

   495 	iStatus = KRequestPending;

   496     User::RequestComplete(pS, aErr);

   497 	SetActive();

   498     }

   499 

   500 void CPushEntryTester::DoCancel()

   501 	{

   502 	}

   503 

   504 void CPushEntryTester::StartL()

   505 	{

   506 	iFailures = 0;

   507 	CreateHeaders();

   508 	iState = ETestInitialising;

   509 	QueueOperationAsync(KErrNone);

   510 	}

   511 

   512 // Halt the Scheduler & inform the user

   513 TInt CPushEntryTester::RunError(TInt aError)

   514 	{

   515 	if (aError != KErrNone)

   516 		{

   517 		LogFormatInt(_L("Error %d  occurred"), aError);

   518 		__LOG_DEBUG("Tests Failed!");

   519 		iFailures++;

   520 		CActiveScheduler::Stop();

   521 		}

   522 	return KErrNone;

   523 	}

   524 

   525 

   526 

   527 

   528 // Tests use of get/set methods on a CSIPushMsgEntry

   529 // Create new entry,set values on TMsvEntry,set Push Entry, display & set new values

   530 void CPushEntryTester::SiGetSetTestL()

   531 	{

   532 	__LOG_ALWAYS("***** TESTING SI SETTER FUNCTIONS *****");

   533 

   534 	CSIPushMsgEntry* siEntry = NULL;

   535 	

   536 #if defined (__HEAP_FAILURE_TESTING)

   537 	TInt error;

   538 	TBool finished = EFalse;

   539 	TInt failCount = 0;

   540 	

   541 	while(!finished)

   542 		{

   543 		__UHEAP_FAILNEXT(failCount++);

   544 		TRAP(error,siEntry = DoSiCreateTestL());		

   545 		if (error == KErrNone)

   546 			{

   547 			__UHEAP_RESET;

   548 			LogFormatInt(_L("Made %d attempts at calling DoSiCreateTestL()"), failCount);

   549 			finished = ETrue;

   550 			}

   551 		else  // Handle error

   552 			{

   553 			// Check if error is out of memory

   554 			gTest(error == KErrNoMemory);

   555 			__UHEAP_RESET;

   556 			}

   557 		}

   558 #else 

   559 	siEntry = DoSiCreateTestL(); 

   560 #endif

   561 	CleanupStack::PushL(siEntry);

   562 	OutputMessageDetailsL(*siEntry);  // Tests our get functions - don't allocate memory

   563 

   564 

   565 #if defined (__HEAP_FAILURE_TESTING)

   566 	error = KErrNone;

   567 	finished = EFalse;

   568 	failCount = 0;

   569 	

   570 	while(!finished)

   571 		{

   572 		__UHEAP_FAILNEXT(failCount++);

   573 		TRAP(error,DoSiSetTestL(*siEntry));		

   574 		if (error == KErrNone)

   575 			{

   576 			__UHEAP_RESET;

   577 			LogFormatInt(_L("Made %d attempts at calling DoSiSetTestL()"), failCount);

   578 			finished = ETrue;

   579 			}

   580 		

   581 		else  // Handle error

   582 			{

   583 			// Check if error is out of memory

   584 			gTest(error == KErrNoMemory);

   585 			__UHEAP_RESET;

   586 			}

   587 		}

   588 #else 

   589 	DoSiSetTestL(*siEntry); 

   590 #endif

   591 

   592 	OutputMessageDetailsL(*siEntry);

   593 	CleanupStack::PopAndDestroy();

   594 	__LOG_ALWAYS("*****   SI SET/GET -  TEST SUCCESSFUL  ******");

   595 	}

   596 

   597 CSIPushMsgEntry* CPushEntryTester::DoSiCreateTestL()

   598 	{	

   599 	TPtrC ptr;

   600 	TMsvEntry entry;

   601 

   602 	entry.iServiceId = 0x0001234;

   603 	entry.iMtm.iUid = 0x0012345;  // dummy value to check default gets set automatically!

   604 	entry.iBioType  = 0x0054321;  // ditto 

   605 	entry.iType = KUidMsvMessageEntry;

   606 	entry.SetMtmData1(0x01FF); 

   607 	ptr.Set(_L("123456@somewhere.com"));

   608 

   609 	CSIPushMsgEntry* siEntry = CSIPushMsgEntry::NewL();

   610 	CleanupStack::PushL(siEntry);

   611 	siEntry->SetEntry(entry);

   612 

   613 	siEntry->SetExpires( TTime(_L("20020000:120000.0000")) );

   614 	siEntry->SetHeaderL(iDummyHeader2);	

   615 	siEntry->SetTextL(KUrl2);

   616 

   617 

   618 	siEntry->SetMsgDescriptionL(ptr);

   619 	siEntry->SetMsgDetailsL(_L("http;//www.garbage.com"));

   620 	

   621 	CleanupStack::Pop();

   622 	return siEntry;	

   623 	}

   624 

   625 void CPushEntryTester::DoSiSetTestL(CSIPushMsgEntry& aSiEntry)

   626 	{

   627 	aSiEntry.SetAction(iDetails->iActionFlag);

   628 	aSiEntry.SetCreated( iDetails->iCreated );

   629 	aSiEntry.SetExpires( iDetails->iExpires);

   630 	aSiEntry.SetFromL(*iDetails->iFrom);

   631 	aSiEntry.SetHeaderL(*iDetails->iHeader);

   632 	aSiEntry.SetIdL(*iDetails->iSiId);

   633 	aSiEntry.SetStatus(iDetails->iStatusFlag); 

   634 	aSiEntry.SetTextL(*iDetails->iText);

   635 	aSiEntry.SetUrlL(*iDetails->iURL);

   636 

   637 	aSiEntry.SetMsgDetailsL(*iDetails->iMsgDetails);

   638 	aSiEntry.SetMsgDescriptionL(*iDetails->iMsgDescription);

   639 	}

   640 

   641 

   642 

   643 // Tests the Save and Retrieve functions - saves a message and then loads it 

   644 // - should remain unchanged

   645 void CPushEntryTester::SiSaveRetrieveTestL()

   646 	{

   647 	__LOG_ALWAYS("*****   TEST STORING NEW SI PUSH ENTRY  DATA   *****");  // Log details

   648 	TMsvId msgEntryId =0;

   649 	CSIPushMsgEntry* siSave =NULL;

   650 

   651 #if defined (__HEAP_FAILURE_TESTING)

   652 	TInt error;

   653 	TBool finished = EFalse;

   654 	TInt failCount = 0;

   655 	

   656 	while(!finished)

   657 		{

   658 		__UHEAP_FAILNEXT(failCount++);

   659 		TRAP(error, siSave = DoSiSaveTestL());		

   660 		if (error == KErrNone)

   661 			{

   662 			__UHEAP_RESET;

   663 			LogFormatInt(_L("Made %d attempts at calling DoSiSaveTestL()"), failCount);

   664 			finished = ETrue;

   665 			}

   666 		

   667 		else  // Handle error

   668 			{

   669 			// Check if error is out of memory

   670 			gTest(error == KErrNoMemory);

   671 			__UHEAP_RESET;

   672 			}

   673 		}

   674 #else 

   675 	siSave = DoSiSaveTestL(); 

   676 #endif

   677 

   678 	CleanupStack::PushL(siSave);

   679 	OutputMessageDetailsL(*siSave);

   680 	msgEntryId = siSave->Entry().Id();

   681 	

   682 	__LOG_ALWAYS("*****  TEST RESTORING DATA INTO NEW PUSH ENTRY  *****");

   683 	CSIPushMsgEntry* siLoad = NULL;

   684 

   685 #if defined (__HEAP_FAILURE_TESTING)

   686 	error = KErrNone;  //reset loop variables

   687 	finished = EFalse;

   688 	failCount = 0;

   689 		while(!finished)

   690 		{

   691 		__UHEAP_FAILNEXT(failCount++);

   692 		TRAP(error,siLoad = DoSiRetrieveTestL(msgEntryId));		

   693 		if (error == KErrNone)

   694 			{

   695 			__UHEAP_RESET;

   696 			LogFormatInt(_L("Made %d attempts at calling DoSiRetrieveTestL(msgEntryId)"), failCount);

   697 			finished = ETrue;

   698 			}

   699 		else  // Handle error

   700 			{

   701 			// Check if error is out of memory

   702 			gTest(error == KErrNoMemory);

   703 			__UHEAP_RESET;

   704 			}

   705 		}

   706 #else 

   707 	siLoad = DoSiRetrieveTestL(msgEntryId); 

   708 #endif

   709 	CleanupStack::PushL(siLoad);

   710 

   711 	OutputMessageDetailsL(*siLoad);

   712 	CleanupStack::PopAndDestroy(2);  //siLoad, siSave

   713 	__LOG_ALWAYS("***** SI  SAVE/RETRIEVE -  TEST SUCCESSFUL  ******");

   714 	if (iDetails->iNullEntries)

   715 		iSINullMsg = msgEntryId; // Hold the id of the null entry for a later test

   716 	else

   717 		iSIToChange = msgEntryId;  //Hold the id of the non null entry for changing later

   718 	}

   719 

   720 CSIPushMsgEntry* CPushEntryTester::DoSiSaveTestL()

   721 	{

   722 	CSIPushMsgEntry* siSave=NULL;

   723 	if (iState==ETestSISaveRetrieveWithStringAppID)

   724 		{	

   725 		siSave = CSIPushMsgEntry::NewL();

   726 		}

   727 	else if (iState==ETestSISaveRetrieveWithIntAppID)

   728 		{

   729 		TInt tmp=5432;

   730 		siSave = CSIPushMsgEntry::NewL(tmp);

   731 		}

   732 	else

   733 		{

   734 		siSave = CSIPushMsgEntry::NewL();

   735 		}

   736 

   737 	CleanupStack::PushL(siSave);

   738 	siSave->SetIdL(*iDetails->iSiId);	

   739 	siSave->SetHeaderL(*iDetails->iHeader);

   740 	siSave->SetAction(iDetails->iActionFlag);

   741 	siSave->SetStatus(iDetails->iStatusFlag);

   742 //	siSave->SetCreated(iDetails->iCreated);

   743 	

   744 	siSave->SetExpires(iDetails->iExpires);

   745 	siSave->SetUrlL(*iDetails->iURL);

   746 	siSave->SetTextL(*iDetails->iText);

   747 	siSave->SetFromL(*iDetails->iFrom); 

   748 	

   749 	TTime now;	

   750 	now.UniversalTime();

   751 	siSave->SetCreated(now);

   752 

   753 	if (iPushMsgFolderId ==KMsvNullIndexEntryId)

   754 		iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId);

   755     siSave->SaveL(iPushUtilities->Session(),iPushMsgFolderId);

   756 	CleanupStack::Pop();

   757 	return siSave;

   758 	}

   759 

   760 CSIPushMsgEntry* CPushEntryTester::DoSiRetrieveTestL(TMsvId aMsgId)

   761 	{

   762 	CSIPushMsgEntry* siLoad = CSIPushMsgEntry::NewL();

   763 	CleanupStack::PushL(siLoad);  

   764 	siLoad->RetrieveL(iPushUtilities->Session(), aMsgId);

   765 	CleanupStack::Pop();

   766 	return siLoad; // for displaying data

   767 	}

   768 

   769 

   770 // Tests use of get/set methods on a CSLPushMsgEntry

   771 // Create new entry,set values on TMsvEntry,set Push Entry, display & set new values

   772 void CPushEntryTester::SlGetSetTestL()

   773 	{

   774 	CSLPushMsgEntry* slEntry = NULL;

   775 	__LOG_ALWAYS("***** TESTING SL SETTER FUNCTIONS  *****");

   776 

   777 #if defined (__HEAP_FAILURE_TESTING)

   778 	TInt error = KErrNone;

   779 	TBool finished = EFalse;

   780 	TInt failCount = 0;

   781 		while(!finished)

   782 		{

   783 		__UHEAP_FAILNEXT(failCount++);

   784 		TRAP(error,slEntry = DoSlCreateTestL());		

   785 		if (error == KErrNone)

   786 			{

   787 			__UHEAP_RESET;

   788 			LogFormatInt(_L("Made %d attempts at calling DoSlCreateTestL()"), failCount);

   789 			finished = ETrue;

   790 			}

   791 		else  // Handle error

   792 			{

   793 			// Check if error is out of memory

   794 			gTest(error == KErrNoMemory);

   795 			__UHEAP_RESET;

   796 			}

   797 		}

   798 #else 

   799 	slEntry = DoSlCreateTestL(); 

   800 #endif

   801 	CleanupStack::PushL(slEntry);

   802 	OutputMessageDetailsL(*slEntry);

   803 

   804 #if defined (__HEAP_FAILURE_TESTING)

   805 	error = KErrNone;

   806 	finished = EFalse;

   807 	failCount = 0;

   808 		while(!finished)

   809 		{

   810 		__UHEAP_FAILNEXT(failCount++);

   811 		TRAP(error,DoSlSetTestL(*slEntry));		

   812 		if (error == KErrNone)

   813 			{

   814 			__UHEAP_RESET;

   815 			LogFormatInt(_L("Made %d attempts at calling DoSlSetTestL()"), failCount);

   816 			finished = ETrue;

   817 			}

   818 		else  // Handle error

   819 			{

   820 			// Check if error is out of memory

   821 			gTest(error == KErrNoMemory);

   822 			__UHEAP_RESET;

   823 			}

   824 		}

   825 #else 

   826 	DoSlSetTestL(*slEntry); 

   827 #endif

   828 

   829 	OutputMessageDetailsL(*slEntry);

   830 	CleanupStack::PopAndDestroy();  //slEntry

   831 	__LOG_ALWAYS("***** SL PUSH ENTRY SET/GET -  TEST SUCCESSFUL  ******");

   832 	}

   833 

   834 CSLPushMsgEntry* CPushEntryTester::DoSlCreateTestL()

   835 	{

   836 	TMsvEntry entry;

   837 	entry.iServiceId = 0x0999999; // Dummy value 

   838 	entry.iMtm.iUid = 0x11111111; //Silly value

   839 	entry.iBioType  = 0x44444444;  //another silly value 

   840 	entry.iType = KUidMsvMessageEntry;

   841 	entry.SetMtmData1(0x1FF);

   842 

   843 	CSLPushMsgEntry* slEntry = CSLPushMsgEntry::NewL();

   844 	CleanupStack::PushL(slEntry);

   845 	slEntry->SetEntry(entry);

   846 	slEntry->SetHeaderL(iDummyHeader2);

   847 	slEntry->SetUrlL(KUrl3);

   848 

   849 	slEntry->SetMsgDescriptionL(_L("http://www.waffle.com"));

   850 	slEntry->SetTimeSent(KDateExpiry4); 

   851 	slEntry->SetMsgDetailsL(_L("Henry Higgins"));

   852 

   853 	CleanupStack::Pop();

   854 	return slEntry;

   855 	}

   856 

   857 void CPushEntryTester::DoSlSetTestL(CSLPushMsgEntry& aSlEntry)

   858 	{

   859 	aSlEntry.SetAction(iDetails->iActionFlag);

   860 	aSlEntry.SetFromL(*iDetails->iFrom);

   861 	aSlEntry.SetStatus(iDetails->iStatusFlag);  

   862 	aSlEntry.SetUrlL(*iDetails->iURL);	

   863 	aSlEntry.SetTimeSent(iDetails->iCreated);

   864 	aSlEntry.SetHeaderL(*iDetails->iHeader);

   865 	}

   866 

   867 

   868 // Tests the Save and Retrieve functions - saves a message and then loads it - should remain unchanged

   869 void CPushEntryTester::SlSaveRetrieveTestL()

   870 	{

   871 	TMsvId msgEntryId;

   872 	CSLPushMsgEntry* slSave = NULL;

   873 

   874 	__LOG_ALWAYS("*****   TEST STORING NEW SL PUSH ENTRY  DATA   *****");  // Log details

   875 

   876 #if defined (__HEAP_FAILURE_TESTING)

   877 	TInt error = KErrNone;

   878 	TBool finished = EFalse;

   879 	TInt failCount = 0;

   880 		while(!finished)

   881 		{

   882 		__UHEAP_FAILNEXT(failCount++);

   883 		TRAP(error,slSave = DoSlSaveTestL());		

   884 		if (error == KErrNone)

   885 			{

   886 			__UHEAP_RESET;

   887 			LogFormatInt(_L("Made %d attempts at calling DoSlSaveTestL()"), failCount);

   888 			finished = ETrue;

   889 			}

   890 		else  // Handle error

   891 			{

   892 			gTest(error == KErrNoMemory);// Check if error is out of memory

   893 			__UHEAP_RESET;

   894 			}

   895 		}

   896 #else 

   897 	slSave = DoSlSaveTestL(); 

   898 #endif

   899 

   900 	CleanupStack::PushL(slSave);

   901 	msgEntryId = slSave->Entry().Id();

   902 	OutputMessageDetailsL(*slSave);

   903 

   904 	CSLPushMsgEntry* slLoad = NULL;

   905 #if defined (__HEAP_FAILURE_TESTING)

   906 	error = KErrNone;

   907 	finished = EFalse;

   908 	failCount = 0;

   909 		while(!finished)

   910 		{

   911 		__UHEAP_FAILNEXT(failCount++);

   912 		TRAP(error,slLoad = DoSlRetrieveTestL(msgEntryId));		

   913 		if (error == KErrNone)

   914 			{

   915 			__UHEAP_RESET;

   916 			LogFormatInt(_L("Made %d attempts at calling DoSlRetrieveTestL()"), failCount);

   917 			finished = ETrue;

   918 			}

   919 		else  // Handle error

   920 			{

   921 			// Check if error is out of memory

   922 			gTest(error == KErrNoMemory);

   923 			__UHEAP_RESET;

   924 			}

   925 		}

   926 #else 

   927 	slLoad = DoSlRetrieveTestL(msgEntryId); 

   928 #endif

   929 

   930 	CleanupStack::PushL(slLoad);

   931 	__LOG_ALWAYS("*****  TEST RESTORING DATA INTO NEW PUSH ENTRY  *****");

   932 	OutputMessageDetailsL(*slLoad);

   933 	CleanupStack::PopAndDestroy(2);  //slLoad, slSave

   934 

   935 	if (iDetails->iNullEntries)

   936 		iSLNullMsg = msgEntryId;

   937 	else

   938 		iSLToChange = msgEntryId;  //Hold the id of the non null entry for changing later

   939 	__LOG_ALWAYS("***** SL  SAVE/RETRIEVE -  TEST SUCCESSFUL  ******");

   940 	}

   941 

   942 CSLPushMsgEntry* CPushEntryTester::DoSlSaveTestL()

   943 	{

   944 	CSLPushMsgEntry* slSave = CSLPushMsgEntry::NewL();

   945 	CleanupStack::PushL(slSave);

   946 	slSave->SetHeaderL(*iDetails->iHeader);

   947 	slSave->SetUrlL(*iDetails->iURL);

   948 	slSave->SetFromL(*iDetails->iFrom); 

   949 	slSave->SetTimeSent(iDetails->iCreated);

   950 	slSave->SetAction(iDetails->iActionFlag);

   951 	slSave->SetStatus(iDetails->iStatusFlag);

   952 	if (iPushMsgFolderId==KMsvNullIndexEntryId)

   953 		iSISLPushUtilities->GetPushMsgFolderIdL(iPushMsgFolderId);

   954 	slSave->SaveL(iPushUtilities->Session(), iPushMsgFolderId);

   955 	CleanupStack::Pop();

   956 	return slSave;

   957 	}

   958 

   959 CSLPushMsgEntry* CPushEntryTester::DoSlRetrieveTestL(TMsvId aId)

   960 	{

   961 	CSLPushMsgEntry* slLoad = CSLPushMsgEntry::NewL();

   962 	CleanupStack::PushL(slLoad);  //slEntry

   963 	slLoad->RetrieveL(iPushUtilities->Session(), aId);

   964 	CleanupStack::Pop();

   965 	return slLoad;

   966 	}

   967 

   968 

   969 // Tests use of get/set methods on a CMultiPushMsgEntry

   970 // Create new entry,set values on TMsvEntry,set Push Entry, display & set new values

   971 void CPushEntryTester::MultiGetSetTestL()

   972 	{

   973 	CMultiPartPushMsgEntry* multiEntry = NULL;

   974 	__LOG_ALWAYS("***** TESTING MULTIPART SETTER FUNCTIONS *****");	

   975 #if defined (__HEAP_FAILURE_TESTING)

   976 	TInt error = KErrNone;

   977 	TBool finished = EFalse;

   978 	TInt failCount = 0;

   979 		while(!finished)

   980 		{

   981 		__UHEAP_FAILNEXT(failCount++);

   982 		TRAP(error,multiEntry= DoMultiCreateTestL());		

   983 		if (error == KErrNone)

   984 			{

   985 			__UHEAP_RESET;

   986 			LogFormatInt(_L("Made %d attempts at calling DoMultiCreateTestL()"), failCount);

   987 			finished = ETrue;

   988 			}

   989 		else  // Handle error

   990 			{

   991 			gTest(error == KErrNoMemory);// Check if error is out of memory

   992 			__UHEAP_RESET;

   993 			}

   994 		}

   995 #else 

   996 	multiEntry = DoMultiCreateTestL();;

   997 #endif

   998 	CleanupStack::PushL(multiEntry);

   999 	OutputMessageDetailsL(*multiEntry);	

  1000 

  1001 #if defined (__HEAP_FAILURE_TESTING)

  1002 	error = KErrNone;

  1003 	finished = EFalse;

  1004 	failCount = 0;

  1005 		while(!finished)

  1006 		{

  1007 		__UHEAP_FAILNEXT(failCount++);

  1008 		TRAP(error,DoMultiSetTestL(*multiEntry) );		

  1009 		if (error == KErrNone)

  1010 			{

  1011 			__UHEAP_RESET;

  1012 			LogFormatInt(_L("Made %d attempts at calling DoMultiSetTestL()"), failCount);

  1013 			finished = ETrue;

  1014 			}

  1015 		else  // Handle error

  1016 			{

  1017 			gTest(error == KErrNoMemory);// Check if error is out of memory

  1018 			__UHEAP_RESET;

  1019 			}

  1020 		}

  1021 #else 

  1022 	DoMultiSetTestL(*multiEntry); 

  1023 #endif

  1024 	OutputMessageDetailsL(*multiEntry);

  1025 	CleanupStack::PopAndDestroy(); //multiEntry

  1026 	__LOG_ALWAYS("*****   MULTIPART SET/GET -  TEST SUCCESSFUL  ******");

  1027 	}

  1028 

  1029 

  1030 CMultiPartPushMsgEntry* CPushEntryTester::DoMultiCreateTestL()

  1031 	{

  1032 	TMsvEntry entry;

  1033 	entry.iServiceId = KMsvLocalServiceIndexEntryId;

  1034 	entry.iMtm.iUid = 0x11111111; //Silly value

  1035 	entry.iBioType  = 0x44444444;  //another silly value 

  1036 	entry.iType = KUidMsvMessageEntry;

  1037 	entry.SetMtmData1(0x1FF);

  1038 

  1039 	CMultiPartPushMsgEntry* multiEntry = CMultiPartPushMsgEntry::NewL();

  1040 	CleanupStack::PushL(multiEntry);

  1041 	multiEntry->SetEntry(entry);

  1042 	multiEntry->SetFromL(_L8("Eliza Dolittle"));

  1043 	multiEntry->SetContentTypeL(KMultiContent);

  1044 	multiEntry->SetStatus(6);

  1045 	multiEntry->SetTimeSent(KDateExpiry3);

  1046 	multiEntry->SetMsgDescriptionL(*iDetails->iText);

  1047 

  1048 	CleanupStack::Pop();

  1049 	return multiEntry;

  1050 	}

  1051 

  1052 void CPushEntryTester::DoMultiSetTestL(CMultiPartPushMsgEntry& aMultiEntry)

  1053 	{

  1054 	aMultiEntry.SetFromL(*iDetails->iFrom);

  1055 	aMultiEntry.SetHeaderL(iDummyHeader1);

  1056 	aMultiEntry.SetStatus(iDetails->iStatusFlag); 

  1057 	aMultiEntry.SetContentTypeL(*iDetails->iContentType);

  1058 	aMultiEntry.SetTimeSent(iDetails->iCreated);

  1059 	}

  1060 

  1061 void CPushEntryTester::MultiSaveRetrieveTestL()

  1062 	{

  1063 	TMsvId msgEntryId;

  1064 	CMultiPartPushMsgEntry*  multiSave = NULL;

  1065 

  1066 #if defined (__HEAP_FAILURE_TESTING)

  1067 	TInt error = KErrNone;

  1068 	TBool finished = EFalse;

  1069 	TInt failCount = 0;

  1070 		while(!finished)

  1071 		{

  1072 		__UHEAP_FAILNEXT(failCount++);

  1073 		TRAP(error,multiSave = DoMultiSaveTestL() );		

  1074 		if (error == KErrNone)

  1075 			{

  1076 			__UHEAP_RESET;

  1077 			LogFormatInt(_L("Made %d attempts at calling DoMultiSaveTestL()"), failCount);

  1078 			finished = ETrue;

  1079 			}

  1080 		else  // Handle error

  1081 			{

  1082 			gTest(error == KErrNoMemory);// Check if error is out of memory

  1083 			__UHEAP_RESET;

  1084 			}

  1085 		}

  1086 #else 

  1087 	multiSave = DoMultiSaveTestL(); 

  1088 #endif

  1089 	CleanupStack::PushL(multiSave);

  1090 	__LOG_ALWAYS("*****   TEST STORING NEW MULTI PUSH ENTRY  DATA   *****");  // Log details

  1091 	msgEntryId = multiSave->Entry().Id();

  1092 	CreateMultiChildrenL(msgEntryId);

  1093 	OutputMessageDetailsL(*multiSave);

  1094 

  1095 	__LOG_ALWAYS("*****  TESTING RESTORING DATA INTO NEW PUSH ENTRY  *****");

  1096 	CMultiPartPushMsgEntry* multiLoad = NULL;

  1097 

  1098 #if defined (__HEAP_FAILURE_TESTING)

  1099 	error = KErrNone;

  1100 	finished = EFalse;

  1101 	failCount = 0;

  1102 		while(!finished)

  1103 		{

  1104 		__UHEAP_FAILNEXT(failCount++);

  1105 		TRAP(error, multiLoad = DoMultiRetrieveTestL(msgEntryId) );		

  1106 		if (error == KErrNone)

  1107 			{

  1108 			__UHEAP_RESET;

  1109 			LogFormatInt(_L("Made %d attempts at calling DoMultiRetrieveTestL()"), failCount);

  1110 			finished = ETrue;

  1111 			}

  1112 		else  // Handle error

  1113 			{

  1114 			gTest(error == KErrNoMemory);// Check if error is out of memory

  1115 			__UHEAP_RESET;

  1116 			}

  1117 		}

  1118 #else 

  1119 	multiLoad = DoMultiRetrieveTestL(msgEntryId); 

  1120 #endif

  1121 

  1122 	CleanupStack::PushL(multiLoad);

  1123 	OutputMessageDetailsL(*multiLoad);

  1124 	

  1125 	// Get the child entries - don't bother with heap testing - tested with Unknown Entries

  1126 	iMsvEntry->SetEntryL(msgEntryId);

  1127 	CMsvEntrySelection* children = iMsvEntry->ChildrenL();

  1128 	CleanupStack::PushL(children);

  1129 	CUnknownPushMsgEntry* unknownMsg = CUnknownPushMsgEntry::NewL();

  1130 	CleanupStack::PushL(unknownMsg);

  1131 

  1132 	for (TInt loop=0; loop<children->Count(); loop++)

  1133 		{

  1134 		__LOG_DEBUG("*****   Details of MultiPart Child entry    *****");