graphicscomposition/openwfcompositionengine/test/tscreeninterface/tscreeninterface.cpp
// 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
}
}