1 // Copyright (c) 2010 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 // OpenWF tests

    15 //

    16 #include <test/extendtef.h>

    17 #include <hal.h>

    18 #include "openwftest.h"

    19 

    20 #define KCompositorVersion	0x01023456

    21 #define KGrowCleanupStack	12

    22 #define KMaxNotificationDelay   5000000 //5 seconds

    23 #define KNotificationWarning    100000  //100 ms

    24 

    25 _LIT(KTestSectionName, "TestInfo");

    26 _LIT(KImageSectionName, "ImageInfo");

    27 _LIT(KContiguousFlag, "ContiguousFlag");

    28 _LIT(KTolerance, "Tolerance");

    29 _LIT(KTestMode, "TestMode");

    30 _LIT(KSaveImage, "SaveImage");

    31 _LIT(KDir, "Dir");

    32 _LIT(KDefaultDir, "c:\\openwftest\\img\\");

    33 _LIT(KCompositionPause, "CompositionPause");

    34 _LIT(KManualPause, "ManualPause");

    35 

    36 //Uncomment this and rebuild if you wish to test if fastpath is enabled using breakpoints

    37 //#define BREAKPOINT_FASTPATH

    38 

    39 /*

    40  * COpenwfTest implementation

    41  */

    42 COpenwfTest::COpenwfTest()

    43 :iFastpathablePixelFormat(EUidPixelFormatXRGB_8888),

    44  iNonFastpathablePixelFormat(EUidPixelFormatRGB_565),

    45  iMappable(ETrue),

    46  iMaxBuffers(2),

    47  iMinBuffers(1),

    48  iCacheAttrib(ECacheNotlisted),

    49  iDeviceId(WFC_INVALID_HANDLE),

    50  iSync(EGL_NO_SYNC_KHR),

    51  iDevice(WFC_INVALID_HANDLE),

    52  iContext(WFC_INVALID_HANDLE)

    53 	{

    54 	}

    55 

    56 COpenwfTest::~COpenwfTest()

    57 	{

    58     TearDown();

    59 	}

    60 

    61 void COpenwfTest::SetupL()

    62     {    

    63     iScheduler = new(ELeave) CActiveScheduler;

    64     CActiveScheduler::Install(iScheduler);

    65 

    66     ReadIniData();

    67     

    68     iEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    69     ASSERT_FALSE(iEGLDisplay == EGL_NO_DISPLAY);

    70     ASSERT_FALSE(iEGLDisplay == EGL_BAD_ALLOC);

    71     ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

    72     eglInitialize(iEGLDisplay, NULL, NULL);

    73     ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

    74     

    75     WFCint filterList[] = { WFC_DEVICE_FILTER_SCREEN_NUMBER, WFC_DEFAULT_SCREEN_NUMBER, WFC_NONE};

    76     ASSERT_TRUE(wfcEnumerateDevices(&iDeviceId, 1, filterList) == 1);

    77     ASSERT_TRUE(iDeviceId != WFC_INVALID_HANDLE);    

    78 

    79     iDevice = wfcCreateDevice(iDeviceId, NULL);

    80     ASSERT_TRUE(iDevice != WFC_INVALID_HANDLE);  

    81     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    82     iContext = wfcCreateOnScreenContext(iDevice, WFC_DEFAULT_SCREEN_NUMBER, NULL);

    83     ASSERT_TRUE(iContext != WFC_INVALID_HANDLE);  

    84     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    85 

    86     iFastpathableHeight = wfcGetContextAttribi(iDevice, iContext, WFC_CONTEXT_TARGET_HEIGHT);

    87     iFastpathableWidth = wfcGetContextAttribi(iDevice, iContext, WFC_CONTEXT_TARGET_WIDTH);

    88     iStride = iFastpathableWidth * 4;

    89 

    90     iFullScreenTRect = TRect(0,0,iFastpathableWidth,iFastpathableHeight);

    91     iFullScreenRect[0] = 0;

    92     iFullScreenRect[1] = 0;

    93     iFullScreenRect[2] = iFullScreenTRect.Width();

    94     iFullScreenRect[3] = iFullScreenTRect.Height();

    95     

    96     iCenterTRect = TRect(iFastpathableWidth/4,iFastpathableHeight/4,

    97             3*iFastpathableWidth/4,3*iFastpathableHeight/4);

    98     iCenterRect[0] = iCenterTRect.iTl.iX;

    99     iCenterRect[1] = iCenterTRect.iTl.iY;

   100     iCenterRect[2] = iCenterTRect.Width();

   101     iCenterRect[3] = iCenterTRect.Height();

   102     

   103     iHalfSizeRect[0] = 0;

   104     iHalfSizeRect[1] = 0;

   105     iHalfSizeRect[2] = iFastpathableWidth/2;

   106     iHalfSizeRect[3] = iFastpathableHeight/2;

   107     

   108     iUtility = CSurfaceUtility::NewL();

   109 

   110     if((iTestMode == EAutomatic) || iSaveImage)

   111         {

   112         // Need to initialise the on screen stream before composition

   113         // to ensure the content is available later 

   114         iUtility->GetOnScreenStream(iDevice, iContext);

   115         }

   116     if (iSaveImage)

   117         {   // Create a directory to save images

   118         iUtility->CreateImagePath(iImageDirectory);                

   119         }

   120     iAllowManualPause = ETrue; //tests can stop it (eg dispXtimes tests) 

   121     

   122     EGLint attrib_list[1] = {EGL_NONE};

   123     iSync = eglCreateSyncKHR(iEGLDisplay,EGL_SYNC_REUSABLE_KHR, attrib_list);

   124     ASSERT_NOT_EQUALS(iSync,EGL_NO_SYNC_KHR);

   125     ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

   126     }

   127 

   128 /**

   129  * test Suite furniture 

   130  **/

   131 void COpenwfTest::TearDownL()

   132     {

   133     // Nothing leaves in this function, 

   134     // but TearDownL() is needed for the CTestFixture (TEF) interface

   135     TearDown();

   136     }

   137 

   138 void COpenwfTest::TearDown()

   139     {

   140     WFCErrorCode wfcError;

   141     if (iDevice != WFC_INVALID_HANDLE)

   142         {

   143         wfcError = wfcGetError(iDevice);

   144         if (wfcError != WFC_ERROR_NONE)

   145             {

   146             INFO_PRINTF2(_L("TearDown: There was a failure in the test. error=%d"),wfcError);

   147             }

   148         }

   149     if (iOnScreenStream != WFC_INVALID_HANDLE)

   150         {

   151         (void)SymbianStreamReleaseReadBuffer(iOnScreenStream, iOnScreenBuffer); //ignore the error

   152         iOnScreenStream = WFC_INVALID_HANDLE;

   153         }

   154     delete iUtility;

   155     iUtility = NULL;

   156     if (iContext != WFC_INVALID_HANDLE)

   157         {

   158         wfcDestroyContext(iDevice, iContext);

   159         iContext = WFC_INVALID_HANDLE;

   160         WFCErrorCode wfcError = wfcGetError(iDevice);

   161         if (wfcError != WFC_ERROR_NONE)

   162             {

   163             INFO_PRINTF2(_L("TearDown: wfcDestroyContext error=%d"),wfcError);

   164             }

   165         }

   166     if (iDevice != WFC_INVALID_HANDLE)

   167         {

   168         WFCErrorCode deviceError = wfcDestroyDevice(iDevice);

   169         iDevice = WFC_INVALID_HANDLE;

   170         if (deviceError != WFC_ERROR_NONE)

   171             {

   172             INFO_PRINTF2(_L("TearDown: wfcDestroyDevice error=%d"),deviceError);

   173             }

   174         }

   175     if (iSync != EGL_NO_SYNC_KHR)

   176         {

   177         EGLBoolean eglSyncError = eglDestroySyncKHR(iEGLDisplay, iSync);

   178         iSync = EGL_NO_SYNC_KHR;

   179         if (eglSyncError != EGL_TRUE)

   180             {

   181             INFO_PRINTF2(_L("TearDown: eglSyncError line %d"),__LINE__);

   182             }

   183         }

   184     if (iEGLDisplay != EGL_NO_DISPLAY)

   185         {

   186         EGLBoolean eglTerminateError = eglTerminate(iEGLDisplay);

   187         iEGLDisplay = EGL_NO_DISPLAY;

   188         if (eglTerminateError != EGL_TRUE)

   189             {

   190             INFO_PRINTF2(_L("TearDown: eglTerminateError line %d"),__LINE__);

   191             }

   192         }

   193     delete iScheduler;

   194     iScheduler = NULL;

   195     }

   196 

   197 /**

   198  * To be called at the beginning of tests

   199  * aActivate default is ON

   200  */

   201 void COpenwfTest::SetupEmptySceneL(TBool aActivate)

   202     {

   203 #ifdef BREAKPOINT_FASTPATH

   204     __BREAKPOINT();

   205 #endif

   206     wfcSetContextAttribi(iDevice, iContext, WFC_CONTEXT_ROTATION, WFC_ROTATION_0);

   207     wfcSetContextAttribi(iDevice, iContext, WFC_CONTEXT_BG_COLOR, 0xFFFFFFFF);

   208     if (aActivate)

   209         {

   210         LOG(("OpenWFTest: Running in autonomous composition mode"));

   211         wfcActivate(iDevice,iContext);

   212         }

   213     else

   214         {

   215         LOG(("OpenWFTest: Running in non autonomous composition mode"));

   216         wfcDeactivate(iDevice,iContext);

   217         }

   218     LOG(("OpenWFTest: Expecting COMPOSITION after next commit"));

   219     wfcCommit(iDevice, iContext, WFC_TRUE);   // Compose the scene

   220     wfcFence(iDevice, iContext, iEGLDisplay, iSync);

   221     ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

   222     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

   223     LOG(("OpenWFTest: Fastpath - setting up scene - fastpath now off"));

   224     }

   225 

   226 void COpenwfTest::ReadIniData()

   227     {

   228 	//test mode

   229     TBool returnValue = iConfig.GetInt(KTestSectionName, KTestMode, iTestMode);

   230     ASSERT_TRUE(returnValue);

   231     

   232     //save images

   233 	iSaveImage=EFalse;

   234     if (iTestMode == EAutomatic)

   235         {

   236         returnValue = iConfig.GetBool(KTestSectionName, KSaveImage, iSaveImage);

   237         }

   238     

   239     // Get path for the images to be saved to

   240     TPtrC dir;

   241     returnValue = iConfig.GetString(KTestSectionName, KDir, dir);

   242     if (returnValue)

   243         {

   244 		iImageDirectory.Set(dir);

   245         }

   246     else

   247         {

   248 		iImageDirectory.Set(KDefaultDir);

   249         }

   250     

   251     // Composition pause in microseconds

   252     TInt compositionPause;

   253     returnValue = iConfig.GetInt(KTestSectionName, KCompositionPause, compositionPause);

   254     ASSERT_TRUE(returnValue);

   255     iCompositionPause = compositionPause;

   256     

   257     // Manual pause in microseconds

   258     iManualPause = 0;

   259     if (iTestMode != EAutomatic)

   260         {

   261 		TInt manualPause;

   262 		returnValue = iConfig.GetInt(KTestSectionName, KManualPause, manualPause);

   263 		ASSERT_TRUE(returnValue);

   264 		iManualPause = manualPause;

   265         }

   266     

   267     // Force contiguous

   268     TBool contiguousFlag;

   269     returnValue = iConfig.GetBool(KImageSectionName, KContiguousFlag, contiguousFlag);

   270     if (returnValue && contiguousFlag)

   271         {

   272         iContiguous = EContiguous;

   273         }

   274     

   275     // Test tolerance

   276     TInt tolerance;

   277     returnValue = iConfig.GetInt(KImageSectionName, KTolerance, tolerance);

   278     if (returnValue)

   279         {

   280         iTolerance = tolerance;

   281         }

   282     }

   283 

   284 /**

   285  * Acquires the on screen stream and buffer number

   286  * NOTE: this function should be paired with a ReleaseOnScreenStream call

   287  * Returns ETrue on success

   288  */

   289 TBool COpenwfTest::AcquireOnScreenStream()

   290 	{

   291 	TInt error = KErrNone;

   292 	ASSERT_TRUE(iOnScreenStream == WFC_INVALID_HANDLE);

   293     if(iTestMode == EAutomatic)

   294     	{	//need to get the on screen stream

   295 		iOnScreenStream = iUtility->GetOnScreenStream(iDevice, iContext);

   296 		if(iOnScreenStream == WFC_INVALID_HANDLE)

   297 			{

   298 			INFO_PRINTF1(_L("Failed getting on screen stream"));

   299 			LOG(("OpenWFTest: *** Failed getting on screen stream"));

   300 			return EFalse;

   301 			}

   302 		error = SymbianStreamAcquireReadBuffer(iOnScreenStream, &iOnScreenBuffer);

   303 		if (error != KErrNone)

   304 			{

   305 			LOG(("OpenWFTest: *** Unable to acquire read buffer. error = %d",error));

   306 			INFO_PRINTF2(_L("Unable to acquire read buffer. error = %d"),error);

   307 			}

   308 		return (error == KErrNone);

   309     	}

   310 	else

   311 		{

   312 		INFO_PRINTF1(_L("No need to get the on screen stream, probably manual checking mode"));

   313 		LOG(("OpenWFTest: *** No need to get the on screen stream, probably manual checking mode"));

   314 		return ETrue;

   315 		}

   316 	}

   317 

   318 /**

   319  * Releases the on screen stream

   320  */

   321 void COpenwfTest::ReleaseOnScreenStream()

   322 	{

   323 	if (iOnScreenStream != WFC_INVALID_HANDLE)

   324 		{

   325 		(void)SymbianStreamReleaseReadBuffer(iOnScreenStream, iOnScreenBuffer);	//ignore the error

   326 		iOnScreenStream = WFC_INVALID_HANDLE;

   327 		}

   328 	if(iTestMode != EAutomatic && iAllowManualPause)

   329 		{

   330 		INFO_PRINTF1(_L("Performing manual wait"));

   331 		LOG(("OpenWFTest: *** Performing manual wait"));

   332 		TRAP_IGNORE(WaitL(iManualPause));

   333 		}

   334 	if(iTestMode != EAutomatic && !iAllowManualPause)

   335 	    {

   336         INFO_PRINTF1(_L("Test not allowing a manual wait"));

   337         LOG(("OpenWFTest: *** Test not allowing a manual wait"));

   338 	    }

   339 	}

   340 

   341 /**

   342  * Checks the rect of the on screen stream

   343  * Returns ETrue on success

   344  */

   345 TBool COpenwfTest::CheckOnScreenStreamRect(TRect aRect, const TRgb& aExpectedColor, TInt aTolerance)

   346 	{

   347     if(iTestMode == EAutomatic)

   348     	{

   349 		if (iOnScreenStream == WFC_INVALID_HANDLE)

   350 			{

   351 			LOG(("OpenWFTest: *** We don't have access to the on screen stream"));

   352 			INFO_PRINTF1(_L("We don't have access to the on screen stream"));

   353 			return EFalse;

   354 			}

   355 		const TSurfaceId* surfaceId = NULL;

   356 		long bufferIndex;

   357 		TInt error = SymbianStreamGetBufferId(iOnScreenStream,iOnScreenBuffer,&bufferIndex,&surfaceId);

   358 		if (error == KErrNone)

   359 			{

   360 			return CheckRect(*surfaceId,bufferIndex,aRect,aExpectedColor,aTolerance);

   361 			}

   362 		else

   363 			{

   364 			LOG(("OpenWFTest: *** Unable to get stream buffer id. error = %d",error));

   365 			INFO_PRINTF2(_L("Unable to get stream buffer id. error = %d"),error);

   366 			return EFalse;

   367 			}

   368     	}

   369     else

   370     	{	//print out what we're hoping to see for manual testing

   371 		LOG(("OpenWFTest: For rect %d %d %d %d",aRect.iTl.iX,aRect.iTl.iY,aRect.iBr.iX,aRect.iBr.iY));

   372 		LOG(("OpenWFTest: The expected color is r=%d g=%d b=%d",aExpectedColor.Red(),aExpectedColor.Green(),

   373 				aExpectedColor.Blue()));

   374 		INFO_PRINTF5(_L("For rect %d %d %d %d"),aRect.iTl.iX,aRect.iTl.iY,aRect.iBr.iX,aRect.iBr.iY);

   375 		INFO_PRINTF4(_L("The expected color is r=%d g=%d b=%d"),aExpectedColor.Red(),aExpectedColor.Green(),

   376 				aExpectedColor.Blue());

   377 		return ETrue;

   378     	}

   379 	}

   380 

   381 /**

   382  * checks the color within the given rectangle of the given surface

   383  * returns ETrue on success

   384  */

   385 TBool COpenwfTest::CheckRect(const TSurfaceId& aSurface, TInt aBuffer,  TRect aRect,

   386 		const TRgb& aExpectedColor, TInt aTolerance)

   387 	{

   388 	INFO_PRINTF1(_L("Starting pixel checking"));

   389 	LOG(("OpenWFTest: *** Starting pixel checking"));

   390 	// Check pixel data

   391 	

   392 	TBool success = iUtility->CheckRectColor(aSurface, aRect, aBuffer, aExpectedColor, aTolerance);

   393 	if (success)

   394 		{

   395 		INFO_PRINTF1(_L("Finished pixel checking - pass"));

   396 		LOG(("OpenWFTest: *** Finished pixel checking - pass"));

   397 		}

   398 	else

   399 		{

   400 		INFO_PRINTF1(_L("Finished pixel checking - fail"));

   401 		LOG(("OpenWFTest: *** Finished pixel checking - fail"));

   402 		}

   403     return success;

   404 	}

   405 

   406 /**

   407  * If in automatic mode it will save a TGA image of the on screen stream.

   408  * It will also print the name of the reference image.

   409  * Returns ETrue on success

   410  */

   411 TBool COpenwfTest::CheckOnScreenReferenceImage()

   412 	{

   413 	TInt error = KErrNone;

   414 	//Create image file name

   415 	_LIT(KSeparator, "_");

   416 	_LIT(KTGAImgFormat, ".tga");

   417 	iImageAddress.Zero();

   418 	iImageAddress.Append(iTestName);

   419 	iImageAddress.Append(KSeparator);

   420 	iImageAddress.AppendNum(iImageCounter);

   421 	iImageAddress.Append(KTGAImgFormat);

   422     

   423 	LOGL((_L("Reference Image:%S"),&iImageAddress));

   424 	INFO_PRINTF2(_L("Reference Image:%S"),&iImageAddress);

   425 	//Add file path

   426 	iImageAddress.Insert(0,iImageDirectory);

   427 	iImageCounter++;

   428 	

   429     if(iTestMode == EAutomatic && iSaveImage)

   430     	{

   431 		if (iOnScreenStream == WFC_INVALID_HANDLE)

   432 			{

   433 			LOG(("OpenWFTest: *** We don't have access to the on screen stream",error));

   434 			INFO_PRINTF1(_L("We don't have access to the on screen stream"));

   435 			return EFalse;

   436 			}

   437 		const TSurfaceId* surfaceId = NULL;

   438 		long bufferIndex;

   439 		error = SymbianStreamGetBufferId(iOnScreenStream,iOnScreenBuffer,&bufferIndex,&surfaceId);

   440 		if (error == KErrNone)

   441 			{

   442 			return SaveImage(*surfaceId,bufferIndex);

   443 			}

   444 		else

   445 			{

   446 			LOG(("OpenWFTest: *** Unable to get stream buffer id. error = %d",error));

   447 			INFO_PRINTF2(_L("Unable to get stream buffer id. error = %d"),error);

   448 			return EFalse;

   449 			}

   450     	}

   451     return ETrue;

   452 	}

   453 

   454 /**

   455  *  helper function for saving images to files

   456  *  returns ETrue on success

   457  */

   458 TBool COpenwfTest::SaveImage(const TSurfaceId& aSurface, TInt aNumOfBuffer)

   459     {

   460 	if(iTestMode == EAutomatic && iSaveImage)

   461 		{

   462 		INFO_PRINTF1(_L("Start to save image"));

   463 		LOG(("OpenWFTest: *** Start to save image"));

   464 		TBool success = EFalse;

   465 		TRAPD(error, success = iUtility->SaveResultImageTGAL(aSurface, aNumOfBuffer, iImageAddress));

   466 		if(error != KErrNone || !success)

   467 			{

   468 			INFO_PRINTF1(_L("Failed saving image"));

   469 			LOG(("OpenWFTest: *** Failed saving image"));

   470 			return EFalse;

   471 			}

   472 		INFO_PRINTF1(_L("Saved image"));

   473 		LOG(("OpenWFTest: *** Saved image"));

   474 		}

   475     return ETrue;

   476     }

   477 

   478 /**

   479  * Basic wait function call. Return amount of other active objects that stopped the scheduler

   480 */

   481 TInt COpenwfTest::WaitL(TTimeIntervalMicroSeconds32 aDelay)	//aDelay in microseconds

   482 	{

   483 	CActiveWaiter* waiter = NULL;

   484 	waiter = CActiveWaiter::NewL();

   485     TInt counter = waiter->Wait(aDelay);

   486 	delete waiter;

   487 	return counter;

   488 	}

   489 

   490 /**

   491  * aMaxDelay    The maximum time we are willing to wait in microseconds

   492  * aNotifications   The amount of notifications we expect to complete, must be >0

   493  * Returns ETrue on success

   494 */

   495 TBool COpenwfTest::WaitForNotifications(TTimeIntervalMicroSeconds32 aMaxDelay,TInt aNotificatons)

   496     {

   497     if (aNotificatons == 0)

   498         {   //use WaitL if no notifications are expected

   499         return EFalse;

   500         }

   501     TTime before;

   502     TTime after;

   503     before.UniversalTime();

   504     TTimeIntervalMicroSeconds diff;

   505     TInt counter = aNotificatons;

   506     CActiveWaiter* waiter = NULL;

   507     TRAP_IGNORE(waiter = CActiveWaiter::NewL());

   508     if (!waiter)

   509         {

   510         INFO_PRINTF1(_L("Failed creating CActiveWaiter"));

   511         LOG(("OpenWFTest: *** Failed creating CActiveWaiter"));

   512         return EFalse;

   513         }

   514     waiter->StartWait(aMaxDelay);

   515     CActiveScheduler::Start();

   516     while(!waiter->iRun)

   517         {

   518         after.UniversalTime();

   519         diff = after.MicroSecondsFrom(before);

   520         if (diff > KNotificationWarning)

   521             {

   522             INFO_PRINTF2(_L("note: Notification took a long time to complete: %ld microseconds"),diff.Int64());

   523             LOG(("OpenWFTest: *** note: Notification took a long time to complete: %ld microseconds",diff.Int64()));

   524             }

   525         counter--;

   526         if (counter == 0)

   527             {   //all expected notifications were completed

   528             delete waiter;

   529             return ETrue;

   530             }

   531         CActiveScheduler::Start();

   532         }

   533     INFO_PRINTF2(_L("Not all notifications completed, counter=%d"),counter);

   534     LOG(("OpenWFTest: *** Not all notifications completed, counter=%d",counter));

   535     delete waiter;

   536     //the notifications didn't complete in time

   537     return EFalse;

   538     }

   539 

   540 // Create a suite of all the tests

   541 CTestSuite* COpenwfTest::CreateSuiteL(const TDesC& aName)

   542 	{

   543 	SUB_SUITE_OPT(COpenwfTest,NULL);

   544 		//positive fastpath tests

   545 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0000L);

   546 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0001L);

   547 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0002L);

   548 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0003L);

   549         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0004L);

   550         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0005L);

   551         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0006L);

   552         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0007L);

   553         //fastpath with notification tests

   554         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0010L);

   555         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0011L);

   556         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0012L);

   557         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0013L);

   558         //negative fastpath tests

   559         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0020L);

   560         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0021L);

   561         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0022L);

   562         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0023L);

   563         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0024L);

   564         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0025L);

   565         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0026L);

   566         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0027L);

   567 		

   568 	END_SUITE;

   569 	}

   570 

   571 void TefUnitFailLeaveL()

   572 	{

   573 	User::Leave(KErrTEFUnitFail);

   574 	}

   575 

   576 CActiveNotification* CActiveNotification::NewL(RSurfaceUpdateSession& aSurfaceUpdateSession,TBool aActivate)

   577 	{

   578 	CActiveNotification* self = new (ELeave) CActiveNotification;

   579 	CleanupStack::PushL(self);

   580 	self->ConstructL(aSurfaceUpdateSession);

   581 	CleanupStack::Pop(self);

   582 	if (aActivate)

   583 		{

   584 		self->SetActive();

   585 		}

   586 	return self;

   587 	}

   588 

   589 void CActiveNotification::ConstructL(RSurfaceUpdateSession& aSurfaceUpdateSession)

   590 	{

   591 	CActiveScheduler::Add(this);

   592 	iSurfaceUpdateSession = aSurfaceUpdateSession;

   593 	}

   594 	

   595 CActiveNotification::CActiveNotification() : CActive(EPriorityNormal)

   596 	{}

   597 

   598 CActiveNotification::~CActiveNotification()

   599 	{

   600 	Cancel();

   601 	}

   602 

   603 void CActiveNotification::DoCancel()

   604 	{  //we need to cancel all notifications - this will impact other notifications in this sus session!

   605     iSurfaceUpdateSession.CancelAllUpdateNotifications();

   606 	}

   607 

   608 void CActiveNotification::RunL()

   609 	{

   610 	CActiveScheduler::Stop();

   611 	}

   612 	

   613 TInt CActiveNotification::RunError(TInt aError)

   614 	{

   615 	return aError; // exists so a break point can be placed on it.

   616 	}

   617 

   618 void CActiveNotification::Activate()

   619 	{

   620 	SetActive();

   621 	}

   622 

   623 CActiveWaiter* CActiveWaiter::NewL()

   624     {

   625 	CActiveWaiter* self = new (ELeave) CActiveWaiter;

   626     CleanupStack::PushL(self);

   627     self->ConstructL();

   628     CleanupStack::Pop(self);

   629     return self;

   630     }

   631     

   632 void CActiveWaiter::ConstructL()

   633     {

   634     User::LeaveIfError(iTimer.CreateLocal());

   635     CActiveScheduler::Add(this);

   636     }

   637     

   638 CActiveWaiter::CActiveWaiter() : CActive(CActive::EPriorityStandard)

   639     {}

   640 

   641 CActiveWaiter::~CActiveWaiter()

   642     {

   643     Cancel();

   644     iTimer.Close();

   645     }

   646 

   647 void CActiveWaiter::DoCancel()

   648     {

   649     iTimer.Cancel();

   650     }

   651 

   652 void CActiveWaiter::RunL()

   653     {

   654 	iRun = ETrue;

   655     CActiveScheduler::Stop();

   656     }

   657     

   658 TInt CActiveWaiter::RunError(TInt aError)

   659     {

   660     return aError; // exists so a break point can be placed on it.

   661     }

   662 

   663 /**

   664  * Waits the set amount of time. Returns the amount of times the active scheduler 

   665  * was stopped (not including its own active scheduler stop)

   666  */

   667 TInt CActiveWaiter::Wait(TTimeIntervalMicroSeconds32 aDelay)   //microseconds

   668     {

   669 	TInt counter = 0;

   670     SetActive();

   671     iTimer.After(iStatus, aDelay);

   672     iRun = EFalse;

   673     CActiveScheduler::Start();

   674     while (!iRun)

   675     	{//may be another object that stops the scheduler running in these tests.

   676 		counter++;

   677 		CActiveScheduler::Start();

   678     	}

   679     return counter;

   680     }

   681 

   682 /**

   683  * Starts an AO with the given delay. Remember the RunL will stop the active scheduler.

   684  */

   685 void CActiveWaiter::StartWait(TTimeIntervalMicroSeconds32 aDelay)   //microseconds

   686     {

   687     SetActive();

   688     iTimer.After(iStatus, aDelay);

   689     }

   690 

   691 /*

   692 @SYMTestCaseID          GRAPHICS-OPENWFC-FASTPATH-0000

   693 @SYMTestCaseDesc        Positive testing - Fastpath one-element scene

   694 @SYMREQ                 

   695 @SYMPREQ                PREQ417-54885

   696 @SYMTestType            Unit Test

   697 @SYMTestPriority        High

   698 @SYMTestPurpose         Check a scene meeting fastpath criteria can be fastpathed

   699 @SYMTestActions         

   700     All compositions are autonomous:

   701     Compose an empty scene

   702     Create a scene containing a screen sized element with no scaling, no alpha, no mask, no rotation

   703     Compose the scene

   704 @SYMTestExpectedResults

   705     The final scene should be fastpathed    

   706 */

   707 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0000L()

   708 	{

   709     iTestName = _L("FASTPATH_0000");

   710     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

   711     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

   712     SetupEmptySceneL();

   713     

   714     TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

   715                                                 iFastpathablePixelFormat,

   716                                                 iStride, iContiguous, iMaxBuffers);

   717     ASSERT_FALSE(surface.IsNull());

   718 

   719     WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

   720     TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

   721     ASSERT_EQUALS(err,KErrNone);

   722     WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

   723     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

   724     

   725     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

   726     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

   727     

   728 #ifdef BREAKPOINT_FASTPATH

   729     __BREAKPOINT();

   730 #endif

   731     wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

   732     LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

   733     wfcCommit(iDevice, iContext, WFC_TRUE);

   734     wfcFence(iDevice, iContext, iEGLDisplay, iSync);

   735     ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

   736     LOG(("OpenWFTest: Fastpath - Now ON"));

   737     

   738     iUtility->FillSurfaceL(surface, 0, KGreen);

   739     err = iUtility->SubmitUpdate(surface, 0, NULL);

   740     ASSERT_EQUALS(err,KErrNone);

   741     WaitL(iCompositionPause);

   742     

   743     ASSERT_TRUE(AcquireOnScreenStream());

   744     ASSERT_TRUE(CheckOnScreenReferenceImage());

   745     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

   746     ReleaseOnScreenStream();

   747 

   748     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

   749     wfcDestroySource(iDevice, fpSource);

   750 	}

   751 

   752 /*

   753 @SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0001

   754 @SYMTestCaseDesc		Positive testing - Fastpath one-element scene  

   755 @SYMREQ					

   756 @SYMPREQ						PREQ417-54885

   757 @SYMTestType				Unit Test

   758 @SYMTestPriority		High	

   759 @SYMTestPurpose			Check a scene including a full screen element with global alpha at opaque level 

   760 										can be fastpathed

   761 @SYMTestActions			

   762 	All compositions are autonomous:

   763 	Compose an empty scene

   764 	Create a scene containing a screen sized element with 2 buffers

   765 	Enable WFC_TRANPARENCY_GLOBAL_ALPHA 

   766 	Set WFC_ELEMENT_GLOBAL_ALPHA to be 255 (opaque)

   767 	Compose the scene

   768 @SYMTestExpectedResults

   769 	The final scene should be fastpathed

   770 */

   771 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0001L()

   772 	{

   773     iTestName = _L("FASTPATH_0001");

   774     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

   775     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

   776     SetupEmptySceneL();

   777     

   778     TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

   779                                                 iFastpathablePixelFormat,

   780                                                 iStride, iContiguous, iMaxBuffers);

   781     ASSERT_FALSE(surface.IsNull());

   782 

   783     WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

   784     TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

   785     ASSERT_EQUALS(err,KErrNone);

   786     WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

   787     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

   788     

   789     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

   790     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

   791     //set element global alpha

   792     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_TRANSPARENCY_TYPES, WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA);

   793     wfcSetElementAttribf(iDevice, fpElement, WFC_ELEMENT_GLOBAL_ALPHA, 1.0f);

   794     

   795 #ifdef BREAKPOINT_FASTPATH

   796     __BREAKPOINT();

   797 #endif

   798     wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

   799     LOG(("OpenWFTest: Expecting FASTPATH after next commit - using element alpha"));

   800     wfcCommit(iDevice, iContext, WFC_TRUE);

   801     wfcFence(iDevice, iContext, iEGLDisplay, iSync);

   802     ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

   803     LOG(("OpenWFTest: Fastpath - now ON - using element alpha"));

   804     

   805     iUtility->FillSurfaceL(surface, 0, KGreen);

   806     err = iUtility->SubmitUpdate(surface, 0, NULL);

   807     ASSERT_EQUALS(err,KErrNone);

   808     WaitL(iCompositionPause);	

   809  

   810     ASSERT_TRUE(AcquireOnScreenStream());

   811     ASSERT_TRUE(CheckOnScreenReferenceImage());

   812     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

   813     ReleaseOnScreenStream();

   814 

   815     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

   816     wfcDestroySource(iDevice, fpSource);  

   817 	}

   818 

   819 /*

   820 @SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0002

   821 @SYMTestCaseDesc		Positive testing - Fastpath one-element scene  

   822 @SYMREQ					

   823 @SYMPREQ						PREQ417-54885

   824 @SYMTestType				Unit Test

   825 @SYMTestPriority		High

   826 @SYMTestPurpose			Check a scene including a full screen element with source alpha flagged but an 

   827 										opaque data format can be fastpathed

   828 @SYMTestActions			

   829 	All compositions are autonomous:

   830 	Compose an empty scene

   831 	Create a scene containing a screen sized element 

   832 	Enable WFC_TRANSPARENCY_SOURCE, but the source format has no alpha value 

   833 	Compose the scene

   834 @SYMTestExpectedResults

   835 	The final scene should be fastpathed

   836 */	

   837 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0002L()

   838 	{

   839     iTestName = _L("FASTPATH_0002");

   840     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

   841     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

   842     SetupEmptySceneL();

   843     

   844     TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

   845 												EUidPixelFormatXRGB_8888,

   846                                                 iStride, iContiguous, iMaxBuffers);

   847     ASSERT_FALSE(surface.IsNull());

   848 

   849     WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

   850     TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

   851     ASSERT_EQUALS(err,KErrNone);

   852     WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

   853     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

   854     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

   855     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

   856     //set pixel alpha on XRGB element

   857     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_TRANSPARENCY_TYPES, WFC_TRANSPARENCY_SOURCE);

   858     

   859 #ifdef BREAKPOINT_FASTPATH

   860     __BREAKPOINT();

   861 #endif

   862     wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

   863     LOG(("OpenWFTest: Expecting FASTPATH after next commit - using pixel alpha"));

   864     wfcCommit(iDevice, iContext, WFC_TRUE);

   865     wfcFence(iDevice, iContext, iEGLDisplay, iSync);

   866     ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

   867     LOG(("OpenWFTest: Fastpath - now ON - using pixel alpha"));

   868     

   869     iUtility->FillSurfaceL(surface, 0, KGreen);

   870     err = iUtility->SubmitUpdate(surface, 0, NULL);

   871     ASSERT_EQUALS(err,KErrNone);

   872     WaitL(iCompositionPause);

   873  

   874     ASSERT_TRUE(AcquireOnScreenStream());

   875     ASSERT_TRUE(CheckOnScreenReferenceImage());

   876     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

   877     ReleaseOnScreenStream();

   878 

   879     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

   880     wfcDestroySource(iDevice, fpSource);  

   881 	}

   882 

   883 /*

   884 @SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0003

   885 @SYMTestCaseDesc		Positive testing - Fastpath scene with a double buffered element

   886 @SYMREQ					

   887 @SYMPREQ						PREQ417-54885

   888 @SYMTestType				Unit Test

   889 @SYMTestPriority		High

   890 @SYMTestPurpose			Check if a scene is fastpathed using the second buffer

   891 @SYMTestActions			

   892 	All compositions are autonomous:

   893 	Compose an empty scene

   894 	A) Create a scene containing an element with 2 buffers

   895 	Set the element screen size

   896 	Set destination and source rectangle to screen size

   897 	Compose the scene

   898 	B) Send an update to buffer 1 with change of colour

   899 	Wait for notification

   900 @SYMTestExpectedResults

   901 	The scene should be fastpathed for A and B

   902 	Screen colour should change after B

   903 */

   904 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0003L()

   905 	{

   906     iTestName = _L("FASTPATH_0003");

   907     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

   908     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

   909     SetupEmptySceneL();

   910     

   911     TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

   912                                                 iFastpathablePixelFormat,

   913                                                 iStride, iContiguous, iMaxBuffers);

   914     ASSERT_FALSE(surface.IsNull());

   915 

   916     WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

   917     TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

   918     ASSERT_EQUALS(err,KErrNone);

   919     WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

   920     wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

   921     

   922     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

   923     wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

   924     

   925 #ifdef BREAKPOINT_FASTPATH

   926     __BREAKPOINT();

   927 #endif

   928     wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

   929     LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

   930     wfcCommit(iDevice, iContext, WFC_TRUE);

   931     wfcFence(iDevice, iContext, iEGLDisplay, iSync);

   932     ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

   933     LOG(("OpenWFTest: Fastpath - now ON"));

   934     

   935     iUtility->FillSurfaceL(surface, 0, KGreen);

   936     err = iUtility->SubmitUpdate(surface, 0, NULL);

   937     ASSERT_EQUALS(err,KErrNone);

   938     WaitL(iCompositionPause);	

   939  

   940     ASSERT_TRUE(AcquireOnScreenStream());

   941     ASSERT_TRUE(CheckOnScreenReferenceImage());

   942     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

   943     ReleaseOnScreenStream();

   944     

   945     //Fill surface is blue

   946     iUtility->FillSurfaceL(surface, 1, KBlue);

   947 	//Do content update for surface buff1

   948     CActiveNotification* buff1disp = CActiveNotification::NewL(iUtility->Session(),ETrue);

   949     CleanupStack::PushL(buff1disp);

   950     TTimeStamp buff1time;

   951     iUtility->NotifyWhenDisplayed(buff1disp->iStatus,buff1time);

   952     

   953     LOG(("OpenWFTest: Fastpath - staying ON..."));

   954     err = iUtility->SubmitUpdate(surface, 1, NULL);

   955 	ASSERT_EQUALS(err,KErrNone);

   956     ASSERT_TRUE(WaitForNotifications(KMaxNotificationDelay,1));	//1 AO should have completed

   957     

   958     //create ref image/check on screen content

   959     ASSERT_TRUE(AcquireOnScreenStream());

   960     ASSERT_TRUE(CheckOnScreenReferenceImage());

   961     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KBlue,iTolerance));

   962     ReleaseOnScreenStream();

   963 

   964     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

   965     wfcDestroySource(iDevice, fpSource);

   966     CleanupStack::PopAndDestroy(buff1disp);

   967 	}

   968 

   969 /*

   970 @SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0004

   971 @SYMTestCaseDesc		Positive testing - Fastpath two-element scene 

   972 @SYMREQ					

   973 @SYMPREQ						PREQ417-54885

   974 @SYMTestType				Unit Test

   975 @SYMTestPriority		Medium

   976 @SYMTestPurpose			Check a scene including a full screen opaque element as the top layer can be 

   977 										fastpathed

   978 @SYMTestActions			

   979 	All compositions are autonomous:

   980 	Compose an empty scene

   981 	A) Create a scene containing a screen sized element with WFC_TRANSPARENCY_NONE enabled

   982 	Compose the scene

   983   B) Create a small rectangle behind the first element

   984 	Compose the scene

   985 */

   986 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0004L()

   987 	{

   988     iTestName = _L("FASTPATH_0004");

   989     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

   990     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

   991     SetupEmptySceneL();

   992 	

   993 	TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

   994 												iFastpathablePixelFormat,

   995 												iStride, iContiguous, iMaxBuffers);

   996 	ASSERT_FALSE(surface.IsNull());

   997 

   998 	WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

   999 	TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

  1000 	ASSERT_EQUALS(err,KErrNone);

  1001 	WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

  1002 	wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);	

  1003 	wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

  1004 	wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

  1005 	

  1006     TSurfaceId surfaceB = iUtility->CreateSurfaceL(TSize(iFastpathableWidth/2,iFastpathableHeight/2),

  1007                                                 iFastpathablePixelFormat,

  1008                                                 iStride, iContiguous, iMaxBuffers);

  1009     ASSERT_FALSE(surfaceB.IsNull());

  1010     WFCSource sourceB = wfcCreateSourceFromStream(iDevice, iContext, reinterpret_cast<WFCNativeStreamType>(&surfaceB), NULL);

  1011     err = iUtility->SubmitUpdate(surfaceB, 0, NULL);

  1012     ASSERT_EQUALS(err,KErrNone);

  1013     WFCElement elementB = wfcCreateElement(iDevice, iContext, NULL);

  1014     wfcSetElementAttribi(iDevice, elementB, WFC_ELEMENT_SOURCE, sourceB);

  1015     wfcSetElementAttribiv(iDevice, elementB, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iHalfSizeRect);

  1016     wfcSetElementAttribiv(iDevice, elementB, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iCenterRect);

  1017 	

  1018 #ifdef BREAKPOINT_FASTPATH

  1019     __BREAKPOINT();

  1020 #endif

  1021 	wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

  1022     LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

  1023 	wfcCommit(iDevice, iContext, WFC_TRUE);

  1024 	wfcFence(iDevice, iContext, iEGLDisplay, iSync);

  1025 	ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

  1026 	LOG(("OpenWFTest: Fastpath - now ON"));

  1027 	

  1028 	iUtility->FillSurfaceL(surface, 0, KGreen);

  1029 	err = iUtility->SubmitUpdate(surface, 0, NULL);

  1030 	ASSERT_EQUALS(err,KErrNone);

  1031 	WaitL(iCompositionPause);

  1032  

  1033     ASSERT_TRUE(AcquireOnScreenStream());

  1034     ASSERT_TRUE(CheckOnScreenReferenceImage());

  1035     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

  1036     ReleaseOnScreenStream();

  1037 	

  1038     LOG(("OpenWFTest: Fastpath - staying ON..."));

  1039 #ifdef BREAKPOINT_FASTPATH

  1040     __BREAKPOINT();

  1041 #endif

  1042 	wfcInsertElement(iDevice, elementB, WFC_INVALID_HANDLE);

  1043     LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

  1044 	wfcCommit(iDevice, iContext, WFC_TRUE);

  1045 	wfcFence(iDevice, iContext, iEGLDisplay, iSync);

  1046 	ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

  1047 	

  1048 	iUtility->FillSurfaceL(surfaceB, 0, KBlue);

  1049 	err = iUtility->SubmitUpdate(surfaceB, 0, NULL);

  1050 	ASSERT_EQUALS(err,KErrNone);

  1051 	WaitL(iCompositionPause);

  1052  

  1053     ASSERT_TRUE(AcquireOnScreenStream());

  1054     ASSERT_TRUE(CheckOnScreenReferenceImage());

  1055     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

  1056     ReleaseOnScreenStream();

  1057 

  1058     ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

  1059 	wfcDestroySource(iDevice, fpSource);

  1060 	wfcDestroySource(iDevice, sourceB);  

  1061 	}

  1062 

  1063 /*

  1064 @SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0005

  1065 @SYMTestCaseDesc		Positive testing - Fastpath two-element scene 

  1066 @SYMREQ					

  1067 @SYMPREQ						PREQ417-54885

  1068 @SYMTestType				Unit Test

  1069 @SYMTestPriority		Medium	

  1070 @SYMTestPurpose			Check a scene including a full screen element with global alpha as the top layer 

  1071 										can be fastpathed

  1072 @SYMTestActions			

  1073 	All compositions are autonomous:

  1074 	Compose an empty scene

  1075 	A) Create a scene containing a screen sized element 

  1076 	Enable WFC_TRANPARENCY_GLOBAL_ALPHA and set WFC_ELEMENT_GLOBAL_ALPHA to be 255 (opaque)

  1077 	Compose the scene

  1078 	B) Create a smaller element behind the first element

  1079 	Compose the scene

  1080 @SYMTestExpectedResults

  1081 	Both compositions should trigger fastpathing.

  1082 */

  1083 void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0005L()

  1084 	{

  1085     iTestName = _L("FASTPATH_0005");

  1086     INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

  1087     LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

  1088     SetupEmptySceneL();

  1089 	

  1090 	TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

  1091 												iFastpathablePixelFormat,

  1092 												iStride, iContiguous, iMaxBuffers);

  1093 	ASSERT_FALSE(surface.IsNull());

  1094 

  1095 	WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

  1096 	TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

  1097 	ASSERT_EQUALS(err,KErrNone);

  1098 	WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

  1099 	wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);	

  1100 	wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

  1101 	wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

  1102 //set element global alpha

  1103 	wfcSetElementAttribf(iDevice, fpElement, WFC_ELEMENT_GLOBAL_ALPHA, 1.0f);

  1104 	wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_TRANSPARENCY_TYPES, WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA);

  1105 	

  1106     TSurfaceId surfaceB = iUtility->CreateSurfaceL(TSize(iFastpathableWidth/2,iFastpathableHeight/2),

  1107                                                 iFastpathablePixelFormat,

  1108                                                 iStride, iContiguous, iMaxBuffers);

  1109     ASSERT_FALSE(surfaceB.IsNull());

  1110     WFCSource sourceB = wfcCreateSourceFromStream(iDevice, iContext, reinterpret_cast<WFCNativeStreamType>(&surfaceB), NULL);

  1111     err = iUtility->SubmitUpdate(surfaceB, 0, NULL);

  1112     ASSERT_EQUALS(err,KErrNone);

  1113     WFCElement elementB = wfcCreateElement(iDevice, iContext, NULL);

  1114     wfcSetElementAttribi(iDevice, elementB, WFC_ELEMENT_SOURCE, sourceB);

  1115     wfcSetElementAttribiv(iDevice, elementB, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iHalfSizeRect);

  1116     wfcSetElementAttribiv(iDevice, elementB, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iCenterRect);

  1117 	

  1118 #ifdef BREAKPOINT_FASTPATH

  1119     __BREAKPOINT();

  1120 #endif

  1121 	wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

  1122     LOG(("OpenWFTest: Expecting FASTPATH after next commit - using element global alpha"));

  1123 	wfcCommit(iDevice, iContext, WFC_TRUE);

  1124 	wfcFence(iDevice, iContext, iEGLDisplay, iSync);

  1125 	ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

  1126 	LOG(("OpenWFTest: Fastpath - now ON... - using element global alpha"));

  1127 	

  1128 	iUtility->FillSurfaceL(surface, 0, KGreen);

  1129 	ASSERT_EQUALS(iUtility->SubmitUpdate(surface, 0, NULL),KErrNone);

  1130 	WaitL(iCompositionPause);

  1131  

  1132     ASSERT_TRUE(AcquireOnScreenStream());

  1133     ASSERT_TRUE(CheckOnScreenReferenceImage());

  1134     ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

  1135     ReleaseOnScreenStream();