--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TKEY.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1119 @@
+// Copyright (c) 1996-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:
+// Testing key event, capturing keys and hot keys
+// 
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+
+#include "TKEY.H"
+
+#define LOGGING 1	//Uncomment this when there is a fail so that you get more logging
+
+GLDEF_D ClientToKill *SecondClient=NULL;
+
+GLDEF_C CTClient *CreateClientToKillL()
+	{
+	return(SecondClient=new(ELeave) ClientToKill());
+	}
+
+GLDEF_C TInt ProcToKill(TAny *aScreenNumber)
+	{
+	TInt ret=KErrNone;
+	ret=TestLibStartUp(CreateClientToKillL,(TInt)aScreenNumber);
+	return(ret);
+	}
+
+CVisibleGroup::CVisibleGroup(TInt aScreenNo): iScreenNo(aScreenNo)
+	{}
+
+void CVisibleGroup::ConstructL()
+	{
+	User::LeaveIfError(iWs.Connect());
+	iScr=new(ELeave) CWsScreenDevice(iWs);
+	User::LeaveIfError(iScr->Construct(iScreenNo));
+	iScr->SetAppScreenMode(iMode);
+	iGroup=RWindowGroup(iWs);
+	User::LeaveIfError(iGroup.Construct(NULL,ETrue));
+	TInt id=TheClient->iGroup->GroupWin()->Identifier();
+	iGroup.SetOwningWindowGroup(id);
+#if defined(LOGGING)
+	TLogMessageText buf;
+	_LIT(KIds,"Window Group Id: Main=%d, 2nd Client=%d");
+	buf.Format(KIds,id,iGroup.Identifier());
+	iWs.LogMessage(buf);
+#endif
+	iWs.Flush();
+	}
+
+CVisibleGroup::~CVisibleGroup()
+	{
+	iGroup.Close();
+	delete iScr;
+	iWs.Close();
+	}
+
+void CVisibleGroup::SetMode(TInt aMode)
+	{
+	iMode=aMode;
+	iScr->SetAppScreenMode(iMode);
+	iWs.Flush();
+	}
+
+ClientToKill::ClientToKill()
+	{}
+
+void ClientToKill::ConstructL()
+	{
+	CTClient::ConstructL();
+	RSemaphore sem;
+	sem.OpenGlobal(KSemaphoreName);
+
+	iGroup=new(ELeave) TestWindowGroup(this);
+	iGroup->ConstructL();
+
+	iScreen->SetScreenMode(0);
+	TSize screenSize=iScreen->SizeInPixels();
+
+	TInt winWidth=3*screenSize.iWidth/4;
+	TInt winHeight=3*screenSize.iHeight/4;
+	iTestWin=new(ELeave) TestWindow();
+	iTestWin->SetUpL(TPoint((screenSize.iWidth+4)/8,(screenSize.iHeight+4)/8),TSize(winWidth,winHeight),iGroup,*iGc);
+
+#if defined(LOGGING)
+	TLogMessageText buf;
+	_LIT(KId,"Window Group Id in 2nd Process=%d");
+	buf.Format(KId,iGroup->GroupWin()->Identifier());
+	LogMessage(buf);
+#endif
+	sem.Signal();	// Signal thread fully initialised
+	sem.Close();
+	}
+
+ClientToKill::~ClientToKill()
+	{
+	delete iTestWin;
+	}
+
+
+// CTKey
+
+CTKey::CTKey(CTestStep* aStep) : CTWsGraphicsBase(aStep)
+	{
+	}
+
+
+
+void CTKey::ConstructL()
+	{
+	iSem.CreateGlobal(KSemaphoreName,0,KOwnerType);
+	iVisibleGroup=new(ELeave) CVisibleGroup(iTest->iScreenNumber);
+	iVisibleGroup->ConstructL();
+	}
+
+CTKey::~CTKey()
+	{
+	delete iVisibleGroup;
+	iSem.Close();
+	// Set focus back to this screen as it went to primary screen when iVisibleGroup was destroyed
+	// Wserv focus handling made focus screen switch to another screen if there is no
+	// focusable window group on that particular screen.
+	TheClient->iWs.SetFocusScreen(iTest->iScreenNumber);
+	}
+
+void CTKey::SendKey(TInt aScanCode)
+	{
+	TKeyEvent keyEvent;
+	keyEvent.iCode=aScanCode;
+	keyEvent.iScanCode=aScanCode;
+	keyEvent.iModifiers=0;
+	keyEvent.iRepeats=0;
+	TheClient->iWs.SimulateKeyEvent(keyEvent);
+	TheClient->iWs.Flush();
+	}
+
+void CTKey::SendUpDown(TInt aScanCode)
+	{
+	TRawEvent rawEvent;
+	rawEvent.Set(TRawEvent::EKeyDown,aScanCode);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	rawEvent.Set(TRawEvent::EKeyUp,aScanCode);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	}
+
+void CTKey::SendCtrlAltShift(TRawEvent::TType aType)
+	{
+	TRawEvent rawEvent;
+	rawEvent.Set(aType,EStdKeyLeftFunc);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	rawEvent.Set(aType,EStdKeyLeftCtrl);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	rawEvent.Set(aType,EStdKeyLeftShift);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	}
+
+void CTKey::SendCtrlAltShift(TInt aScanCode)
+	{
+	SendCtrlAltShift(TRawEvent::EKeyDown);
+	SendUpDown(aScanCode);
+	SendCtrlAltShift(TRawEvent::EKeyUp);
+	TheClient->iWs.Flush();
+	}
+
+void CTKey::LogWindowGroupIds()
+	{
+	CArrayFixFlat<TInt>* idList=new(ELeave) CArrayFixFlat<TInt>(5);
+	if (!idList)
+		return;
+	TheClient->iWs.WindowGroupList(0,idList);
+	TLogMessageText buf;
+	_LIT(KWinGp,"Window Group Id's: %d");
+	_LIT(KId,", %d");
+	TInt ii=0;
+	buf.Format(KWinGp,(*idList)[ii]);
+	while (++ii<idList->Count())
+		buf.AppendFormat(KId,(*idList)[ii]);
+	LOG_MESSAGE(buf);
+	delete idList;
+	}
+
+void CTKey::SetHotKey(THotKey aType, TUint aKeyCode)
+	{
+	TheClient->iWs.SetHotKey(aType,aKeyCode-'A'+1,EFuncCtrlShift,EFuncCtrlShift);
+	}
+
+void CTKey::KeyOfOrientation()
+	{	
+	TInt numScreenModes = TheClient->iScreen->NumScreenModes();
+	TInt originalScreenMode = TheClient->iScreen->CurrentScreenMode();
+	if(numScreenModes >= 2)
+		{
+		//1 possible rotation of 180deg found in wsini.ini screenmode 8
+		iVisibleGroup->SetMode(numScreenModes-1);
+		TheClient->iScreen->SetScreenMode(numScreenModes-1);
+		SendCtrlAltShift('O');
+		TheClient->iWs.Flush();
+		//1 possible rotation of 90deg found in wsini.ini screenmode 7
+		iVisibleGroup->SetMode(numScreenModes-2);
+		TheClient->iScreen->SetScreenMode(numScreenModes-2);
+		SendCtrlAltShift('O');
+		TheClient->iWs.Flush();
+		//reset to original screenmode
+		iVisibleGroup->SetMode(originalScreenMode);
+		TheClient->iScreen->SetScreenMode(originalScreenMode);
+		}	
+	else
+		{
+		TEST(numScreenModes>2);
+		INFO_PRINTF2(_L("numScreenModes - Expected: >2, Actual: %d"), numScreenModes);
+		}
+	TPixelsAndRotation originalSizeAndRotation;
+	TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreen->CurrentScreenMode(),originalSizeAndRotation);
+	SendCtrlAltShift('O');
+	TheClient->iWs.Flush();
+	TPixelsAndRotation sizeAndRotation;
+	TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreen->CurrentScreenMode(),sizeAndRotation);
+	TEST(sizeAndRotation.iRotation!=originalSizeAndRotation.iRotation);
+	if (sizeAndRotation.iRotation==originalSizeAndRotation.iRotation)
+		INFO_PRINTF3(_L("iRotation - Not Expected: %d, Actual: %d"), originalSizeAndRotation.iRotation, sizeAndRotation.iRotation);
+	SendCtrlAltShift('O');
+	TheClient->iWs.Flush();
+	}
+
+void CTKey::CycleDisplaySize()
+	{
+	// The test does nothing if there is only one possible screen mode -> return
+	TInt numScreenModes = TheClient->iScreen->NumScreenModes();
+	if (numScreenModes<2)
+		{
+		TEST(numScreenModes>2);
+		INFO_PRINTF2(_L("numScreenModes - Expected: >2, Actual: %d"), numScreenModes);
+		return;
+		}
+	//Get original screen mode and size values
+	TInt originalScreenMode = TheClient->iScreen->CurrentScreenMode();	
+	TPixelsAndRotation sizeAndRotation;
+	TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreen->CurrentScreenMode(),sizeAndRotation);
+	TSize originalScreenSize = sizeAndRotation.iPixelSize;
+	
+	SendCtrlAltShift('U');
+	TheClient->iWs.Flush();
+	TheClient->iScreen->GetScreenModeSizeAndRotation(TheClient->iScreen->CurrentScreenMode(),sizeAndRotation);
+	TEST(sizeAndRotation.iPixelSize.iHeight!=originalScreenSize.iHeight && sizeAndRotation.iPixelSize.iWidth!=originalScreenSize.iWidth);
+	if (sizeAndRotation.iPixelSize.iHeight==originalScreenSize.iHeight || sizeAndRotation.iPixelSize.iWidth==originalScreenSize.iWidth)
+		INFO_PRINTF5(_L("iPixelSize - Expected: !%d !%d, Actual: %d %d"), originalScreenSize.iHeight, originalScreenSize.iWidth, sizeAndRotation.iPixelSize.iHeight, sizeAndRotation.iPixelSize.iWidth);
+	TheClient->iScreen->SetScreenMode(originalScreenMode);
+	TheClient->iWs.Flush();
+	}
+
+void CTKey::KeyOfDeathL()
+	{
+	//Key of Death
+#if defined(LOGGING)
+	TLogMessageText buf;
+	_LIT(KNum1,"Priority Zero Window Groups=%d Total=%d (Before Process Creation)");
+	buf.Format(KNum1,TheClient->iWs.NumWindowGroups(0),TheClient->iWs.NumWindowGroups());
+	LOG_MESSAGE(buf);
+	LogWindowGroupIds();
+#endif
+	CProcess* process = CProcess::NewL(CProcess::eProcessKeyTest,iTest->iScreenNumber);
+	RWindowGroup group(TheClient->iWs);
+	group.Construct(1234);
+	TheClient->Flush();		//Make sure the window group above is created before the one in the other process
+	TInt id=TheClient->iGroup->GroupWin()->Identifier();
+	group.SetOwningWindowGroup(id);
+	group.DefaultOwningWindow();
+
+	iSem.Wait();
+	User::After(TTimeIntervalMicroSeconds32(100000));		//0.1 secs
+	TInt numGroups=TheClient->iWs.NumWindowGroups();
+	TInt numGroups0=TheClient->iWs.NumWindowGroups(0);
+
+#if defined(LOGGING)
+	_LIT(KNum2,"NewWinGpId=%d Priority Zero Window Groups=%d Total=%d (After Process Creation)");
+	buf.Format(KNum2,id,numGroups0,numGroups);
+	LOG_MESSAGE(buf);
+	_LIT(KLog1,"Sending Key Of Death");
+	buf.Copy(KLog1);
+	LOG_MESSAGE(buf);
+	LogWindowGroupIds();
+#endif
+	group.SetOrdinalPosition(1);		//Make sure that the window group we have just created is behind the one created by the other process (belt and braces)
+	SendCtrlAltShift('K');
+	TheClient->iWs.Flush();
+#if defined(LOGGING)
+	_LIT(KLog2,"Sent Key Of Death");
+	buf.Copy(KLog2);
+	LOG_MESSAGE(buf);
+#endif
+	TInt numGroups2;
+	TInt numGroups0b;
+	TInt tries=3;
+	FOREVER		//On multi-core platforms need to wait for the Key of Death procedure to complete
+		{
+		numGroups2=TheClient->iWs.NumWindowGroups();
+		numGroups0b=TheClient->iWs.NumWindowGroups(0);
+		if (--tries==0)
+			break;
+		if (numGroups!=numGroups2 || numGroups0!=numGroups0b)
+			{
+			tries=1;
+			continue;
+			}
+		User::After(100000);		//0.1secs
+		}
+	TEST(numGroups==numGroups2+1);
+	_LIT(KLog,"KeyOfDeath Num WinGps Before=%d After=%d (should be one less)");
+	if (numGroups!=numGroups2+1)
+		LOG_MESSAGE3(KLog,numGroups,numGroups2);
+	TEST(numGroups0==numGroups0b+1);
+	if (numGroups0!=numGroups0b+1)
+		LOG_MESSAGE3(KLog,numGroups0,numGroups0b);
+	group.Close();
+
+	TBool processDead=!process->StillAlive();
+	TEST(processDead);
+	if (!processDead)
+		{
+		_LIT(KLog,"Other Thread Still Alive");
+		LOG_MESSAGE(KLog);
+		}
+	delete process;
+
+#if defined(LOGGING)
+	_LIT(KLog3,"Finished KeyOfDeath Test");
+	buf.Copy(KLog3);
+	LOG_MESSAGE(buf);
+	LogWindowGroupIds();
+#endif
+	}
+
+#define CONTRAST_UP 'A'		//'a'-'a'+1
+#define CONTRAST_DOWN 'B'		//'b'-'a'+1
+
+void CTKey::TestContrastL(TBool aChange)
+	{
+	TInt contrast=0;
+	TInt newContrast=0;
+	TInt maxContrast=0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrastMax,maxContrast));
+	TInt diff=aChange ? 1:0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,contrast));
+
+	SendCtrlAltShift(CONTRAST_UP);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	if ((contrast==maxContrast) && aChange)
+		{
+		TEST(newContrast==0);
+		if (newContrast!=0)
+			INFO_PRINTF3(_L("newContrast==0 - Expected: %d, Actual: %d"), 0, newContrast);		
+		}
+	else
+		{
+		TEST(contrast+diff==newContrast);
+		if (contrast+diff!=newContrast)
+			INFO_PRINTF3(_L("contrast+diff==newContrast - Expected: %d, Actual: %d"), contrast+diff, newContrast);
+		}
+
+	SendCtrlAltShift(CONTRAST_DOWN);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	TEST(contrast==newContrast);
+	if (contrast!=newContrast)
+			INFO_PRINTF3(_L("contrast==newContrast - Expected: %d, Actual: %d"), contrast, newContrast);
+
+	SendCtrlAltShift(CONTRAST_DOWN);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	if (contrast==0)
+		{
+		TEST(maxContrast==newContrast);
+		if (maxContrast!=newContrast)
+			INFO_PRINTF3(_L("maxContrast==newContrast - Expected: %d, Actual: %d"), maxContrast, newContrast);
+
+		}
+	else
+		{
+		TEST(contrast-diff==newContrast);
+		if (contrast-diff!=newContrast)
+			INFO_PRINTF3(_L("contrast-diff==newContrast - Expected: %d, Actual: %d"), contrast-diff, newContrast);
+
+		}
+
+	SendCtrlAltShift(CONTRAST_UP);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	TEST(contrast==newContrast);
+	if (contrast!=newContrast)
+		INFO_PRINTF3(_L("contrast==newContrast - Expected: %d, Actual: %d"), contrast, newContrast);
+
+	}
+
+void CTKey::TestDefaultContrastL(TBool aChange)
+	{
+	TInt contrast=0;
+	TInt newContrast=0;
+	TInt maxContrast=0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrastMax,maxContrast));
+	TInt diff=aChange ? 1:0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,contrast));
+
+	SendKey(EKeyIncContrast);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	if ((contrast==maxContrast) && aChange)
+		{
+		TEST(newContrast==0);
+		if (0!=newContrast)
+			INFO_PRINTF3(_L("newContrast==0 - Expected: %d, Actual: %d"), 0, newContrast);
+		}
+	else
+		{
+		TEST(contrast+diff==newContrast);
+		if (contrast+diff!=newContrast)
+			INFO_PRINTF3(_L("newContrast==contrast+diff - Expected: %d, Actual: %d"), contrast+diff, newContrast);
+		}
+
+	SendKey(EKeyDecContrast);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	TEST(contrast==newContrast);
+	if (contrast!=newContrast)
+			INFO_PRINTF3(_L("contrast==newContrast - Expected: %d, Actual: %d"), contrast, newContrast);
+
+	SendKey(EKeyDecContrast);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	if (contrast==0)
+		{
+		TEST(maxContrast==newContrast);
+		if (maxContrast!=newContrast)
+			INFO_PRINTF3(_L("maxContrast==newContrast - Expected: %d, Actual: %d"), maxContrast, newContrast);
+		}
+	else
+		{
+		TEST(contrast-diff==newContrast);
+		if (contrast-diff!=newContrast)
+			INFO_PRINTF3(_L("contrast-diff==newContrast - Expected: %d, Actual: %d"), contrast-diff, newContrast);
+		}
+
+	SendKey(EKeyIncContrast);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,newContrast));
+	TEST(contrast==newContrast);
+	if (contrast!=newContrast)
+		INFO_PRINTF3(_L("contrast==newContrast - Expected: %d, Actual: %d"), contrast, newContrast);
+
+	}
+
+void CTKey::ContrastKeysL()
+	{
+	TInt maxContrast=0;
+	TInt contrast=0;
+	TInt err=HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrastMax,maxContrast);
+	if (err==KErrNotSupported)
+		return;
+	else if (err==KErrNone)
+		err=HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,contrast);
+	if (err==KErrNotSupported)
+		return;
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		INFO_PRINTF3(_L("HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,contrast)=KErrNone - Expected: %d, Actual: %d"), KErrNone, err);
+
+	if (contrast==0)
+		err=HAL::Set(iTest->iScreenNumber,HALData::EDisplayContrast,++contrast);
+	else if (contrast==maxContrast)
+		err=HAL::Set(iTest->iScreenNumber,HALData::EDisplayContrast,--contrast);
+	if (err==KErrNotSupported)
+		return;
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		INFO_PRINTF3(_L("HAL::Get(iTest->iScreenNumber,HALData::EDisplayContrast,contrast)=KErrNone - Expected: %d, Actual: %d"), KErrNone, err);
+	TestDefaultContrastL(ETrue);
+
+	SetHotKey(EHotKeyIncContrast,CONTRAST_UP);
+	SetHotKey(EHotKeyDecContrast,CONTRAST_DOWN);
+	TestContrastL(ETrue);
+	TestDefaultContrastL(ETrue);
+
+	TheClient->iWs.ClearHotKeys(EHotKeyIncContrast);
+	TheClient->iWs.ClearHotKeys(EHotKeyDecContrast);
+	TestContrastL(EFalse);
+	TestDefaultContrastL(EFalse);
+
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyIncContrast);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyDecContrast);
+	TestContrastL(EFalse);
+	TestDefaultContrastL(ETrue);
+
+	SetHotKey(EHotKeyIncContrast,CONTRAST_UP);
+	SetHotKey(EHotKeyDecContrast,CONTRAST_DOWN);
+	TestContrastL(ETrue);
+	TestDefaultContrastL(ETrue);
+
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyIncContrast);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyDecContrast);
+	TestContrastL(EFalse);
+	TestDefaultContrastL(ETrue);
+	}
+
+#define BACKLIGHT_ON 'A'	//'o'-'a'+1
+#define BACKLIGHT_OFF 'B'	//'p'-'a'+1
+#define BACKLIGHT_TOGGLE 'C'	//'q'-'a'+1
+/** Test for reaction against backlight ON/OFF/TOGGLE buttons defined above.
+  If aChange is false button presses must not affect the state of backlight.
+*/
+void CTKey::TestBackLightL(TBool aChange)
+	{
+	TBool state;
+	SendCtrlAltShift(BACKLIGHT_ON);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+	if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendCtrlAltShift(BACKLIGHT_TOGGLE);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	SendCtrlAltShift(BACKLIGHT_TOGGLE);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+	if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendCtrlAltShift(BACKLIGHT_OFF);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	SendCtrlAltShift(BACKLIGHT_TOGGLE);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+		if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendCtrlAltShift(BACKLIGHT_TOGGLE);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	}
+
+/** Test for reaction against default backlight ON/OFF/TOGGLE buttons.
+  If aChange is false button presses must not affect the state of backlight.
+*/
+void CTKey::TestDefaultBackLightL(TBool aChange)
+	{
+	TBool state;
+	SendKey(EKeyBacklightOn);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+	if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendKey(EKeyBacklightToggle);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	SendKey(EKeyBacklightToggle);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+	if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendKey(EKeyBacklightOff);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	SendKey(EKeyBacklightToggle);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==aChange);
+	if (state!=aChange)
+		INFO_PRINTF3(_L("state==aChange - Expected: %d, Actual: %d"), aChange, state);
+
+	SendKey(EKeyBacklightToggle);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,state));
+	TEST(state==EFalse);
+	if (state!=EFalse)
+		INFO_PRINTF3(_L("state==EFalse - Expected: %d, Actual: %d"), EFalse, state);
+
+	}
+
+void CTKey::BackLightKeysL()
+	{
+	// Turns backlight off
+	TBool prevState;
+	TInt err=HAL::Get(iTest->iScreenNumber,HALData::EBacklightState,prevState);
+	if (err==KErrNotSupported)
+		{
+		_LIT(KLog,"Cannot test BackLight Key presses as cannot read its state on screen %d");
+		LOG_MESSAGE2(KLog,iTest->iScreenNumber);
+		return;
+		}
+	else if (err==KErrNone)
+		err=HAL::Set(iTest->iScreenNumber,HALData::EBacklightState,EFalse);
+	if (err==KErrNotSupported)
+		{
+		_LIT(KLog,"Cannot test BackLight Key presses as cannot set its state on screen %d");
+		LOG_MESSAGE2(KLog,iTest->iScreenNumber);
+		return;
+		}
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		{
+		_LIT(KLog,"Reading or Setting BackLight state gave error %d on screen %d");
+		LOG_MESSAGE3(KLog,err,iTest->iScreenNumber);
+		}
+
+	// Tests that default backlight ON/OFF/TOGGLE buttons work
+	TestDefaultBackLightL(ETrue);
+
+	// Sets user defined backlight buttons and tests that both default and user defined buttons work
+	SetHotKey(EHotKeyBacklightOn,BACKLIGHT_ON);
+	SetHotKey(EHotKeyBacklightOff,BACKLIGHT_OFF);
+	SetHotKey(EHotKeyBacklightToggle,BACKLIGHT_TOGGLE);
+	TestBackLightL(ETrue);
+	TestDefaultBackLightL(ETrue);
+
+	// Calls RWsSession::ClearHotKeys and tests that both default and user defined buttons don't work
+	TheClient->iWs.ClearHotKeys(EHotKeyBacklightOn);
+	TheClient->iWs.ClearHotKeys(EHotKeyBacklightOff);
+	TheClient->iWs.ClearHotKeys(EHotKeyBacklightToggle);
+	TestBackLightL(EFalse);
+	TestDefaultBackLightL(EFalse);
+
+	// Calls RWsSession::RestoreDefaultHotKey and tests that only default buttons work
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightOn);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightOff);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightToggle);
+	TestBackLightL(EFalse);
+	TestDefaultBackLightL(ETrue);
+
+	// Sets user defined backlight buttons and tests that both default and user defined buttons work
+	SetHotKey(EHotKeyBacklightOn,BACKLIGHT_ON);
+	SetHotKey(EHotKeyBacklightOff,BACKLIGHT_OFF);
+	SetHotKey(EHotKeyBacklightToggle,BACKLIGHT_TOGGLE);
+	TestBackLightL(ETrue);
+	TestDefaultBackLightL(ETrue);
+
+	// Calls RWsSession::RestoreDefaultHotKey and tests that only default buttons work
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightOn);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightOff);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyBacklightToggle);
+	TestBackLightL(EFalse);
+	TestDefaultBackLightL(ETrue);
+
+	//Restores previous backlight state
+	//err=UserHal::SetBacklightOn(prevState);
+	err=HAL::Set(iTest->iScreenNumber,HALData::EBacklightState,prevState);
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		{
+		_LIT(KLog,"Failed to set BackLight state back to previous state: %d on screen %d, error code: %d");
+		LOG_MESSAGE4(KLog,prevState,iTest->iScreenNumber,err);
+		}
+	}
+
+#define BRIGHTNESS_UP 'N'
+#define BRIGHTNESS_DOWN 'J'
+/** If aChange is true, checks that programmicaly defined brightness buttons increase and decrease brightness properly.
+ If aChange is false, checks that programmicaly defined brightness buttons don't affect brightness.
+*/
+void CTKey::TestBrightnessL(TBool aChange)
+	{
+	TInt brightness;
+	TInt newBrightness;
+	TInt diff=aChange ? 1:0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,brightness));
+
+	SendCtrlAltShift(BRIGHTNESS_UP);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness+diff==newBrightness);
+	if (brightness+diff!=newBrightness)
+		INFO_PRINTF3(_L("brightness+diff==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness+diff);
+
+	SendCtrlAltShift(BRIGHTNESS_DOWN);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness==newBrightness);
+	if (brightness!=newBrightness)
+		INFO_PRINTF3(_L("brightness==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness);
+
+	SendCtrlAltShift(BRIGHTNESS_DOWN);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness-diff==newBrightness);
+	if (brightness-diff!=newBrightness)
+		INFO_PRINTF3(_L("brightness-diff==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness-diff);
+
+	SendCtrlAltShift(BRIGHTNESS_UP);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness==newBrightness);
+	if (brightness!=newBrightness)
+		INFO_PRINTF3(_L("brightness==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness);
+	}
+
+/** If aChange is true, checks that default brightness buttons increase and decrease brightness properly (increase/decrease by 1).
+  If aChange is false, checks that default brightness buttons don't affect brightness.
+*/
+void CTKey::TestDefaultBrightnessL(TBool aChange)
+	{
+	TInt brightness;
+	TInt newBrightness;
+	TInt diff=aChange ? 1:0;
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,brightness));
+
+	SendKey(EKeyIncBrightness);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness+diff==newBrightness);
+	if (brightness+diff!=newBrightness)
+		INFO_PRINTF3(_L("brightness+diff==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness+diff);
+
+	SendKey(EKeyDecBrightness);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness==newBrightness);
+	if (brightness!=newBrightness)
+		INFO_PRINTF3(_L("brightness==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness);
+
+	SendKey(EKeyDecBrightness);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness-diff==newBrightness);
+	if (brightness-diff!=newBrightness)
+		INFO_PRINTF3(_L("brightness-diff==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness-diff);
+
+	SendKey(EKeyIncBrightness);
+	User::LeaveIfError(HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,newBrightness));
+	TEST(brightness==newBrightness);
+	if (brightness!=newBrightness)
+		INFO_PRINTF3(_L("brightness==newBrightness - Expected: %d, Actual: %d"), newBrightness, brightness);
+	}
+
+void CTKey::BrightnessKeysL()
+	{
+	INFO_PRINTF1(_L("AUTO  Brightness Key Test "));
+	TInt maxBrightness;
+	TInt brightness=0;		//To stop warning
+	// get maximum brightness and current
+	TInt err=HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightnessMax,maxBrightness);
+	if (err==KErrNotSupported)
+		return;
+	else if (err==KErrNone)
+		err=HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,brightness);
+	if (err==KErrNotSupported)
+		return;
+	INFO_PRINTF1(_L(" Supported"));
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		INFO_PRINTF3(_L("HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,brightness) return value - Expected: %d, Actual: %d"), KErrNone, err);
+
+	// sets brightness to be neither maximal nor minimal
+	if (brightness==0)
+		err=HAL::Set(iTest->iScreenNumber,HALData::EDisplayBrightness,++brightness);
+	else if (brightness==maxBrightness)
+		err=HAL::Set(iTest->iScreenNumber,HALData::EDisplayBrightness,--brightness);
+	if (err==KErrNotSupported)
+		return;
+	INFO_PRINTF1(_L(" Changeable"));
+	TEST(err==KErrNone);
+	if (err!=KErrNone)
+		INFO_PRINTF3(_L("HAL::Get(iTest->iScreenNumber,HALData::EDisplayBrightness,brightness) return value - Expected: %d, Actual: %d"), KErrNone, err);
+
+	// Test default brightness buttons increase/decrease brightness by 1
+	TestDefaultBrightnessL(ETrue);
+
+	// Add new inc/dec buttons, test that default and program defined brightness buttons increase/decrease brightness by 1
+	INFO_PRINTF1(_L(" First Test"));
+	SetHotKey(EHotKeyIncBrightness,BRIGHTNESS_UP);
+	SetHotKey(EHotKeyDecBrightness,BRIGHTNESS_DOWN);
+	TestBrightnessL(ETrue);
+	TestDefaultBrightnessL(ETrue);
+
+	// Clear brightness buttons, test that default and program defined brightness buttons doesn't affect brightness
+	INFO_PRINTF1(_L(" Second Test"));
+	TheClient->iWs.ClearHotKeys(EHotKeyIncBrightness);
+	TheClient->iWs.ClearHotKeys(EHotKeyDecBrightness);
+	TestBrightnessL(EFalse);
+	TestDefaultBrightnessL(EFalse);
+
+	// Restore default brightness buttons, test that only default brightness buttons increase/decrease brightness by 1
+	INFO_PRINTF1(_L(" Third Test"));
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyIncBrightness);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyDecBrightness);
+	TestBrightnessL(EFalse);
+	TestDefaultBrightnessL(ETrue);
+
+	// Add new inc/dec buttons, test that default and program defined brightness buttons increase/decrease brightness by 1
+	INFO_PRINTF1(_L(" Fourth Test"));
+	SetHotKey(EHotKeyIncBrightness,BRIGHTNESS_UP);
+	SetHotKey(EHotKeyDecBrightness,BRIGHTNESS_DOWN);
+	TestBrightnessL(ETrue);
+	TestDefaultBrightnessL(ETrue);
+
+	// Restore default brightness buttons, test that only default brightness buttons increase/decrease brightness by 1
+	INFO_PRINTF1(_L(" Fifth Test"));
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyIncBrightness);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyDecBrightness);
+	TestBrightnessL(EFalse);
+	TestDefaultBrightnessL(ETrue);
+	}
+
+void CTKey::TestDefaultScreenSizeModeL(TInt aKeys,TBool aChange)
+	{
+	TInt screenMode=TheClient->iScreen->CurrentScreenMode();
+	TInt key;
+	TInt retVal;
+	for (key=0;key<aKeys;++key)
+		{
+		iVisibleGroup->SetMode(key);
+		SendKey(EKeyScreenDimension0+key);
+		if (aChange)
+			{
+			retVal = TheClient->iScreen->CurrentScreenMode();
+			TEST(retVal==key);
+			if (retVal!=key)
+				INFO_PRINTF3(_L("TheClient->iScreen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), key, retVal);
+			}
+		else
+			{
+			retVal = TheClient->iScreen->CurrentScreenMode();
+			TEST(retVal==screenMode);
+			if (retVal!=screenMode)
+				INFO_PRINTF3(_L("TheClient->iScreen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), screenMode, retVal);
+			}
+		}
+	}
+
+#define DIMENSION0 'P'
+#define DIMENSION1 'Q'
+#define DIMENSION2 'R'
+#define DIMENSION3 'N'
+void CTKey::TestScreenSizeModeL(TInt aKeys,TBool aChange)
+	{
+	TInt screenMode=TheClient->iScreen->CurrentScreenMode();
+	TInt key;
+	TInt retVal;
+	for (key=0;key<aKeys;++key)
+		{
+		iVisibleGroup->SetMode(key);
+		switch (key)
+		{
+		case 0:
+			SendCtrlAltShift(DIMENSION0);
+			break;
+		case 1:
+			SendCtrlAltShift(DIMENSION1);
+			break;
+		case 2:
+			SendCtrlAltShift(DIMENSION2);
+			break;
+		case 3:
+			SendCtrlAltShift(DIMENSION3);
+			break;
+		default:
+			INFO_PRINTF2(_L("Error Invalid Key: %d"),key);
+			TEST(EFalse);
+			break;
+		}
+			
+		
+		if (aChange)
+			{
+			retVal = TheClient->iScreen->CurrentScreenMode();
+			TEST(retVal==key);
+			if (retVal!=key)
+				INFO_PRINTF3(_L("TheClient->iScreen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), key, retVal);
+	
+			}
+		else
+			{
+			retVal = TheClient->iScreen->CurrentScreenMode();
+			TEST(retVal==screenMode);
+			if (retVal!=screenMode)
+				INFO_PRINTF3(_L("TheClient->iScreen->CurrentScreenMode() return value - Expected: %d, Actual: %d"), screenMode, retVal);
+	
+			}
+		}
+	}
+
+void CTKey::ScreenSizeModeKeysL()
+	{
+	// The test does nothing if there is only one possible screen mode -> return
+	TInt numScreenModes=TheClient->iScreen->NumScreenModes();
+	if (numScreenModes<2)
+		return;
+
+	// Use at most 4 different modes for the test
+	if (numScreenModes>4) {numScreenModes=4;}
+
+	// Set screen mode 3
+	TInt screenMode=TheClient->iScreen->CurrentScreenMode();
+	iVisibleGroup->SetMode(numScreenModes-1);
+	TheClient->iScreen->SetScreenMode(numScreenModes-1);
+
+	// Test default screen mode switch buttons
+	TestDefaultScreenSizeModeL(numScreenModes,ETrue);
+
+	// Add new screen mode switch buttons. Test that default and program defined screen mode switch buttons switch modes.
+	SetHotKey(EHotKeyScreenDimension0,DIMENSION0);
+	SetHotKey(EHotKeyScreenDimension1,DIMENSION1);
+	SetHotKey(EHotKeyScreenDimension2,DIMENSION2);
+	SetHotKey(EHotKeyScreenDimension3,DIMENSION3);
+	TestDefaultScreenSizeModeL(numScreenModes,ETrue);
+	TestScreenSizeModeL(numScreenModes,ETrue);
+
+	// Clear all screen mode switch buttons. Test that default and program defined screen mode switch buttons don't affect screen modes
+	TheClient->iWs.ClearHotKeys(EHotKeyScreenDimension0);
+	TheClient->iWs.ClearHotKeys(EHotKeyScreenDimension1);
+	TheClient->iWs.ClearHotKeys(EHotKeyScreenDimension2);
+	TheClient->iWs.ClearHotKeys(EHotKeyScreenDimension3);
+	TestDefaultScreenSizeModeL(numScreenModes,EFalse);
+	TestScreenSizeModeL(numScreenModes,EFalse);
+
+	// Restore default screen mode switch buttons. Test that only default screen mode switch buttons switch screen modes
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension0);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension1);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension2);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension3);
+	TestDefaultScreenSizeModeL(numScreenModes,ETrue);
+	TestScreenSizeModeL(numScreenModes,EFalse);
+
+	// Add new screen mode switch buttons. Test that default and program defined screen mode switch buttons switch modes.
+	SetHotKey(EHotKeyScreenDimension0,DIMENSION0);
+	SetHotKey(EHotKeyScreenDimension1,DIMENSION1);
+	SetHotKey(EHotKeyScreenDimension2,DIMENSION2);
+	SetHotKey(EHotKeyScreenDimension3,DIMENSION3);
+	TestDefaultScreenSizeModeL(numScreenModes,ETrue);
+	TestScreenSizeModeL(numScreenModes,ETrue);
+
+	// Restore default screen mode switch buttons. Test that only default screen mode switch buttons switch screen modes
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension0);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension1);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension2);
+	TheClient->iWs.RestoreDefaultHotKey(EHotKeyScreenDimension3);
+	TestDefaultScreenSizeModeL(numScreenModes,ETrue);
+	TestScreenSizeModeL(numScreenModes,EFalse);
+
+	// Restore initial screen mode
+	iVisibleGroup->SetMode(screenMode);
+	TheClient->iScreen->SetScreenMode(screenMode);
+	}
+
+void CTKey::RunTestCaseL(TInt /*aCurTestCase*/)
+	{
+	_LIT(KTest0,"KeyOfDeath");
+	_LIT(KTest1,"Contrast");
+	_LIT(KTest2,"BackLight");
+	_LIT(KTest3,"Brightness");
+	_LIT(KTest4,"Screen Size Mode");
+	((CTKeyStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+#ifdef _DEBUG
+	_LIT(KTest5,"Orientation");
+	_LIT(KTest6,"CycleDisplaySize");
+#endif
+	switch(++iTest->iState)
+		{
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0106
+
+@SYMDEF             DEF081259
+
+@SYMTestCaseDesc    Key of Death test
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Creates a new client process and runs it.
+					Waits until the process is started and simulates Ctrl-Alt-Shift-K press.
+					When starts the process assumes that TAutoServer.exe exists in z:\sys\bin directory.
+					Otherwise the test will not exit a wait-state and will be aborted.
+
+@SYMTestExpectedResults Checks that the process is dead after the Ctrl-Alt-Shift-K press.
+					Check also that the difference between amounts of window groups efore
+					death-key press and after death-key press is 1.
+*/
+		case 1:
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0106"));
+			iTest->LogSubTest(KTest0);
+			KeyOfDeathL();
+			break;
+		case 2:
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0539
+*/
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0539"));
+			iTest->LogSubTest(KTest1);
+			ContrastKeysL();
+			break;
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0107
+
+@SYMDEF             DEF081259
+
+@SYMTestCaseDesc    Test backlight
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Does nothing if hardware attributes are not supported.
+					1. Turns backlight off.
+					2. Tests that default backlight ON/OFF/TOGGLE buttons work.
+					3. Sets user defined backlight buttons and tests that both default and user defined buttons work.
+					4. Calls RWsSession::ClearHotKeys and tests that both default and user defined buttons don't work.
+					5. Calls RWsSession::RestoreDefaultHotKey and tests that only default buttons work.
+					6. Sets user defined backlight buttons and tests that both default and user defined buttons work.
+					7. Calls RWsSession::RestoreDefaultHotKey and tests that only default buttons work.
+					8. Restores previous backlight state.
+
+@SYMTestExpectedResults Expects that actions described above give positive result.
+						The test also checks that programmatic turn off/on doesn't fail.
+*/
+		case 3:
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0107"));
+			iTest->LogSubTest(KTest2);
+			BackLightKeysL();
+			break;
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0108
+
+@SYMDEF             DEF081259
+
+@SYMTestCaseDesc    Test brightness
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     Does nothing if hardware attributes are not supported.
+					1. Get maximum brightness and current, test that those operations don't fail
+					2. Sets brightness to be neither maximal nor minimal, test that those operations don't fail
+					3. Test default brightness buttons increase/decrease brightness by 1
+					4. Add new inc/dec buttons, test that default and program defined brightness buttons increase/decrease brightness by 1
+					5. Clear brightness buttons, test that default and program defined brightness buttons doesn't affect brightness
+					6. Restore default brightness buttons, test that only default brightness buttons increase/decrease brightness by 1
+					7. Add new inc/dec buttons, test that default and program defined brightness buttons increase/decrease brightness by 1
+					8. Restore default brightness buttons, test that only default brightness buttons increase/decrease brightness by 1
+
+@SYMTestExpectedResults Expects that actions described above give positive result.
+						The test also checks that programmatic brightness increase and decrease doesn't fail.
+*/
+		case 4:
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0108"));
+			iTest->LogSubTest(KTest3);
+			BrightnessKeysL();
+			break;
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0109
+
+@SYMDEF             DEF081259
+
+@SYMTestCaseDesc    Test screen mode switching
+
+@SYMTestPriority    High
+
+@SYMTestStatus      Implemented
+
+@SYMTestActions     The test does nothing if there is only one possible screen mode. It uses at most 4 different modes for the test.
+					1. Test default screen mode switch buttons
+					2. Add new screen mode switch buttons. Test that default and program defined screen mode switch buttons switch modes.
+					3. Clear all screen mode switch buttons. Test that default and program defined screen mode switch buttons don't affect screen modes
+					4. Restore default screen mode switch buttons. Test that only default screen mode switch buttons switch screen modes
+					5. Add new screen mode switch buttons. Test that default and program defined screen mode switch buttons switch modes.
+					6. Restore default screen mode switch buttons. Test that only default screen mode switch buttons switch screen modes
+					7. Restore initial screen mode
+
+
+
+@SYMTestExpectedResults Expects that actions described above give positive result.
+*/
+		case 5:
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0109"));
+			iTest->LogSubTest(KTest4);
+			ScreenSizeModeKeysL();
+			break;
+#ifdef _DEBUG			
+		case 6:
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0540
+*/
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0540"));
+			iTest->LogSubTest(KTest5);
+			KeyOfOrientation();
+			break;
+		case 7:
+/**
+@SYMTestCaseID		GRAPHICS-WSERV-0541
+*/
+			((CTKeyStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0541"));
+			iTest->LogSubTest(KTest6);
+			CycleDisplaySize();
+			break;
+#endif		
+		default:
+			((CTKeyStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			((CTKeyStep*)iStep)->CloseTMSGraphicsStep();
+			TestComplete();
+		}
+	((CTKeyStep*)iStep)->RecordTestResultL();
+	}
+
+
+__WS_CONSTRUCT_STEP__(Key)