// Copyright (c) 2008-2010 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:

//

/**

 @file

*/

#include "wsdynamicresbasic.h"

#include <test/extendtef.h>

#include "globalsettings.h"

#include <w32debug.h>

#include <w32stdgraphic.h>

#include "regionextend.h"

#include <fbs.h>

#include <e32svr.h>

#include <u32hal.h>

#include <graphics/surfaceconfiguration.h>

#include "surfaceutility.h"

#include <graphics/testscreencapture.h>

//verify which base code is available to the test

#include <dispchannel.h>

#if (!defined(K_DISPLAY_CH_MAJOR_VERSION_NUMBER) && !defined(K_DISPLAY_CH_MINOR_VERSION_NUMBER))

#define MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

#endif

//#define VISIBLE_PAUSES 1000

#define OVERLAPPING_CELL	0	//'m'	//0 indicates cells do not overlap

/*

 * CWsGceTestPlaceSurfExtra implementation

 * 

 * 

 * 

 * 

 */

CWsDynamicResBasic::CWsDynamicResBasic()

{

}

CWsDynamicResBasic::~CWsDynamicResBasic()

{

}

void CWsDynamicResBasic::SetupL()

	{

	MyBase::SetupL();

	}

void CWsDynamicResBasic::TearDownL()

	{

	MyBase::TearDownL();

	}

void CWsDynamicResBasic::TearDownFromDeleteL()

	{

	MyBase::TearDownFromDeleteL();

	}

CTestSuite* CWsDynamicResBasic::CreateSuiteL( const TDesC& aName )

	{

	//Create the surface manager here, before the test suite creates additional threads

	if (GCEIsSupportedStatic())

		{

		TRAP_IGNORE(PostTestCleanupInstance().CreateSharedUtilityL());

		}

	SUB_SUITE_OPT(CWsDynamicResBasic,NULL);

		//BASIC

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0001L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0002L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0003L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0004L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0005L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0006L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0007L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0008L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0009L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0010L);	//only run on screen 1

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0011L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0012L);	//only run on screen 0

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0013L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0014L);	//only run on screen 1

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0015L);	//only run with no scaling

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0016L);	//only run with anisotropic scaling

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0017L);	//only run with integer scaling

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0018L);

		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0021L);	//only run on screen 1

		//OOM

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0031L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0032L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0033L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0034L);	//dont run with no scaling on screen 0

		//SCREEN CAPTURE

		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0041L);

		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0042L);

		//DYNAMIC SCREEN MODE - only run these with no scaling and isotropic scaling

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0051L);	

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0052L);	//only run on screen 1 (multiple resolutions)

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0053L);

		//DEFECT

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0101L);

		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0102L);

	END_SUITE;

	}

#define LOG_AND_PANIC_IF_NOT_GCE											\

		{																	\

		if (!GCEIsSupported())												\

			{																\

			INFO_PRINTF1(_L("Test skipped: GCE support is not loaded"));	\

			User::Panic(_L("GCE.Wrong.Mode"),1);							\

			return;															\

			}																\

		}

CWsDisplayEvent::CWsDisplayEvent(RWsSession *aWs):

CActive(EPriorityStandard), iWs(aWs), iConfigSpinner(0), iResListSpinner(0),iReceivedEventCount(0), 

iReceivedPointerEventCount(0), iPointerPosTestPass(ETrue) 

	{

	CActiveScheduler::Add(this);

	}

CWsDisplayEvent::~CWsDisplayEvent()

	{

	Cancel();

	}

void CWsDisplayEvent::DoCancel()

	{

	iWs->EventReadyCancel();

	}

void CWsDisplayEvent::Request()

	{

	iWs->EventReady(&iStatus);

	SetActive();

	}

void CWsDisplayEvent::RunL()

	{

	TWsEvent event;

	iWs->GetEvent(event);

	if(iStatus == KErrNone)

		{

		switch(event.Type())

			{

			case EEventScreenDeviceChanged:

				{

				iReceivedDeviceEventCount++;

				}

			case EEventPointer:

				{

				iReceivedPointerEventCount++;

				TPointerEvent* ptEvent = event.Pointer();

				//make 1 pixels distance allowance, as non integer scalling from composition to app may occur

				//1 pixels allowance because we never scale greater than 2 times

				if(ptEvent->iPosition.iX < iPointerPos.iX - 1 && ptEvent->iPosition.iX > iPointerPos.iX + 1

						&& ptEvent->iPosition.iY < iPointerPos.iY - 1 &&ptEvent->iPosition.iY > iPointerPos.iY + 1)

					{

					iPointerPosTestPass = EFalse;

					}

				}

			case EEventDisplayChanged:

				{

				iConfigSpinner = event.DisplayChanged()->iConfigurationChangeId;

				iResListSpinner = event.DisplayChanged()->iResolutionListChangeId;

				iReceivedEventCount++;

				}

				break;

			default:

				break;

			}

		}

	else

		User::Leave(iStatus.Int());

	Request();

	}

CEventTimer* CEventTimer::NewL()

	{

	CEventTimer* self = new (ELeave) CEventTimer;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CEventTimer::ConstructL()

	{

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

	CActiveScheduler::Add(this);

	}

CEventTimer::CEventTimer() : CActive(EPriorityStandard)

	{

	}

CEventTimer::~CEventTimer()

	{

	Cancel();

	iTimer.Close();

	}

void CEventTimer::DoCancel()

	{

	iTimer.Cancel();

	CActiveScheduler::Stop();

	}

void CEventTimer::RunL()

	{

	CActiveScheduler::Stop();

	}

void CEventTimer::Wait(TInt aDelay)

	{

	iTimer.After(iStatus, aDelay);

	SetActive();

	CActiveScheduler::Start();

	}

//Set display state to normal and to the first decent resolution

//A failed test could leave it in a bad state

void CWsDynamicResBasic::ResetScreens()

	{

	Pause(1000);

#ifndef MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

	TInt displayState = ENormalResolution; 

	UserSvr::HalFunction(EHalGroupDisplay | (iScreenDevice->GetScreenNumber()<<16), EDisplayHalSetDisplayState, &displayState, NULL);

#endif

	MDisplayControl* interface = static_cast<MDisplayControl*>

				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface);

	RArray<TInt> appModeIndexList;

	TInt currMode=iScreenDevice->CurrentScreenMode();

	iScreenDevice->GetScreenSizeModeList(&appModeIndexList);

	if (appModeIndexList[0]!=currMode)

		{

		iScreenDevice->SetAppScreenMode(appModeIndexList[0]);

		iScreenDevice->SetScreenMode(appModeIndexList[0]);

		}

	appModeIndexList.Close();

	TInt resolutions = interface->NumberOfResolutions();

	ASSERT_TRUE (resolutions > 0);

	RArray<MDisplayControl::TResolution> resolutionList1;

	TInt error = interface->GetResolutions(resolutionList1);

	ASSERT_EQUALS(error,KErrNone);

	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

	TDisplayConfiguration config;

	TInt goodRes=0;

	if (resolutionList1[goodRes].iPixelSize==TSize())

		{

		goodRes++;

		ASSERT_TRUE(resolutions>goodRes);		//First res was blank, and no more to choose!

		}

	config.SetResolution(resolutionList1[goodRes].iPixelSize);

	error=interface->SetConfiguration(config);

	ASSERT_EQUALS(error,KErrNone);

	resolutionList1.Close();

	}

/**

@SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0001L

@SYMTestCaseDesc		WSERV Screen Device GetInterface returns known interface

@SYMREQ					REQ10325

@SYMPREQ				PREQ2102

@SYMTestType			CT

@SYMTestPriority		1

@SYMTestPurpose			Basic classic behaviour

@SYMTestActions			

	Call GetInterface with a well known GUID

@SYMTestExpectedResults	

	Returns a pointer

*/

void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0001L()

	{

	LOG_AND_PANIC_IF_NOT_GCE;

	MakeTitleAndCompareWindowsL(_L("GRAPHICS_WSERV_DYNAMICRES_0001L"),_L("Basic Dynamic Resolution test"));

	MDisplayControlBase* interface1 = static_cast<MDisplayControlBase*>

			(iScreenDevice->GetInterface(MDisplayControlBase::ETypeId));

	ASSERT_TRUE(interface1);

	MDisplayControl* interface2 = static_cast<MDisplayControl*>

			(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface2);

	MDisplayMappingBase* interface3 = static_cast<MDisplayMappingBase*>

			(iScreenDevice->GetInterface(MDisplayMappingBase::ETypeId));

	ASSERT_TRUE(interface3);

	MDisplayMapping* interface4 = static_cast<MDisplayMapping*>

			(iScreenDevice->GetInterface(MDisplayMapping::ETypeId));

	ASSERT_TRUE(interface4);

	}

/**

@SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0002L

@SYMTestCaseDesc		Basic test for NumberOfResolutions

@SYMREQ					REQ10328

@SYMPREQ				PREQ2102

@SYMTestType			CT

@SYMTestPriority		1

@SYMTestPurpose			NumberOfResolutions returns correctly

@SYMTestActions			

	GetInterface

	then call NumberOfResolutions.

@SYMTestExpectedResults	

	It shouldn't return KErrNotSupported

*/

void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0002L()

	{

	LOG_AND_PANIC_IF_NOT_GCE;

	MDisplayControl* interface = static_cast<MDisplayControl*>

				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface);

	TInt resolutions = interface->NumberOfResolutions();

	ASSERT_TRUE (resolutions != KErrNotSupported);

	}

/**

@SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0003L

@SYMTestCaseDesc		Basic test for GetResolutions

@SYMREQ					REQ10328

@SYMPREQ				PREQ2102

@SYMTestType			CT

@SYMTestPriority		

@SYMTestPurpose			Check GetResolutions returns a valid TSize RArray

@SYMTestActions			

	GetInterface

	Call NumberOfResolutions

	Create an array and garbage fill based on amount of resolutions

	Call GetResolutions on this array

	Create an array (dont garbage fill)

	Call GetResolutions on this empty array

	Create an array with smaller size than required

	Call GetResolutions on this array

	Create an array with larger size than required

	Call GetResolutions on this array

@SYMTestExpectedResults	

	For both GetResolutions calls, it should allocate memory if needed, and fill

	with correct sizes

*/

void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0003L()

	{

	LOG_AND_PANIC_IF_NOT_GCE;

	TInt count;

	TInt error;

	MDisplayControl* interface = static_cast<MDisplayControl*>

				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface);

	TInt resolutions = interface->NumberOfResolutions();

	ASSERT_TRUE (resolutions > 0);

	RArray<MDisplayControl::TResolution> resolutionList1;

	for (count=0;count<resolutions;count++)

		{

		resolutionList1.Append(MDisplayControl::TResolution(TSize(),TSize()));

		}

	error = interface->GetResolutions(resolutionList1);

	ASSERT_EQUALS(error,KErrNone);

	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

	RArray<MDisplayControl::TResolution> resolutionList2;

	error = interface->GetResolutions(resolutionList2);

	ASSERT_EQUALS(error,KErrNone);

	ASSERT_EQUALS(resolutionList2.Count(), resolutions);

	RArray<MDisplayControl::TResolution> resolutionList3;

	for (count=0;count<resolutions-1;count++)

		{

		resolutionList3.Append(MDisplayControl::TResolution(TSize(),TSize()));

		}

	error = interface->GetResolutions(resolutionList3);

	ASSERT_EQUALS(error,KErrNone);

	ASSERT_EQUALS(resolutionList3.Count(), resolutions);

	RArray<MDisplayControl::TResolution> resolutionList4;

	for (count=0;count<resolutions+2;count++)

		{

		resolutionList4.Append(MDisplayControl::TResolution(TSize(),TSize()));

		}

	error = interface->GetResolutions(resolutionList4);

	ASSERT_EQUALS(error,KErrNone);

	ASSERT_EQUALS(resolutionList4.Count(), resolutions);

	for (count=0;count<resolutions;count++)

		{

		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList2[count].iPixelSize);

		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList3[count].iPixelSize);

		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList4[count].iPixelSize);

		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList2[count].iTwipsSize);

		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList3[count].iTwipsSize);

		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList4[count].iTwipsSize);

		if (!(resolutionList1[count].iFlags == resolutionList2[count].iFlags))

			{

			ASSERT_TRUE(EFalse);

			}

		if (!(resolutionList1[count].iFlags == resolutionList3[count].iFlags))

			{

			ASSERT_TRUE(EFalse);

			}

		if (!(resolutionList1[count].iFlags == resolutionList4[count].iFlags))

			{

			ASSERT_TRUE(EFalse);

			}

		}

	resolutionList1.Close();

	resolutionList2.Close();

	resolutionList3.Close();

	resolutionList4.Close();

	}

/**

@SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0004L

@SYMTestCaseDesc		Test for GetConfiguration

@SYMREQ					REQ10328

@SYMPREQ				PREQ2102

@SYMTestType			CT

@SYMTestPriority		1

@SYMTestPurpose			Check GetConfiguration returns a configuration object

@SYMTestActions			

	GetInterface

	GetConfiguration with standard TDisplayConfiguration

	GetResolution from the TDisplayConfiguration object

	GetConfiguration with TDisplayConfiguration object with a greater version/size

	GetResolution from the TDisplayConfiguration object

	GetConfiguration with TDisplayConfiguration object with a smaller version/size -- equal to TDisplayConfiguration1

	GetResolution from the TDisplayConfiguration object

	Check all the resolutions should be same

@SYMTestExpectedResults	

*/

void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0004L()

	{

	LOG_AND_PANIC_IF_NOT_GCE;

	MDisplayControl* interface = static_cast<MDisplayControl*>

				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface);

	TDisplayConfiguration dispConfig;

	interface->GetConfiguration(dispConfig);

	ASSERT_TRUE(dispConfig.IsDefined(TDisplayConfigurationBase::EResolution));

	TSize size;

	TSize twips;

	ASSERT_TRUE(dispConfig.GetResolution(size));

	ASSERT_TRUE(dispConfig.GetResolutionTwips(twips));

	TDisplayConfiguration dispConfig1(TDisplayConfiguration().Version() + 10);

	interface->GetConfiguration(dispConfig1);

	ASSERT_TRUE(dispConfig1.IsDefined(TDisplayConfigurationBase::EResolution));

	TSize size1;

	TSize twips1;

	ASSERT_TRUE(dispConfig1.GetResolution(size1));

	ASSERT_TRUE(dispConfig1.GetResolutionTwips(twips1));

	TDisplayConfiguration dispConfig2(TDisplayConfiguration1().Version());

	interface->GetConfiguration(dispConfig2);

	ASSERT_TRUE(dispConfig2.IsDefined(TDisplayConfigurationBase::EResolution));

	TSize size2;

	TSize twips2;

	ASSERT_TRUE(dispConfig2.GetResolution(size2));

	ASSERT_TRUE(dispConfig2.GetResolutionTwips(twips2));

	ASSERT_EQUALS(size, size1);

	ASSERT_EQUALS(size, size2);

	ASSERT_EQUALS(twips, twips1);

	ASSERT_EQUALS(twips, twips2);

	}

/**

@SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0005L

@SYMTestCaseDesc		Test getting display change event from event queue

@SYMREQ					REQ10329 REQ10330

@SYMPREQ				PREQ2102

@SYMTestType			CT

@SYMTestPriority		1

@SYMTestPurpose			Verify the correct behaviour of display change notification

@SYMTestActions			

	Run through various ways of changing resolution

	For each, check if event has been received

@SYMTestExpectedResults	

	Based on type of change, check event

*/

void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0005L()

	{

	LOG_AND_PANIC_IF_NOT_GCE;

	ResetScreens();

#ifdef MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

	ASSERT_FALSE("Display connection test not compiled because MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER");

#else

	TInt screenNo = iScreenDevice->GetScreenNumber();

	MDisplayControl* interface = static_cast<MDisplayControl*>

				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

	ASSERT_TRUE(interface);

	interface->EnableDisplayChangeEvents(ETrue);

	ASSERT_TRUE(interface->DisplayChangeEventsEnabled());