1 // Copyright (c) 2003-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 // This file contains the implementation of the various 

    15 // ALLOC tests for DevVideo

    16 // 

    17 //

    18 

    19 // Test system includes

    20 #include <testframework.h>

    21 

    22 #include "TestDevVideoPlugins/decoder.h"

    23 #include "TestDevVideoPlugins/postproc.h"

    24 

    25 #include "TestDevVideoPlugins/encoder.h"

    26 #include "TestDevVideoPlugins/preproc.h"

    27 

    28 #include "TestStepDevVideoAllocFailNew.h"

    29 #include "TestDevVideoPlayTestData.h"

    30 

    31 

    32 // --------------------------------------------

    33 

    34 /**

    35  *

    36  * Test step constructor.

    37  * Each test step initialises its own name.

    38  *

    39  */

    40 CTestStepDevVideoPlayAllocFail::CTestStepDevVideoPlayAllocFail(const TDesC& aTestName)

    41 	{

    42 	// store the name of this test case

    43 	// this is the name that is used by the script file

    44 	iTestStepName = aTestName;

    45 	}

    46 

    47 /**

    48  *

    49  * Test step destructor.

    50  * 

    51  */

    52 CTestStepDevVideoPlayAllocFail::~CTestStepDevVideoPlayAllocFail()

    53 	{

    54 	}

    55 

    56 // MMMFDevVideoPlayObserver

    57 void CTestStepDevVideoPlayAllocFail::MdvpoNewBuffers()

    58 	{

    59 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoNewBuffers()"));

    60 	}

    61 

    62 void CTestStepDevVideoPlayAllocFail::MdvpoReturnPicture(TVideoPicture* /*aPicture*/)

    63 	{

    64 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoReturnPicture()"));

    65 	}

    66 

    67 void CTestStepDevVideoPlayAllocFail::MdvpoSupplementalInformation(const TDesC8& /*aData*/, 

    68 								  const TTimeIntervalMicroSeconds& /*aTimestamp*/, 

    69 								  const TPictureId& /*aPictureId*/)

    70 	{

    71 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoSupplementalInformation()"));

    72 	}

    73 

    74 void CTestStepDevVideoPlayAllocFail::MdvpoPictureLoss()

    75 	{

    76 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoPictureLoss()"));

    77 	}

    78 

    79 void CTestStepDevVideoPlayAllocFail::MdvpoPictureLoss(const TArray<TPictureId>& /*aPictures*/)

    80 	{

    81 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoPictureLoss(TArray)"));

    82 	}

    83 

    84 void CTestStepDevVideoPlayAllocFail::MdvpoSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/)

    85 	{

    86 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoSliceLoss()"));

    87 	}

    88 

    89 void CTestStepDevVideoPlayAllocFail::MdvpoReferencePictureSelection(const TDesC8& /*aSelectionData*/)

    90 	{

    91 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoReferencePictureSelection()"));

    92 	}

    93 

    94 void CTestStepDevVideoPlayAllocFail::MdvpoTimedSnapshotComplete(TInt /*aError*/, 

    95 								TPictureData* /*aPictureData*/, 

    96 								const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, 

    97 								const TPictureId& /*aPictureId*/)

    98 	{

    99 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoTimedSnapshotComplete()"));

   100 	}

   101 

   102 void CTestStepDevVideoPlayAllocFail::MdvpoNewPictures()

   103 	{

   104 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoNewPictures()"));

   105 	}

   106 

   107 void CTestStepDevVideoPlayAllocFail::MdvpoFatalError(TInt aError)

   108 	{

   109 	iError = aError;

   110 	INFO_PRINTF2(_L("CTestStepDevVideoPlayAllocFail::MdvpoFatalError()\nError = %d"), aError);

   111 	}

   112 

   113 void CTestStepDevVideoPlayAllocFail::MdvpoInitComplete(TInt aError)

   114 	{

   115 	iError = aError;

   116 	INFO_PRINTF2(_L("CTestStepDevVideoPlayAllocFail::MdvpoInitComplete():  Error = %d"), aError);

   117 	}

   118 

   119 void CTestStepDevVideoPlayAllocFail::MdvpoStreamEnd()

   120 	{

   121 	INFO_PRINTF1(_L("CTestStepDevVideoPlayAllocFail::MdvpoStreamEnd()"));

   122 	}

   123 

   124 /**

   125  *

   126  * Do the test step.

   127  * Each test step must supply an implementation for DoTestStepL.

   128  *

   129  * @return	"TVerdict"

   130  *			The result of the test step

   131  *

   132  */

   133 TVerdict CTestStepDevVideoPlayAllocFail::DoTestStepL()

   134 	{

   135 	TVerdict ret = EFail;

   136 

   137 	// do we want to do anything else in the base class?

   138 

   139 	// call alloc test step

   140 	ret = DoTestL();

   141 

   142 	return	ret;

   143 	}

   144 

   145 

   146 //----------------------------------------------------------------------------

   147 

   148 CTestStepDevVideoPlayAllocFailNew::CTestStepDevVideoPlayAllocFailNew(const TDesC& aTestName)

   149 	:CTestStepDevVideoPlayAllocFail(aTestName)

   150 	{

   151 	}

   152 

   153 CTestStepDevVideoPlayAllocFailNew* CTestStepDevVideoPlayAllocFailNew::NewL(const TDesC& aTestName)

   154 	{

   155 	CTestStepDevVideoPlayAllocFailNew* self = new(ELeave) CTestStepDevVideoPlayAllocFailNew(aTestName);

   156 	return self;

   157 	}

   158 

   159 CTestStepDevVideoPlayAllocFailNew::~CTestStepDevVideoPlayAllocFailNew()

   160 	{

   161 	}

   162 

   163 TVerdict CTestStepDevVideoPlayAllocFailNew::DoTestL()

   164 	{

   165 	iTestStepResult = EPass;

   166     TInt err       = KErrNone;

   167 

   168 	// Printing to the console and log file

   169 	INFO_PRINTF1(_L("this is an Alloc Failure test of initialising CMMFDevVideoPlay with NewL()"));

   170 

   171 	__UHEAP_MARK;

   172 	TRAP( err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this) );

   173 	delete iDevVideoPlay;

   174 	iDevVideoPlay = NULL;

   175 	__UHEAP_MARKEND;

   176 

   177 	if (err != KErrNone)

   178 		return EFail;

   179 

   180 	TInt failCount = 1;

   181 	TBool completed = EFalse;

   182 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

   183 	for(;;)	

   184 		{

   185 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

   186 		__MM_HEAP_MARK;

   187 

   188 		TRAP( err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this);

   189 				   iDevVideoPlay->SelectDecoderL(KUidDevVideoTestDecodeHwDevice);

   190 				   iDevVideoPlay->SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice); );

   191 

   192 		completed = EFalse;

   193 		if (err == KErrNone)

   194 			{

   195 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   196 			if (testAlloc==NULL)

   197 				{

   198 				reachedEnd = ETrue;

   199 				failCount--; // -= 1;

   200 				}

   201 			else

   202 				User::Free(testAlloc);

   203 			

   204 			}

   205 		else if (err != KErrNoMemory) // bad error code

   206 			completed = ETrue;

   207 

   208 		// see if valid result and break if wrong - might be premature result

   209 		if (iDevVideoPlay)

   210 			{

   211 			delete iDevVideoPlay;

   212 			iDevVideoPlay = NULL;

   213 			}

   214 		completed = reachedEnd;

   215 		__MM_HEAP_MARKEND;

   216 		__UHEAP_SETFAIL(RHeap::ENone ,0);

   217 

   218 		if (completed)

   219 			break; // exit loop

   220 

   221 		failCount++;

   222 		}

   223 

   224 	if (err != KErrNone)

   225 		{

   226 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

   227 		iTestStepResult = EFail;

   228 		}

   229 	else 

   230 		{

   231 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

   232 		iTestStepResult = EPass;

   233 		}

   234 

   235 	if (iDevVideoPlay)

   236 		{

   237 		delete iDevVideoPlay;

   238 		iDevVideoPlay = NULL;

   239 		}

   240 

   241 	INFO_PRINTF1(_L("finished with this test step"));

   242 	// test steps return a result

   243 	return iTestStepResult;

   244 	}

   245 

   246 //----------------------------------------------------------------------------

   247 

   248 

   249 CTestStepDevVideoPlayAllocFailFindPlugins::CTestStepDevVideoPlayAllocFailFindPlugins(const TDesC& aTestName)

   250 	:CTestStepDevVideoPlayAllocFail(aTestName)

   251 	{

   252 	}

   253 

   254 CTestStepDevVideoPlayAllocFailFindPlugins* CTestStepDevVideoPlayAllocFailFindPlugins::NewL(const TDesC& aTestName)

   255 	{

   256 	CTestStepDevVideoPlayAllocFailFindPlugins* self = new(ELeave) CTestStepDevVideoPlayAllocFailFindPlugins(aTestName);

   257 	return self;

   258 	}

   259 

   260 CTestStepDevVideoPlayAllocFailFindPlugins::~CTestStepDevVideoPlayAllocFailFindPlugins()

   261 	{

   262 	}

   263 

   264 TVerdict CTestStepDevVideoPlayAllocFailFindPlugins::DoTestL()

   265 	{

   266 	iTestStepResult = EPass;

   267     TInt err       = KErrNone;

   268 

   269 	// Printing to the console and log file

   270 	INFO_PRINTF1(_L("this is an Alloc Failure test of finding decoder and post processor plugins"));

   271 

   272 

   273 	TInt failCount = 1;

   274 	TBool completed = EFalse;

   275 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

   276 	for(;;)	

   277 		{

   278 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

   279 		__MM_HEAP_MARK;

   280 

   281 		err = KErrNone;

   282 

   283 		if (!err)

   284 			TRAP(err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));

   285 		if (!err)

   286 			TRAP(err, GetDecodersL());

   287 		if (!err)

   288 			TRAP(err, GetPostProcessorsL());

   289 		if (!err)

   290 			TRAP(err, FindDecodersL());

   291 		if (!err)

   292 			TRAP(err, FindPostProcessorsL());

   293 

   294 		REComSession::FinalClose();

   295 

   296 		completed = EFalse;

   297 		if (err == KErrNone)

   298 			{

   299 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   300 			if (testAlloc==NULL)

   301 				{

   302 				reachedEnd = ETrue;

   303 				failCount--; // -= 1;

   304 				}

   305 			else

   306 				User::Free(testAlloc);

   307 			

   308 			}

   309 		else if (err != KErrNoMemory) // bad error code

   310 			completed = ETrue;

   311 

   312 		// see if valid result and break if wrong - might be premature result

   313 		delete iDevVideoPlay;

   314 		iDevVideoPlay = NULL;

   315 

   316 		__MM_HEAP_MARKEND;

   317 		__UHEAP_SETFAIL(RHeap::ENone ,0);

   318 

   319 		if (completed || reachedEnd)

   320 			break; // exit loop

   321 

   322 		failCount++;

   323 		}

   324 

   325 	if (err != KErrNone)

   326 		{

   327 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

   328 		iTestStepResult = EFail;

   329 		}

   330 	else 

   331 		{

   332 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

   333 		iTestStepResult = EPass;

   334 		}

   335 

   336 	delete iDevVideoPlay;

   337 	iDevVideoPlay = NULL;

   338 

   339 	INFO_PRINTF1(_L("finished with this test step"));

   340 	// test steps return a result

   341 	return iTestStepResult;

   342 	}

   343 

   344 void CTestStepDevVideoPlayAllocFailFindPlugins::CheckPluginsL(const RArray<TUid>& aFoundPlugins, const RArray<TUid>& aExpectedPlugins, const RArray<TUid>& aUnExpectedPlugins)

   345 	{

   346 	TBool foundUnExpected = EFalse;

   347 	TInt numberToBeFoundInExpectedPlugins = aExpectedPlugins.Count();

   348 

   349 	for (TInt i=0; i<aFoundPlugins.Count(); i++)

   350 		{

   351 		TUid uidToLookFor = aFoundPlugins[i];

   352 		TInt j;

   353 		for (j=0; j<aExpectedPlugins.Count(); j++)

   354 			{

   355 			if (aExpectedPlugins[j] == uidToLookFor)

   356 				{

   357 				numberToBeFoundInExpectedPlugins--;

   358 				break;//j

   359 				}

   360 			}

   361 		for (j=0; j<aUnExpectedPlugins.Count(); j++)

   362 			{

   363 			if (aUnExpectedPlugins[j] == uidToLookFor)

   364 				{

   365 				foundUnExpected = ETrue;

   366 				break;//j

   367 				}

   368 			}

   369 		}

   370 

   371 	if ((foundUnExpected) || (numberToBeFoundInExpectedPlugins!=0))

   372 		User::Leave(KErrGeneral);

   373 

   374 	}

   375 

   376 

   377 void CTestStepDevVideoPlayAllocFailFindPlugins::FindDecodersL()

   378 	{

   379 	RArray<TUid> foundDecoders;

   380 	CleanupClosePushL(foundDecoders);

   381 	RArray<TUid> expectedDecoders;

   382 	CleanupClosePushL(expectedDecoders);

   383 	RArray<TUid> unExpectedDecoders;

   384 	CleanupClosePushL(unExpectedDecoders);

   385 

   386 	

   387 	// Supported mime type and post proc type (by exact match)

   388 	_LIT8(KMimeType5, "video/zippyvideo");

   389 	TUint32 requestedPostProcType = EPpMirror|EPpInputCrop;

   390 	foundDecoders.Reset();

   391 	expectedDecoders.Reset();

   392 	unExpectedDecoders.Reset();

   393 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

   394 	User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

   395 	User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

   396 	User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

   397 	User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

   398 

   399 	iDevVideoPlay->FindDecodersL(KMimeType5(), requestedPostProcType, foundDecoders, ETrue);

   400 	CheckPluginsL(foundDecoders, expectedDecoders, unExpectedDecoders);

   401 

   402 	CleanupStack::PopAndDestroy(3);

   403 	}

   404 

   405 void CTestStepDevVideoPlayAllocFailFindPlugins::FindPostProcessorsL()

   406 	{

   407 	RArray<TUid> foundPostProx;

   408 	CleanupClosePushL(foundPostProx);

   409 	RArray<TUid> expectedPostProx;

   410 	CleanupClosePushL(expectedPostProx);

   411 	RArray<TUid> unExpectedPostProx;

   412 	CleanupClosePushL(unExpectedPostProx);

   413 

   414 	TUint32	requestedPostProcType = EPpMirror|EPpInputCrop;

   415 	foundPostProx.Reset();

   416 	expectedPostProx.Reset();

   417 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

   418 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

   419 	User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));

   420 	User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));

   421 	User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));

   422 

   423 	iDevVideoPlay->FindPostProcessorsL(requestedPostProcType, foundPostProx);

   424 	CheckPluginsL(foundPostProx, expectedPostProx, unExpectedPostProx);

   425 

   426 	CleanupStack::PopAndDestroy(3);

   427 	}

   428 

   429 void CTestStepDevVideoPlayAllocFailFindPlugins::GetDecodersL()

   430 	{

   431 	RArray<TUid> foundDecoders;

   432 	CleanupClosePushL(foundDecoders);

   433 	RArray<TUid> expectedDecoders;

   434 	CleanupClosePushL(expectedDecoders);

   435 	RArray<TUid> unExpectedDecoders;

   436 	CleanupClosePushL(unExpectedDecoders);

   437 

   438 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

   439 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

   440 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

   441 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

   442 	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

   443 

   444 	iDevVideoPlay->GetDecoderListL(foundDecoders);

   445 

   446 	CheckPluginsL(foundDecoders, expectedDecoders, unExpectedDecoders);

   447 

   448 	CleanupStack::PopAndDestroy(3); //foundDecoders, expectedDecoders, unExpectedDecoders

   449 	}

   450 

   451 void CTestStepDevVideoPlayAllocFailFindPlugins::GetPostProcessorsL()

   452 	{

   453 	RArray<TUid> foundPostProx;

   454 	CleanupClosePushL(foundPostProx);

   455 	RArray<TUid> expectedPostProx;

   456 	CleanupClosePushL(expectedPostProx);

   457 	RArray<TUid> unExpectedPostProx;

   458 	CleanupClosePushL(unExpectedPostProx);

   459 

   460 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

   461 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

   462 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));

   463 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));

   464 	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));

   465 

   466 	iDevVideoPlay->GetPostProcessorListL(foundPostProx);

   467 

   468 	CheckPluginsL(foundPostProx, expectedPostProx, unExpectedPostProx);

   469 

   470 	CleanupStack::PopAndDestroy(3);//foundPostProx, expectedPostProx, unExpectedPostProx

   471 	}

   472 

   473 //----------------------------------------------------------------------------

   474 

   475 CTestStepDevVideoPlayAllocFailInfoDecoder::CTestStepDevVideoPlayAllocFailInfoDecoder(const TDesC& aTestName)

   476 	:CTestStepDevVideoPlayAllocFail(aTestName)

   477 	{

   478 	}

   479 

   480 CTestStepDevVideoPlayAllocFailInfoDecoder* CTestStepDevVideoPlayAllocFailInfoDecoder::NewL(const TDesC& aTestName)

   481 	{

   482 	CTestStepDevVideoPlayAllocFailInfoDecoder* self = new(ELeave) CTestStepDevVideoPlayAllocFailInfoDecoder(aTestName);

   483 	return self;

   484 	}

   485 

   486 CTestStepDevVideoPlayAllocFailInfoDecoder::~CTestStepDevVideoPlayAllocFailInfoDecoder()

   487 	{

   488 	}

   489 

   490 TVerdict CTestStepDevVideoPlayAllocFailInfoDecoder::DoTestL()

   491 	{

   492 	iTestStepResult = EPass;

   493     TInt err       = KErrNone;

   494 

   495 	// Printing to the console and log file

   496 	INFO_PRINTF1(_L("this is an Alloc Failure test of VideoDecoderInfoLC()"));

   497 

   498 	// moved creation and destruction of iDevVideoPlay inside the heap marks.

   499 	// reason :- VideoDecoderInfoLC may allocate onto it

   500 	

   501 	TInt failCount = 1;

   502 	TBool completed = EFalse;

   503 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

   504 	for(;;)	

   505 		{

   506 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

   507 		__MM_HEAP_MARK;

   508 

   509 		TRAP (err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));

   510 		if (err == KErrNone)

   511 			{

   512 

   513 			CVideoDecoderInfo* vidInfo = NULL;

   514 

   515 			TRAP( err, vidInfo = iDevVideoPlay->VideoDecoderInfoLC(KUidDevVideoTestDecodeHwDevice);

   516 					   CleanupStack::Pop(vidInfo); );

   517 

   518 			completed = EFalse;

   519 			if (err == KErrNone)

   520 				{

   521 				TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   522 				if (testAlloc==NULL)

   523 					{

   524 					reachedEnd = ETrue;

   525 					failCount--; // -= 1;

   526 					}

   527 				else

   528 					User::Free(testAlloc);

   529 			

   530 				}

   531 			else if (err != KErrNoMemory) // bad error code

   532 				completed = ETrue;

   533 

   534 			// see if valid result and break if wrong - might be premature result

   535 		

   536 			if (vidInfo)

   537 				{

   538 				delete vidInfo;

   539 				vidInfo = NULL;

   540 				}

   541 			}

   542 		else if (err != KErrNoMemory) // bad error code

   543 			completed = ETrue;

   544 			

   545 		if (iDevVideoPlay)

   546 			{

   547 			delete iDevVideoPlay;

   548 			iDevVideoPlay = NULL;

   549 			}

   550 

   551 		completed = reachedEnd;

   552 

   553 		__MM_HEAP_MARKEND;

   554 		__UHEAP_SETFAIL(RHeap::ENone ,0);

   555 

   556 		if (completed)

   557 			break; // exit loop

   558 

   559 		failCount++;

   560 		}

   561 

   562 	if (err != KErrNone)

   563 		{

   564 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

   565 		iTestStepResult = EFail;

   566 		}

   567 	else 

   568 		{

   569 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

   570 		iTestStepResult = EPass;

   571 		}

   572 

   573 	INFO_PRINTF1(_L("finished with this test step"));

   574 	// test steps return a result

   575 	return iTestStepResult;

   576 	}

   577 

   578 

   579 //----------------------------------------------------------------------------

   580 

   581 CTestStepDevVideoPlayAllocFailInfoPostProc::CTestStepDevVideoPlayAllocFailInfoPostProc(const TDesC& aTestName)

   582 	:CTestStepDevVideoPlayAllocFail(aTestName)

   583 	{

   584 	}

   585 

   586 CTestStepDevVideoPlayAllocFailInfoPostProc* CTestStepDevVideoPlayAllocFailInfoPostProc::NewL(const TDesC& aTestName)

   587 	{

   588 	CTestStepDevVideoPlayAllocFailInfoPostProc* self = new(ELeave) CTestStepDevVideoPlayAllocFailInfoPostProc(aTestName);

   589 	return self;

   590 	}

   591 

   592 CTestStepDevVideoPlayAllocFailInfoPostProc::~CTestStepDevVideoPlayAllocFailInfoPostProc()

   593 	{

   594 	}

   595 

   596 TVerdict CTestStepDevVideoPlayAllocFailInfoPostProc::DoTestL()

   597 	{

   598 	iTestStepResult = EPass;

   599     TInt err       = KErrNone;

   600 

   601 	// Printing to the console and log file

   602 	INFO_PRINTF1(_L("this is an Alloc Failure test of PostProcessorInfoLC()"));

   603 

   604 	// will leave on error

   605 	TRAP (err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));

   606 	

   607 	if (err != KErrNone)

   608 		{

   609 		ERR_PRINTF1(_L("Error - Couldn't construct CMMFDevVideoPlay!"));

   610 		return EInconclusive;

   611 		}

   612 

   613 	CPostProcessorInfo* postInfo = NULL;

   614 

   615 	TInt failCount = 1;

   616 	TBool completed = EFalse;

   617 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

   618 	for(;;)	

   619 		{

   620 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

   621 		__MM_HEAP_MARK;

   622 

   623 		TRAP( err, postInfo = iDevVideoPlay->PostProcessorInfoLC(KUidDevVideoTestPostProcHwDevice);

   624 				   CleanupStack::Pop(postInfo); );

   625 

   626 		REComSession::FinalClose();

   627 

   628 		completed = EFalse;

   629 		if (err == KErrNone)

   630 			{

   631 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   632 			if (testAlloc==NULL)

   633 				{

   634 				reachedEnd = ETrue;

   635 				failCount--; // -= 1;

   636 				}

   637 			else

   638 				User::Free(testAlloc);

   639 			

   640 			}

   641 		else if (err != KErrNoMemory) // bad error code

   642 			completed = ETrue;

   643 

   644 		// see if valid result and break if wrong - might be premature result

   645 		

   646 		if (postInfo)

   647 			{

   648 			delete postInfo;

   649 			postInfo = NULL;

   650 			}

   651 

   652 		completed = reachedEnd;

   653 

   654 		__MM_HEAP_MARKEND;

   655 		__UHEAP_SETFAIL(RHeap::ENone ,0);

   656 

   657 		if (completed)

   658 			break; // exit loop

   659 

   660 		failCount++;

   661 		}

   662 

   663 	if (err != KErrNone)

   664 		{

   665 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

   666 		iTestStepResult = EFail;

   667 		}

   668 	else 

   669 		{

   670 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

   671 		iTestStepResult = EPass;

   672 		}

   673 

   674 	if (iDevVideoPlay)

   675 		{

   676 		delete iDevVideoPlay;

   677 		iDevVideoPlay = NULL;

   678 		}

   679 

   680 	INFO_PRINTF1(_L("finished with this test step"));

   681 	// test steps return a result

   682 	return iTestStepResult;

   683 	}

   684 

   685 

   686 //----------------------------------------------------------------------------

   687 

   688 

   689 CTestStepDevVideoPlayAllocFailGetPictures::CTestStepDevVideoPlayAllocFailGetPictures(const TDesC& aTestName)

   690 	:CTestStepDevVideoPlayAllocFail(aTestName)

   691 	{

   692 	}

   693 

   694 CTestStepDevVideoPlayAllocFailGetPictures* CTestStepDevVideoPlayAllocFailGetPictures::NewL(const TDesC& aTestName)

   695 	{

   696 	CTestStepDevVideoPlayAllocFailGetPictures* self = new(ELeave) CTestStepDevVideoPlayAllocFailGetPictures(aTestName);

   697 	return self;

   698 	}

   699 

   700 CTestStepDevVideoPlayAllocFailGetPictures::~CTestStepDevVideoPlayAllocFailGetPictures()

   701 	{

   702 	}

   703 

   704 TVerdict CTestStepDevVideoPlayAllocFailGetPictures::DoTestL()

   705 	{

   706 	iTestStepResult = EPass;

   707     TInt err       = KErrNone;

   708 

   709 	// Printing to the console and log file

   710 	INFO_PRINTF1(_L("this is an Alloc Failure test of retrieving and returning pictures to the plugin"));

   711 

   712 

   713 	TInt failCount = 1;

   714 	TBool completed = EFalse;

   715 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

   716 	for(;;)	

   717 		{

   718 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

   719 		__MM_HEAP_MARK;

   720 

   721 		TRAP(err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));

   722 		if (!err)

   723 			TRAP(err, PerformTestL());

   724 

   725 		REComSession::FinalClose();

   726 

   727 		completed = EFalse;

   728 		if (err == KErrNone)

   729 			{

   730 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   731 			if (testAlloc==NULL)

   732 				{

   733 				reachedEnd = ETrue;

   734 				failCount--; // -= 1;

   735 				}

   736 			else

   737 				User::Free(testAlloc);

   738 			

   739 			}

   740 		else if (err != KErrNoMemory) // bad error code

   741 			completed = ETrue;

   742 

   743 		// see if valid result and break if wrong - might be premature result

   744 		delete iDevVideoPlay;

   745 		iDevVideoPlay = NULL;

   746 

   747 		__MM_HEAP_MARKEND;

   748 		__UHEAP_SETFAIL(RHeap::ENone ,0);

   749 

   750 		if (completed || reachedEnd)

   751 			break; // exit loop

   752 

   753 		failCount++;

   754 		}

   755 

   756 	if (err != KErrNone)

   757 		{

   758 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

   759 		iTestStepResult = EFail;

   760 		}

   761 	else 

   762 		{

   763 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

   764 		iTestStepResult = EPass;

   765 		}

   766 

   767 	delete iDevVideoPlay;

   768 	iDevVideoPlay = NULL;

   769 

   770 	INFO_PRINTF1(_L("finished with this test step"));

   771 	// test steps return a result

   772 	return iTestStepResult;

   773 	}

   774 

   775 

   776 void CTestStepDevVideoPlayAllocFailGetPictures::PerformTestL()

   777 	{

   778 	iTestError = KErrNone;

   779 

   780 	// select decoder

   781 	iDevVideoPlay->SelectDecoderL(KUidDevVideoTestDecodeHwDevice);

   782 

   783 	// select post-processor

   784 	iDevVideoPlay->SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice);

   785 

   786 	//Tell plugin to start creating pictures.

   787 	iDevVideoPlay->SetVideoDestScreenL(EFalse);

   788 

   789 	// initialize CDevVideoPlay and wait for response

   790 	iDevVideoPlay->Initialize();

   791 

   792 	User::LeaveIfError(iTestError);

   793 

   794 	iDevVideoPlay->Start();//Tell plugin to start creating pictures.

   795 	// We should now get a series of NewPicture() callbacks.

   796 

   797 	User::LeaveIfError(iTestError);

   798 	}

   799 

   800 void CTestStepDevVideoPlayAllocFailGetPictures::MdvpoInitComplete(TInt aError)

   801 	{

   802 	iTestError = aError;

   803 	}

   804 

   805 void CTestStepDevVideoPlayAllocFailGetPictures::MdvpoNewPictures()

   806 	{

   807 	TRAP(iTestError, DoNewPicturesL());

   808 	}

   809 

   810 void CTestStepDevVideoPlayAllocFailGetPictures::CheckNewPictureInfoL(TUint aNumPictures, const TTimeIntervalMicroSeconds& aFirst, const TTimeIntervalMicroSeconds& aLast)

   811 	{

   812 	TUint numPictures = 0;

   813 	TTimeIntervalMicroSeconds first(0);

   814 	TTimeIntervalMicroSeconds last(0);

   815 	iDevVideoPlay->GetNewPictureInfo(numPictures, first, last);

   816 

   817 	if ((numPictures!=aNumPictures) || (first!=aFirst) || (last!=aLast))

   818 		{

   819 		User::Leave(KErrGeneral);

   820 		}

   821 	}

   822 

   823 void CTestStepDevVideoPlayAllocFailGetPictures::DoNewPicturesL()

   824 	{

   825 	User::LeaveIfError(iTestError);//Don't go any further if we have an error

   826 	switch (iCurrentPictureNumber)

   827 		{

   828 		case 0:

   829 			{

   830 			iCurrentPictureNumber++;

   831 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   832 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   833 			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   834 			iDevVideoPlay->ReturnPicture(picture);

   835 			break;

   836 			}

   837 		case 1:

   838 			{

   839 			iCurrentPictureNumber++;

   840 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(1), TTimeIntervalMicroSeconds(1));

   841 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   842 			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   843 			iDevVideoPlay->ReturnPicture(picture);

   844 			break;

   845 			}

   846 		case 2:

   847 			{

   848 			iCurrentPictureNumber++;

   849 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(2), TTimeIntervalMicroSeconds(2));

   850 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   851 			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   852 			iDevVideoPlay->ReturnPicture(picture);

   853 			break;

   854 			}

   855 		case 3:

   856 			{

   857 			iCurrentPictureNumber++;

   858 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(3), TTimeIntervalMicroSeconds(3));

   859 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   860 			iDevVideoPlay->ReturnPicture(picture);

   861 			break;

   862 			}

   863 		case 4:

   864 			{

   865 			iCurrentPictureNumber++;

   866 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(4), TTimeIntervalMicroSeconds(4));

   867 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   868 			iDevVideoPlay->ReturnPicture(picture);

   869 			break;

   870 			}

   871 		case 5:

   872 			{

   873 			iCurrentPictureNumber++;

   874 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(5), TTimeIntervalMicroSeconds(5));

   875 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   876 			iDevVideoPlay->ReturnPicture(picture);

   877 			break;

   878 			}

   879 		case 6:

   880 			{

   881 			iCurrentPictureNumber++;

   882 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(6));

   883 			break;

   884 			}

   885 		case 7:

   886 			{

   887 			iCurrentPictureNumber++;

   888 			CheckNewPictureInfoL(2, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(7));

   889 			break;

   890 			}

   891 		case 8:

   892 			{

   893 			iCurrentPictureNumber++;

   894 			CheckNewPictureInfoL(3, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(8));

   895 			break;

   896 			}

   897 		case 9:

   898 			{

   899 			iCurrentPictureNumber++;

   900 			CheckNewPictureInfoL(4, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(9));

   901 			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

   902 			iDevVideoPlay->ReturnPicture(picture);

   903 			CheckNewPictureInfoL(3, TTimeIntervalMicroSeconds(7), TTimeIntervalMicroSeconds(9));

   904 			picture = iDevVideoPlay->NextPictureL();

   905 			iDevVideoPlay->ReturnPicture(picture);

   906 			CheckNewPictureInfoL(2, TTimeIntervalMicroSeconds(8), TTimeIntervalMicroSeconds(9));

   907 			picture = iDevVideoPlay->NextPictureL();

   908 			iDevVideoPlay->ReturnPicture(picture);

   909 			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(9), TTimeIntervalMicroSeconds(9));

   910 			picture = iDevVideoPlay->NextPictureL();

   911 			iDevVideoPlay->ReturnPicture(picture);

   912 			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   913 			break;

   914 			}

   915 		default:

   916 			User::Leave(KErrGeneral);

   917 			break;

   918 		};

   919 	}

   920 

   921 

   922 //----------------------------------------------------------------------------

   923 

   924 // DEVVIDEORECORD //

   925 

   926 /**

   927  *

   928  * Test step constructor.

   929  * Each test step initialises its own name.

   930  *

   931  * 

   932  */

   933 CTestStepDevVideoRecordAllocFail::CTestStepDevVideoRecordAllocFail(const TDesC& aTestName)

   934 	{

   935 	// store the name of this test case

   936 	// this is the name that is used by the script file

   937 	iTestStepName = aTestName;

   938 	}

   939 

   940 /**

   941  *

   942  * Test step destructor.

   943  *

   944  * 

   945  */

   946 CTestStepDevVideoRecordAllocFail::~CTestStepDevVideoRecordAllocFail()

   947 	{

   948 	}

   949 

   950 // MMMFDevVideoRecordObserver

   951 void CTestStepDevVideoRecordAllocFail::MdvroNewBuffers()

   952 	{

   953 	INFO_PRINTF1(_L("CTestStepDevVideoRecordAllocFail::MdvroNewBuffers()"));

   954 	}

   955 

   956 void CTestStepDevVideoRecordAllocFail::MdvroReturnPicture(TVideoPicture* /*aPicture*/)

   957 	{

   958 	INFO_PRINTF1(_L("CTestStepDevVideoRecordAllocFail::MdvroReturnPicture()"));

   959 	}

   960 

   961 void CTestStepDevVideoRecordAllocFail::MdvroSupplementalInfoSent()

   962 	{

   963 	INFO_PRINTF1(_L("CTestStepDevVideoRecordAllocFail::MdvroSupplementalInfoSent()"));

   964 	}

   965 

   966 void CTestStepDevVideoRecordAllocFail::MdvroFatalError(TInt aError)

   967 	{

   968 	iError = aError;

   969 	INFO_PRINTF2(_L("CTestStepDevVideoRecordAllocFail::MdvroFatalError()\nError = %d"), aError);

   970 	}

   971 

   972 void CTestStepDevVideoRecordAllocFail::MdvroInitializeComplete(TInt aError)

   973 	{

   974 	iError = aError;

   975 	INFO_PRINTF2(_L("CTestStepDevVideoRecordAllocFail::MdvroInitializeComplete():  Error = %d"), aError);

   976 	}

   977 

   978 void CTestStepDevVideoRecordAllocFail::MdvroStreamEnd()

   979 	{

   980 	INFO_PRINTF1(_L("CTestStepDevVideoRecordAllocFail::MdvroStreamEnd()"));

   981 	}

   982 

   983 /**

   984  *

   985  * Do the test step.

   986  * Each test step must supply an implementation for DoTestStepL.

   987  *

   988  * @return	"TVerdict"

   989  *			The result of the test step

   990  *

   991  */

   992 TVerdict CTestStepDevVideoRecordAllocFail::DoTestStepL()

   993 	{

   994 	TVerdict ret = EFail;

   995 

   996 	// call alloc test step

   997 	ret = DoTestL();

   998 

   999 	return	ret;

  1000 	}

  1001 

  1002 //----------------------------------------------------------------------------

  1003 

  1004 CTestStepDevVideoRecordAllocFailNew::CTestStepDevVideoRecordAllocFailNew(const TDesC& aTestName)

  1005 	:CTestStepDevVideoRecordAllocFail(aTestName)

  1006 	{

  1007 	}

  1008 

  1009 CTestStepDevVideoRecordAllocFailNew* CTestStepDevVideoRecordAllocFailNew::NewL(const TDesC& aTestName)

  1010 	{

  1011 	CTestStepDevVideoRecordAllocFailNew* self = new(ELeave) CTestStepDevVideoRecordAllocFailNew(aTestName);

  1012 	return self;

  1013 	}

  1014 

  1015 CTestStepDevVideoRecordAllocFailNew::~CTestStepDevVideoRecordAllocFailNew()

  1016 	{

  1017 	}

  1018 

  1019 TVerdict CTestStepDevVideoRecordAllocFailNew::DoTestL()

  1020 	{

  1021 	iTestStepResult = EPass;

  1022     TInt err       = KErrNone;

  1023 

  1024 	// Printing to the console and log file

  1025 	INFO_PRINTF1(_L("this is an Alloc Failure test of initialising CMMFDevVideoRecord with NewL()"));

  1026 

  1027 	__MM_HEAP_MARK;

  1028 	TRAP( err, iDevVideoRecord = CMMFDevVideoRecord::NewL(*this) );

  1029 	delete iDevVideoRecord;

  1030 	iDevVideoRecord = NULL;

  1031 	__MM_HEAP_MARKEND;

  1032 

  1033 	if (err != KErrNone)

  1034 		return EFail;

  1035 

  1036 	TInt failCount = 1;

  1037 	TBool completed = EFalse;

  1038 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

  1039 	for(;;)	

  1040 		{

  1041 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);

  1042 		__MM_HEAP_MARK;

  1043 

  1044 		TRAP( err, iDevVideoRecord = CMMFDevVideoRecord::NewL(*this);

  1045 				   iDevVideoRecord->SelectEncoderL(KUidDevVideoTestEncodeHwDevice);

  1046 				   iDevVideoRecord->SelectPreProcessorL(KUidDevVideoTestPreProcHwDevice); );

  1047 

  1048 		completed = EFalse;

  1049 		if (err == KErrNone)

  1050 			{

  1051 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

  1052 			if (testAlloc==NULL)

  1053 				{

  1054 				reachedEnd = ETrue;

  1055 				failCount--; // -= 1;

  1056 				}

  1057 			else

  1058 				User::Free(testAlloc);

  1059 			

  1060 			}

  1061 		else if (err != KErrNoMemory) // bad error code

  1062 			completed = ETrue;

  1063 

  1064 		// see if valid result and break if wrong - might be premature result

  1065 		if (iDevVideoRecord)

  1066 			{

  1067 			delete iDevVideoRecord;

  1068 			iDevVideoRecord = NULL;

  1069 			}

  1070 		completed = reachedEnd;

  1071 		__MM_HEAP_MARKEND;

  1072 		__UHEAP_SETFAIL(RHeap::ENone ,0);

  1073 

  1074 		if (completed)

  1075 			break; // exit loop

  1076 

  1077 		failCount++;

  1078 		}

  1079 

  1080 	if (err != KErrNone)

  1081 		{

  1082 		INFO_PRINTF3(_L("Error(%d) with %d memory allocations tested"), err, failCount);

  1083 		iTestStepResult = EFail;

  1084 		}

  1085 	else 

  1086 		{

  1087 		INFO_PRINTF2(_L("Completed OK with %d memory allocations tested"), failCount);

  1088 		iTestStepResult = EPass;

  1089 		}

  1090 

  1091 	if (iDevVideoRecord)

  1092 		{

  1093 		delete iDevVideoRecord;

  1094 		iDevVideoRecord = NULL;

  1095 		}

  1096 

  1097 	INFO_PRINTF1(_L("finished with this test step"));

  1098 	// test steps return a result

  1099 	return iTestStepResult;

  1100 	}

  1101 

  1102 //----------------------------------------------------------------------------

  1103 

  1104 CTestStepDevVideoRecordAllocFailInfoEncoder::CTestStepDevVideoRecordAllocFailInfoEncoder(const TDesC& aTestName)

  1105 	:CTestStepDevVideoRecordAllocFail(aTestName)

  1106 	{

  1107 	}

  1108 

  1109 CTestStepDevVideoRecordAllocFailInfoEncoder* CTestStepDevVideoRecordAllocFailInfoEncoder::NewL(const TDesC& aTestName)

  1110 	{

  1111 	CTestStepDevVideoRecordAllocFailInfoEncoder* self = new(ELeave) CTestStepDevVideoRecordAllocFailInfoEncoder(aTestName);

  1112 	return self;

  1113 	}

  1114 

  1115 CTestStepDevVideoRecordAllocFailInfoEncoder::~CTestStepDevVideoRecordAllocFailInfoEncoder()

  1116 	{

  1117 	}

  1118 

  1119 TVerdict CTestStepDevVideoRecordAllocFailInfoEncoder::DoTestL()

  1120 	{

  1121 	iTestStepResult = EPass;

  1122     TInt err       = KErrNone;

  1123 

  1124 	// Printing to the console and log file

  1125 	INFO_PRINTF1(_L("this is an Alloc Failure test of VideoEncoderInfoLC()"));

  1126 

  1127 	// moved creation and destruction of iDevVideoRecord inside the heap marks.

  1128 	// reason :- VideoEncoderInfoLC may allocate onto it

  1129 	

  1130 	TInt failCount = 1;

  1131 	TBool completed = EFalse;

  1132 	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging

  1133 	for(;;)	

  1134 		{

  1135 		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);