diff -r e8c1ea2c6496 -r 8758140453c0 localisation/apparchitecture/tef/T_RuleBasedLaunchingStep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/localisation/apparchitecture/tef/T_RuleBasedLaunchingStep.cpp	Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,467 @@
+// 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 the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// The following test cases test the funtionality of RuleBased plugins framework.
+// 
+//
+
+
+
+/**
+ @file
+ @internalComponent - Internal Symbian test code
+*/
+
+#include <apacmdln.h>
+#include "..\tef\tRuleBasedApps\RuleBasedUID.H" //The UID'S for the 4 applications used during testing
+#include "T_RuleBasedLaunchingStep.h"
+#include <APGICNFL.H>
+#include "testableapalssession.h"
+
+const TUint KNonNativeApplicationType = 0x10207f90;
+const TUint KNonNativeApplication = 0xA0000B6E;
+
+_LIT(KLitNativeExecutable, "z:\\sys\\bin\\TNNAPP2.EXE");
+_LIT(KLitLogicalExecutableA, "c:\\A.NNAPP2"); // this file never actually needs to exist
+_LIT8(KLitMimeTypeA, "x-epoc/a-nnapp2");
+
+CTRuleBasedLaunchingStep::CTRuleBasedLaunchingStep()
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KT_RuleBasedLaunchingStep);
+	}
+
+CTRuleBasedLaunchingStep::~CTRuleBasedLaunchingStep()
+	{
+	iWs.Close();
+	iFs.Close();
+	}
+
+void CTRuleBasedLaunchingStep::ExecuteL()
+	{
+	RTestableApaLsSession theLs;
+	User::LeaveIfError(theLs.Connect());
+	CleanupClosePushL(theLs);
+	
+	//DONT_CHECK since app list is updated
+	HEAP_TEST_LS_SESSION(theLs, 0, DONT_CHECK, TestLaunchNonNativeApplicationForRuleBasedL(theLs), NO_CLEANUP);	
+	//DONT_CHECK since result is unstable
+	HEAP_TEST_LS_SESSION(theLs, 0, DONT_CHECK, LaunchAppTests1L(theLs), theLs.FlushRecognitionCache() );
+	HEAP_TEST_LS_SESSION(theLs, 0, 0, LaunchAppTests2L(theLs), theLs.FlushRecognitionCache() );
+	HEAP_TEST_LS_SESSION(theLs, 0, 0, LaunchAppTests3L(theLs), theLs.FlushRecognitionCache() );
+	HEAP_TEST_LS_SESSION(theLs, 0, 0, LaunchAppTests4L(theLs), theLs.FlushRecognitionCache() );
+	HEAP_TEST_LS_SESSION(theLs, 0, 0, LaunchAppTests5L(theLs), theLs.FlushRecognitionCache() );
+	HEAP_TEST_LS_SESSION(theLs, 0, 0, LaunchAppTests6L(theLs), theLs.FlushRecognitionCache() );
+	
+	CleanupStack::PopAndDestroy(&theLs);
+	}
+	
+LOCAL_C void DeregisterNonNativeForRuleBased(TAny* aApparcServer)
+	{
+	RApaLsSession& apparcServer = *static_cast<RApaLsSession*>(aApparcServer);
+	TRAP_IGNORE(apparcServer.PrepareNonNativeApplicationsUpdatesL());
+	TRAP_IGNORE(apparcServer.DeregisterNonNativeApplicationL(TUid::Uid(KNonNativeApplication)));
+	TRAP_IGNORE(apparcServer.CommitNonNativeApplicationsUpdatesL());
+	TRAP_IGNORE(apparcServer.DeregisterNonNativeApplicationTypeL(TUid::Uid(KNonNativeApplicationType)));
+	}
+
+void CTRuleBasedLaunchingStep::TestLaunchNonNativeApplicationForRuleBasedL(RApaLsSession& aApparcServer)
+	{
+	INFO_PRINTF1(_L("TestLaunchNonNativeApplicationForRuleBasedL..."));
+
+	// make sure we're starting from a clean sheet
+	aApparcServer.PrepareNonNativeApplicationsUpdatesL();
+	aApparcServer.DeregisterNonNativeApplicationL(TUid::Uid(KNonNativeApplication));
+	aApparcServer.CommitNonNativeApplicationsUpdatesL();
+	aApparcServer.DeregisterNonNativeApplicationTypeL(TUid::Uid(KNonNativeApplicationType));
+	CleanupStack::PushL(TCleanupItem(DeregisterNonNativeForRuleBased, &aApparcServer));
+
+	aApparcServer.RegisterNonNativeApplicationTypeL(TUid::Uid(KNonNativeApplicationType), KLitNativeExecutable);
+
+	CApaRegistrationResourceFileWriter* const registrationResourceFileWriter = CApaRegistrationResourceFileWriter::NewL(TUid::Uid(KNonNativeApplication), KLitLogicalExecutableA, TApaAppCapability::ENonNative);
+	CleanupStack::PushL(registrationResourceFileWriter);
+	registrationResourceFileWriter->AddDataTypeL(KDataTypePriorityNormal, KLitMimeTypeA);
+
+	CApaCommandLine* const commandLineForNonNativeApp = CApaCommandLine::NewLC();
+	commandLineForNonNativeApp->SetExecutableNameL(KLitLogicalExecutableA);
+
+	INFO_PRINTF1(_L("..registering app using RegisterNonNativeApplicationL() "));
+	aApparcServer.PrepareNonNativeApplicationsUpdatesL();
+	aApparcServer.RegisterNonNativeApplicationL(TUid::Uid(KNonNativeApplicationType), EDriveC, *registrationResourceFileWriter, NULL, NULL);
+	aApparcServer.CommitNonNativeApplicationsUpdatesL();
+
+	// Since NonNative application will be launched inspite of Rule saying it should not be launched 
+	INFO_PRINTF1(_L("Testing launching of a NonNativeApp..."));
+	TEST(aApparcServer.StartApp(*commandLineForNonNativeApp) == KErrCancel);
+
+	INFO_PRINTF1(_L("..deregistering app using DeregisterNonNativeApplicationL() "));
+	aApparcServer.PrepareNonNativeApplicationsUpdatesL();
+	aApparcServer.DeregisterNonNativeApplicationL(TUid::Uid(KNonNativeApplication));
+	aApparcServer.CommitNonNativeApplicationsUpdatesL();
+
+ 	// clean-up
+	CleanupStack::PopAndDestroy(3); 
+	}
+
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0023  
+@SYMPREQ 			PREQ1122   
+@SYMTestCaseDesc 	Rule Based Launching of Applications     
+@SYMTestPriority 	High   
+@SYMTestStatus 		Implemented   
+
+@SYMTestActions 		The test utilises 4 test applications that simply display the appication name.
+   			Each application is launched and closed in sequence.
+
+@SYMTestExpectedResults The test verifies that each application can be opened and closed normally.
+*/
+void CTRuleBasedLaunchingStep::LaunchAppTests1L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 1 started"));
+	
+	// App1 is launched and closed
+	TEST(AppLaunchedL(aLs, KUidApp1) == KErrNone);
+	TEST(AppClosed(KUidApp1) == KErrNone);
+
+	// App2 is launched and closed
+	TEST(AppLaunchedL(aLs, KUidApp2) == KErrNone);
+	TEST(AppClosed(KUidApp2) == KErrNone);
+
+	// App3 is launched and closed
+	TEST(AppLaunchedL(aLs, KUidApp3) == KErrNone);
+	TEST(AppClosed(KUidApp3) == KErrNone);
+
+	// App4 is launched and closed
+	TEST(AppLaunchedL(aLs, KUidApp4) == KErrNone);
+	TEST(AppClosed(KUidApp4) == KErrNone);
+	
+	// Close all apps
+	ClosedAllTestApp();
+	
+	INFO_PRINTF1(_L("Test case 1 finished"));
+	}
+	
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0024  
+@SYMPREQ 			PREQ1122   
+@SYMTestCaseDesc 	Rule Based Launching of Applications     
+@SYMTestPriority 	High   
+@SYMTestStatus 		Implemented
+
+@SYMTestActions 	The test utilises 3 test applications that simply display the appication name.
+   			The test utilises a single plugin that implements 2 rules.
+   			Only the first rule is executed(Launching App3 closes App1).
+
+@SYMTestExpectedResults The test verifies that that when an application is launched, 
+					  the rule based mechanism is invoked and only the corresponding rule executed.
+ 					      
+*/	
+void CTRuleBasedLaunchingStep::LaunchAppTests2L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 2 started"));
+
+	TEST(AppLaunchedL(aLs, KUidApp1) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp2) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp3) == KErrNone);
+
+	TApaTaskList taskList(iWs);
+
+	//Wait 2sec for App1 to be closed
+	User::After(2 * 1000000);
+
+	// App1 should be closed when App3 is launched
+	const TApaTask task1 = taskList.FindApp(KUidApp1);
+	TEST(!task1.Exists());
+	const TApaTask task2 = taskList.FindApp(KUidApp2);
+	TEST(task2.Exists());
+	const TApaTask task3 = taskList.FindApp(KUidApp3);
+	TEST(task3.Exists());
+	
+	// Close all apps
+	ClosedAllTestApp();
+	
+	INFO_PRINTF1(_L("Test case 2 finished"));
+	}
+	
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0025
+@SYMPREQ 			PREQ1122 
+@SYMTestCaseDesc 	Rule Based Launching of Applications  
+@SYMTestPriority 	High 
+@SYMTestStatus 		Implemented
+
+@SYMTestActions 	The test utilises 2 test applications that simply display the appication name.
+   			Only the first rule is executed(A running App3 prevents App1 launching).
+   			Only the second rule is executed(App1 cannot launch if App3 is running).
+
+@SYMTestExpectedResults The test verifies that multiple rules can be implemented in a single plugin and 
+                      only the correct rule is executed.
+ 					      	
+*/		
+void CTRuleBasedLaunchingStep::LaunchAppTests3L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 3 started"));
+	
+	// App1 cannot be launched if App3 is running	
+	TEST(AppLaunchedL(aLs, KUidApp2) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp3) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp1) == KErrCancel);
+
+	TApaTaskList taskList(iWs);
+
+	const TApaTask task1 = taskList.FindApp(KUidApp1);
+	TEST(!task1.Exists());
+	const TApaTask task2 = taskList.FindApp(KUidApp2);
+	TEST(task2.Exists());
+	const TApaTask task3 = taskList.FindApp(KUidApp3);
+	TEST(task3.Exists());
+
+	// Close all apps
+	ClosedAllTestApp();
+	
+	INFO_PRINTF1(_L("Test case 3 finished"));
+	}
+	
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0026
+@SYMPREQ 			PREQ1122 
+@SYMTestCaseDesc 	Rule Based Launching of Applications  
+@SYMTestPriority 	High 
+@SYMTestStatus 		Implemented
+
+@SYMTestActions 	The test utilises 3 test applications that simply display the appication name.
+   			The test utilises 2 plugins.
+   			Rules from both plugins are executed.
+   			Plugin1 (Launching App4 closes App2)
+   			Plugin2 (Launching App4 closes App3)
+   				
+@SYMTestExpectedResults The test verifies that multiple rules can be implemented in multiple plugins and 
+                      only the correct rules are executed.
+*/		
+void CTRuleBasedLaunchingStep::LaunchAppTests4L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 4 started"));
+	
+	// App2 and App3 are closed if App4 is launched
+	TEST(AppLaunchedL(aLs, KUidApp3) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp2) == KErrNone);
+	TEST(AppLaunchedL(aLs, KUidApp4) == KErrNone);
+	
+	TApaTaskList taskList(iWs);
+	
+	//Wait 2sec for App2 and App3 to be closed 
+	User::After(2 * 1000000);
+
+	const TApaTask task2 = taskList.FindApp(KUidApp2);
+	TEST(!task2.Exists());
+	const TApaTask task3 = taskList.FindApp(KUidApp3);
+	TEST(!task3.Exists());
+	const TApaTask task4 = taskList.FindApp(KUidApp4);
+	TEST(task4.Exists());
+	
+	// Close all apps
+	ClosedAllTestApp();
+	
+	INFO_PRINTF1(_L("Test case 4 finished"));	
+	}
+
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0027
+@SYMPREQ 			PREQ1122 
+@SYMTestCaseDesc 	Rule Based Launching of Applications  
+@SYMTestPriority 	High 
+@SYMTestStatus 		Implemented
+
+@SYMTestActions 	The test cases is similar to APPFWK-APPARC-0025 but it launching applications 
+					via associated documents.
+
+@SYMTestExpectedResults The test verifies that multiple rules can be implemented in a single plugin and 
+                      only the correct rule is executed.
+ 					      	
+*/		
+void CTRuleBasedLaunchingStep::LaunchAppTests5L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 5 started"));
+	
+	// App1 cannot be launched if App3 is running
+	TEST(LaunchAppFromAssociatedDocument(aLs, KUidApp2) == KErrNone);
+	TEST(LaunchAppFromAssociatedDocument(aLs, KUidApp3) == KErrNone);
+	// Wait 2sec for App2 and App3 to be closed
+	User::After(2 * 1000000);
+	TEST(LaunchAppFromAssociatedDocument(aLs, KUidApp1) == KErrCancel);
+		
+	TApaTaskList taskList(iWs);
+	
+	const TApaTask task1 = taskList.FindApp(KUidApp1);
+	TEST(!task1.Exists());
+	const TApaTask task2 = taskList.FindApp(KUidApp2);
+	TEST(task2.Exists());
+	const TApaTask task3 = taskList.FindApp(KUidApp3);
+	TEST(task3.Exists());
+	
+	// Close all apps
+	ClosedAllTestApp();
+	
+	INFO_PRINTF1(_L("Test case 5 finished"));
+	}
+
+/**
+@SYMTestCaseID 		APPFWK-APPARC-0028
+@SYMPREQ 			PREQ1122 
+@SYMTestCaseDesc 	Rule Based Launching of Applications  
+@SYMTestPriority 	High 
+@SYMTestStatus 		Implemented
+
+@SYMTestActions 	The test case launches an applications where file name defined whether without extension or 
+					disk drive, or as non system path.
+
+@SYMTestExpectedResults Rule based framework has to process this name correctly and apply pre-defined rules.
+ 					      	
+*/		
+void CTRuleBasedLaunchingStep::LaunchAppTests6L(RApaLsSession& aLs)
+	{
+	INFO_PRINTF1(_L("Test case 6 started"));
+	
+	TPtrC arFileName[] =  {	_L("tRuleBasedApp1.exe"),
+							_L("\\sys\\bin\\tRuleBasedApp1.exe"),
+							_L("\\nonsys\\bin\\tRuleBasedApp1.exe"),
+							_L("\\sys\\bin\\tRuleBasedApp1"),
+							_L("tRuleBasedApp1"),
+						  };
+	TInt sizeOfFileNameArray = sizeof(arFileName) / sizeof(arFileName[0]);
+	
+	for(TInt ii = 0; ii < sizeOfFileNameArray; ii++)
+		{
+		TEST(LaunchAppFromAssociatedDocument(aLs, KUidApp3) == KErrNone);
+		TEST(AppLaunchedL(aLs, arFileName[ii]) == KErrCancel);
+
+		TApaTaskList taskList(iWs);
+
+		const TApaTask task1 = taskList.FindApp(KUidApp1);
+		TEST(!task1.Exists());
+		const TApaTask task3 = taskList.FindApp(KUidApp3);
+		TEST(task3.Exists());
+		if(task1.Exists() || !task3.Exists())
+			{	
+			INFO_PRINTF2(_L("The name %S is not recognized by rule based plug-ins as a valid"), &arFileName[ii]);
+			}
+		
+		// Close all apps
+		ClosedAllTestApp();
+		}
+		
+	INFO_PRINTF1(_L("Test case 6 finished"));
+	}
+	
+/**
+The function is used to launch an app whose UID is supplied as its second input parameter.
+The function returns KErrNone upon success, KErrGeneral otherwise.
+*/
+TInt CTRuleBasedLaunchingStep::AppLaunchedL(RApaLsSession& aLs, const TUid& aAppUid)
+	{	
+	TApaAppInfo info; 
+	TFileName fileName;
+	aLs.GetAppInfo(info,aAppUid);
+	//Wait 0.5sec for function to complete
+	User::After(500000);
+	fileName = info.iFullName; 
+	CApaCommandLine* cmdLn = CApaCommandLine::NewLC();     
+	cmdLn->SetExecutableNameL(fileName);
+	TInt result = aLs.StartApp(*cmdLn);
+	//Wait 0.5sec for App to start
+	User::After(500000);
+	CleanupStack::PopAndDestroy(cmdLn);
+	return result;
+	}
+
+/**
+The function is used to launch an application using full file name as param.
+*/
+TInt CTRuleBasedLaunchingStep::AppLaunchedL(RApaLsSession& aLs, const TDesC& aAppFullFileName)
+	{	
+	CApaCommandLine* cmdLn = CApaCommandLine::NewLC();     
+	cmdLn->SetExecutableNameL(aAppFullFileName);
+	TInt result = aLs.StartApp(*cmdLn);
+	//Wait 0.5sec for App to start
+	User::After(500000);
+	CleanupStack::PopAndDestroy(cmdLn);
+	return result;
+	}
+
+/**
+The function is used to launch an application via dummy document associated with this application.
+*/
+TInt CTRuleBasedLaunchingStep::LaunchAppFromAssociatedDocument(RApaLsSession& aLs,const TUid& aAppUid)
+	{	
+	TDataType theDataType(aAppUid); 
+	TThreadId theThreadId;
+	TInt result = aLs.StartDocument(KNullDesC, theDataType, theThreadId);
+	//Wait 2sec for App to start
+	User::After(2 * 1000000);
+	return result;
+	}
+
+/**
+The function is used to close an app whose UID is supplied as the input parameter.
+The function returns KerrNone upon success, KErrGeneral othewise.
+*/
+TInt CTRuleBasedLaunchingStep::AppClosed(TUid AppUid)
+	{
+	TInt result = KErrNone;
+	TApaTaskList taskList(iWs);
+	TApaTask task1 = taskList.FindApp(AppUid);
+	if(task1.Exists())
+		{
+		task1.EndTask();
+		//Wait 0.5sec for the App to close
+		User::After(500000);
+
+		const TApaTask task2 = taskList.FindApp(AppUid);
+		if (task2.Exists())
+			{
+			result = KErrGeneral;
+			}
+		}
+	return result;
+	}
+
+/** The function close all test applications */ 
+void CTRuleBasedLaunchingStep::ClosedAllTestApp()
+	{
+	AppClosed(KUidApp1);
+	AppClosed(KUidApp2);
+	AppClosed(KUidApp3);
+	AppClosed(KUidApp4);
+	}
+
+TVerdict CTRuleBasedLaunchingStep::doTestStepL()
+	{
+	INFO_PRINTF1(_L("TRuleBasedLaunchingStep test started...."));
+	
+	User::LeaveIfError(FbsStartup());
+	TInt ret=RFbsSession::Connect();
+
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iWs.Connect());
+	
+	TEST(ret==KErrNone);
+	__UHEAP_MARK;			
+	TRAPD(err, ExecuteL()); 	
+	TEST(err == KErrNone);
+	INFO_PRINTF2(_L("execute tests ended with return value '%d'"), err);
+	__UHEAP_MARKEND; 			
+	
+	RFbsSession::Disconnect();
+	INFO_PRINTF1(_L(".... TRuleBasedLaunchingStep test finished!!"));
+	return TestStepResult();
+	}