--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicscomposition/openwfcompositionengine/test/tscreeninterface/tscreeninterface.cpp Tue Aug 31 16:31:06 2010 +0300
@@ -0,0 +1,971 @@
+// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+//
+// Description:
+// Implementation of test class for OpenWF-C RI display driver interface
+//
+
+#include <WF/openwfc_ri_display.h>
+#include <WF/openwfc_ri_display_update.h>
+#include <test/extendtef.h>
+#include <test/tefunit.h>
+#include <hal.h>
+#include "tscreeninterface.h"
+
+#define KCompositorVersion 0x01023456
+#define KRgbRed TRgb(0x0000ff)
+#define KRgbGreen TRgb(0x00ff00)
+#define KRgbYellow TRgb(0x00ffff)
+#define KRgbBlue TRgb(0xff0000)
+
+const TInt KDefaultScreenNumber = 0;
+const TTimeIntervalMicroSeconds32 KDelay = 1000000; //delay in microseconds
+const TTimeIntervalMicroSeconds32 KMinimalDelay = 1000; //delay in microseconds
+
+_LIT(KImageSectionName, "ImageInfo");
+_LIT(KContiguousFlag, "ContiguousFlag");
+_LIT(KNonFastpathablePixelFormat, "NonFastpathablePixelFormat");
+_LIT(KFastpathablePixelFormat, "FastpathablePixelFormat");
+
+/*
+ * CTestScreenInterface implementation
+ */
+
+CTestScreenInterface::CTestScreenInterface()
+:iContiguous(EFlagNotListed),
+ iFastpathablePixelFormat(EUidPixelFormatARGB_8888_PRE),
+ iNonFastpathablePixelFormat(EUidPixelFormatRGB_565),
+ iMappable(ETrue),
+ iMaxBuffers(2),
+ iMinBuffers(1),
+ iCacheAttrib(ECacheNotlisted)
+ {
+ // No implementation required
+ }
+
+CTestScreenInterface::~CTestScreenInterface()
+ {
+ TearDown();
+ }
+
+void CTestScreenInterface::SetupL()
+ {
+ iUtility = CStreamUtility::NewL();
+ iRed.SetInternal(0xFFFF0000);
+ iGreen.SetInternal(0xFF00FF00);
+ iBlue.SetInternal(0xFF0000FF);
+ ReadIniData();
+ User::After(KDelay); // consider reading delay from ini file
+ }
+
+/**
+ * test Suite furniture
+ **/
+void CTestScreenInterface::TearDownL()
+ {
+ // Nothing leaves in this function,
+ // but TearDownL() is needed for the CTestFixture (TEF) interface
+ TearDown();
+ }
+
+void CTestScreenInterface::TearDown()
+ {
+ if(iUtility)
+ {
+ delete iUtility;
+ iUtility = NULL;
+ }
+ }
+
+// Create a suite of all the tests
+CTestSuite* CTestScreenInterface::CreateSuiteL(const TDesC& aName)
+ {
+ SymbianStreamRegisterScreenNotifications(0, 10, KCompositorVersion);
+ SUB_SUITE_OPT(CTestScreenInterface,NULL);
+
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0100L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0101L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0102L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0103L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0104L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0105L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0106L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0107L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0108L);
+ ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0109L);
+
+ END_SUITE;
+
+ }
+
+/// This handles any non-member uses of the extended ASSERT_XXX macros
+void TefUnitFailLeaveL()
+ {
+ User::Leave(KErrTEFUnitFail);
+ }
+
+void CTestScreenInterface::ReadIniData()
+ {
+ TBool contiguousFlag;
+ TBool returnValue = iConfig.GetBool(KImageSectionName, KContiguousFlag, contiguousFlag);
+ if (returnValue)
+ {
+ if(contiguousFlag)
+ {
+ iContiguous = EContiguous;
+ }
+ else
+ {
+ iContiguous = ENonContiguous;
+ }
+ }
+
+ TInt fastpathablePixelFormat;
+ returnValue = iConfig.GetHex(KImageSectionName, KFastpathablePixelFormat, fastpathablePixelFormat);
+ if(returnValue)
+ {
+ iFastpathablePixelFormat = static_cast<TUidPixelFormat>(fastpathablePixelFormat);
+ }
+
+ TInt nonFastpathablePixelFormat;
+ returnValue = iConfig.GetHex(KImageSectionName, KNonFastpathablePixelFormat, nonFastpathablePixelFormat);
+ if(returnValue)
+ {
+ iNonFastpathablePixelFormat = static_cast<TUidPixelFormat>(nonFastpathablePixelFormat);
+ }
+ }
+
+TInt CTestScreenInterface::BaseTestContiguousFlag(TBool aContiguous)
+ {
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, aContiguous, 1);
+ ASSERT_FALSE((*ns).IsNull());
+
+ iUtility->FillStreamL(ns, KRgbGreen);
+
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrAll, _L("SetTopLayerSurface() returned %i"),err );
+ RDebug::Printf("SetTopLayerSurface() returned %i",err);
+
+ if (err==KErrNone)
+ { //Must successfully SetTopLayerSurface before calling UpdateDisplay.
+ screenContext->UpdateDisplay();
+ }
+
+ CleanupStack::PopAndDestroy(screenContext);
+
+ return err;
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0100
+@SYMTestCaseDesc Create a screen size stream and display on screen
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Verify a COpenWFC_RI_Display object can be properly created and a stream can be displayed on screen
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a screen size stream based on the display attributes with contigous and non-contiguous flags
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+@SYMTestExpectedResults
+ If contiguous flag is set in the ini file, and the stream is created using the flag,
+ the stream should be properly displayed on screen. The stream created using the opposit flag from ini value should fail.
+ If contiguous flag is not set in the ini file,
+ the stream should be properly displayed on screen for contiguous and non-contiguous flag.
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()"));
+ LOG((" *** CTestScreenInterface test 0100L"));
+
+ if(iContiguous != EFlagNotListed)
+ {
+
+ // We expect the opposit flag to the one from the ini file to fail
+ if(iContiguous == EContiguous)
+ {
+ ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(ENonContiguous));
+ }
+ else
+ {
+ ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(EContiguous));
+ }
+ // The contiguous flag from the ini file should pass
+ ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(iContiguous));
+ // The last run here should be the "good" run so that it can do a Display() call.
+ }
+ else
+ {
+ // Contiguous or Non-contiguous flags should both pass if nothing set in the ini file
+ ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(EContiguous));
+ ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(ENonContiguous));
+ }
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L() done"));
+ LOG((" *** CTestScreenInterface test 0100L done"));
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0101
+@SYMTestCaseDesc Create a stream, display on screen, then rotate the screen involving scaling
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority Medium
+@SYMTestPurpose Verify screen rotation works
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a screen size stream
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+ Rotate the screen 90 degrees, 180 degrees, 270 degrees
+ Update the screen respectively
+@SYMTestExpectedResults
+ Methods should complete without error.
+ The stream should be properly displayed on screen
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()"));
+ LOG((" *** CTestScreenInterface test 0101L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ if (attributes.iSupportedRotations > 1)
+ {
+ INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);
+ TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation0,
+ sizeof(screenRotation0));
+ screenContext->CommitAttribute();
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+
+ ASSERT_FALSE((*ns).IsNull());
+ iUtility->FillStreamL(ns, KRgbRed);
+
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+
+ INFO_PRINTF1(_L("Rotate screen 90 degree"));
+ // Rotate screen 90 degree and test
+ TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation1,
+ sizeof(screenRotation1));
+ screenContext->CommitAttribute();
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+
+ if (attributes.iSupportedRotations > 2)
+ {
+ INFO_PRINTF1(_L("Rotate screen 180 degree"));
+ // Rotate screen 180 degree and test
+ TUint32 screenRotation2 = COpenWFC_RI_Display::EScreenRotate180;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation2,
+ sizeof(screenRotation2));
+ screenContext->CommitAttribute();
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ }
+
+ if (attributes.iSupportedRotations > 3)
+ {
+ INFO_PRINTF1(_L("Rotate screen 270 degree"));
+ // Rotate screen 270 degree and test
+ TUint32 screenRotation3 = COpenWFC_RI_Display::EScreenRotate270;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation3,
+ sizeof(screenRotation3));
+ screenContext->CommitAttribute();
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ }
+
+ // Set screen back to rotation 0
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation0,
+ sizeof(screenRotation0));
+ screenContext->CommitAttribute();
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));
+ }
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0102
+@SYMTestCaseDesc Create a stream, display on screen, then rotate the screen, not involving scaling
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority Medium
+@SYMTestPurpose Verify screen rotation works
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a stream of the size (screenHeight, screenWidth)
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+ Rotate the screen 90 degrees
+ Update the screen
+@SYMTestExpectedResults
+ Methods should complete without error.
+ The stream should be properly displayed on screen
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()"));
+ LOG((" *** CTestScreenInterface test 0102L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ if (attributes.iSupportedRotations > 1)
+ {
+ INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);
+ TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation0,
+ sizeof(screenRotation0));
+ screenContext->CommitAttribute();
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalHeight,attributes.iNormalWidth),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+
+ ASSERT_FALSE((*ns).IsNull());
+ iUtility->FillStreamL(ns, KRgbRed);
+
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+
+ INFO_PRINTF1(_L("Rotate screen 90 degree"));
+ // Rotate screen 90 degree and test
+ TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation1,
+ sizeof(screenRotation1));
+ screenContext->CommitAttribute();
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));
+ }
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0103
+@SYMTestCaseDesc Create a stream, fill the stream several times and display on screen
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check displaying stream repeatedly
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a screen size stream
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+ Repeat filling the stream, associate with toplayer and update several times
+ Destory the screen context
+@SYMTestExpectedResults
+ Methods should complete without error.
+ Each time, the stream should be properly displayed on screen
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()"));
+ LOG((" *** CTestScreenInterface test 0103L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+ ASSERT_FALSE((*ns).IsNull());
+
+ iUtility->FillStreamL(ns, KRgbYellow);
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ User::After(KDelay);
+
+ iUtility->FillStreamL(ns, KRgbRed);
+ err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ User::After(KDelay);
+
+ iUtility->FillStreamL(ns, KRgbGreen);
+ err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ User::After(KDelay);
+
+ iUtility->FillStreamL(ns, KRgbYellow);
+ err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ User::After(KDelay);
+
+ iUtility->FillStreamL(ns, KRgbRed);
+ err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+ User::After(KDelay);
+
+ // Set a non-topmost layer
+ err = screenContext->SetLayerSurface(1, ns);
+ ASSERT_TRUE(err == KErrArgument);
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0104
+@SYMTestCaseDesc Display all display attributes
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check display attributes
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Get all display attribtues
+ Destory the screen context
+@SYMTestExpectedResults
+ Methods should complete without error.
+ Display attributes should be correct
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0104L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0104L()"));
+ LOG((" *** CTestScreenInterface test 0104L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ INFO_PRINTF1(_L("Printing attribute values: "));
+ INFO_PRINTF2(_L("EScreenAttributeSupportedRotation: %i "), attributes.iSupportedRotations);
+ INFO_PRINTF2(_L("EScreenAttributeCurrentRotation: 0x%x "), attributes.iCurrentRotation);
+ INFO_PRINTF2(_L("EScreenAttributeDefaultRotation: 0x%x "), attributes.iDefaultRotation);
+ INFO_PRINTF2(_L("EScreenAttributeBytesPerPixel: %i "), attributes.iBytesPerPixel);
+ INFO_PRINTF2(_L("EScreenAttributeFlippedHeight: %i "), attributes.iFlippedHeight);
+ INFO_PRINTF2(_L("EScreenAttributeFlippedWidth: %i "), attributes.iFlippedWidth);
+ INFO_PRINTF2(_L("EScreenAttributeFlippedStride: %i "), attributes.iFlippedStride);
+ INFO_PRINTF2(_L("EScreenAttributeNormalHeight: %i "), attributes.iNormalHeight);
+ INFO_PRINTF2(_L("EScreenAttributeNormalWidth: %i "), attributes.iNormalWidth);
+ INFO_PRINTF2(_L("EScreenAttributeNormalStride: %i "), attributes.iNormalStride);
+ INFO_PRINTF2(_L("EScreenAttributePixelFormat: 0x%x "), attributes.iPixelFormat);
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0105
+@SYMTestCaseDesc Create a screen size stream of non-fastpathable pixel format and display on screen
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test - Negative Test
+@SYMTestPriority High
+@SYMTestPurpose Verify a COpenWFC_RI_Display object can be properly created and a stream can be displayed on screen
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a screen size stream based on the display attributes with a non-fastpathable pixelformat
+ Fill the stream
+ Associate the stream with the topmost display layer
+@SYMTestExpectedResults
+ Test should pass.
+ SetTopLayerSurface should return KErrNotSupported.
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0105L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0105L()"));
+ LOG((" *** CTestScreenInterface test 0105L"));
+
+ if (!iNonFastpathablePixelFormat)
+ {
+ INFO_PRINTF1(_L("No non-fastpathable format specified - negative test cannot be run."));
+ User::Leave(KErrTEFUnitInconclusive);
+ }
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iNonFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+ ASSERT_FALSE((*ns).IsNull());
+
+ iUtility->FillStreamL(ns, KRgbGreen);
+
+ ASSERT_TRUE(KErrNotSupported == screenContext->SetTopLayerSurface(ns));
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0106
+@SYMTestCaseDesc Create a stream, display on screen and repeat for a number of times
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check stream display repeatedly
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a stream
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+ Destory the screen context
+ Repeat the above actions for a number of times in a for loop
+@SYMTestExpectedResults
+ Methods should complete without error.
+ Each time, the stream should be properly displayed on screen
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0106L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0106L()"));
+ LOG((" *** CTestScreenInterface test 0106L"));
+
+ SymbianStreamType ns = NULL;
+ const TInt loopMaxNum = 10;
+
+ for (TInt i = 0; i < loopMaxNum; ++i)
+ {
+ //INFO_PRINTF2(_L("Create screen context and stream loop: %i"), i);
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ if(ns == NULL)
+ {
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+ ASSERT_FALSE((*ns).IsNull());
+ }
+
+ if(i%3 == 0)
+ {
+ iUtility->FillStreamL(ns, KRgbRed);
+ }
+ else if (i%3 == 1)
+ {
+ iUtility->FillStreamL(ns, KRgbGreen);
+ }
+ else
+ {
+ iUtility->FillStreamL(ns, KRgbBlue);
+ }
+
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+
+ CleanupStack::PopAndDestroy(screenContext);
+
+ User::After(KDelay);
+ }
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0107
+@SYMTestCaseDesc Simple Non Trivial Attributes
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check that simple non-trivial attributes are accepted by SetTopLayerSurface.
+ Note this test does not pass in "real" attributes, so the result is predictable.
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Create a fastpathable stream
+ Fill the stream
+ Associate the stream with the topmost display layer
+ and NULL Non Trivial Atrributes
+ Update the screen
+ Associate the stream with the topmost display layer
+ and empty Non Trivial Atrributes
+ Update the screen
+ Associate the stream with the topmost display layer
+ and wrong Non Trivial Atrributes
+ This should fail
+ Destory the screen context
+@SYMTestExpectedResults
+ SetTopLayerSurface should not fail, except for wrong attribute.
+ SetTopLayerSurface should not crash or panic.
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0107L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0107L()"));
+ LOG((" *** CTestScreenInterface test 0107L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ TSurfaceId surface = TSurfaceId::CreateNullId();
+ SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 1);
+ ASSERT_FALSE((*ns).IsNull());
+
+ iUtility->FillStreamL(ns, KRgbGreen);
+
+ TInt err = screenContext->SetTopLayerSurface(ns,NULL);
+ ASSERT_FALSE(err);
+ screenContext->UpdateDisplay();
+
+ TInt emptyList=0;
+ err = screenContext->SetTopLayerSurface(ns,&emptyList);
+ ASSERT_FALSE(err);
+ screenContext->UpdateDisplay();
+
+ TInt wrongList=-1;
+ err = screenContext->SetTopLayerSurface(ns,&wrongList);
+ ASSERT_TRUE(err);
+
+ //Calling UpdateDisplay should fall-back to the previous setting of top layer surface
+ screenContext->UpdateDisplay();
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0108
+@SYMTestCaseDesc Test getting and setting attributes
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check getting and setting attibutes with good and bad values
+@SYMTestActions
+ Create a screen context
+ Get and set attributes with good and bad values
+ Destory the screen context
+@SYMTestExpectedResults
+ GetAttribute should always succeed with all valid TScreenAttribute values
+ and appropriate attribute size
+ SetAttribute should succeed for modifying the current rotation
+ Invalid valued for getting and setting attributes should return correct error code
+ **/
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0108L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0108L()"));
+ LOG((" *** CTestScreenInterface test 0108L"));
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ TInt err;
+
+ for(TUint ii = COpenWFC_RI_Display::EScreenAttributeInvalid; ii <= COpenWFC_RI_Display::EScreenAttributeScreenGeometry; ++ii)
+ {
+ if(ii == COpenWFC_RI_Display::EScreenAttributeScreenGeometry)
+ {
+ err = screenContext->GetAttribute(ii, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+ }
+ else
+ {
+ err = screenContext->GetAttribute(ii, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenAttribute));
+ }
+
+ if(ii == COpenWFC_RI_Display::EScreenAttributeInvalid)
+ {
+ ASSERT_TRUE(err == KErrNotSupported);
+ }
+ else
+ {
+ ASSERT_TRUE(err == KErrNone);
+ }
+ }
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ err = screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, &screenRotation,
+ sizeof(screenRotation));
+ // The only parameter that can be modified is the current rotation
+ ASSERT_TRUE(err == KErrNone);
+
+ err = screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeSupportedRotation, &screenRotation,
+ sizeof(screenRotation));
+ ASSERT_TRUE(err == KErrNotSupported);
+
+ // Set attribute to NULL
+ err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, NULL,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+ ASSERT_TRUE(err == KErrArgument);
+
+ // Set attribute size to be 0
+ err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeBytesPerPixel, &attributes, 0);
+ ASSERT_TRUE(err == KErrArgument);
+
+ // Set attribute == NULL
+ err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeBytesPerPixel, NULL,
+ sizeof(COpenWFC_RI_Display::TScreenAttribute));
+ ASSERT_TRUE(err != KErrNone);
+
+ // Set attribute with wrong size
+ err = screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenAttribute));
+ ASSERT_TRUE(err != KErrNone);
+
+ CleanupStack::PopAndDestroy(screenContext);
+ }
+
+/**
+@SYMTestCaseID GRAPHICS_OPENWFC_SCREENINTERFACE_0109
+@SYMTestCaseDesc Create a stream, display on screen and repeat for a number of times
+@SYMREQ
+@SYMPREQ REQ 417-54885
+@SYMTestType Unit Test
+@SYMTestPriority High
+@SYMTestPurpose Check stream display repeatedly
+@SYMTestActions
+ Create a screen context
+ Set display attributes
+ Repeat the below actions for a number of times in a for loop
+ Create a stream
+ Fill the stream
+ Associates the stream with the topmost display layer
+ Update the screen
+ Finally
+ Destory the screen context
+
+@SYMTestExpectedResults
+ Methods should complete without error.
+ Each time, the stream should be properly displayed on screen
+ The streams should be destroyed in a timely manner after they stop being displayed
+ **/
+
+void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0109L()
+ {
+ INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0109L()"));
+ LOG((" *** CTestScreenInterface test 0106L"));
+ _LIT(KDirectPost, "DirectPost");
+ TBool directPost; //If DirectPost is not defined then the exact order of buffer releasing cannot be asserted.
+ TBool definedDirectPost = iConfig.GetBool(KImageSectionName, KDirectPost, directPost);
+ TInt offset;
+ TInt error;
+ TSurfaceId surface;
+ SymbianStreamType ns = NULL;
+ TSurfaceId prevsurface = TSurfaceId::CreateNullId();
+
+ COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);
+ CleanupStack::PushL(screenContext);
+
+ for (TInt i = 0; i < 10; ++i)
+ {
+ //INFO_PRINTF2(_L("Create stream loop: %i"), i);
+
+ TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;
+ screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation,
+ &screenRotation,
+ sizeof(screenRotation));
+ screenContext->CommitAttribute();
+
+ COpenWFC_RI_Display::TScreenGeometryAttribute attributes;
+ screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes,
+ sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));
+
+ surface = TSurfaceId::CreateNullId();
+ ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight),
+ iFastpathablePixelFormat, attributes.iNormalStride,
+ surface, iContiguous, 2);
+ ASSERT_FALSE((*ns).IsNull());
+
+ if(i%3 == 0)
+ {
+ iUtility->FillStreamL(ns, KRgbRed);
+ }
+ else if (i%3 == 1)
+ {
+ iUtility->FillStreamL(ns, KRgbGreen);
+ }
+ else
+ {
+ iUtility->FillStreamL(ns, KRgbBlue);
+ }
+
+
+ if (!prevsurface.IsNull())
+ {
+ error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);
+ ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);
+ }
+ TInt err = screenContext->SetTopLayerSurface(ns);
+ ASSERT_TRUE(err == KErrNone);
+ //GetBufferOffset is a safe way to check if the surface is still alive
+ if (!prevsurface.IsNull())
+ {
+ error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);
+ ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);
+ }
+
+ err = screenContext->UpdateDisplay();
+ ASSERT_TRUE(err == KErrNone);
+
+ User::After(KMinimalDelay);
+
+ error=iUtility->Manager().GetBufferOffset(surface,0,offset);
+ ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);
+
+ if (!prevsurface.IsNull())
+ {
+ error=iUtility->Manager().GetBufferOffset(prevsurface,0,offset);
+ ASSERT_TRUE(error); //previous surface should definitely be deleted by now
+ }
+ iUtility->DestroyStream(ns);
+ error=iUtility->Manager().GetBufferOffset(surface,0,offset);
+ ASSERT_TRUE(definedDirectPost ? error == (directPost?KErrNone:KErrArgument) :1);
+ prevsurface=surface;
+
+ User::After(KDelay);
+ }
+ CleanupStack::PopAndDestroy(screenContext);
+
+ if (!prevsurface.IsNull())
+ {
+ error=iUtility->Manager().GetBufferOffset(surface,0,offset);
+ ASSERT_TRUE(error); //previous surface should definitely be deleted by now
+ }
+ }
+