Symaptic: os/graphics/graphicscomposition/openwfcompositionengine/test/tscreeninterface/tscreeninterface.cpp@bde4ae8d615e

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

     2 //

     3 // Permission is hereby granted, free of charge, to any person obtaining a

     4 // copy of this software and/or associated documentation files (the

     5 // "Materials"), to deal in the Materials without restriction, including

     6 // without limitation the rights to use, copy, modify, merge, publish,

     7 // distribute, sublicense, and/or sell copies of the Materials, and to

     8 // permit persons to whom the Materials are furnished to do so, subject to

     9 // the following conditions:

    10 //

    11 // The above copyright notice and this permission notice shall be included

    12 // in all copies or substantial portions of the Materials.

    13 //

    14 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

    18 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

    19 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

    20 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21 //

    22 // Description:

    23 // Implementation of test class for OpenWF-C RI display driver interface

    24 //

    26 #include <WF/openwfc_ri_display.h>

    27 #include <WF/openwfc_ri_display_update.h>

    28 #include <test/extendtef.h>

    29 #include <test/tefunit.h>

    30 #include <hal.h>

    31 #include "tscreeninterface.h"

    33 #define KCompositorVersion 0x01023456

    34 #define KRgbRed         TRgb(0x0000ff)

    35 #define KRgbGreen       TRgb(0x00ff00)

    36 #define KRgbYellow      TRgb(0x00ffff)

    37 #define KRgbBlue        TRgb(0xff0000)

    39 const TInt KDefaultScreenNumber = 0;

    40 const TTimeIntervalMicroSeconds32 KDelay = 1000000;  //delay in microseconds

    41 const TTimeIntervalMicroSeconds32 KMinimalDelay = 1000;  //delay in microseconds

    43 _LIT(KImageSectionName, "ImageInfo");

    44 _LIT(KContiguousFlag, "ContiguousFlag");

    45 _LIT(KNonFastpathablePixelFormat, "NonFastpathablePixelFormat");

    46 _LIT(KFastpathablePixelFormat, "FastpathablePixelFormat");

    48 /*

    49  * CTestScreenInterface implementation

    50  */

    52 CTestScreenInterface::CTestScreenInterface()

    53 :iContiguous(EFlagNotListed),

    54  iFastpathablePixelFormat(EUidPixelFormatARGB_8888_PRE),

    55  iNonFastpathablePixelFormat(EUidPixelFormatRGB_565),

    56  iMappable(ETrue),

    57  iMaxBuffers(2),

    58  iMinBuffers(1),

    59  iCacheAttrib(ECacheNotlisted)

    60 	{

    61 	// No implementation required

    62 	}

    64 CTestScreenInterface::~CTestScreenInterface()

    65 	{

    66     TearDown();

    67 	}

    69 void CTestScreenInterface::SetupL()

    70 	{

    71 	iUtility = CStreamUtility::NewL();

    72 	iRed.SetInternal(0xFFFF0000);

    73 	iGreen.SetInternal(0xFF00FF00);

    74 	iBlue.SetInternal(0xFF0000FF);

    75 	ReadIniData();

    76     User::After(KDelay); // consider reading delay from ini file

    77 	}

    79 /**

    80  * test Suite furniture

    81  **/

    82 void CTestScreenInterface::TearDownL()

    83 	{

    84     // Nothing leaves in this function,

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

    86     TearDown();

    87 	}

    89 void CTestScreenInterface::TearDown()

    90     {

    91     if(iUtility)

    92         {

    93         delete iUtility;

    94         iUtility = NULL;

    95         }

    96     }

    98 // Create a suite of all the tests

    99 CTestSuite* CTestScreenInterface::CreateSuiteL(const TDesC& aName)

   100 	{

   101 	SymbianStreamRegisterScreenNotifications(0, 10, KCompositorVersion);

   102 	SUB_SUITE_OPT(CTestScreenInterface,NULL);

   104 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0100L);

   105 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0101L);

   106 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0102L);

   107 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0103L);

   108 		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0104L);

   109         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0105L);

   110         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0106L);

   111         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0107L);

   112         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0108L);

   113         ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0109L);

   115         END_SUITE;

   117 	}

   119 /// This handles any non-member uses of the extended ASSERT_XXX macros

   120 void TefUnitFailLeaveL()

   121 	{

   122 	User::Leave(KErrTEFUnitFail);

   123 	}

   125 void CTestScreenInterface::ReadIniData()

   126     {

   127     TBool contiguousFlag;

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

   129     if (returnValue)

   130         {

   131         if(contiguousFlag)

   132             {

   133             iContiguous = EContiguous;

   134             }

   135         else

   136             {

   137             iContiguous = ENonContiguous;

   138             }

   139         }

   141     TInt fastpathablePixelFormat;

   142     returnValue = iConfig.GetHex(KImageSectionName, KFastpathablePixelFormat, fastpathablePixelFormat);

   143     if(returnValue)

   144         {

   145         iFastpathablePixelFormat = static_cast<TUidPixelFormat>(fastpathablePixelFormat);

   146         }

   148     TInt nonFastpathablePixelFormat;

   149     returnValue = iConfig.GetHex(KImageSectionName, KNonFastpathablePixelFormat, nonFastpathablePixelFormat);

   150     if(returnValue)

   151         {

   152         iNonFastpathablePixelFormat = static_cast<TUidPixelFormat>(nonFastpathablePixelFormat);

   153         }

   154     }

   156 TInt CTestScreenInterface::BaseTestContiguousFlag(TBool aContiguous)

   157      {

   158       COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   159       CleanupStack::PushL(screenContext);

   161       TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   162       screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   163                                   &screenRotation,

   164                                   sizeof(screenRotation));

   165       screenContext->CommitAttribute();

   167       COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   168       screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   169                                   sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   171       TSurfaceId surface = TSurfaceId::CreateNullId();

   172       SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   173                                                   iFastpathablePixelFormat, attributes.iNormalStride,

   174                                                   surface, aContiguous, 1);

   175       ASSERT_FALSE((*ns).IsNull());

   177       iUtility->FillStreamL(ns, KRgbGreen);

   179       TInt err = screenContext->SetTopLayerSurface(ns);

   180       Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrAll, _L("SetTopLayerSurface() returned %i"),err );

   181 	  RDebug::Printf("SetTopLayerSurface() returned %i",err);

   183 	  if (err==KErrNone)

   184 	      {    //Must successfully SetTopLayerSurface before calling UpdateDisplay.

   185           screenContext->UpdateDisplay();

   186 	      }

   188       CleanupStack::PopAndDestroy(screenContext);

   190       return err;

   191      }

   193 /**

   194 @SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0100

   195 @SYMTestCaseDesc		Create a screen size stream and display on screen

   196 @SYMREQ

   197 @SYMPREQ				REQ 417-54885

   198 @SYMTestType            Unit Test

   199 @SYMTestPriority        High

   200 @SYMTestPurpose			Verify a COpenWFC_RI_Display object can be properly created and a stream can be displayed on screen

   201 @SYMTestActions

   202                         Create a screen context

   203                         Set display attributes

   204                         Create a screen size stream based on the display attributes with contigous and non-contiguous flags

   205                         Fill the stream

   206                         Associates the stream with the topmost display layer

   207                         Update the screen

   208 @SYMTestExpectedResults

   209                         If contiguous flag is set in the ini file, and the stream is created using the flag,

   210                         the stream should be properly displayed on screen. The stream created using the opposit flag from ini value should fail.

   211                         If contiguous flag is not set in the ini file,

   212                         the stream should be properly displayed on screen for contiguous and non-contiguous flag.

   213  **/

   214 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()

   215 	{

   216     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()"));

   217     LOG((" *** CTestScreenInterface test 0100L"));

   219     if(iContiguous != EFlagNotListed)

   220         {

   222         // We expect the opposit flag to the one from the ini file to fail

   223         if(iContiguous == EContiguous)

   224             {

   225             ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(ENonContiguous));

   226             }

   227         else

   228             {

   229             ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(EContiguous));

   230             }

   231         // The contiguous flag from the ini file should pass

   232         ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(iContiguous));

   233         // The last run here should be the "good" run so that it can do a Display() call.

   234         }

   235     else

   236         {

   237         // Contiguous or Non-contiguous flags should both pass if nothing set in the ini file

   238         ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(EContiguous));

   239         ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(ENonContiguous));

   240         }

   241     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L() done"));

   242     LOG((" *** CTestScreenInterface test 0100L done"));

   243 	}

   245 /**

   246 @SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0101

   247 @SYMTestCaseDesc		Create a stream, display on screen, then rotate the screen involving scaling

   248 @SYMREQ

   249 @SYMPREQ				REQ 417-54885

   250 @SYMTestType            Unit Test

   251 @SYMTestPriority        Medium

   252 @SYMTestPurpose			Verify screen rotation works

   253 @SYMTestActions

   254                         Create a screen context

   255                         Set display attributes

   256                         Create a screen size stream

   257                         Fill the stream

   258                         Associates the stream with the topmost display layer

   259                         Update the screen

   260                         Rotate the screen 90 degrees, 180 degrees, 270 degrees

   261                         Update the screen respectively

   262 @SYMTestExpectedResults

   263                         Methods should complete without error.

   264                         The stream should be properly displayed on screen

   265  **/

   266 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()

   267 	{

   268     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()"));

   269     LOG((" *** CTestScreenInterface test 0101L"));

   271     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   272     CleanupStack::PushL(screenContext);

   274     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   275     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   276                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   278     if (attributes.iSupportedRotations > 1)

   279         {

   280         INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);

   281         TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;

   282         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   283                                 &screenRotation0,

   284                                 sizeof(screenRotation0));

   285         screenContext->CommitAttribute();

   287         TSurfaceId surface = TSurfaceId::CreateNullId();

   288         SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   289                                                 iFastpathablePixelFormat, attributes.iNormalStride,

   290                                                 surface, iContiguous, 1);

   292         ASSERT_FALSE((*ns).IsNull());

   293         iUtility->FillStreamL(ns, KRgbRed);

   295         TInt err = screenContext->SetTopLayerSurface(ns);

   296         ASSERT_TRUE(err == KErrNone);

   298         err = screenContext->UpdateDisplay();

   299         ASSERT_TRUE(err == KErrNone);

   301         INFO_PRINTF1(_L("Rotate screen 90 degree"));

   302         // Rotate screen 90 degree and test

   303         TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;

   304         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   305                                 &screenRotation1,

   306                                 sizeof(screenRotation1));

   307         screenContext->CommitAttribute();

   309         err = screenContext->UpdateDisplay();

   310         ASSERT_TRUE(err == KErrNone);

   312         if (attributes.iSupportedRotations > 2)

   313             {

   314             INFO_PRINTF1(_L("Rotate screen 180 degree"));

   315             // Rotate screen 180 degree and test

   316             TUint32 screenRotation2 = COpenWFC_RI_Display::EScreenRotate180;

   317             screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   318                                     &screenRotation2,

   319                                     sizeof(screenRotation2));

   320             screenContext->CommitAttribute();

   322             err = screenContext->UpdateDisplay();

   323             ASSERT_TRUE(err == KErrNone);

   324             }

   326         if (attributes.iSupportedRotations > 3)

   327             {

   328             INFO_PRINTF1(_L("Rotate screen 270 degree"));

   329             // Rotate screen 270 degree and test

   330             TUint32 screenRotation3 = COpenWFC_RI_Display::EScreenRotate270;

   331             screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   332                                     &screenRotation3,

   333                                     sizeof(screenRotation3));

   334             screenContext->CommitAttribute();

   336             err = screenContext->UpdateDisplay();

   337             ASSERT_TRUE(err == KErrNone);

   338             }

   340         // Set screen back to rotation 0

   341         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   342                                     &screenRotation0,

   343                                     sizeof(screenRotation0));

   344         screenContext->CommitAttribute();

   345         err = screenContext->UpdateDisplay();

   346         ASSERT_TRUE(err == KErrNone);

   347         }

   348     else

   349         {

   350         INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));

   351         }

   353     CleanupStack::PopAndDestroy(screenContext);

   354 	}

   356 /**

   357 @SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0102

   358 @SYMTestCaseDesc        Create a stream, display on screen, then rotate the screen, not involving scaling

   359 @SYMREQ

   360 @SYMPREQ                REQ 417-54885

   361 @SYMTestType            Unit Test

   362 @SYMTestPriority        Medium

   363 @SYMTestPurpose         Verify screen rotation works

   364 @SYMTestActions

   365                         Create a screen context

   366                         Set display attributes

   367                         Create a stream of the size (screenHeight, screenWidth)

   368                         Fill the stream

   369                         Associates the stream with the topmost display layer

   370                         Update the screen

   371                         Rotate the screen 90 degrees

   372                         Update the screen

   373 @SYMTestExpectedResults

   374                         Methods should complete without error.

   375                         The stream should be properly displayed on screen

   376  **/

   377 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()

   378 	{

   379     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()"));

   380     LOG((" *** CTestScreenInterface test 0102L"));

   382     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   383     CleanupStack::PushL(screenContext);

   385     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   386     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   387                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   389     if (attributes.iSupportedRotations > 1)

   390         {

   391         INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);

   392         TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;

   393         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   394                                 &screenRotation0,

   395                                 sizeof(screenRotation0));

   396         screenContext->CommitAttribute();

   398         TSurfaceId surface = TSurfaceId::CreateNullId();

   399         SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalHeight,attributes.iNormalWidth),

   400                                                 iFastpathablePixelFormat, attributes.iNormalStride,

   401                                                 surface, iContiguous, 1);

   403         ASSERT_FALSE((*ns).IsNull());

   404         iUtility->FillStreamL(ns, KRgbRed);

   406         TInt err = screenContext->SetTopLayerSurface(ns);

   407         ASSERT_TRUE(err == KErrNone);

   409         err = screenContext->UpdateDisplay();

   410         ASSERT_TRUE(err == KErrNone);

   412         INFO_PRINTF1(_L("Rotate screen 90 degree"));

   413         // Rotate screen 90 degree and test

   414         TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;

   415         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   416                                 &screenRotation1,

   417                                 sizeof(screenRotation1));

   418         screenContext->CommitAttribute();

   420         err = screenContext->UpdateDisplay();

   421         ASSERT_TRUE(err == KErrNone);

   422         }

   423     else

   424         {

   425         INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));

   426         }

   428     CleanupStack::PopAndDestroy(screenContext);

   429 	}

   431 /**

   432 @SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0103

   433 @SYMTestCaseDesc		Create a stream, fill the stream several times and display on screen

   434 @SYMREQ

   435 @SYMPREQ                REQ 417-54885

   436 @SYMTestType            Unit Test

   437 @SYMTestPriority        High

   438 @SYMTestPurpose	        Check displaying stream repeatedly

   439 @SYMTestActions

   440                         Create a screen context

   441                         Set display attributes

   442                         Create a screen size stream

   443                         Fill the stream

   444                         Associates the stream with the topmost display layer

   445                         Update the screen

   446                         Repeat filling the stream, associate with toplayer and update several times

   447                         Destory the screen context

   448 @SYMTestExpectedResults

   449                         Methods should complete without error.

   450                         Each time, the stream should be properly displayed on screen

   451  **/

   452 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()

   453 	{

   454     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()"));

   455     LOG((" *** CTestScreenInterface test 0103L"));

   457     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   458     CleanupStack::PushL(screenContext);

   460     TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   461     screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   462                                 &screenRotation,

   463                                 sizeof(screenRotation));

   464     screenContext->CommitAttribute();

   466     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   467     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   468                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   470     TSurfaceId surface = TSurfaceId::CreateNullId();

   471     SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   472                                                 iFastpathablePixelFormat, attributes.iNormalStride,

   473                                                 surface, iContiguous, 1);

   474     ASSERT_FALSE((*ns).IsNull());

   476     iUtility->FillStreamL(ns, KRgbYellow);

   477     TInt err = screenContext->SetTopLayerSurface(ns);

   478     ASSERT_TRUE(err == KErrNone);

   479     err = screenContext->UpdateDisplay();

   480     ASSERT_TRUE(err == KErrNone);

   481     User::After(KDelay);

   483     iUtility->FillStreamL(ns, KRgbRed);

   484     err = screenContext->SetTopLayerSurface(ns);

   485     ASSERT_TRUE(err == KErrNone);

   486     err = screenContext->UpdateDisplay();

   487     ASSERT_TRUE(err == KErrNone);

   488     User::After(KDelay);

   490     iUtility->FillStreamL(ns, KRgbGreen);

   491     err = screenContext->SetTopLayerSurface(ns);

   492     ASSERT_TRUE(err == KErrNone);

   493     err = screenContext->UpdateDisplay();

   494     ASSERT_TRUE(err == KErrNone);

   495     User::After(KDelay);

   497     iUtility->FillStreamL(ns, KRgbYellow);

   498     err = screenContext->SetTopLayerSurface(ns);

   499     ASSERT_TRUE(err == KErrNone);

   500     err = screenContext->UpdateDisplay();

   501     ASSERT_TRUE(err == KErrNone);

   502     User::After(KDelay);

   504     iUtility->FillStreamL(ns, KRgbRed);

   505     err = screenContext->SetTopLayerSurface(ns);

   506     ASSERT_TRUE(err == KErrNone);

   507     err = screenContext->UpdateDisplay();

   508     ASSERT_TRUE(err == KErrNone);

   509     User::After(KDelay);

   511     // Set a non-topmost layer

   512     err = screenContext->SetLayerSurface(1, ns);

   513     ASSERT_TRUE(err == KErrArgument);

   515     CleanupStack::PopAndDestroy(screenContext);

   516 	}

   518 /**

   519 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0104

   520 @SYMTestCaseDesc        Display all display attributes

   521 @SYMREQ

   522 @SYMPREQ                REQ 417-54885

   523 @SYMTestType            Unit Test

   524 @SYMTestPriority        High

   525 @SYMTestPurpose         Check display attributes

   526 @SYMTestActions

   527                         Create a screen context

   528                         Set display attributes

   529                         Get all display attribtues

   530                         Destory the screen context

   531 @SYMTestExpectedResults

   532                         Methods should complete without error.

   533                         Display attributes should be correct

   534  **/

   535 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0104L()

   536     {

   537     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0104L()"));

   538     LOG((" *** CTestScreenInterface test 0104L"));

   540     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   541     CleanupStack::PushL(screenContext);

   543     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   544     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   545                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   547     INFO_PRINTF1(_L("Printing attribute values: "));

   548     INFO_PRINTF2(_L("EScreenAttributeSupportedRotation: %i "), attributes.iSupportedRotations);

   549     INFO_PRINTF2(_L("EScreenAttributeCurrentRotation: 0x%x "), attributes.iCurrentRotation);

   550     INFO_PRINTF2(_L("EScreenAttributeDefaultRotation: 0x%x "), attributes.iDefaultRotation);

   551     INFO_PRINTF2(_L("EScreenAttributeBytesPerPixel: %i "), attributes.iBytesPerPixel);

   552     INFO_PRINTF2(_L("EScreenAttributeFlippedHeight: %i "), attributes.iFlippedHeight);

   553     INFO_PRINTF2(_L("EScreenAttributeFlippedWidth: %i "), attributes.iFlippedWidth);

   554     INFO_PRINTF2(_L("EScreenAttributeFlippedStride: %i "), attributes.iFlippedStride);

   555     INFO_PRINTF2(_L("EScreenAttributeNormalHeight: %i "), attributes.iNormalHeight);

   556     INFO_PRINTF2(_L("EScreenAttributeNormalWidth: %i "), attributes.iNormalWidth);

   557     INFO_PRINTF2(_L("EScreenAttributeNormalStride: %i "), attributes.iNormalStride);

   558     INFO_PRINTF2(_L("EScreenAttributePixelFormat: 0x%x "), attributes.iPixelFormat);

   560     CleanupStack::PopAndDestroy(screenContext);

   561     }

   563 /**

   564 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0105

   565 @SYMTestCaseDesc        Create a screen size stream of non-fastpathable pixel format and display on screen

   566 @SYMREQ

   567 @SYMPREQ                REQ 417-54885

   568 @SYMTestType            Unit Test - Negative Test

   569 @SYMTestPriority        High

   570 @SYMTestPurpose         Verify a COpenWFC_RI_Display object can be properly created and a stream can be displayed on screen

   571 @SYMTestActions

   572                         Create a screen context

   573                         Set display attributes

   574                         Create a screen size stream based on the display attributes with a non-fastpathable pixelformat

   575                         Fill the stream

   576                         Associate the stream with the topmost display layer

   577 @SYMTestExpectedResults

   578                         Test should pass.

   579                         SetTopLayerSurface should return KErrNotSupported.

   580  **/

   581 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0105L()

   582     {

   583     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0105L()"));

   584     LOG((" *** CTestScreenInterface test 0105L"));

   586     if (!iNonFastpathablePixelFormat)

   587         {

   588         INFO_PRINTF1(_L("No non-fastpathable format specified - negative test cannot be run."));

   589         User::Leave(KErrTEFUnitInconclusive);

   590         }

   591     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   592     CleanupStack::PushL(screenContext);

   594     TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   595     screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   596                                  &screenRotation,

   597                                  sizeof(screenRotation));

   598     screenContext->CommitAttribute();

   600     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   601     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   602                                  sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   604     TSurfaceId surface = TSurfaceId::CreateNullId();

   605     SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   606                                                  iNonFastpathablePixelFormat, attributes.iNormalStride,

   607                                                  surface, iContiguous, 1);

   608     ASSERT_FALSE((*ns).IsNull());

   610     iUtility->FillStreamL(ns, KRgbGreen);

   612     ASSERT_TRUE(KErrNotSupported == screenContext->SetTopLayerSurface(ns));

   614     CleanupStack::PopAndDestroy(screenContext);

   615     }

   617 /**

   618 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0106

   619 @SYMTestCaseDesc        Create a stream, display on screen and repeat for a number of times

   620 @SYMREQ

   621 @SYMPREQ                REQ 417-54885

   622 @SYMTestType            Unit Test

   623 @SYMTestPriority        High

   624 @SYMTestPurpose         Check stream display repeatedly

   625 @SYMTestActions

   626                         Create a screen context

   627                         Set display attributes

   628                         Create a stream

   629                         Fill the stream

   630                         Associates the stream with the topmost display layer

   631                         Update the screen

   632                         Destory the screen context

   633                         Repeat the above actions for a number of times in a for loop

   634 @SYMTestExpectedResults

   635                         Methods should complete without error.

   636                         Each time, the stream should be properly displayed on screen

   637  **/

   638 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0106L()

   639     {

   640     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0106L()"));

   641     LOG((" *** CTestScreenInterface test 0106L"));

   643     SymbianStreamType ns = NULL;

   644     const TInt loopMaxNum = 10;

   646     for (TInt i = 0; i < loopMaxNum; ++i)

   647         {

   648         //INFO_PRINTF2(_L("Create screen context and stream loop: %i"), i);

   650         COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   651         CleanupStack::PushL(screenContext);

   653         TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   654         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   655                                 &screenRotation,

   656                                 sizeof(screenRotation));

   657         screenContext->CommitAttribute();

   659         COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   660         screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   661                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   663         if(ns == NULL)

   664             {

   665             TSurfaceId surface = TSurfaceId::CreateNullId();

   666             ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   667                                                 iFastpathablePixelFormat, attributes.iNormalStride,

   668                                                 surface, iContiguous, 1);

   669             ASSERT_FALSE((*ns).IsNull());

   670             }

   672         if(i%3 == 0)

   673             {

   674             iUtility->FillStreamL(ns, KRgbRed);

   675             }

   676         else if (i%3 == 1)

   677             {

   678             iUtility->FillStreamL(ns, KRgbGreen);

   679             }

   680             else

   681                 {

   682                 iUtility->FillStreamL(ns, KRgbBlue);

   683                 }

   685         TInt err = screenContext->SetTopLayerSurface(ns);

   686         ASSERT_TRUE(err == KErrNone);

   688         err = screenContext->UpdateDisplay();

   689         ASSERT_TRUE(err == KErrNone);

   691         CleanupStack::PopAndDestroy(screenContext);

   693         User::After(KDelay);

   694         }

   695     }

   697 /**

   698 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0107

   699 @SYMTestCaseDesc        Simple Non Trivial Attributes

   700 @SYMREQ

   701 @SYMPREQ                REQ 417-54885

   702 @SYMTestType            Unit Test

   703 @SYMTestPriority        High

   704 @SYMTestPurpose         Check that simple non-trivial attributes are accepted by SetTopLayerSurface.

   705                         Note this test does not pass in "real" attributes, so the result is predictable.

   706 @SYMTestActions

   707                         Create a screen context

   708                         Set display attributes

   709                         Create a fastpathable stream

   710                         Fill the stream

   711                         Associate the stream with the topmost display layer

   712                             and NULL Non Trivial Atrributes

   713                         Update the screen

   714                         Associate the stream with the topmost display layer

   715                             and empty Non Trivial Atrributes

   716                         Update the screen

   717                         Associate the stream with the topmost display layer

   718                             and wrong Non Trivial Atrributes

   719                         This should fail

   720                         Destory the screen context

   721 @SYMTestExpectedResults

   722                         SetTopLayerSurface should not fail, except for wrong attribute.

   723                         SetTopLayerSurface should not crash or panic.

   724  **/

   725 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0107L()

   726     {

   727     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0107L()"));

   728     LOG((" *** CTestScreenInterface test 0107L"));

   730     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   731     CleanupStack::PushL(screenContext);

   733     TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   734     screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   735                              &screenRotation,

   736                              sizeof(screenRotation));

   737     screenContext->CommitAttribute();

   739     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   740     screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   741                              sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   743     TSurfaceId surface = TSurfaceId::CreateNullId();

   744     SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   745                                              iFastpathablePixelFormat, attributes.iNormalStride,

   746                                              surface, iContiguous, 1);

   747     ASSERT_FALSE((*ns).IsNull());

   749     iUtility->FillStreamL(ns, KRgbGreen);

   751     TInt err = screenContext->SetTopLayerSurface(ns,NULL);

   752     ASSERT_FALSE(err);

   753     screenContext->UpdateDisplay();

   755     TInt emptyList=0;

   756     err = screenContext->SetTopLayerSurface(ns,&emptyList);

   757     ASSERT_FALSE(err);

   758     screenContext->UpdateDisplay();

   760     TInt wrongList=-1;

   761     err = screenContext->SetTopLayerSurface(ns,&wrongList);

   762     ASSERT_TRUE(err);

   764     //Calling UpdateDisplay should fall-back to the previous setting of top layer surface

   765     screenContext->UpdateDisplay();

   767     CleanupStack::PopAndDestroy(screenContext);

   768    }

   770 /**

   771 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0108

   772 @SYMTestCaseDesc        Test getting and setting attributes

   773 @SYMREQ

   774 @SYMPREQ                REQ 417-54885

   775 @SYMTestType            Unit Test

   776 @SYMTestPriority        High

   777 @SYMTestPurpose         Check getting and setting attibutes with good and bad values

   778 @SYMTestActions

   779                         Create a screen context

   780                         Get and set attributes with good and bad values

   781                         Destory the screen context

   782 @SYMTestExpectedResults

   783                         GetAttribute should always succeed with all valid TScreenAttribute values

   784                         and appropriate attribute size

   785                         SetAttribute should succeed for modifying the current rotation

   786                         Invalid valued for getting and setting attributes should return correct error code

   787  **/

   788 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0108L()

   789     {

   790     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0108L()"));

   791     LOG((" *** CTestScreenInterface test 0108L"));

   793     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   794     CleanupStack::PushL(screenContext);

   796     COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   797     TInt err;

   799     for(TUint ii = COpenWFC_RI_Display::EScreenAttributeInvalid; ii <= COpenWFC_RI_Display::EScreenAttributeScreenGeometry; ++ii)

   800         {

   801         if(ii == COpenWFC_RI_Display::EScreenAttributeScreenGeometry)

   802             {

   803             err = screenContext->GetAttribute(ii, &attributes,

   804                              sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   805             }

   806         else

   807             {

   808             err = screenContext->GetAttribute(ii, &attributes,

   809                              sizeof(COpenWFC_RI_Display::TScreenAttribute));

   810             }

   812         if(ii == COpenWFC_RI_Display::EScreenAttributeInvalid)

   813             {

   814             ASSERT_TRUE(err == KErrNotSupported);

   815             }

   816         else

   817             {

   818             ASSERT_TRUE(err == KErrNone);

   819             }

   820         }

   822     TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   823     err = screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, &screenRotation,

   824                     sizeof(screenRotation));

   825     // The only parameter that can be modified is the current rotation

   826     ASSERT_TRUE(err == KErrNone);

   828     err = screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeSupportedRotation, &screenRotation,

   829                     sizeof(screenRotation));

   830     ASSERT_TRUE(err == KErrNotSupported);

   832     // Set attribute to NULL

   833     err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, NULL,

   834                      sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   835     ASSERT_TRUE(err == KErrArgument);

   837     // Set attribute size to be 0

   838     err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeBytesPerPixel, &attributes, 0);

   839     ASSERT_TRUE(err == KErrArgument);

   841     // Set attribute == NULL

   842     err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeBytesPerPixel, NULL,

   843                      sizeof(COpenWFC_RI_Display::TScreenAttribute));

   844     ASSERT_TRUE(err != KErrNone);

   846     // Set attribute with wrong size

   847     err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   848                      sizeof(COpenWFC_RI_Display::TScreenAttribute));

   849     ASSERT_TRUE(err != KErrNone);

   851     CleanupStack::PopAndDestroy(screenContext);

   852     }

   854 /**

   855 @SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0109

   856 @SYMTestCaseDesc        Create a stream, display on screen and repeat for a number of times

   857 @SYMREQ

   858 @SYMPREQ                REQ 417-54885

   859 @SYMTestType            Unit Test

   860 @SYMTestPriority        High

   861 @SYMTestPurpose         Check stream display repeatedly

   862 @SYMTestActions

   863                         Create a screen context

   864                         Set display attributes

   865                         Repeat the below actions for a number of times in a for loop

   866                         Create a stream

   867                         Fill the stream

   868                         Associates the stream with the topmost display layer

   869                         Update the screen

   870                         Finally

   871                         Destory the screen context

   873 @SYMTestExpectedResults

   874                         Methods should complete without error.

   875                         Each time, the stream should be properly displayed on screen

   876                         The streams should be destroyed in a timely manner after they stop being displayed

   877  **/

   879 void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0109L()

   880     {

   881     INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0109L()"));

   882     LOG((" *** CTestScreenInterface test 0106L"));

   883     _LIT(KDirectPost, "DirectPost");

   884     TBool   directPost; //If DirectPost is not defined then the exact order of buffer releasing cannot be asserted.

   885     TBool definedDirectPost = iConfig.GetBool(KImageSectionName, KDirectPost, directPost);

   886     TInt offset;

   887     TInt error;

   888     TSurfaceId surface;

   889     SymbianStreamType ns = NULL;

   890     TSurfaceId prevsurface = TSurfaceId::CreateNullId();

   892     COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

   893     CleanupStack::PushL(screenContext);

   895     for (TInt i = 0; i < 10; ++i)

   896         {

   897         //INFO_PRINTF2(_L("Create  stream loop: %i"), i);

   899         TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

   900         screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,

   901                                 &screenRotation,

   902                                 sizeof(screenRotation));

   903         screenContext->CommitAttribute();

   905         COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

   906         screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,

   907                                 sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

   909         surface = TSurfaceId::CreateNullId();

   910         ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),

   911                                             iFastpathablePixelFormat, attributes.iNormalStride,

   912                                             surface, iContiguous, 2);

   913         ASSERT_FALSE((*ns).IsNull());

   915         if(i%3 == 0)

   916             {

   917             iUtility->FillStreamL(ns, KRgbRed);

   918             }

   919         else if (i%3 == 1)

   920             {

   921             iUtility->FillStreamL(ns, KRgbGreen);

   922             }

   923             else

   924                 {

   925                 iUtility->FillStreamL(ns, KRgbBlue);

   926                 }

   929         if (!prevsurface.IsNull())

   930             {

   931             error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);

   932             ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);

   933             }

   934         TInt err = screenContext->SetTopLayerSurface(ns);

   935         ASSERT_TRUE(err == KErrNone);

   936         //GetBufferOffset is a safe way to check if the surface is still alive

   937         if (!prevsurface.IsNull())

   938             {

   939             error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);

   940             ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);

   941             }

   943         err = screenContext->UpdateDisplay();

   944         ASSERT_TRUE(err == KErrNone);

   946         User::After(KMinimalDelay);

   948         error=iUtility->Manager().GetBufferOffset(surface,0,offset);

   949         ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);

   951         if (!prevsurface.IsNull())

   952             {

   953             error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);

   954             ASSERT_TRUE(error);   //previous surface should definitely be deleted by now

   955             }

   956         iUtility->DestroyStream(ns);

   957         error=iUtility->Manager().GetBufferOffset(surface,0,offset);

   958         ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);

   959         prevsurface=surface;

   961         User::After(KDelay);

   962         }

   963     CleanupStack::PopAndDestroy(screenContext);

   965     if (!prevsurface.IsNull())

   966         {

   967         error=iUtility->Manager().GetBufferOffset(surface,0,offset);

   968         ASSERT_TRUE(error);   //previous surface should definitely be deleted by now

   969         }

   970     }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--