--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/commonuisupport/uikon/test/teikenv/teikenv.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,1127 @@
+// 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 code exercises uikon classes: CEikEnv, CEikDocument, CEikAppUi.
+//
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include <eikenv.h>
+#include "teikenv.hrh"
+#include "teikenv.h"
+#include <teikenv.rsg>
+#include "apgtask.h"
+#include <ecom/ecom.h>
+#include "tbitmap.h"
+#include <eikrutil.h>
+#include <gulicon.h>
+#include <prnsetup.h>
+#include "eiksrvc.h"
+
+_LIT(KFileName, "c:\\dummy.doc");
+_LIT(KTEikEnvResourceFilePath, "z:\\system\\test\\teikenv\\teikenv.rsc");
+_LIT(KParameter,"Event");
+_LIT(KInfo, "Info Msg");
+const TInt KErrTestHandle=(10);
+
+const TUid KTestPictureType={5711};
+const TUid KTestPictureType1={5712};
+const TUid KTestPictureTypeUnused={5713};
+const TUid KMessageUid1={KUidApaMessageSwitchOpenFileValue};
+const TUid KMessageUid2={KUidApaMessageSwitchCreateFileValue};
+const TUid KMessageUid3={NULL};
+
+/**
+ Auxiliary Function For all Test Cases
+
+ Creates a new document. Called by the application DLL framework to create a
+ new instance of the document associated with the application.
+
+ */
+CApaDocument* CTEikEnvApplication::CreateDocumentL()
+ {
+ CApaDocument* theDocument = new (ELeave) CTEikEnvDocument(*this);
+ return theDocument;
+ }
+
+CTEikEnvApplication theApplication;
+CTEikEnvDocument *theDocument;
+
+//
+// class CTEikEnvAppUi
+//
+CTEikEnvAppUi::CTEikEnvAppUi(CTmsTestStep* aStep) :
+ CTestAppUi(aStep, KTEikEnvResourceFilePath)
+/**
+ Constructor
+ */
+ {
+ }
+
+/**
+ Auxiliary Fn for all Test Cases
+
+ The method creates application’s user interface and prepares it for running
+ tests in auto mode.
+
+ */
+void CTEikEnvAppUi::ConstructL()
+ {
+ CTestAppUi::ConstructL();
+
+ AutoTestManager().StartAutoTest();
+ }
+
+CTEikEnvAppUi::~CTEikEnvAppUi()
+/**
+ Destructor
+ */
+ {
+ RemoveFromStack(iParentControl);
+ delete iParentControl;
+ }
+
+/**
+ Auxiliary Fn for all Test Cases
+
+ The method is an override from CTestAppUi. The method initiates all tests
+ to be performed on uikon classes CEikEnv, CEikDocument, CEikAppUi.
+
+ */
+void CTEikEnvAppUi::RunTestStepL(TInt aNumStep)
+ {
+ User::After(TTimeIntervalMicroSeconds32(500000));
+ switch(aNumStep)
+ {
+ case 1:
+ SetTestStepID(_L("UIF-teikenv-TestEikonEnv"));
+ TestEikonEnv();
+ RecordTestResultL();
+ break;
+ case 2:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestEikonEnvPictureFactoryL"));
+ TRAPD(err, TestEikonEnvPictureFactoryL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 3:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestPopUpMenuL"));
+ TRAPD(err, TestPopUpMenuL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 4:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestEikonAppUiL"));
+ TRAPD(err, TestEikonAppUiL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 5:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestCreateBitmapL"));
+ TRAPD(err, TestCreateBitmapL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 6:
+ {
+ SetTestStepID(_L("UIF-UIKTEST-0002"));
+ TRAPD(err,TestREikAppUiSessionApiL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 7:
+ {
+ SetTestStepID(_L("UIF-UIKTEST-0001"));
+ TRAPD(err,TestMessageApiL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 8:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestAddDialogLikeControlToStackL"));
+ TRAPD(err,TestAddDialogLikeControlToStackL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 9:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestAddAlertDialogLikeControlToStackL"));
+ TRAPD(err,TestAddAlertDialogLikeControlToStackL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 10:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestUpdateNameL"));
+ TRAPD(err,TestUpdateNameL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ break;
+ }
+ case 11:
+ {
+ SetTestStepID(_L("UIF-teikenv-TestFocusL"));
+ TRAPD(err,TestFocusL());
+ TEST(err == KErrNone);
+ RecordTestResultL();
+ CloseTMSGraphicsStep();
+ break;
+ }
+ case 12:
+ {
+ INFO_PRINTF1(_L("Tests completed.\n"));
+ delete theDocument;
+ AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestCreateBitmapL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Test CEikonEnv::CreateBitmapL(const TDesC &aFileName, TInt aId)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method invokes CEikonEnv::Static() to get the instance of CEikonEnv.
+ It then tests CreateBitmapL() (by passing wildcharacter ("*") as the filename) in TBITMAP.exe application.
+
+ @SYMTestExpectedResults The method should return application default bitmap if wild character("*")
+ is passed as the filename to CEikonEnv::CreateBitmapL(const TDesC &aFileName, TInt aId);
+ */
+
+void CTEikEnvAppUi::TestCreateBitmapL()
+ {
+ _LIT(KBitMapAppFileName,"z:\\sys\\bin\\TBITMAP.exe");
+
+ CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
+ RProcess bitmapProc;
+ TInt ret = bitmapProc.Create(KBitMapAppFileName,KNullDesC);
+ TEST(ret == KErrNone);
+ User::LeaveIfError(ret);
+ CleanupClosePushL(bitmapProc);
+
+ INFO_PRINTF1(_L("Create Bitmap Process"));
+
+ //attach commandline to Bitmap process
+ TRAP(ret,cmdLine->SetProcessEnvironmentL(bitmapProc));
+ TEST(ret == KErrNone);
+
+ TRequestStatus trs;
+ bitmapProc.Logon(trs);
+ bitmapProc.Resume();
+ User::WaitForRequest(trs);
+
+ // check exit values
+ TEST(bitmapProc.ExitReason() == KErrNone); // specifically, it must be different to KErrBitMapDoesNotMatch
+ TEST(bitmapProc.ExitType() == EExitKill);
+
+ CleanupStack::PopAndDestroy(&bitmapProc);
+ CleanupStack::PopAndDestroy(cmdLine);
+ }
+
+ /**
+ @SYMTestCaseID UIF-UIKTEST-0001
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Testing the Apis which give messages to the user
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The apis are called which handle messages,errors and give out
+ messages to the user.Also some other miscellaneous apis are
+ verified from classes CEikDocument,CEikAppUi
+
+ @SYMTestExpectedResults Test should complete without any leave, panic or error.
+
+ */
+
+void CTEikEnvAppUi::TestMessageApiL()
+ {
+ INFO_PRINTF1(_L("Test step MessageApiL started"));
+ TFileName noFile;
+ TBool exist=CEikAppUi::ProcessCommandParametersL(EApaCommandCreate,noFile);
+ TEST(!exist);
+
+ TBuf8<128> buf;
+ buf.Copy(KFileName);
+ TMessageResponse response;
+ response=CEikAppUi::HandleMessageL(1,KMessageUid1,buf);
+ TEST(response==EMessageHandled);
+ response=CEikAppUi::HandleMessageL(1,KMessageUid2,buf);
+ TEST(response==EMessageHandled);
+ response=CEikAppUi::HandleMessageL(1,KMessageUid3,buf);
+ TEST(response==EMessageNotHandled);
+
+ TBool empty=theDocument->IsEmpty();
+ TEST(empty);
+
+ CEikonEnv* theEnv = CEikonEnv::Static();
+
+ TRAPD(err,theEnv->UpdateSystemFontsL());
+ TEST(err==KErrNone);
+
+ TBufC<16> bufc2(KParameter);
+ TPtr ptr = bufc2.Des();
+ theEnv->SendEventToEikonServer(-16,&ptr,16);
+ bufc2=KNullDesC;
+ theEnv->SendEventToEikonServer(1,&ptr,16);
+
+ // the following tests are tested through display of required info
+ TBufC<10> msg(KInfo);
+ theEnv->SetVerboseInfoReporting(ETrue);
+ theEnv->VerboseInfoMsg(msg);
+
+
+ theEnv->DisplayTaskList();
+ User::After(1000000);
+ theEnv->DismissTaskList();//if the tasklist is displayed , it will be closed by this api....hence tested
+
+ theEnv->WservAllocInfoMsg();
+ User::After(1000000);
+ theEnv->AllocInfoMsg();
+ User::After(1000000);
+ theEnv->FservAllocInfoMsg();
+ User::After(1000000);
+
+ theEnv->HandleErrorWithContext(KErrTestHandle,R_EIKENV_APP_ERR_HANDLE);
+ // display tests over
+ INFO_PRINTF1(_L("Test step MessageApiL completed!"));
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestAddDialogLikeControlToStackL
+
+ @SYMPREQ PDEF098453
+
+ @SYMTestCaseDesc Test CEikonEnv::AddDialogLikeControlToStackL(CCoeControl* aControl)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method invokes CEikonEnv::Static() to get the instance of CEikonEnv.
+ It then tests AddDialogLikeControlToStackL() method with the following scenarios.
+ 1) Creates a control with "ECoeStackPrioritySoftkey" priority and displays on the screen
+ and then invokes AddDialogLikeControlToStackL().
+ 2) Creates a control with "ECoeStackPrioritySoftkey-1" priority and displays on the screen
+ and then invokes AddDialogLikeControlToStackL().
+
+ @SYMTestExpectedResults
+ 1) Should return KErrNone
+ 2) Should return KLeaveWithoutAlert
+
+ */
+
+void CTEikEnvAppUi::TestAddDialogLikeControlToStackL()
+ {
+ TInt res=0;
+ CEikonEnv* theEnv = CEikonEnv::Static();
+ CTestControl* control1 = CTestControl::NewL();
+ AddToStackL(control1,ECoeStackPrioritySoftkey);
+ INFO_PRINTF1(_L("Control with softkey priority is added to Control Stack"));
+ control1->DrawNow();
+ CTestControl* control2 = CTestControl::NewL();
+ TRAP(res,theEnv->AddDialogLikeControlToStackL(control2));
+ TEST(res==KErrNone);
+ INFO_PRINTF1(_L("Control with dialog priority is added to the Control Stack"));
+ control2->DrawNow();
+ theEnv->RemoveFromStack(control1);
+ theEnv->RemoveFromStack(control2);
+
+ AddToStackL(control1,ECoeStackPrioritySoftkey-1);
+ INFO_PRINTF1(_L("Control with ECoeStackPrioritySoftkey-1 priority is added to Control Stack"));
+ control1->DrawNow();
+ TRAP(res,theEnv->AddDialogLikeControlToStackL(control2));
+ TEST(res==KLeaveWithoutAlert);
+ INFO_PRINTF1(_L("Control with dialog priority is not added to the Control Stack"));
+ theEnv->RemoveFromStack(control1);
+
+ delete control1;
+ delete control2;
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestFocusL
+
+ @SYMDEF 105102
+
+ @SYMTestCaseDesc Test CCoeAppUi::HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination)
+
+ @SYMTestPriority Critical
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method tests a particular scenario which is as follows.
+ The defect is reproduced when a focus event is called on a control which doesn't exist in the stack.
+ To simulate the scenario the following steps are carried and executed with and without fix.
+ 1) Create control 1(parent) with default settings.
+ Add to control stack with 'ECoeStackPrioritySoftkey' priority. Activate parent.
+ 2) Create control 2(child) with default settings.
+ Add to control stack with 'ECoeStackPriorityEnvironmentFilter' (higher than parent) priority.
+ Activate child.
+ 3) Raise focus lost event (EEventFocusLost). Call HandleWsEventL on child.
+ 4) When HandleWsEventL is called the overridden HandleForeGroundEventL is called internally.
+ 5) It deletes the child control which has the current focus.
+ This should cause a KERN:EXEC 3 panic which is fixed by making changes in
+ CCoeAppUi::HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination).
+
+ @SYMTestExpectedResults
+ 1) Should not panic.
+
+ */
+
+void CTEikEnvAppUi::TestFocusL()
+ {
+ iParentControl = CTestControl::NewL();
+ AddToStackL(iParentControl,ECoeStackPrioritySoftkey);
+ INFO_PRINTF1(_L("Create parent control and add to control stack with ECoeStackPrioritySoftkey priority."));
+
+ iChildControl = CTestControl::NewL();
+ iChildControl->SetContainerWindowL(*iParentControl);
+ AddToStackL(iChildControl,ECoeStackPriorityEnvironmentFilter);
+ INFO_PRINTF1(_L("Create Child control and add to control stack with priority more than parent."));
+
+ TWsEvent event;
+ event.SetType(EEventFocusLost);
+ INFO_PRINTF1(_L("Raise 'EEventFocusLost' event and call HandleWsEventL "));
+
+ HandleWsEventL(event,iChildControl);
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestAddAlertDialogLikeControlToStackL
+
+ @SYMPREQ PDEF098453
+
+ @SYMTestCaseDesc Test CEikonEnv::AddAlertDialogLikeControlToStackL(CCoeControl* aControl)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method invokes CEikonEnv::Static() to get the instance of CEikonEnv.
+ It then tests AddAlertDialogLikeControlToStackL() method with the following scenarios.
+ 1) Creates a control with "ECoeStackPrioritySoftkey" priority and displays on the screen
+ and then invokes AddAlertDialogLikeControlToStackL().
+ 2) Creates a control with "ECoeStackPrioritySoftkey-1" priority and displays on the screen
+ and then invokes AddAlertDialogLikeControlToStackL().
+
+ @SYMTestExpectedResults
+ 1) Should return KErrNone
+ 2) Should return KLeaveWithoutAlert
+
+ */
+
+void CTEikEnvAppUi::TestAddAlertDialogLikeControlToStackL()
+ {
+ TInt res=0;
+ CEikonEnv* theEnv = CEikonEnv::Static();
+ CTestControl* control1 = CTestControl::NewL();
+ AddToStackL(control1,ECoeStackPrioritySoftkey);
+ INFO_PRINTF1(_L("Control with softkey priority is added to Control Stack"));
+ control1->DrawNow();
+ CTestControl* control2 = CTestControl::NewL();
+ TRAP(res,theEnv->AddAlertDialogLikeControlToStackL(control2));
+ TEST(res==KErrNone);
+ INFO_PRINTF1(_L("Control with alert priority is added to the Control Stack"));
+ control2->DrawNow();
+ theEnv->RemoveFromStack(control1);
+ theEnv->RemoveFromStack(control2);
+
+ AddToStackL(control1,ECoeStackPrioritySoftkey-1);
+ INFO_PRINTF1(_L("Control with ECoeStackPrioritySoftkey-1 priority is added to Control Stack"));
+ control1->DrawNow();
+ TRAP(res,theEnv->AddAlertDialogLikeControlToStackL(control2));
+ TEST(res==KLeaveWithoutAlert);
+ INFO_PRINTF1(_L("Control with alert priority is not added to the Control Stack"));
+ theEnv->RemoveFromStack(control1);
+
+ delete control1;
+ delete control2;
+ }
+/**
+ @SYMTestCaseID UIF-teikenv-TestEikonEnv
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Tests CEikonEnv APIs.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions This method invokes CEikonEnv::Static() to get the instance
+ of CEikonEnv.\n
+ The following setter APIs are then tested for values ETrue and EFalse.
+ 1. CEikonEnv::SetBusy()\n
+ 2. CEikonEnv::SetSystem()\n
+ 3. CEikonEnv::SetDocNameIsAFile()\n
+ 4. CEikonEnv::SetRespondsToShutdownEvent()\n
+ 5. CEikonEnv::SetRespondsToSwitchFilesEvent()\n
+ It also tests APIs
+ 6. CEikonEnv::Version()
+ 7. CEikonEnv::GetErrorText()
+ 8. CEikonEnv::LeaveWithInfoMsg()
+
+ @SYMTestExpectedResults The method verifies results against expected results. The
+ setter APIs are verified by checking results produced by their getter method
+ against expected results.
+
+ */
+void CTEikEnvAppUi::TestEikonEnv()
+ {
+ CEikonEnv* theEnv = CEikonEnv::Static();
+
+ theEnv->SetBusy(ETrue);
+ INFO_PRINTF1(_L("Set env to busy"));
+ TBool theRes = theEnv->IsBusy();
+ TEST(theRes);
+ theEnv->SetBusy(EFalse);
+ INFO_PRINTF1(_L("Set env to free"));
+ theRes = theEnv->IsBusy();
+ TEST(!theRes);
+
+ INFO_PRINTF1(_L("Check the version number"));
+ TVersion theVersion = theEnv->Version();
+ TEST(theVersion.iMajor >= 0);
+ TEST(theVersion.iMinor <= 99);
+ TEST(theVersion.iMinor >= 0);
+ TEST(theVersion.iMinor < theVersion.iMajor);
+ TEST(theVersion.iBuild >= 0);
+
+// Check a system attribute
+ INFO_PRINTF1(_L("Set system attribute"));
+ theEnv->SetSystem(ETrue);
+ theRes = theEnv->IsSystem();
+ TEST(theRes);
+
+ theEnv->SetSystem(EFalse);
+ theRes = theEnv->IsSystem();
+ TEST(!theRes);
+//
+
+ TBuf<256> buf;
+ theEnv->GetErrorText(buf, -1);
+ TEST(buf==_L("Not found"));
+ theEnv->GetErrorText(buf, 2);
+ TEST(buf==_L("Unknown error"));
+ theEnv->GetErrorText(buf, 2, KNullUid);
+ TEST(buf==_L("Unknown error"));
+
+//
+ TRAPD(res1, theEnv->LeaveWithInfoMsg(R_EIKENV_APP_ERR_TEXT));
+ TEST(res1 != KErrNone);
+ TEST(res1==KLeaveWithoutAlert);
+
+//
+ theEnv->SetDocNameIsAFile(EFalse);
+ TBool res = theEnv->DocNameIsAFile();
+ TEST(!res);
+
+ theEnv->SetDocNameIsAFile(ETrue);
+ res = theEnv->DocNameIsAFile();
+ TEST(res);
+
+//
+ INFO_PRINTF1(_L("Test responds to shutdown event"));
+ theEnv->SetRespondsToShutdownEvent(EFalse);
+ res = theEnv->RespondsToShutdownEvent();
+ TEST(!res);
+
+ theEnv->SetRespondsToShutdownEvent(ETrue);
+ res = theEnv->RespondsToShutdownEvent();
+ TEST(res);
+
+ theEnv->SetRespondsToSwitchFilesEvent(EFalse);
+ res = theEnv->RespondsToSwitchFilesEvent();
+ TEST(!res);
+
+ theEnv->SetRespondsToSwitchFilesEvent(ETrue);
+ res = theEnv->RespondsToSwitchFilesEvent();
+ TEST(res);
+ }
+
+ /**
+ @SYMTestCaseID UIF-UIKTEST-0002
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Testing the Apis
+
+ @SYMTestPriority Low
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The APIs from REikAppUiSession classes of
+ UIKON are called and verified.
+
+
+ @SYMTestExpectedResults Test should complete without any leave, panic or error.
+
+ */
+
+void CTEikEnvAppUi::TestREikAppUiSessionApiL()
+{
+ INFO_PRINTF1(_L("Test step REikAppUiSessionApiL started"));
+ _LIT(KResolveError,"ResolveError");
+ TInt ret;
+ REikAppUiSession uiSession;
+
+ TEST(uiSession.Connect()==KErrNone);
+ CleanupClosePushL(uiSession);
+
+ TSecurityInfo info;
+ info.Set(RProcess());
+ uiSession.BlankScreen();//BlankScreen is seen
+ User::After(1000000);
+ uiSession.UnblankScreen();//Screen is seen Again, hence tested
+
+ ret=uiSession.EnableTaskList();
+ TEST(ret==KErrNone);//on successful return
+
+ CEikonEnv::TErrorValidity errValid;
+ TInt error=-90;
+ TUid appUid={0x10004c6A};
+ TBuf<250> buffer(KResolveError);
+ errValid=uiSession.ResolveError(buffer,error,appUid);
+ TEST(errValid==CEikonEnv::EErrorNumValid);
+ INFO_PRINTF2(_L("The errorValid is %d"),errValid);
+
+ uiSession.Close();
+ CleanupStack::PopAndDestroy(&uiSession);
+
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestPopUpMenuL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Test loading menu from resource.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method invokes CEikonEnv::Static() to get the instance of
+ CEikonEnv.It then calls auxiliary method LaunchPopupMenuL() which loads
+ menu from resource file. The method then simulates the enter key event
+ by invoking CEikonEnv::SimulateKeyEventL() close the menu.
+
+ @SYMTestExpectedResults The method should load the menu and close the menu
+ with the simulated enter key event.
+
+ */
+void CTEikEnvAppUi::TestPopUpMenuL()
+ {
+ CEikonEnv* theEnv = CEikonEnv::Static();
+
+ LaunchPopupMenuL();
+
+ TKeyEvent theKeyEvent;
+ theKeyEvent.iCode = EKeyEnter;
+ theKeyEvent.iScanCode = EStdKeyEnter;
+ theKeyEvent.iModifiers = 0;
+ theKeyEvent.iRepeats = 0;
+ theEnv->SimulateKeyEventL(theKeyEvent,EEventKey);
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestEikonEnvPictureFactoryL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Test adding/retrieving picture factory to/from Eikon environment.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method creates two Picture factory objects and invokes
+ CEikonEnv::AddPictureFactoryL() to add them to the Eikon environment. It then
+ invokes CEikonEnv::ExtendedPictureFactory() to retrieve these Picture factory
+ objects. The test checks CEikonEnv::ExtendedPictureFactory() by using valid &
+ invalid picture factory identifers. It tests CEikonEnv::RemovePictureFactory()
+ to remove a specified picture factory object.
+
+ @SYMTestExpectedResults Each of these tests verify the results against expected
+ results.
+
+ */
+void CTEikEnvAppUi::TestEikonEnvPictureFactoryL()
+ {
+ CEikonEnv* theEnv = CEikonEnv::Static();
+
+ RFs theFs;
+ theFs.Connect();
+ CTPictureFactory* theFactory = new (ELeave) CTPictureFactory(theFs, KTestPictureType);
+ CTPictureFactory* theFactory1 = new (ELeave) CTPictureFactory(theFs, KTestPictureType1);
+
+ CleanupStack::PushL(theFactory);
+ CleanupStack::PushL(theFactory1);
+
+ TUid Id = theFactory -> Id();
+ theEnv->AddPictureFactoryL(*theFactory);
+
+ theEnv->AddPictureFactoryL(*theFactory1);
+
+
+ MEikPictureFactory* thePictureFactury = theEnv->ExtendedPictureFactory(KTestPictureTypeUnused);
+ TEST(thePictureFactury == NULL);
+
+ thePictureFactury = theEnv->ExtendedPictureFactory(KTestPictureType1);
+ TEST(thePictureFactury == theFactory1);
+
+ theEnv->RemovePictureFactory(Id);
+ thePictureFactury = theEnv->ExtendedPictureFactory(KTestPictureType);
+ TEST(thePictureFactury == NULL);
+
+ CleanupStack::PopAndDestroy(2, theFactory);
+
+ theFs.Close();
+ }
+
+/**
+ Auxiliary Fn for teikenv-TestPopUpMenuL
+
+ The method invokes CEikonEnv::LaunchPopupMenuL() to launch the pop up menu
+ identified by the resource id R_EIKENV_MENU. It also test that no leave
+ occurs in the process.
+
+ */
+void CTEikEnvAppUi::LaunchPopupMenuL()
+ {
+ CEikonEnv* theEnv = CEikonEnv::Static();
+ TPoint theTargetPos(0, 0);
+ TInt theResourceId = R_EIKENV_MENU;
+ TRAPD(res, theEnv->LaunchPopupMenuL(theResourceId, theTargetPos));
+
+ TEST(!res);
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestEikonAppUiL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Test CEikAppUi APIs.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method checks whether CEikAppUi::ProcessMessageL() method,
+ invokes overloaded methods of CEikAppUi::OpenFileL() and
+ CEikAppUi::CreateFileL() when message UIDs KUidApaMessageSwitchOpenFile16
+ and KUidApaMessageSwitchCreateFile16. It then tests whether
+ CEikonEnv::ClosePopup() closes the pop up menu launched by LaunchPopupMenuL()
+ method. The method then invokes CEikonEnv::CreateHotKeyControlL() to create
+ hot key control specified by resource id R_TEST_ENV_HOTKEYS. The hot key
+ combination is simulated to verify. Finally the method tests
+ CEikAppUi::HandleError() and CEikDocument::SetChanged() APIs.
+
+ @SYMTestExpectedResults All test results are verified against expected results.
+
+ */
+void CTEikEnvAppUi::TestEikonAppUiL()
+ {
+ TBuf8<128> buf;
+ buf.Copy(KFileName);
+ ProcessMessageL(KUidApaMessageSwitchOpenFile16, buf);
+
+ ProcessMessageL(KUidApaMessageSwitchCreateFile16, buf);
+//
+ LaunchPopupMenuL();
+
+ ClosePopup();
+//
+ INFO_PRINTF1(_L("Create a hot key control from resource file"));
+ iResponseForHotKey = EFalse;
+ CreateHotKeyControlL(R_TEST_ENV_HOTKEYS);
+
+ TKeyEvent theKeyEvent;
+ theKeyEvent.iCode = 2;
+ theKeyEvent.iScanCode = 66; // for 'b'
+ theKeyEvent.iModifiers = EModifierLeftCtrl | EModifierCtrl | EModifierAutorepeatable;
+ theKeyEvent.iRepeats = 0;
+
+ CEikonEnv* theEnv = CEikonEnv::Static();
+ theEnv->SimulateKeyEventL(theKeyEvent, EEventKey);
+
+ User::After(2000000);
+
+ TEST(iResponseForHotKey);
+//
+ User::After(2000000);
+
+ theEnv->HandleError(KErrPathNotFound);
+
+//
+ TInt res = theDocument->HasChanged();
+ TEST(!res);
+
+ theDocument->SetChanged(ETrue);
+ res = theDocument->HasChanged();
+ TEST(res);
+ }
+
+
+/**
+ Auxiliary Fn for teikenv-TestEikonAppUiL
+
+ The method is overloaded from CEikAppUi class. It is used to test
+ ProcessMessageL() when KUidApaMessageSwitchOpenFile16 message uid
+ is passed to it as parameter.
+
+ */
+void CTEikEnvAppUi::OpenFileL(const TDesC& aFileName)
+ {
+ TPtrC8 ptrc(((TText8*)aFileName.Ptr()),aFileName.Length() * sizeof(TText));
+
+ TBuf8<128> buf;
+ buf.Copy(KFileName);
+
+ TInt res = ptrc.CompareC(buf);
+ TEST(res==0);
+ }
+
+/**
+ Auxiliary Fn for teikenv-TestEikonAppUiL
+
+ The method is overloaded from CEikAppUi class. It is used to verify
+ the ProcessMessageL() when KUidApaMessageSwitchCreateFile16 message uid is
+ passed to it as parameter.
+
+ */
+void CTEikEnvAppUi::CreateFileL(const TDesC& aFileName)
+ {
+ TPtrC8 ptrc(((TText8*)aFileName.Ptr()),aFileName.Length() * sizeof(TText));
+
+ TBuf8<128> buf;
+ buf.Copy(KFileName);
+
+ TInt res = ptrc.CompareC(buf);
+ TEST(res==0);
+ }
+/**
+ Auxiliary Fn for teikenv-TestEikonAppUiL
+
+ The method is overloaded from CEikAppUi class. It is used to test
+ the simulated hot key event created by CEikonEnv::CreateHotKeyControlL().
+
+ */
+void CTEikEnvAppUi::HandleCommandL(TInt aCommand)
+ {
+ switch(aCommand)
+ {
+ case ETestUiCmd1:
+ iResponseForHotKey = ETrue;
+ break;
+ case ETestUiCmd2:
+ iResponseForHotKey = ETrue;
+ break;
+ }
+ }
+
+/**
+ Auxiliary Fn for teikenv-TestEikonAppUiL
+
+ The method is overloaded from CEikAppUi class. It is used to test
+ the simulated behaviour of CEikAppUi::HandleError() when
+ KErrPathNotFound is to be handled.
+
+ */
+TErrorHandlerResponse CTEikEnvAppUi::HandleError(TInt aError, const SExtendedError& ,
+ TDes& aErrorText, TDes& aContextText)
+ {
+ if(aError == KErrPathNotFound)
+ {
+ aErrorText.Copy(_L("Path Not Found"));
+ aContextText.Copy(_L("File input/output operation"));
+ return EInfoDisplay;
+ }
+ else if(aError==KErrTestHandle)
+ {
+ aErrorText.Copy(_L("error handled"));
+ aContextText.Copy(_L("testing api"));
+ return EInfoDisplay;
+ }
+
+ return EErrorNotHandled;
+ }
+
+/**
+ @SYMTestCaseID UIF-teikenv-TestUpdateNameL
+
+ @SYMDEF DEF119031
+
+ @SYMTestCaseDesc Test the caption of a process is valid to rename this process or thread.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The method creates a process whose caption(in .rss file)is invalid
+ with more than 80 characters and with special symbols included. The API
+ CEikonEnv::UpdateTaskNameL() will verify this caption and update it accordingly.
+
+ @SYMTestExpectedResults Eventhough this test process caption is invalid, it will modified with
+ suitable caption and RenameThread() and RenameProcess() in CEikonEnv::UpdateTaskNameL()
+ will successfully invoked.
+ */
+void CTEikEnvAppUi::TestUpdateNameL()
+ {
+ INFO_PRINTF1(_L("Create Caption test Process"));
+ _LIT(KNameTestAppFileName,"z:\\sys\\bin\\tnametest1.exe");
+
+ RProcess nameProc;
+ TInt ret = nameProc.Create(KNameTestAppFileName,KNullDesC);
+ TEST(ret == KErrNone);
+ User::LeaveIfError(ret);
+ CleanupClosePushL(nameProc);
+ nameProc.Resume();
+
+ //Time for the nametest process to launch itself
+ User::After(500000);
+ TEST(nameProc.ExitReason() == KErrNone);
+
+ // This LIT is the anticipated modified form of that specified in tcaptiontest_reg.rss,
+ // to which the test process should be renamed.
+ // Note the wild-card to accomodate kernel decorations.
+ _LIT( KCheckUpdateProcName, "CheckforValidASCIICharactersBetween-=(32)and~(126)_RemoveIllegalCh*");
+ TFindProcess findProc( KCheckUpdateProcName );
+ TFullName fullName;
+ TEST( KErrNone == findProc.Next(fullName) );
+
+ CleanupStack::PopAndDestroy(&nameProc);
+ }
+
+/**
+ This method is part of Two - phase construction. It creates a test control.
+ */
+CTestControl* CTestControl::NewL()
+ { // static
+ CTestControl* control=new(ELeave) CTestControl;
+ CleanupStack::PushL(control);
+ control->ConstructL();
+ CleanupStack::Pop(control);
+ return control;
+ }
+
+CTestControl::~CTestControl()
+/**
+ Destructor
+ */
+ {
+ }
+
+CTestControl::CTestControl()
+/**
+ Constructor
+ */
+ {
+ }
+
+/**
+ Second phase constructor for the CTestControl.\n
+ Creates a control window, sets the control's extent and activates the control.\n
+ */
+void CTestControl::ConstructL()
+ {
+ RWsSession& windowServerSession=iCoeEnv->WsSession();
+ windowServerSession.SetAutoFlush(ETrue);
+ CreateWindowL();
+ CWsScreenDevice& screenDevice=*iCoeEnv->ScreenDevice();
+ const TSize screenSize(screenDevice.SizeInPixels());
+ SetExtent(TPoint(50, 50), TSize(screenSize.iWidth-100, screenSize.iHeight-100));
+ ActivateL();
+ }
+
+void CTEikEnvAppUi::HandleForegroundEventL(TBool /*aBool*/)
+ {
+ if (iChildControl)
+ {
+ INFO_PRINTF1(_L("Remove Child control from Stack "));
+ RemoveFromStack(iChildControl);
+ delete iChildControl;
+ iChildControl=NULL;
+ }
+ }
+/**
+ This method is an override from CCoeControl.It draws the control.
+ */
+void CTestControl::Draw(const TRect&) const
+ {
+ CWindowGc& graphicsContext=SystemGc();
+ graphicsContext.SetPenStyle(CGraphicsContext::ESolidPen);
+ graphicsContext.SetPenColor(KRgbRed);
+ graphicsContext.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ graphicsContext.SetBrushColor(KRgbGray);
+ TRect rectangle(TPoint(0, 0), Rect().Size());
+ graphicsContext.DrawRect(rectangle);
+ }
+
+/**
+ Auxiliary Function for all Test Cases
+
+ The method creates a document for the application,prepares the document for
+ editing & sets UI which manipulates this document’s data as application's UI.
+
+ */
+void CEikEnvStep::ConstructAppL(CEikonEnv* aEikEnv)
+ { // runs inside a TRAP harness
+ aEikEnv->ConstructL();
+
+ // goes out of scope when function leaves and private members are destroyed. App Architecture handles
+ // CEikAppUI destruction
+ theDocument = (CTEikEnvDocument *) (theApplication.CreateDocumentL());
+ theDocument->iStep = this;
+ theDocument->PrepareToEditL();
+ aEikEnv->SetAppUi(theDocument->AppUi());
+ }
+
+CEikEnvStep::~CEikEnvStep()
+/**
+ Destructor
+ */
+ {
+ }
+
+CEikEnvStep::CEikEnvStep()
+/**
+ Constructor
+ */
+ {
+ // Call base class method to set up the human readable name for logging
+ SetTestStepName(KEikEnvStep);
+ }
+
+
+
+/**
+ The method creates & sets the application's user interface object to
+ launch the application to initiate the tests.
+ */
+TVerdict CEikEnvStep::doTestStepL()
+ {
+ INFO_PRINTF1(_L("Test Started"));
+ PreallocateHALBuffer();
+ __UHEAP_MARK;
+
+ CEikonEnv* eikEnv=new CEikonEnv;
+ if (eikEnv==NULL)
+ {
+ INFO_PRINTF1(_L("Failed to create Eikon Environment due to lack of Memory"));
+ SetTestStepResult(EFail);
+ return TestStepResult();
+ }
+ TRAPD(err,ConstructAppL(eikEnv));
+ if (err!=KErrNone)
+ {
+ SetTestStepResult(EFail);
+ delete eikEnv;
+ INFO_PRINTF2(_L("Failed to construct Eikon Environment, error %d"), err);
+ }
+ else
+ eikEnv->ExecuteD();
+
+ REComSession::FinalClose();
+
+ __UHEAP_MARKEND;
+
+ INFO_PRINTF1(_L("Test Finished"));
+ return TestStepResult();
+ }
+
+//----------------
+
+
+/**
+ The method is an overrride from MEikPictureFactory. It enables editing
+ viewing of an Picture Factory object.
+ */
+void CTPictureFactory::EditL(const TPictureHeader& ,TBool )
+ {
+ }
+
+/**
+ This method is an override from MEikPictureFactory.It checks if the factory
+ supports the specified picture type aPictureType.
+ */
+TBool CTPictureFactory::SupportsPictureType(TUid aPictureType) const
+ {
+ return aPictureType == iPictureType;
+ }
+
+/**
+ This method is an override from MEikPictureFactory. It returns a pointer to
+ the picture factory object.
+ */
+const MPictureFactory* CTPictureFactory::PictureFactory(TUid aPictureType) const
+ {
+ if(aPictureType == iPictureType)
+ {
+ return this;
+ }
+ return NULL;
+ }
+
+/**
+ This method is an override from MEikPictureFactory. It returns TPictureHeader
+ object.
+ */
+TPictureHeader CTPictureFactory::InsertL(TUid aPictureType,CBase* )
+ {
+ TPictureHeader header;
+ if (aPictureType==iPictureType)
+ {
+ }
+ return header;
+
+ }
+
+/**
+ This method is an override from MEikPictureFactory.
+ */
+void CTPictureFactory::NewPictureL(TPictureHeader& ,const CStreamStore& )const
+ {
+ }