--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/tptroffset.cpp Thu Jul 15 20:08:02 2010 +0300
@@ -0,0 +1,484 @@
+// Copyright (c) 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:
+// YShifting, Wserv gradual reduction of YOffset test code
+//
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "PARSEINIDATA.H"
+#include "tptroffset.h"
+#include <e32cmn.h>
+#include <hal.h>
+
+//#define FAILLOG 1 // Uncomment this code to get detailed log
+
+//CTPointerOffsetBuffer
+CTPointerOffsetBuffer::CTPointerOffsetBuffer(RWsSession *aWs, CTPointerOffsetTest *aTest, CTPointerOffsetClient* aClient)
+ : CTEvent(aWs), iTest(aTest), iClient(aClient)
+ {
+ }
+
+CTPointerOffsetBuffer::~CTPointerOffsetBuffer()
+ {
+ }
+
+void CTPointerOffsetBuffer::ConstructL()
+ {
+ CTEventBase::Construct();
+ iEventBuffer.SetLengthL(EEventBufferSize);
+ }
+
+void CTPointerOffsetBuffer::AddExpectedEvent(TWsEvent &aEvent)
+ {
+ iEventBuffer.Add(&aEvent);
+ }
+
+TInt CTPointerOffsetBuffer::EventsRemaining()
+ {
+ return iEventBuffer.Count();
+ }
+
+
+// Main function which gets the event, checks with the event in buffer
+// Then calls function NextSetOfEventsL for running other tests of a particualar test case
+void CTPointerOffsetBuffer::doRunL()
+ {
+ // Get the event from wserv
+ TWsEvent wsEvent;
+ iWs->GetEvent(wsEvent);
+
+ TWsEvent expectedEvent;
+ TInt wsType=wsEvent.Type();
+
+ // if this is called accidentally
+ TInt count=iEventBuffer.Count();
+ if (count==0 && wsType==EEventFocusGained)
+ {
+ goto End;
+ }
+
+ iEventBuffer.Remove(&expectedEvent);
+ iEventCount++;
+
+#if defined(FAILLOG)
+ TLogMessageText logText;
+ _LIT(KEventCountCheck, "Checking event number = %d");
+ logText.Format(KEventCountCheck, iEventCount);
+ iTest->LOG_MESSAGE(logText);
+ _LIT(KEventType, "Actual Event type from Wserv = %d Expected Event Type = %d ");
+ logText.Format(KEventType, wsEvent.Type(), expectedEvent.Type());
+ iTest->LOG_MESSAGE(logText);
+#endif
+
+ TestL(wsEvent.Type() == expectedEvent.Type());
+
+#if defined(FAILLOG)
+ _LIT(KEventHandle, "Actual Window Handle from Wserv = %d Expected Window Handle = %d ");
+ logText.Format(KEventHandle, wsEvent.Handle(), expectedEvent.Handle());
+ iTest->LOG_MESSAGE(logText);
+#endif
+ TestL(wsEvent.Handle() == expectedEvent.Handle());
+
+ TAdvancedPointerEvent *expectedPointerEvent = expectedEvent.Pointer();
+ TAdvancedPointerEvent *actualPointerEvent = wsEvent.Pointer();
+
+ if (wsType == EEventPointer)
+ {
+#if defined(FAILLOG)
+ _LIT(KPointerType, "Actual PointerType from Wserv = %d Expected PointerType = %d ");
+ logText.Format(KPointerType, actualPointerEvent->iType, expectedPointerEvent->iType);
+ iTest->LOG_MESSAGE(logText);
+#endif
+ TestL(actualPointerEvent->iType == expectedPointerEvent->iType);
+
+#if defined(FAILLOG)
+ _LIT(KPointerPosition, "Actual PointerPosition from Wserv = (%d, %d) Expected PointerPosition = (%d, %d) ");
+ logText.Format(KPointerPosition, actualPointerEvent->iPosition.iX, actualPointerEvent->iPosition.iY, expectedPointerEvent->iPosition.iX, expectedPointerEvent->iPosition.iY);
+ iTest->LOG_MESSAGE(logText);
+#endif
+ TestL(actualPointerEvent->iPosition == expectedPointerEvent->iPosition);
+
+#if defined(FAILLOG)
+ _LIT(KPointerNumber, "Actual PointerNumber from Wserv = %d Expected PointerNumber = %d ");
+ logText.Format(KPointerNumber, actualPointerEvent->PointerNumber(), expectedPointerEvent->PointerNumber());
+ iTest->LOG_MESSAGE(logText);
+#endif
+ TestL(actualPointerEvent->PointerNumber() == expectedPointerEvent->PointerNumber());
+ }
+
+End:
+ // Call NextSetOfEvents() when all the events have been checked
+ if (iEventBuffer.Count()==0)
+ {
+ iTest->NextSetOfEventsL(); // Cannot Leave
+ }
+ }
+
+void CTPointerOffsetBuffer::TestL(TInt aTest)
+ {
+ if (!aTest)
+ {
+ iTest->Failed();
+ User::Leave(ETestFailed);
+ }
+ }
+
+//CTPointerOffsetClient
+CTPointerOffsetClient::CTPointerOffsetClient(CTPointerOffsetTest *aTest)
+ : iTest(aTest)
+ {
+ }
+
+CTPointerOffsetClient::~CTPointerOffsetClient()
+ {
+ delete iWin;
+ }
+
+void CTPointerOffsetClient::ConstructL()
+ {
+ CTClient::ConstructL();
+
+ // Create a group window and assign it iGroup
+ iGroup = new(ELeave) CTWindowGroup(this);
+ iGroup->ConstructL();
+
+ iWinSize = iScreen->SizeInPixels();
+ iWinPos = TPoint();
+
+ // Create window for this client so that events can come to this client
+ iWin=new(ELeave) CTBlankWindow();
+ iWin->ConstructL(*iGroup);
+ iWin->SetExt(iWinPos, iWinSize);
+ iWin->SetColor(KRgbRed);
+ iWin->BaseWin()->EnableAdvancedPointers();
+ iWin->Activate();
+ iWs.Flush();
+ }
+
+void CTPointerOffsetClient::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle)
+ {
+ TWsEvent ptrEvent;
+ ptrEvent.SetType(EEventPointer);
+ ptrEvent.Pointer()->iParentPosition = aPos;
+ ptrEvent.Pointer()->iType = aType;
+ ptrEvent.Pointer()->iPosition = aPos;
+ ptrEvent.SetPointerNumber(aPointerNumber);
+ if (!aHandle)
+ ptrEvent.SetHandle((TUint)iWin);
+ else
+ ptrEvent.SetHandle(aHandle);
+
+ static_cast<CTPointerOffsetBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);
+ }
+
+void CTPointerOffsetClient::AddExpectedWsEvent(TEventCode aType, TInt /*aPointerNumber*/, TUint aHandle)
+ {
+ TWsEvent ptrEvent;
+ ptrEvent.SetType(aType);
+ if (!aHandle)
+ ptrEvent.SetHandle((TUint)iGroup);
+ else
+ ptrEvent.SetHandle(aHandle);
+ static_cast<CTPointerOffsetBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);
+ }
+
+// Create and store CTPointerOffsetBuffer in iEventHandler
+void CTPointerOffsetClient::ConstructEventHandlerL()
+ {
+ CTPointerOffsetBuffer* eventBufferAndHandler = new(ELeave) CTPointerOffsetBuffer(&iWs, iTest, this);
+ eventBufferAndHandler->ConstructL();
+ iEventHandler = eventBufferAndHandler;
+ }
+
+//CTPointerOffsetTest
+CTPointerOffsetTest::CTPointerOffsetTest(CTestStep* aStep)
+ : CTWsGraphicsBase(aStep)
+ {
+ }
+
+CTPointerOffsetTest::~CTPointerOffsetTest()
+ {
+ delete iPointerOffsetClient;
+ }
+
+void CTPointerOffsetTest::ConstructL()
+ {
+ // If YOffsetValues are not defined in wsini file then just return without doing anything
+ _LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");
+ CIniData* iniData = CIniData::NewL(KWsIniFile, ' ');
+ _LIT( KWsiniYShiftingTop, "YSHIFTINGTOP");
+ if (iniData->FindVar(KWsiniYShiftingTop, iYOffsetTop) == EFalse)
+ goto FAIL;
+ _LIT( KWsiniYShiftingBottom, "YSHIFTINGBOTTOM");
+ if (iniData->FindVar(KWsiniYShiftingBottom, iYOffsetBottom) == EFalse)
+ goto FAIL;
+ _LIT( KWsiniYShiftingMax, "YSHIFTINGMAX");
+ if (iniData->FindVar(KWsiniYShiftingMax, iYOffsetMax) == EFalse)
+ goto FAIL;
+ delete iniData;
+
+ if (!iYOffsetTop || !iYOffsetBottom || !iYOffsetMax)
+ {
+FAIL:
+ delete iniData;
+ TLogMessageText logText1;
+ _LIT(KWrongHALConfig, "Y Offset values are incorrect. \n");
+ logText1.Append(KWrongHALConfig);
+ LOG_MESSAGE(logText1);
+ TEST(EFalse);
+ User::Leave(KErrArgument);
+ }
+ iPhysicalScreenSize = TheClient->iScreen->SizeInPixels();
+
+ // If we fail to get the maxpointernumber then just test with single pointer
+ TInt ret = HAL::Get(HALData::EPointerMaxPointers, iMaxPointerNumbers);
+ if (ret != KErrNone || iMaxPointerNumbers < 2 || iMaxPointerNumbers > 8)
+ {
+ iMaxPointerNumbers = 1;
+ }
+ }
+
+// Common function for all tests
+// Important point to remember is that this function should not leave when running tests
+void CTPointerOffsetTest::NextSetOfEventsL()
+ {
+ // For each test case calls its respective tests
+ switch (iTest->iState)
+ {
+ case 0:
+ TestYOffsetValues();
+ break;
+ case 1:
+ TestYOffsetValues();
+ break;
+ default:
+ AutoPanic(EAutoPanicWrongTest);
+ }
+ }
+
+void CTPointerOffsetTest::SimulatePointerEvent(TRawEvent::TType aType, TInt aX, TInt aY, TUint8 aPointerNumber)
+ {
+ TRawEvent rawEvent;
+ rawEvent.Set(aType, aX, aY, 0, aPointerNumber);
+ UserSvr::AddEvent(rawEvent);
+ }
+
+void CTPointerOffsetTest::AddExpectedPointerEvent(TPointerEvent::TType aType, TInt aX, TInt aY, TUint8 aPointerNumber, TUint aHandle)
+ {
+ iPointerOffsetClient->AddExpectedPointerEvent(aType, TPoint(aX, aY), aPointerNumber, aHandle);
+ }
+
+void CTPointerOffsetTest::AddExpectedWsEvent(TEventCode aType, TInt aPointerNumber, TUint aHandle)
+ {
+ iPointerOffsetClient->AddExpectedWsEvent(aType, aPointerNumber, aHandle);
+ }
+
+// If any of the Tests fails, bring the wserv in a consistent state for other test to run,
+// stop ActiveScheduler and display some logs where the fail occured.
+void CTPointerOffsetTest::Failed()
+ {
+ // Display the test case number, subtest case number and number of events left in the buffer which can be used to
+ // find out which event actually caused the failure when any test fails
+ TLogMessageText logText1;
+ _LIT(KEventsAdded, "Test case number %d Sub test case number %d Events remaining in the buffer %d \n");
+ logText1.AppendFormat(KEventsAdded, iTest->iState, iEventSet, iPointerOffsetClient->EventBuffer()->EventsRemaining());
+ LOG_MESSAGE(logText1);
+ RDebug::Printf("Test case number %d Sub test case number %d Events remaining in the buffer %d \n", iTest->iState, iEventSet, iPointerOffsetClient->EventBuffer()->EventsRemaining());
+
+ CActiveScheduler::Stop();
+ iFailed=ETrue;
+ }
+
+// Get YValue after applying YOffset using iYOffsetTop, iYOffsetBottom and iYOffsetMax variables.
+// Depending upon the Y poistion of input, yOffset is gradually reduced from top of the screen to
+// bottom of the screen.
+TInt CTPointerOffsetTest::GetShiftedYValue(TInt aY)
+ {
+ if (!iYOffsetTop || !iYOffsetMax || !iYOffsetBottom)
+ return aY;
+
+ TInt offset = 0;
+ TInt returnValue = aY;
+ TInt displayHeight = TheClient->iScreen->SizeInPixels().iHeight;
+ if (aY >= iYOffsetMax)
+ {
+ // Gradual reduction of Yoffset depending upon the aY value
+ offset = iYOffsetTop + iYOffsetBottom - (iYOffsetTop * aY / displayHeight );
+ if ( offset > iYOffsetMax )
+ {
+ offset = iYOffsetMax;
+ }
+ returnValue -= offset;
+ if (returnValue > (displayHeight-1))
+ {
+ returnValue = displayHeight-1;
+ }
+ }
+ else
+ {
+ returnValue = 0;
+ }
+
+ return returnValue;
+ }
+
+// Common function for all test cases
+void CTPointerOffsetTest::RunTestsL()
+ {
+ // Create CTPointerOffsetClient for each test case and call NextSetOfEventsL()
+ iPointerOffsetClient = new(ELeave) CTPointerOffsetClient(this);
+ iPointerOffsetClient->SetScreenNumber(iTest->iScreenNumber);
+ iPointerOffsetClient->ConstructL();
+
+ iEventSet=0;
+
+ TRAPD(err, NextSetOfEventsL());
+ if (err != KErrNone)
+ {
+ iFailed = ETrue;
+ }
+
+ // Start nested activescheduler if it is not failed
+ if (!iFailed)
+ {
+ CActiveScheduler::Start();
+ }
+
+ TInt eventsRem = iPointerOffsetClient->EventBuffer()->EventsRemaining();
+ if (eventsRem > 0)
+ {
+ iFailed=ETrue;
+ }
+
+ delete iPointerOffsetClient;
+ iPointerOffsetClient = NULL;
+ }
+
+// This function is called by TestExecute Framework, through which all the testcases are run
+void CTPointerOffsetTest::RunTestCaseL(TInt /*aCurTestCase*/)
+ {
+ _LIT(KTest0, "PointerOffset tests");
+ _LIT(KTest1, "PointerOffset tests for other pointer");
+
+ switch(iTest->iState)
+ {
+ case 0:
+ iTest->LogSubTest(KTest0);
+ iPointerNumber = 0;
+ RunTestsL();
+ break;
+ case 1:
+ if (iMaxPointerNumbers == 1)
+ {
+ TestComplete();
+ }
+ else
+ {
+ iTest->LogSubTest(KTest1);
+ iPointerNumber = iMaxPointerNumbers-1;
+ RunTestsL();
+ }
+ break;
+ case 2:
+ // Keep this code in last case statement for main test completion
+ TestComplete();
+ break;
+ default:
+ AutoPanic(EAutoPanicWrongTest);
+ }
+
+ //
+ if (iFailed)
+ {
+ TEST(EFalse);
+ iFailed=EFalse;
+ }
+ ++iTest->iState;
+ }
+
+
+void CTPointerOffsetTest::TestYOffsetValues()
+ {
+ TLogMessageText logText;
+ _LIT(KSet, "Offset tests number : %d of 5");
+ logText.AppendFormat(KSet, iEventSet);
+ LOG_MESSAGE(logText);
+
+ TPoint simulatedPos(iPhysicalScreenSize.iWidth/2, iPhysicalScreenSize.iHeight/2);
+ TPoint expectedPos(simulatedPos);
+ switch(iEventSet++)
+ {
+ case 0:
+ // Test any point which has Y value less than YOffsetMax, where Y position would be 0
+ simulatedPos.iY = iYOffsetMax - 1;
+ SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+ SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+
+ expectedPos.iY = 0;
+ AddExpectedWsEvent(EEventFocusGained);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ break;
+ case 1:
+ // Test any point which has Y value just over YOffsetMax
+ simulatedPos.iY = iYOffsetMax + 1;
+ SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+ SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+
+ expectedPos.iY = GetShiftedYValue(simulatedPos.iY);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ break;
+ case 2:
+ // Test any point which has Y value middle of the screen
+ SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+ SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+
+ expectedPos.iY = GetShiftedYValue(simulatedPos.iY);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ break;
+ case 3:
+ // Test any point which has Y value less than bottommost of the screen
+ simulatedPos.iY = iPhysicalScreenSize.iHeight - 10;
+ SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+ SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+
+ expectedPos.iY = GetShiftedYValue(simulatedPos.iY);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ break;
+ case 4:
+ // Test any point which has Y value at bottom of the screen
+ // As pixels are zero counted and so it cannot be >= iPhysicalScreenSize.iHeight
+ simulatedPos.iY = iPhysicalScreenSize.iHeight-1;
+ SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+ SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
+
+ expectedPos.iY = GetShiftedYValue(simulatedPos.iY);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
+ break;
+ default:
+ CActiveScheduler::Stop();
+ }
+ }
+// Macro which is used for construction of CTPointerOffsetTestStep object
+// and also used to call CreateTestL() which creates CTPointerOffsetTest and CTestBase objects
+__WS_CONSTRUCT_STEP__(PointerOffsetTest)