diff -r 000000000000 -r 2f259fa3e83a commonuisupport/uikon/test/teikenv/teikenv.cpp
--- /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
+	{
+	}