diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/cone/tef/TCONE1STEP.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/cone/tef/TCONE1STEP.CPP Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,627 @@ +// 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: +// The test step tests CCoeControl Apis. A test control is created and +// Key and Pointer events are generated asynchronously using AutoTest Manager.\n +// These events are then handled by the appropriate handlers of the test control.\n +// +// + +/** + @file + @internalComponent - Internal Symbian test code +*/ + + +#include +#include +#include +#include +#include +#include + +#include "TCone1Step.h" + + +//#include +//RTest test(_L("tcone1")); + +//#define FORCE_AUTO + +// +// class CTestControl +// + +/** + Second phase constructor for Test control.\n + Creates a control's window. + The created window is the child of the application's window group.\n + Creates a Font.\n + Requests pointer drag events using EnableDragEvents.\n + This function should be called if a control is required to + receive pointer drag and move events.\n +*/ +void CTestControl::ConstructL() + { + CreateWindowL(); + CreateFontL(); + EnableDragEvents(); + SetExtent(TPoint(20,20),TSize(600,200)); + ActivateL(); + } + +/** Creates a font used by the test control.\n */ + +void CTestControl::CreateFontL() + { + TFontSpec spec(_L("Arial"),240); + iFont=iCoeEnv->CreateScreenFontL(spec); + } +/** + Destructor for the CTestControl class.\n + Calls the ReleaseScreenFont API of CCoeEnv to free all resources used by the font.\n + +*/ +CTestControl::~CTestControl() + { + iCoeEnv->ReleaseScreenFont(iFont); + } +/** + Responds to focus changed.\n + This function is called whenever a control gains or loses focus + as a result of a call to SetFocus().\n + A typical use of FocusChanged() is to change the appearance of the control + to indicate whether or not it has focus, + for example by drawing a focus rectangle around it.\n + +*/ +void CTestControl::FocusChanged(TDrawNow aDrawNow) + { + if (aDrawNow) + { + ActivateGc(); + DrawBorder(); + DeactivateGc(); + } + } +/** + Draws the border for the control window.\n +*/ +void CTestControl::DrawBorder() const + { + CWindowGc& gc=SystemGc(); + TRect rect=Rect(); + gc.DrawRect(rect); + if (!IsFocused()) + gc.SetPenColor(KRgbWhite); + rect.Shrink(1,1); + gc.DrawRect(rect); + rect.Shrink(1,1); + gc.DrawRect(rect); + } +/** + Draw function for the Test Control.\n + The method draws the border using DrawBorder function.\n + Later draws the message using DrawMessage function.\n +*/ +void CTestControl::Draw(const TRect& /*aRect*/) const + { + DrawBorder(); + DrawMessage(); + } +/** + Draw function to draw a message specific to a key event.\n + Gets a pointer to the Windows Graphic context which enables drawing.\n + Sets the pen color, brush style and font for drawing message.\n + Uses CWindowGc::DrawText API to draw the message.\n +*/ +void CTestControl::DrawMessage() const + { + TRect rect=Rect(); + rect.Shrink(3,3); + CWindowGc& gc=SystemGc(); + gc.UseFont(iFont); + TInt ascent=(rect.iBr.iY-rect.iTl.iY-iFont->HeightInPixels())/2 + iFont->AscentInPixels(); + gc.SetPenColor(KRgbBlack); + gc.SetBrushStyle(CGraphicsContext::ESolidBrush); + gc.DrawText(iMessage,rect,ascent,CGraphicsContext::ECenter); + } +/** + This function draws the message on the window after handling a key event or a pointer event + The method is called by the HandlerPointerEventL and OfferKeyEventL functions.\n + Activates the Graphic context.\n + Then invokes the DrawMessage function to draw the message.\n + De activates the Graphic context.\n +*/ +void CTestControl::DrawMessageNow() const + { + ActivateGc(); + DrawMessage(); + DeactivateGc(); + } +/** + Auxilliary Function for Pointer based events.\n + The method is an override from CCoeControl.\n + The function handles the following pointer events.\n + Double click Event.\n +*/ +void CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + { + TInt modifiers=aPointerEvent.iModifiers; + if (modifiers&EModifierDoubleClick) + iMessage.Format(_L("Double click event at (%d,%d)"),aPointerEvent.iPosition.iX,aPointerEvent.iPosition.iY); + else + iMessage.Format(_L("Pointer event %d at (%d,%d)"),aPointerEvent.iType,aPointerEvent.iPosition.iX,aPointerEvent.iPosition.iY); + DrawMessageNow(); + } + +/** + Auxiliary Function for all key event based test cases.\n + + The method is an override from CCoeControl.\n + The function is called to handle the key events. It handles the following key events.\n + 1. (Ctrl or Shift)+ KeyLeft Arrow Key Event.\n + 2. (Ctrl or Shift)+KeyRight Arrow Key Event.\n + 3. (Ctrl or Shift)+ KeyDown Arrow Key Event.\n + 4. (Ctrl or Shift)+ KeyUp Arrow Key Event.\n + + */ + +TKeyResponse CTestControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if (aType!=EEventKey) + return(EKeyWasConsumed); + TInt modifiers=aKeyEvent.iModifiers; + TInt code=aKeyEvent.iCode; + iMessage.Format(_L("Key 0x%x, modifier 0x%x"),code,modifiers); + DrawMessageNow(); + if (code==CTRL('e')) + { + iCoeEnv->Flush(200000); + CBaActiveScheduler::Exit(); + } + if (((modifiers&EAllStdModifiers)==(EModifierCtrl))|((modifiers&EAllStdModifiers)==(EModifierShift))) + { + TPoint pos=Position(); + switch (code) + { + case EKeyLeftArrow: + pos.iX--; + break; + case EKeyRightArrow: + pos.iX++; + break; + case EKeyUpArrow: + pos.iY--; + break; + case EKeyDownArrow: + pos.iY++; + break; + default: + break; + } + if (pos != Position()) + { + SetPosition(pos); + } + } + return(EKeyWasConsumed); + } + + + +/** + Constructor for the CCone1Test AppUi class.\n + Calls the base class CTestCoeAppUi constructor.\n +*/ + +CCone1TestAppUi::CCone1TestAppUi(CTmsTestStep* aStep) : + CTestCoeAppUi(aStep) +{} + +/** + Second phase constructor for CCone1Test AppUi class.\n + Calls the second phase constructor of base class CTestCoeAppUi.\n + Creates a Test control which handles the received key events.\n + Adds the control to the control stack so that it can receive key events.\n + Executes the testcases asynchronously using Autotest Manager.\n +*/ + +void CCone1TestAppUi::ConstructL() + { + CTestCoeAppUi::ConstructL(); + + iControl=new(ELeave) CTestControl; + iControl->ConstructL(); + AddToStackL(iControl); + + AutoTestManager().StartAutoTest(); + } +/** + Destructor for CCone1TestAppUi class.\n + Removes the Test control from the control stack.\n + Deletes the test control.\n +*/ +CCone1TestAppUi::~CCone1TestAppUi() + { + RemoveFromStack(iControl); + delete iControl; + } + + + +/** + @SYMTestCaseID UIF-TCone1Step-TestKeyDownL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + to simulate a key down event.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Key 0x11, modifier 0xcccccccc".\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestKeyDownL() + { + TKeyEvent theKeyEvent; + theKeyEvent.iCode = CTRL('q'); + INFO_PRINTF1(_L("Emulation the event KeyDown")); + iControl->OfferKeyEventL(theKeyEvent,EEventKey); + } + + +/** + @SYMTestCaseID UIF-TCone1Step-TestButtonDownL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate a Button 1 or pen down event.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Pointer event 0 at (10,20)".\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestButtonDownL() + { + TPointerEvent thePointerEvent; + + thePointerEvent.iType=TPointerEvent::EButton1Down; + thePointerEvent.iModifiers = 0; + thePointerEvent.iPosition.iX = 10; + thePointerEvent.iPosition.iY = 20; + INFO_PRINTF1(_L("Emulation the point event")); + iControl->HandlePointerEventL(thePointerEvent); + } + + +/** + @SYMTestCaseID UIF-TCone1Step-TestDoubleClickL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate a double click event.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Double click event at (30,40)".\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestDoubleClickL() + { + TPointerEvent thePointerEvent; + thePointerEvent.iModifiers = EModifierDoubleClick; + thePointerEvent.iPosition.iX = 30; + thePointerEvent.iPosition.iY = 40; + INFO_PRINTF1(_L("Emulation the double click point event")); + iControl->HandlePointerEventL(thePointerEvent); + } + + +/** + @SYMTestCaseID UIF-TCone1Step-TestCtrlKeyDownKeyRightArrowL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate prossing the control and right arrow keys together.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Key 0xf808, modifier 0x80".\n + The position of the control on the screen is also moved one unit to the right.\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestCtrlKeyDownKeyRightArrowL() + { + TKeyEvent theKeyEvent; + theKeyEvent.iModifiers=EModifierCtrl; + theKeyEvent.iCode = EKeyRightArrow; + INFO_PRINTF1(_L("Emulation the event KeyDown with code EKeyRightArrow")); + iControl->OfferKeyEventL(theKeyEvent,EEventKey); + } + + +/** + @SYMTestCaseID UIF-TCone1Step-TestCtrlKeyDownKeyLeftArrowL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate prossing the control and left arrow keys together.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Key 0xf807, modifier 0x80".\n + The position of the control on the screen is also moved one unit to the left.\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestCtrlKeyDownKeyLeftArrowL() + { + TKeyEvent theKeyEvent; + theKeyEvent.iModifiers=EModifierCtrl; + theKeyEvent.iCode = EKeyLeftArrow; + INFO_PRINTF1(_L("Emulation the event KeyDown with code EKeyLeftArrow")); + iControl->OfferKeyEventL(theKeyEvent,EEventKey); + } + + +/** + @SYMTestCaseID UIF-TCone1Step-TestCtrlKeyDownKeyDownArrowL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate prossing the control and left arrow keys together.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Key 0xf80a, modifier 0x80".\n + The position of the control on the screen is also moved one unit down.\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestCtrlKeyDownKeyDownArrowL() + { + TKeyEvent theKeyEvent; + theKeyEvent.iModifiers=EModifierCtrl; + theKeyEvent.iCode = EKeyDownArrow; + INFO_PRINTF1(_L("Emulation the event KeyDown with code EKeyDownArrow")); + iControl->OfferKeyEventL(theKeyEvent,EEventKey); + } + + + +/** + @SYMTestCaseID UIF-TCone1Step-TestCtrlKeyDownKeyUpArrowL + + @SYMPREQ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + to simulate prossing the control and left arrow keys together.\n + + @SYMTestExpectedResults. This test is manually verified, the system will display this string on the screen: + "Key 0xf809, modifier 0x80".\n + The poition of the control on the screen is also moved one unit up.\n + + @SYMTestType : CIT + + */ + +void CCone1TestAppUi::TestCtrlKeyDownKeyUpArrowL() + { + TKeyEvent theKeyEvent; + theKeyEvent.iModifiers=EModifierCtrl; + theKeyEvent.iCode = EKeyUpArrow; + INFO_PRINTF1(_L("Emulation the event KeyDown with code EKeyUpArrow")); + iControl->OfferKeyEventL(theKeyEvent,EEventKey); + } + +/** + Auxiliary Function for all Test Cases.\n + + The method is an override from CTestCoeAppUi.\n + This function is called asynchronously by RunL function of the + AutotestManager after previous test case is executed.\n + Generates the following key events iteratively.\n + Key Down Event.\n + Button Down Pointer Event.\n + Double Click Event.\n + Key Down event for LeftArrow Key.\n + Key Down event for RightArrow Key.\n + Key Down event for Up Arrow Key.\n + Key Down event for Down Arrow Key.\n + */ + +void CCone1TestAppUi::RunTestStepL(TInt aStepNum) + { + + User::After(TTimeIntervalMicroSeconds32(1000000)); + + switch(aStepNum) + { + case 1: + SetTestStepID(_L("UIF-TCone1Step-TestKeyDownL")); + TestKeyDownL(); + RecordTestResultL(); + break; + + case 2: + SetTestStepID(_L("UIF-TCone1Step-TestButtonDownL")); + TestButtonDownL(); + RecordTestResultL(); + break; + case 3: + SetTestStepID(_L("UIF-TCone1Step-TestDoubleClickL")); + TestDoubleClickL(); + RecordTestResultL(); + break; + case 4: + SetTestStepID(_L("UIF-TCone1Step-TestCtrlKeyDownKeyRightArrowL")); + // follow on... + case 5: case 6: case 7: case 8: + TestCtrlKeyDownKeyRightArrowL(); + if( aStepNum == 8 ) + { + RecordTestResultL(); + } + break; + + case 9: + SetTestStepID(_L("UIF-TCone1Step-TestCtrlKeyDownKeyLeftArrowL")); + // follow on... + case 10: case 11: case 12: case 13: + TestCtrlKeyDownKeyLeftArrowL(); + if( aStepNum == 13 ) + { + RecordTestResultL(); + } + break; + + case 14: + SetTestStepID(_L("UIF-TCone1Step-TestCtrlKeyDownKeyDownArrowL")); + // follow on... + case 15: case 16: case 17: case 18: + TestCtrlKeyDownKeyDownArrowL(); + if( aStepNum == 18 ) + { + RecordTestResultL(); + } + break; + + case 19: + SetTestStepID(_L("UIF-TCone1Step-TestCtrlKeyDownKeyUpArrowL")); + // follow on... + case 20: case 21: case 22: case 23: + TestCtrlKeyDownKeyUpArrowL(); + if( aStepNum == 23 ) + { + RecordTestResultL(); + CloseTMSGraphicsStep(); + } + break; + + case 24: + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + break; + + } + } + + +/** + Completes the construction of the Control Environment(CCoeEnv object).\n + Instantiates the CCone1TestAppUi class which serves as a AppUi class.\n + Sets the CCone1TestAppUi object as the application's user interface object.\n + Sets the system wide double click settings.\n + Invokes the second phase constructor of the application's UI.\n +*/ +void CTCone1Step::ConstructCone1AppL(CCoeEnv* aCoe) + { // runs inside a TRAP harness + aCoe->ConstructL(); + CCone1TestAppUi* appUi=new(ELeave) CCone1TestAppUi(this); + aCoe->SetAppUi(appUi); + aCoe->WsSession().SetDoubleClick(1000000,4); + appUi->ConstructL(); + } + +/** + Constructor for CTCone1Step class.\n + Sets the test step name as KTCone1Step.\n +*/ +CTCone1Step::CTCone1Step() + { + SetTestStepName(KTCone1Step); + } +/** + Destructor for Cone1Step class.\n +*/ +CTCone1Step::~CTCone1Step() +{} +/** + Entry function for CTCone1 Test Step.\n + Sets up the control environment.\n + Constructs and Launches the CTCone1 Test application.\n + +*/ +TVerdict CTCone1Step::doTestStepL() // main function called by E32 + { + INFO_PRINTF1(_L("Test Started")); + + PreallocateHALBuffer(); + + __UHEAP_MARK; + + CCoeEnv* coe=new(ELeave) CCoeEnv; + TRAPD(err,ConstructCone1AppL(coe)); + + if (!err) + coe->ExecuteD(); + else + { + SetTestStepResult(EFail); + delete coe; + } + REComSession::FinalClose(); + + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test Finished")); + return TestStepResult(); + } + + +