--- /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();
+ }