Added GLES 1.x spinning cube-rendering code to eglbringuptest
The coordinate, color and index data are uploaded to server-side
buffers by the CGLES1Cube::KhrSetup function. CGLES1Cube::KhrPaint
just sets the view matrix and issues a draw command.
Which demo to display can be selected by passing its name on the
command line, e.g.
eglbringuptest vgline
eglbringuptest gles1cube
If no name is provided, the application defaults to vgline.
/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include "T_DataWsScreenDevice.h"
#include "T_GraphicsUtil.h"
/*@{*/
_LIT(KDataClassname, "CWsScreenDevice");
/// Fields
_LIT(KFldAlgStyle, "alg_style");
_LIT(KFldBackLight, "backlight");
_LIT(KFldBitmap, "bitmap");
_LIT(KFldDefaultScreenNumber, "defaultscreennumber");
_LIT(KFldExpected, "expected");
_LIT(KFldExpectedCount, "expectedcount");
_LIT(KFldFinish, "finish");
_LIT(KFldFlags, "flags");
_LIT(KFldFormatFieldNumber, "%S%d");
_LIT(KFldFontUid, "font_uid");
_LIT(KFldMode, "mode");
_LIT(KFldPalette, "palette");
_LIT(KFldPixel, "pixel");
_LIT(KFldPixelSize, "pixelsize");
_LIT(KFldRect, "rect");
_LIT(KFldRect1, "rect1");
_LIT(KFldRect2, "rect2");
_LIT(KFldRotation, "rotation");
_LIT(KFldStart, "start");
_LIT(KFldTwips, "twips");
_LIT(KFldTwipsSize, "twipssize");
_LIT(KFldWindowGc, "windowgc");
_LIT(KFldWs, "ws");
_LIT(KFldFont, "font");
_LIT(KFldContext, "context");
/// Commands
_LIT(KCmdnew, "new");
_LIT(KCmddisown, "disown");
_LIT(KCmdDestructor, "~CWsScreenDevice");
_LIT(KCmdDestructorGeneral, "~");
_LIT(KCmdConstruct, "Construct");
_LIT(KCmdCopyScreenToBitmap, "CopyScreenToBitmap");
_LIT(KCmdCreateContext, "CreateContext");
_LIT(KCmdCurrentScreenMode, "CurrentScreenMode");
_LIT(KCmdGetCurrentScreenModeScale, "GetCurrentScreenModeScale");
_LIT(KCmdGetCurrentScreenModeScaledOrigin, "GetCurrentScreenModeScaledOrigin");
_LIT(KCmdGetDefaultScreenModeOrigin, "GetDefaultScreenModeOrigin");
_LIT(KCmdGetDefaultScreenSizeAndRotation, "GetDefaultScreenSizeAndRotation");
_LIT(KCmdGetFontById, "GetFontById");
_LIT(KCmdGetRotationsList, "GetRotationsList");
_LIT(KCmdGetScreenModeDisplayMode, "GetScreenModeDisplayMode");
_LIT(KCmdGetScreenModeOrigin, "GetScreenModeOrigin");
_LIT(KCmdGetScreenModeScale, "GetScreenModeScale");
_LIT(KCmdGetScreenModeScaledOrigin, "GetScreenModeScaledOrigin");
_LIT(KCmdGetScreenModeSizeAndRotation, "GetScreenModeSizeAndRotation");
_LIT(KCmdGetScreenNumber, "GetScreenNumber");
_LIT(KCmdGetScreenSizeModeList, "GetScreenSizeModeList");
_LIT(KCmdNumScreenModes, "NumScreenModes");
_LIT(KCmdRectCompare, "RectCompare");
_LIT(KCmdPointerRect, "PointerRect");
_LIT(KCmdScreenModeEnforcement, "ScreenModeEnforcement");
_LIT(KCmdSetAppScreenMode, "SetAppScreenMode");
_LIT(KCmdSetBackLight, "SetBackLight");
_LIT(KCmdSetCustomPalette, "SetCustomPalette");
_LIT(KCmdSetScreenSizeAndRotation, "SetScreenSizeAndRotation");
_LIT(KCmdcheckPixels, "checkPixels");
_LIT(KCmdcheckLineColor, "checkLineColor");
_LIT(KCmdcheckRectColor, "checkRectColor");
_LIT(KFormatFieldNumber, "%S%d");
/// Logging
_LIT(KLogColor, "Color Red=%d Green=%d Blue=%d Alpha=%d");
_LIT(KLogPoint, "Point X=%d Y=%d");
_LIT(KLogError, "Error=%d");
_LIT(KLogMissingParameter, "Missing parameter '%S'");
_LIT(KLogNotExpectedValue, "Not expected value");
/*@}*/
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CT_DataWsScreenDevice* CT_DataWsScreenDevice::NewL()
/**
* Two phase constructor
*/
{
CT_DataWsScreenDevice* ret=new (ELeave) CT_DataWsScreenDevice();
CleanupStack::PushL(ret);
ret->ConstructL();
CleanupStack::Pop(ret);
return ret;
}
CT_DataWsScreenDevice::CT_DataWsScreenDevice()
/**
* Protected constructor. First phase construction
*/
: CT_DataBitmapDevice()
, iWsScreenDevice(NULL)
{
}
void CT_DataWsScreenDevice::ConstructL()
/**
* Second phase construction
*/
{
}
CT_DataWsScreenDevice::~CT_DataWsScreenDevice()
/**
* Public destructor
*/
{
DestroyData();
}
TAny* CT_DataWsScreenDevice::GetObject()
/**
* Return a pointer to the object that the data wraps
*
* @return pointer to the object that the data wraps
*/
{
return iWsScreenDevice;
}
void CT_DataWsScreenDevice::SetObjectL(TAny* aAny)
/**
* Set the object that the data wraps
*
* @param aObject object that the wrapper is testing
*
*/
{
DestroyData();
iWsScreenDevice = static_cast<CWsScreenDevice*> (aAny);
}
void CT_DataWsScreenDevice::DisownObjectL()
/**
* The object will no longer be owned by this
*
* @leave KErrNotSupported if the the function is not supported
*/
{
iWsScreenDevice = NULL;
}
void CT_DataWsScreenDevice::DestroyData()
{
delete iWsScreenDevice;
iWsScreenDevice=NULL;
}
MWsClientClass* CT_DataWsScreenDevice::GetClientClass() const
{
return iWsScreenDevice;
}
MGraphicsDeviceMap* CT_DataWsScreenDevice::GetGraphicsDeviceMap() const
{
return iWsScreenDevice;
}
CGraphicsDevice* CT_DataWsScreenDevice::GetGraphicsDevice() const
{
return iWsScreenDevice;
}
CBitmapDevice* CT_DataWsScreenDevice::GetBitmapDevice() const
{
return iWsScreenDevice;
}
/**
* Process a command read from the ini file
*
* @param aCommand the command to process
* @param aSection the entry in the ini file requiring the command to be processed
* @param aAsyncErrorIndex index of command. used for async calls
*
* @return ETrue if the command is processed
*/
TBool CT_DataWsScreenDevice::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
{
TBool ret = ETrue;
if ( aCommand==KCmdDestructor || aCommand==KCmdDestructorGeneral )
{
DoCmdDestructor();
}
else if ( aCommand==KCmdnew || aCommand==KDataClassname )
{
DoCmdnewL(aSection);
}
else if ( aCommand==KCmddisown )
{
DisownObjectL();
}
else if ( aCommand==KCmdConstruct )
{
DoCmdConstruct(aSection);
}
else if ( aCommand==KCmdCopyScreenToBitmap )
{
DoCmdCopyScreenToBitmapL(aSection);
}
else if ( aCommand==KCmdCreateContext )
{
DoCmdCreateContextL(aSection);
}
else if ( aCommand==KCmdCurrentScreenMode )
{
DoCmdCurrentScreenMode(aSection);
}
else if ( aCommand==KCmdGetCurrentScreenModeScale )
{
DoCmdGetCurrentScreenModeScale(aSection);
}
else if ( aCommand==KCmdGetCurrentScreenModeScaledOrigin )
{
DoCmdGetCurrentScreenModeScaledOrigin(aSection);
}
else if ( aCommand==KCmdGetDefaultScreenModeOrigin )
{
DoCmdGetDefaultScreenModeOrigin(aSection);
}
else if ( aCommand==KCmdGetDefaultScreenSizeAndRotation )
{
DoCmdGetDefaultScreenSizeAndRotation(aSection);
}
else if ( aCommand==KCmdGetFontById )
{
DoCmdGetFontByIdL(aSection);
}
else if ( aCommand==KCmdGetRotationsList )
{
DoCmdGetRotationsListL(aSection);
}
else if ( aCommand==KCmdGetScreenModeDisplayMode )
{
DoCmdGetScreenModeDisplayMode(aSection);
}
else if ( aCommand==KCmdGetScreenModeOrigin )
{
DoCmdGetScreenModeOrigin(aSection);
}
else if ( aCommand==KCmdGetScreenModeScale )
{
DoCmdGetScreenModeScale(aSection);
}
else if ( aCommand==KCmdGetScreenModeScaledOrigin )
{
DoCmdGetScreenModeScaledOrigin(aSection);
}
else if ( aCommand==KCmdGetScreenModeSizeAndRotation )
{
DoCmdGetScreenModeSizeAndRotation(aSection);
}
else if ( aCommand==KCmdGetScreenNumber )
{
DoCmdGetScreenNumber(aSection);
}
else if ( aCommand==KCmdGetScreenSizeModeList )
{
DoCmdGetScreenSizeModeListL(aSection);
}
else if ( aCommand==KCmdNumScreenModes )
{
DoCmdNumScreenModes(aSection);
}
else if ( aCommand==KCmdPointerRect )
{
DoCmdPointerRect(aSection);
}
else if ( aCommand==KCmdRectCompare )
{
DoCmdRectCompare(aSection);
}
else if ( aCommand==KCmdScreenModeEnforcement )
{
DoCmdScreenModeEnforcement(aSection);
}
else if ( aCommand==KCmdSetAppScreenMode )
{
DoCmdSetAppScreenMode(aSection);
}
else if ( aCommand==KCmdSetBackLight )
{
DoCmdSetBackLight(aSection);
}
else if ( aCommand==KCmdSetCustomPalette )
{
DoCmdSetCustomPaletteL(aSection);
}
else if ( aCommand==KCmdSetScreenSizeAndRotation )
{
DoCmdSetScreenSizeAndRotation(aSection);
}
else if ( aCommand==KCmdcheckPixels )
{
DoCmdcheckPixels(aSection);
}
else if ( aCommand==KCmdcheckLineColor )
{
DoCmdcheckLineColor(aSection);
}
else if ( aCommand==KCmdcheckRectColor )
{
DoCmdcheckRectColor(aSection);
}
else if ( CT_DataBitmapDevice::DoCommandL(aCommand, aSection, aAsyncErrorIndex) )
{
}
else
{
ret=CT_DataWsClientClass::DoCommandL(*this, aCommand, aSection, aAsyncErrorIndex);
}
return ret;
}
/**
Test Constructor
*/
void CT_DataWsScreenDevice::DoCmdnewL(const TDesC& aSection)
{
DestroyData();
// Get test data for command input parameter(s)
RWsSession* ws=NULL;
TPtrC wsName;
if ( GetStringFromConfig(aSection, KFldWs, wsName) )
{
ws = static_cast<RWsSession*>(GetDataObjectL(wsName));
}
TInt err;
if ( ws!= NULL )
{
// Execute command and log parameters
INFO_PRINTF1(_L("execute new CWsScreenDevice(RWsSession)"));
TRAP( err, iWsScreenDevice = new (ELeave) CWsScreenDevice(*ws) );
}
else
{
// Execute command and log parameters
INFO_PRINTF1(_L("execute new CWsScreenDevice()"));
TRAP(err, iWsScreenDevice = new (ELeave) CWsScreenDevice());
}
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
}
/**
Test Destructor
*/
void CT_DataWsScreenDevice::DoCmdDestructor()
{
INFO_PRINTF1(_L("execute ~CWsScreenDevice()"));
DestroyData();
}
/**
Test Construct()
*/
void CT_DataWsScreenDevice::DoCmdConstruct(const TDesC& aSection)
{
// Get test data for command input parameter(s)
TInt err=KErrNone;
TInt datDefaultScreenNumber;
if ( GetIntFromConfig(aSection, KFldDefaultScreenNumber, datDefaultScreenNumber) )
{
// Execute command and log parameters
INFO_PRINTF1(_L("execute Construct(TInt)"));
err=iWsScreenDevice->Construct(datDefaultScreenNumber);
}
else
{
// Execute command and log parameters
INFO_PRINTF1(_L("execute Construct()"));
err=iWsScreenDevice->Construct();
}
// Check the command return code.
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
}
/**
Test CopyScreenToBitmap()
*/
void CT_DataWsScreenDevice::DoCmdCopyScreenToBitmapL(const TDesC& aSection)
{
// Get test data for command input parameter(s)
CFbsBitmap* bitmap=NULL;
TBool hasBitmap=CT_GraphicsUtil::GetFbsBitmapL(*this, aSection, KFldBitmap, bitmap);
if ( !hasBitmap )
{
ERR_PRINTF2(KLogMissingParameter, &KFldBitmap);
SetBlockResult(EFail);
}
else
{
// Execute command and log parameters
TInt err=KErrNone;
TRect datRect;
if ( GetRectFromConfig(aSection, KFldRect, datRect) )
{
INFO_PRINTF1(_L("execute CopyScreenToBitmap(CFbsBitmap, TRect)"));
err=iWsScreenDevice->CopyScreenToBitmap(bitmap, datRect);
}
else
{
INFO_PRINTF1(_L("execute CopyScreenToBitmap(CFbsBitmap)"));
err=iWsScreenDevice->CopyScreenToBitmap(bitmap);
}
// Check the command return code.
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
}
}
/**
Test CreateContext()
*/
void CT_DataWsScreenDevice::DoCmdCreateContextL(const TDesC& aSection)
{
// Get test data for command input parameter(s)
TPtrC datWindowGc;
if ( !GetStringFromConfig(aSection, KFldWindowGc, datWindowGc) )
{
//CT_DataBitmapDevice::DoCommandL(aCommand, aSection, aAsyncErrorIndex);
// get BitmapUtilData object from parameters
if ( !GetStringFromConfig(aSection, KFldContext, datWindowGc) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldContext());
SetBlockResult(EFail);
}
else
{
CGraphicsContext* context=NULL;
INFO_PRINTF1(_L("execute CreateContext(CGraphicsContext*&)"));
TInt returnCode=GetGraphicsDevice()->CreateContext(context);
// Check the command return code.
if ( returnCode!=KErrNone )
{
ERR_PRINTF2(KLogError, returnCode);
SetError(returnCode);
}
else
{
SetDataObjectL(datWindowGc, context);
}
}
}
else
{
// Execute command and log parameters
CWindowGc* windowGc;
INFO_PRINTF1(_L("execute CreateContext(CWindowGc)"));
TInt returnCode = iWsScreenDevice->CreateContext(windowGc);
// Check the command return code.
if ( returnCode!=KErrNone )
{
ERR_PRINTF2(KLogError, returnCode);
SetError(returnCode);
}
else
{
SetDataObjectL(datWindowGc, windowGc);
}
}
}
/**
Test CurrentScreenMode()
*/
void CT_DataWsScreenDevice::DoCmdCurrentScreenMode(const TDesC& aSection)
{
TInt actual=iWsScreenDevice->CurrentScreenMode();
INFO_PRINTF2(_L("CurrentScreenMode()=%d"), actual);
TInt expected;
if ( !GetIntFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test GetCurrentScreenModeScale()
*/
void CT_DataWsScreenDevice::DoCmdGetCurrentScreenModeScale(const TDesC& aSection)
{
TSize actual=iWsScreenDevice->GetCurrentScreenModeScale();
INFO_PRINTF3(_L("GetCurrentScreenModeScale(TInt) height=%d width=%d"), actual.iHeight, actual.iWidth);
TSize expected;
if ( !GetSizeFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test GetCurrentScreenModeScaledOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetCurrentScreenModeScaledOrigin(const TDesC& aSection)
{
TPoint actual=iWsScreenDevice->GetCurrentScreenModeScaledOrigin();
INFO_PRINTF3(_L("GetCurrentScreenModeScaledOrigin() x=%d y=%d"), actual.iX, actual.iY);
TPoint expected;
if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test GetDefaultScreenModeOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetDefaultScreenModeOrigin(const TDesC& aSection)
{
TPoint actual=iWsScreenDevice->GetDefaultScreenModeOrigin();
INFO_PRINTF3(_L("GetDefaultScreenModeOrigin() x=%d y=%d"), actual.iX, actual.iY);
TPoint expected;
if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test GetDefaultScreenSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdGetDefaultScreenSizeAndRotation(const TDesC& aSection)
{
CFbsBitGc::TGraphicsOrientation rotation;
TBool checkRotation=CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation);
TSize pixelSize;
TBool checkPixelSize=GetSizeFromConfig(aSection, KFldPixelSize, pixelSize);
TBool twips=EFalse;
GetBoolFromConfig(aSection, KFldTwips, twips);
if ( twips )
{
TPixelsTwipsAndRotation param;
iWsScreenDevice->GetDefaultScreenSizeAndRotation(param);
INFO_PRINTF2(_L("GetDefaultScreenSizeAndRotation(TPixelsTwipsAndRotation) Rotation=%d"), param.iRotation);
INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
INFO_PRINTF3(_L("Twips height=%d width=%d"), param.iTwipsSize.iHeight, param.iTwipsSize.iWidth);
if ( checkRotation )
{
if ( rotation!=param.iRotation )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
if ( checkPixelSize )
{
if ( pixelSize!=param.iPixelSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
TSize twipsSize;
if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
{
if ( twipsSize!=param.iTwipsSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
else
{
TPixelsAndRotation param;
iWsScreenDevice->GetDefaultScreenSizeAndRotation(param);
INFO_PRINTF2(_L("GetDefaultScreenSizeAndRotation(TPixelsAndRotation) Rotation=%d"), param.iRotation);
INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
if ( checkRotation )
{
if ( rotation!=param.iRotation )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
if ( checkPixelSize )
{
if ( pixelSize!=param.iPixelSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetFontById()
*/
void CT_DataWsScreenDevice::DoCmdGetFontByIdL(const TDesC& aSection)
{
INFO_PRINTF1(_L("Call GetFontById()"));
TBool dataOk=ETrue;
// get font uid from parameters
TInt fontUid;
if(!GetIntFromConfig(aSection, KFldFontUid(), fontUid))
{
dataOk=EFalse;
ERR_PRINTF2(_L("No %S"), &KFldFontUid());
SetBlockResult(EFail);
}
// get TAlgStyle from parameters
TAlgStyle* algStyle=NULL;
CT_GraphicsUtil::GetAlgStyleL(*this, aSection, KFldAlgStyle(), algStyle);
if ( algStyle==NULL )
{
dataOk=EFalse;
ERR_PRINTF2(_L("No %S"), &KFldAlgStyle());
SetBlockResult(EFail);
}
// get font wrapper name
TPtrC datFbsFont;
if( !GetStringFromConfig(aSection, KFldFont, datFbsFont) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldFont());
SetBlockResult(EFail);
}
// call GetFontById()
else
{
if ( dataOk )
{
CFont* fbsFont=NULL;
INFO_PRINTF1(_L("execute GetFontById(CFont *&aFont, TUid aUid, const TAlgStyle &aAlgStyle)"));
TInt err = iWsScreenDevice->GetFontById(fbsFont, TUid::Uid(fontUid), *algStyle);
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
else
{
SetDataObjectL(datFbsFont, fbsFont);
}
}
}
}
/**
Test GetRotationsList()
*/
void CT_DataWsScreenDevice::DoCmdGetRotationsListL(const TDesC& aSection)
{
CArrayFixFlat<TInt>* rotations=new(ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL(rotations);
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
else
{
TInt err=iWsScreenDevice->GetRotationsList(mode, rotations);
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("GetRotationsList count=%d"), rotations->Count());
TInt expectedCount;
if ( GetIntFromConfig(aSection, KFldExpectedCount, expectedCount) )
{
if ( expectedCount!=rotations->Count() )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
else
{
INFO_PRINTF1(_L("Check elements in the rotations list"));
TBuf<KMaxTestExecuteCommandLength> tempStore;
TBool ok=ETrue;
for ( TInt index = 0; (index < expectedCount) && (ok); )
{
tempStore.Format(KFormatFieldNumber, &KFldRotation, ++index);
CFbsBitGc::TGraphicsOrientation rotation;
ok = CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, tempStore, rotation);
if ( !ok )
{
ERR_PRINTF2(KLogMissingParameter, &tempStore);
SetBlockResult(EFail);
}
else
{
if( rotation != (*rotations)[index-1])
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
ok = EFalse;
}
}
}
}
}
}
}
CleanupStack::PopAndDestroy();
}
/**
Test GetScreenModeDisplayMode()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeDisplayMode(const TDesC& aSection)
{
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
else
{
TDisplayMode actual=iWsScreenDevice->GetScreenModeDisplayMode(mode);
INFO_PRINTF2(_L("GetScreenModeDisplayMode(TInt)=%d"), actual);
TDisplayMode expected;
if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetScreenModeOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeOrigin(const TDesC& aSection)
{
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
else
{
TPoint actual=iWsScreenDevice->GetScreenModeOrigin(mode);
INFO_PRINTF3(_L("GetScreenModeOrigin(TInt) x=%d y=%d"), actual.iX, actual.iY);
TPoint expected;
if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetScreenModeScale()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeScale(const TDesC& aSection)
{
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
else
{
TSize actual=iWsScreenDevice->GetScreenModeScale(mode);
INFO_PRINTF3(_L("GetScreenModeScale(TInt) height=%d width=%d"), actual.iHeight, actual.iWidth);
TSize expected;
if ( !GetSizeFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetScreenModeScaledOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeScaledOrigin(const TDesC& aSection)
{
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
else
{
TPoint actual=iWsScreenDevice->GetScreenModeScaledOrigin(mode);
INFO_PRINTF3(_L("GetScreenModeScaledOrigin(TInt) x=%d y=%d"), actual.iX, actual.iY);
TPoint expected;
if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetScreenModeSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeSizeAndRotation(const TDesC& aSection)
{
TInt mode=0;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldMode);
SetBlockResult(EFail);
}
CFbsBitGc::TGraphicsOrientation rotation;
TBool checkRotation=CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation);
TSize pixelSize;
TBool checkPixelSize=GetSizeFromConfig(aSection, KFldPixelSize, pixelSize);
TBool twips=EFalse;
GetBoolFromConfig(aSection, KFldTwips, twips);
if ( twips )
{
TPixelsTwipsAndRotation param;
iWsScreenDevice->GetScreenModeSizeAndRotation(mode, param);
INFO_PRINTF2(_L("GetScreenModeSizeAndRotation(TInt, TPixelsTwipsAndRotation) Rotation=%d"), param.iRotation);
INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
INFO_PRINTF3(_L("Twips height=%d width=%d"), param.iTwipsSize.iHeight, param.iTwipsSize.iWidth);
if ( checkRotation )
{
if ( rotation!=param.iRotation )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
if ( checkPixelSize )
{
if ( pixelSize!=param.iPixelSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
TSize twipsSize;
if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
{
if ( twipsSize!=param.iTwipsSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
else
{
TPixelsAndRotation param;
iWsScreenDevice->GetScreenModeSizeAndRotation(mode, param);
INFO_PRINTF2(_L("GetScreenModeSizeAndRotation(TInt, TPixelsAndRotation) Rotation=%d"), param.iRotation);
INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
if ( checkRotation )
{
if ( rotation!=param.iRotation )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
if ( checkPixelSize )
{
if ( pixelSize!=param.iPixelSize )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test GetScreenNumber()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenNumber(const TDesC& aSection)
{
// Execute command and log parameters
TInt actual=iWsScreenDevice->GetScreenNumber();
INFO_PRINTF2(_L("execute GetScreenNumber()=%d"), actual);
// Diaplay command return value, check if it matches the expected value
TInt expected;
if ( !GetIntFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test GetScreenSizeModeList()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenSizeModeListL(const TDesC& aSection)
{
RArray<TInt> screenModes;
CleanupClosePushL(screenModes);
TInt number = iWsScreenDevice->GetScreenSizeModeList(&screenModes);
if (number < 0)
{
ERR_PRINTF2(KLogError, number);
SetError(number);
}
else
{
INFO_PRINTF2(_L("GetScreenSizeModeList count=%d"), screenModes.Count());
TInt expectedCount;
if ( GetIntFromConfig(aSection, KFldExpectedCount, expectedCount) )
{
if ( expectedCount!=screenModes.Count() || expectedCount != number)
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
else
{
INFO_PRINTF1(_L("Check elements in the modes list"));
TBuf<KMaxTestExecuteCommandLength> tempStore;
TBool ok=ETrue;
for ( TInt index = 0; (index < number) && (ok); )
{
tempStore.Format(KFormatFieldNumber, &KFldMode, ++index);
TInt expectedMode = 0;
ok=GetIntFromConfig(aSection, tempStore, expectedMode);
if ( !ok )
{
ERR_PRINTF2(KLogMissingParameter, &tempStore);
SetBlockResult(EFail);
}
else
{
if( expectedMode != screenModes[index-1])
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
ok = EFalse;
}
}
}
}
}
}
CleanupStack::PopAndDestroy(&screenModes);
}
/**
Test NumScreenModes()
*/
void CT_DataWsScreenDevice::DoCmdNumScreenModes(const TDesC& aSection)
{
TInt actual=iWsScreenDevice->NumScreenModes();
INFO_PRINTF2(_L("NumScreenModes()=%d"), actual);
TInt expected;
if ( GetIntFromConfig(aSection, KFldExpected, expected) )
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test PointerRect()
*/
void CT_DataWsScreenDevice::DoCmdPointerRect(const TDesC& aSection)
{
TRect actual=iWsScreenDevice->PointerRect();
LogRect(_L("PointerRect()"), actual);
TRect expected;
if ( GetRectFromConfig(aSection, KFldExpected, expected) )
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test RectCompare()
*/
void CT_DataWsScreenDevice::DoCmdRectCompare(const TDesC& aSection)
{
TBool dataOk=ETrue;
// Get test data for command input parameter(s)
TRect datRect1;
if ( !GetRectFromConfig(aSection, KFldRect1, datRect1) )
{
dataOk=EFalse;
ERR_PRINTF2(KLogMissingParameter, &KFldRect1);
SetBlockResult(EFail);
}
TRect datRect2;
if ( !GetRectFromConfig(aSection, KFldRect2, datRect2) )
{
dataOk=EFalse;
ERR_PRINTF2(KLogMissingParameter, &KFldRect2);
SetBlockResult(EFail);
}
if ( dataOk )
{
TBool actual=EFalse;
// Execute command and log parameters
TUint datFlags;
if ( CT_GraphicsUtil::ReadSpriteInCompare(*this, aSection, KFldFlags, datFlags) )
{
actual=iWsScreenDevice->RectCompare(datRect1, datRect2, datFlags);
INFO_PRINTF2(_L("execute RectCompare(TRect, TRect, TUint)=%d"), actual);
}
else
{
actual=iWsScreenDevice->RectCompare(datRect1, datRect2);
INFO_PRINTF2(_L("execute RectCompare(TRect, TRect)=%d"), actual);
}
// Diaplay command return value, check if it matches the expected value
TBool expected;
if ( !GetBoolFromConfig(aSection, KFldExpected, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
SetBlockResult(EFail);
}
else
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
}
/**
Test ScreenModeEnforcement()
*/
void CT_DataWsScreenDevice::DoCmdScreenModeEnforcement(const TDesC& aSection)
{
TScreenModeEnforcement actual=iWsScreenDevice->ScreenModeEnforcement();
INFO_PRINTF2(_L("execute ScreenModeEnforcement()=%d"), actual);
TScreenModeEnforcement expected;
if ( CT_GraphicsUtil::ReadScreenModeEnforcement(*this, aSection, KFldExpected, expected) )
{
if ( actual!=expected )
{
ERR_PRINTF1(KLogNotExpectedValue);
SetBlockResult(EFail);
}
}
}
/**
Test SetAppScreenMode()
*/
void CT_DataWsScreenDevice::DoCmdSetAppScreenMode(const TDesC& aSection)
{
TInt mode;
if ( !GetIntFromConfig(aSection, KFldMode, mode) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldRect2);
SetBlockResult(EFail);
}
else
{
INFO_PRINTF1(_L("SetAppScreenMode()"));
iWsScreenDevice->SetAppScreenMode(mode);
}
}
/**
Test SetBackLight()
*/
void CT_DataWsScreenDevice::DoCmdSetBackLight(const TDesC& aSection)
{
TBool backLight;
if ( !GetBoolFromConfig(aSection, KFldBackLight, backLight) )
{
ERR_PRINTF2(KLogMissingParameter, &KFldBackLight);
SetBlockResult(EFail);
}
else
{
TInt err=iWsScreenDevice->SetBackLight(backLight);
if ( err!=KErrNone )
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
}
}
/**
Test SetCustomPalette()
*/
void CT_DataWsScreenDevice::DoCmdSetCustomPaletteL(const TDesC& aSection)
{
INFO_PRINTF1(_L("Calls CWsScreenDevice::SetCustomPalette() by previously created palette"));
// get CPalette object passed as a parameter
CPalette* palette = NULL;
if(!CT_GraphicsUtil::GetPaletteL(*this, aSection, KFldPalette(), palette))
{
ERR_PRINTF2(KLogMissingParameter, &KFldPalette);
SetBlockResult(EFail);
}
else
{
// call SetPalette()
TInt err = iWsScreenDevice->SetCustomPalette(palette);
if(err != KErrNone)
{
ERR_PRINTF2(KLogError, err);
SetError(err);
}
}
}
/**
Test SetScreenSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdSetScreenSizeAndRotation(const TDesC& aSection)
{
TBool dataOk=ETrue;
CFbsBitGc::TGraphicsOrientation rotation;
if ( !CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation) )
{
dataOk=EFalse;
ERR_PRINTF2(KLogMissingParameter, &KFldRotation);
SetBlockResult(EFail);
}
TSize pixelSize;
if ( !GetSizeFromConfig(aSection, KFldPixelSize, pixelSize) )
{
dataOk=EFalse;
ERR_PRINTF2(KLogMissingParameter, &KFldPixelSize);
SetBlockResult(EFail);
}
if ( dataOk )
{
TSize twipsSize;
if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
{
TPixelsTwipsAndRotation param;
param.iPixelSize=pixelSize;
param.iRotation=rotation;
param.iTwipsSize=twipsSize;
INFO_PRINTF1(_L("execute SetScreenSizeAndRotation(const TPixelsTwipsAndRotation&)"));
iWsScreenDevice->SetScreenSizeAndRotation(param);
}
else
{
TPixelsAndRotation param;
param.iPixelSize=pixelSize;
param.iRotation=rotation;
INFO_PRINTF1(_L("execute SetScreenSizeAndRotation(const TPixelsAndRotation&)"));
iWsScreenDevice->SetScreenSizeAndRotation(param);
}
}
}
/**
* The source codes hereafter are NOT simple wrapper functions of CWsScreenDevice class,
* but use combinations of CWsScreenDevice (and other) class functions to check if what
* take from the CWsScreenDevice matches with the expected value specified in TEF testdata.
*
*/
/**
* DoCmdcheckPixels: to check the color of specified pixels on the screen device, and compare
* with the expected color specidied in the TEF testdata.
* pixel<n>: specify the position of the screen device to check
* expected<n>: specify the expected color to be compared with
*
*/
void CT_DataWsScreenDevice::DoCmdcheckPixels(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> tempStore;
TBool moreData=ETrue;
for ( TInt index=1; moreData; ++index )
{
// get the pixel position on the screen to check/verify
tempStore.Format(KFldFormatFieldNumber, &KFldPixel, index);
TPoint point;
if ( !GetPointFromConfig(aSection, tempStore, point) )
{
moreData=EFalse;
}
else
{
TRgb actual;
iWsScreenDevice->GetPixel(actual, point);
tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
TRgb expected;
if ( GetRgbFromConfig(aSection, tempStore, expected) )
{
if ( actual!=expected )
{
ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
SetBlockResult(EFail);
}
}
}
}
}
/**
* DoCmdcheckLineColor: to check the color of specified lines on the screen device, and compare
* with the expected color specidied in the TEF testdata.
* start<n>: specify the starting position of the line on the screen device to check
* finish<n>: specify the finish position of the line on the screen device to check
* expected<n>: specify the expected color to be compared with
* Note: the straight line (from start to the finish points) is constructed by TLinearDDA
*
*/
void CT_DataWsScreenDevice::DoCmdcheckLineColor(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> tempStore;
CPalette* palette=NULL;
iWsScreenDevice->GetPalette(palette);
TBool moreData=ETrue;
for ( TInt index=1; moreData; ++index )
{
// get the the start and finish points of the line to check/verify
tempStore.Format(KFldFormatFieldNumber, &KFldStart, index);
TPoint startPoint;
if ( !GetPointFromConfig(aSection, tempStore, startPoint) )
{
moreData=EFalse;
}
tempStore.Format(KFldFormatFieldNumber, &KFldFinish, index);
TPoint endPoint;
if ( !GetPointFromConfig(aSection, tempStore, endPoint) )
{
moreData=EFalse;
}
if ( moreData )
{
// get the expected color from testdata
tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
TRgb expected;
if ( !GetRgbFromConfig(aSection, tempStore, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &tempStore);
SetBlockResult(EFail);
}
else
{
if ( palette!=NULL )
{
expected=palette->NearestEntry(expected);
}
TLinearDDA lineDDA;
lineDDA.Construct(startPoint, endPoint, TLinearDDA::ECenter);
// for each pixels on the line (from start to finish points), check if its color matches expected
TPoint point;
while ( !lineDDA.SingleStep(point) )
{
TRgb actual;
iWsScreenDevice->GetPixel(actual, point);
if ( actual!=expected )
{
ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
ERR_PRINTF3(KLogPoint, point.iX, point.iY);
SetBlockResult(EFail);
}
}
}
}
}
delete palette;
}
/**
* DoCmdcheckRectColor: to check the color of specified rectangle on the screen device, and
* compare with the expected color specidied in the TEF testdata.
* rect<n>: specify the rectangle area on the screen device to check
* expected<n>: specify the expected color to be compared with
*
*/
void CT_DataWsScreenDevice::DoCmdcheckRectColor(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> tempStore;
CPalette* palette=NULL;
iWsScreenDevice->GetPalette(palette);
TBool moreData=ETrue;
for ( TInt index=1; moreData; ++index )
{
// get the the rectangle to check/verify
tempStore.Format(KFldFormatFieldNumber, &KFldRect, index);
TRect rect;
if ( !GetRectFromConfig(aSection, tempStore, rect) )
{
moreData=EFalse;
}
else
{
// get the expected color from testdata
tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
TRgb expected;
if ( !GetRgbFromConfig(aSection, tempStore, expected) )
{
ERR_PRINTF2(KLogMissingParameter, &tempStore);
SetBlockResult(EFail);
}
else
{
if ( palette!=NULL )
{
expected=palette->NearestEntry(expected);
}
TPoint point;
for ( point.iX=rect.iTl.iX; point.iX<rect.iBr.iX; ++point.iX)
{
for ( point.iY=rect.iTl.iY; point.iY<rect.iBr.iY; ++point.iY )
{
TRgb actual;
iWsScreenDevice->GetPixel(actual, point);
if ( actual!=expected )
{
ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
ERR_PRINTF3(KLogPoint, point.iX, point.iY);
SetBlockResult(EFail);
}
}
}
}
}
}
delete palette;
}