diff -r e8c1ea2c6496 -r 8758140453c0 localisation/apparchitecture/tef/T_Serv2Step.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/localisation/apparchitecture/tef/T_Serv2Step.CPP Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,1828 @@ +// Copyright (c) 2007-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: +// Test wrapper to Application Architecture Server. +// Tests Application information, Data recognition and application +// launching capabilities of the application architecture server.\n +// +// + + + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include +#include +#include +#include +#include +#include "testableapalssession.h" +#include +#include +#include +#include +#include +#include +#include "tstapp.h" +// +#include +#include "T_Serv2Step.h" + +#include +#include +#include "TAppEmbedUids.h" +#include "appfwk_test_utils.h" + +// Constants +const TInt KOneSecondDelay = 1000000; + + +/** + This function accepts a filename with full path and searches all available + drives for the presence of file. + The method returns Filename if a match is found. +*/ +TFileName CT_Serv2Step::SearchAndReturnCompleteFileName(const TDesC& aFileName) + { + RFs fs; + TInt ret = fs.Connect(); + TEST(ret==KErrNone); + + TParsePtrC parse(aFileName); + TFindFile findFile(fs); + ret = findFile.FindByDir(parse.NameAndExt(), parse.Path()); + if (ret!=KErrNone) + { + TBuf<64> buffer; + buffer.Format(_L("Error while finding the file, %d"), ret); + } + fs.Close(); + return findFile.File(); + } + + +/** + @SYMTestCaseID T-Serv2Step-AppInfoTest1 + + @SYMPREQ + + @SYMTestCaseDesc Test RApaLsSession::GetNextApp() + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Call RApaLsSession::GetAllApps() to initialize the process of + getting all applications in the cached list. Traverse the application list + by calling RApaLsSession::GetNextApp() to search for application tstapp. + Test the application info obtained from GetNextApp() to ensure the application + info obtained is of tstapp. Complete traversal of the list to ensure that at + the end of the list, the enum ENoMoreAppInList is returned by GetNextApp().\n + API Calls:\n + RApaLsSession::GetAllApps() const\n + RApaLsSession::GetNextApp(TApaAppInfo& aInfo) const\n + + @SYMTestExpectedResults The test compares the results obtained with expected values. + + */ +void CT_Serv2Step::AppInfoTest1(RApaLsSession& aLs) + { + _LIT(KLitAppPath,"z:\\sys\\bin\\tstapp.exe"); + TFullName appPath(KLitAppPath); + //Search for TestApp + TApaAppInfo info; + TInt ret = aLs.GetAllApps(); + TEST(ret==KErrNone); + + do + { + ret=aLs.GetNextApp(info); + } + while (ret==KErrNone && info.iUid!=KUidTestApp); + + TEST(ret==KErrNone); + info.iFullName.LowerCase(); + TEST(info.iFullName.Compare(appPath) == 0); + + //Make sure ENoMoreAppsInList is returned at the end of list. + do + { + ret=aLs.GetNextApp(info); + } + while (ret != RApaLsSession::ENoMoreAppsInList); + + ret=aLs.GetNextApp(info); + TEST(ret==RApaLsSession::ENoMoreAppsInList); + } + + +/** + @SYMTestCaseID T-Serv2Step-DoCheckServerIconLoadingBySizeL + + @SYMPREQ + + @SYMTestCaseDesc Test loading of Icon by size. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Allocate a flat dynamic buffer which would hold available icon + sizes for tstapp. Call RApaLsSession::GetAppIconSizes() to store the sizes + of icons available for the app tstapp to the allocated flat dynamic buffer. + Call RApaLsSession::GetAppIcon() by passing each of the icon sizes stored. + Verify whether icon is retrieved each time by GetAppIcon(). + Test calling RApaLsSession::GetAppIcon() by specifying reduced size than + the actual icon size. Since no match would be found, KErrNotFound should be + returned. Test GetAppIcon() again by specifying an increased size than the + actual icon size. Observe whether the GetAppIcon() in this case gets the + closest icon available.\n + API Calls:\n + RApaLsSession::GetAppIcon(TUid aAppUid, TSize aSize, CApaMaskedBitmap& aAppBitmap) const\n + + @SYMTestExpectedResults The results obtained are compared with the expected values to verify + functionality of RApaLsSession::GetAppIcon(). + + */ +void CT_Serv2Step::DoCheckServerIconLoadingBySizeL(RApaLsSession& aLs) + { + CArrayFixFlat* array=new(ELeave) CArrayFixFlat(3); + CleanupStack::PushL(array); + TInt ret=KErrNone; + ret=aLs.GetAppIconSizes(KUidTestApp,*array); + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNone); + TEST(array->Count()); + for(TInt i=0;iCount();i++) + { + CApaMaskedBitmap* iconBySize=CApaMaskedBitmap::NewLC(); + ret=aLs.GetAppIcon(KUidTestApp,(*array)[i],*iconBySize); //by Size + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNone); + TEST(iconBySize->SizeInPixels()==(*array)[i]); + CleanupStack::PopAndDestroy(); //iconBySize + } + + // now try non exact sizes + CApaMaskedBitmap* iconBySize=CApaMaskedBitmap::NewLC(); + ret=aLs.GetAppIcon(KUidTestApp,((*array)[0])+TSize(-5,-5),*iconBySize); //by Size + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNotFound); + CleanupStack::PopAndDestroy(); //iconBySize + + for(TInt ii=0;iiCount();ii++) + { + CApaMaskedBitmap* iconBySize=CApaMaskedBitmap::NewLC(); + ret=aLs.GetAppIcon(KUidTestApp,((*array)[ii])+TSize(5,5),*iconBySize); //by Size + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNone); + TEST(iconBySize->SizeInPixels()==(*array)[ii]); // should get size below always!!! + CleanupStack::PopAndDestroy(); //iconBySize + } + CleanupStack::PopAndDestroy(); //array + } + + +/** + @SYMTestCaseID T-Serv2Step-AppInfoTest3 + + @SYMPREQ + + @SYMTestCaseDesc Test RApaLsSession::GetNextApp() + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Call RApaLsSession::GetAllApps() to initialize the process of + getting all applications in the cached list. Traverse the application list + by calling RApaLsSession::GetNextApp() to search for application tstapp. + Test the application information obtained from GetNextApp() to ensure that + information retrieved is of tstapp.\n + API Calls:\n + RApaLsSession::GetAllApps() const\n + RApaLsSession::GetNextApp(TApaAppInfo& aInfo) const\n + + @SYMTestExpectedResults The test compares the results obtained with expected values. + + */ +void CT_Serv2Step::AppInfoTest3(RApaLsSession& aLs) + { + _LIT(KLitAppPath,"z:\\sys\\bin\\tstapp.exe"); + TFullName appPath(KLitAppPath); + // get the first app... + TApaAppInfo info; + TInt ret = aLs.GetAllApps(); + TEST(ret==KErrNone); + + do + { + aLs.GetNextApp(info); + } + while (info.iUid!=KUidTestApp); + + TEST(ret==KErrNone); + TEST(info.iUid==KUidTestApp); + info.iFullName.LowerCase(); + TEST(info.iFullName.Compare(appPath) == 0); + } + + +/** + @SYMTestCaseID T-Serv2Step-AppInfoTest4 + + @SYMPREQ + + @SYMTestCaseDesc Test RApaLsSession::GetAppInfo(). + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Call RApaLsSession::GetAppInfo() by passing the Uid of test + application tstapp and test the application info obtained from GetAppInfo() + to ensure the obtained information is of test application tstapp.\n + API Calls:\n + RApaLsSession::GetAppInfo(TApaAppInfo& aInfo,TUid aAppUid) const\n + + @SYMTestExpectedResults The test confirms that RApaLsSession::GetAppInfo() + returns the expected application info. + + */ +void CT_Serv2Step::AppInfoTest4(RApaLsSession& aLs) + { + _LIT(KLitAppPath,"z:\\sys\\bin\\tstapp.exe"); + TFullName appPath(KLitAppPath); + // Get info for an app that exists + TApaAppInfo info; + TInt ret = aLs.GetAppInfo(info,KUidTestApp); + TEST(ret==KErrNone); + TEST(info.iUid==KUidTestApp); + info.iFullName.LowerCase(); + TEST(info.iFullName.Compare(appPath) == 0); + } + + +/** + @SYMTestCaseID T-Serv2Step-AppInfoTest5 + + @SYMPREQ + + @SYMTestCaseDesc Test if RApaLsSession::GetAppInfo() return KErrNotFound. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RApaLsSession::GetAppInfo() by passing the null Uid + KNullUid. Observe whether KErrNotFound is returned when Uid that doesn't match + is passed to GetAppInfo().\n + API Calls:\n + RApaLsSession::GetAppInfo(TApaAppInfo& aInfo,TUid aAppUid) const\n + + @SYMTestExpectedResults The test confirms RApaLsSession::GetAppInfo() returns + KErrNotFound when no match is found for the Uid passed.\n + + */ +void CT_Serv2Step::AppInfoTest5(RApaLsSession& aLs) + { + // get info for a non-existant app + TApaAppInfo info; + TInt ret = aLs.GetAppInfo(info,KNullUid); + TEST(ret==KErrNotFound); + } + + +/** + Auxiliary Fn for Test Case ID T-Serv2Step-AppInfoTest1, T-Serv2Step-AppInfoTest3, T-Serv2Step-AppInfoTest4, T-Serv2Step-AppInfoTest5 + + This function initiates test for retrieving Application Information. + +*/ +void CT_Serv2Step::DoAppInfoTests(RApaLsSession& aLs) + { + AppInfoTest1(aLs); + AppInfoTest3(aLs); + AppInfoTest4(aLs); + AppInfoTest5(aLs); + } + + +/** + @SYMTestCaseID T-Serv2Step-StartAppTests1L + + @SYMPREQ + + @SYMTestCaseDesc Test Launching of an application. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Prepare command line information to start an application using + CApaCommandLine Apis.Call RApaLsSession::StartApp() to start an + application defined by the command line information.\n + Test the launching of application for following scenarios:\n + (1) When Application specified by command line exists.\n + (2) When Application specified by command line does not exist.\n + API Calls:\n + RApaLsSession::StartApp(const CApaCommandLine& aCommandLine)\n + + @SYMTestExpectedResults The test observes that StartApp() returns KErrNone and + starts the app in the first scenario. In the second case KErrNotFound is + returned. + + */ +void CT_Serv2Step::StartAppTests1L(RApaLsSession& aLs) +{ + CApaCommandLine* cmdLn=CApaCommandLine::NewLC(); + TFileName filename; + _LIT(KLitExePath,"\\sys\\bin\\texe.exe"); + TFullName exePath(KLitExePath); + filename = SearchAndReturnCompleteFileName(exePath); + + _LIT8(KLitDogfish,"dogfish"); + _LIT(KLitWibble,"wibble"); + cmdLn->SetExecutableNameL(filename); + cmdLn->SetTailEndL(KLitDogfish); + TInt ret = aLs.StartApp(*cmdLn); // explicit + TEST(ret==KErrNone); + + // start a non-existant app + cmdLn->SetExecutableNameL(KLitWibble); + ret = aLs.StartApp(*cmdLn); + TEST(ret==KErrNotFound); + // + // + CleanupStack::PopAndDestroy(); // cmdLn + +} + +/** + * @SYMTestCaseID T_Serv2Step_StartAppTests4L + * + * @SYMPREQ + * + * @SYMTestCaseDesc Test Launching of an application. + * + * @SYMTestActions Call RApaLsSession::StartDocument() to start an + * application defined by the command line information.\n + * Test the launching of application for following scenarios:\n + * (1) When Application specified by command line is EmbeddableOnly.\n + * (2) When Application specified by command line is EmbeddableUiNotStandAlone.\n + * (3) When Application specified by command line is Embeddable or StandAlone.\n + * API Calls:\n + * RApaLsSession::StartDocument(const TDesC &aFileName, TUid aAppUid, TThreadId &aId, TLaunchType aLaunchType=ELaunchNewApp)\n + * + * @SYMTestExpectedResults The test observes that StartDocument() returns KErrNone and + * starts the app in the third scenario. In the first and second case KErrNotSupported is + * returned. + * + */ + +void CT_Serv2Step::StartAppTests4L(RApaLsSession& aLs) + { + TInt ret; + TThreadId id; + + _LIT(KLitSdkDocPath,"\\system\\data\\sdk.txt"); + TFileName filename = SearchAndReturnCompleteFileName(KLitSdkDocPath); + + // Test starting a file using an app which can be embeddable only. + ret=aLs.StartDocument(filename,KUidAppEmbeddableUiNotStandAlone,id); + TEST(ret==KErrNotSupported); + + // Test starting a file using an app which can be embeddable only. + ret=aLs.StartDocument(filename,KUidAppEmbeddableOnly,id); + TEST(ret==KErrNotSupported); + + // Test starting a file using an app which can be embeddable or standalone. + ret=aLs.StartDocument(filename,KUidAppEmbeddable,id); + TEST(ret==KErrNone); + } + +/** +* Auxiliary Fn for Test Case ID T_Serv2Step_StartAppTests1L, T_Serv2Step_StartAppTests3L,StartAppTests4L(aLs) +* +* This method tests launching of an application from command line by calling +* CT_Serv2Step::StartAppTests1L(). +* +*/ +void CT_Serv2Step::DoStartAppTestsL(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("Checking application launching")); + + // start the test exe + StartAppTests1L(aLs); + StartAppTests4L(aLs); + } + +/** + @SYMTestCaseID T-Serv2Step-DoEnquiryTestsL + + @SYMPREQ + + @SYMTestCaseDesc Tests querying of data (MIME) type information. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test setting and getting the confidence threshold for + successful data recognition by calling RApaLsSession::SetAcceptedConfidence() + and RApaLsSession::GetAcceptedConfidence().\n + Test setting and getting maximum size of the data that can be read + from a file for the purpose of recognizing the data type by calling + RApaLsSession::SetMaxDataBufSize() and RApaLsSession::GetMaxDataBufSize(). + Finally test retrieval of all supported data (MIME) types.\n + API Calls:\n + RApaLsSession::SetAcceptedConfidence(TInt aConfidence)\n + RApaLsSession::GetAcceptedConfidence(TInt& aConfidence) const\n + RApaLsSession::SetMaxDataBufSize(TInt aBufSize)\n + RApaLsSession::GetMaxDataBufSize(TInt& aBufSize) const\n + RApaLsSession::GetSupportedDataTypesL(CDataTypeArray& aDataTypes) const\n + + @SYMTestExpectedResults Test results against expected values. + + */ +void CT_Serv2Step::DoEnquiryTestsL(RApaLsSession& aLs) + { + TInt temp=1234; + TInt ret; + TSecurityInfo info; + info.Set(RProcess()); + + TBool hasCapability=info.iCaps.HasCapability(ECapabilityWriteDeviceData); + + if(hasCapability) + { + ret=aLs.SetAcceptedConfidence(temp); + INFO_PRINTF2(_L(" Error= %d \n"),ret); + TEST(ret==KErrNone); + } + else + { + ret=aLs.SetAcceptedConfidence(temp); + INFO_PRINTF2(_L(" Error= %d \n"),ret); + TEST(ret==KErrPermissionDenied); + } + temp=0; + ret=aLs.GetAcceptedConfidence(temp); + TEST(ret==KErrNone); + TEST(temp==1234); + ret=aLs.SetMaxDataBufSize(temp); + TEST(ret==KErrNone); + temp=0; + ret=aLs.GetMaxDataBufSize(temp); + CDataTypeArray* dataTypes=new(ELeave) CDataTypeArray(5); + CleanupStack::PushL(dataTypes); + TInt err=0; + TInt failRate=0; + for (failRate=1;failRate<=KMaxTInt;failRate++) + { + __UHEAP_RESET; + __UHEAP_SETFAIL(RHeap::EFailNext,failRate); + TRAP(err, ret=aLs.GetSupportedDataTypesL(*dataTypes)); + if (err!=KErrNoMemory) + { + if (err==KErrNone) + { + err=ret; + } + break; + } + } + __UHEAP_RESET; + TEST(ret==KErrNone); + TEST(err==KErrNone); + TEST(dataTypes->Count()>=4); + CleanupStack::PopAndDestroy(); // dataTypes + } + +/** + @SYMTestCaseID T-Serv2-DoGetAllApps + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Check that RApaLsSession::GetAllApps() hasn't been + affected by the new code to filter the app list + based on embeddability (implemented for CR PHAR-5Q4FX8) + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetAllApps() once, followed by repeated calls + to GetNextApp until something other than KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should return app info for the following test apps: + TAppNotEmbeddable.app + TAppEmbeddable.app + TAppEmbeddableOnly.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetAllApps(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetAllApps")); + + TInt ret = aLs.GetAllApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppNotEmbeddable) + bitFlags |= 0x01; + else if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableOnly) + bitFlags |= 0x04; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + else if (appInfo.iUid == KUidAppEmbeddableUiNotStandAlone) + bitFlags |= 0x10; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x1F); + } + + +/* + @SYMTestCaseID T-Serv2-LaunchAppThruCreateDocL + + @SYMTestCaseDesc + Check for the functionality of RApaLsSession::CreateDocument(). + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call CreateDocument(const TDesC& aFileName, TUid aAppUid, TThreadId& aThreadId) + + @SYMTestExpectedResults + Verify whether the Application is launched and Document is created for the respective + Application UID passed. +*/ + +void CT_Serv2Step::LaunchAppThruCreateDocL(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("LaunchAppThruCreateDocL")); + _LIT(KFileName, "c:\\nofile.txt"); + TThreadId startAppThreadID; + TInt errCreate=aLs.CreateDocument(KFileName,KUidAppEmbeddable,startAppThreadID); + TEST(errCreate == KErrNone); + + //we need to close the started thread, if appropiate + if (errCreate==KErrNone) + { + RThread thread; + User::LeaveIfError(thread.Open(startAppThreadID)); + CleanupClosePushL(thread); + + RProcess process; + User::LeaveIfError(thread.Process(process)); + CleanupClosePushL(process); + + process.Kill(0); + + CleanupStack::PopAndDestroy(&process); + CleanupStack::PopAndDestroy(&thread); + } + + } + +/** + @SYMTestCaseID T-Serv2-DoGetEmbeddableApps + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Check that RApaLsSession::GetEmbeddableApps() hasn't been + affected by the new code to filter the app list + based on embeddability (implemented for CR PHAR-5Q4FX8) + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetEmbeddableApps() once, followed by repeated calls + to GetNextApp until something other than KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should return app info for the following test apps: + TAppEmbeddable.app + TAppEmbeddableOnly.app + and should not return app info for: + TAppNotEmbeddable.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetEmbeddableApps(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetEmbeddableApps")); + + TInt ret = aLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppNotEmbeddable) + bitFlags |= 0x01; + else if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableOnly) + bitFlags |= 0x04; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + else if (appInfo.iUid == KUidAppEmbeddableUiNotStandAlone) + bitFlags |= 0x10; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x06); + } + +/** + @SYMTestCaseID T-Serv2-DoEmbeddableAppCount + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + The number of apps returned by GetEmbeddableApps should be the + same as EmbeddableAppCount returns. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Count the number of apps returned by calling GetEmbeddableApps + followed by repeated calls to GetNextApp. + Count the number of apps returned by EmbeddableAppCount. + + @SYMTestExpectedResults + The counts should be equal. + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoEmbeddableAppCount(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoEmbeddableAppCount")); + + TInt ret = aLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TInt count1 = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + count1 ++; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + TInt count2 = 0; + ret = aLs.EmbeddableAppCount(count2); + TEST(ret==KErrNone); + + TEST(count1 == count2); + } + +/** + @SYMTestCaseID T-Serv2-DoGetAppCapability + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Confirm that the application embeddability value that a specific app + defines in it's AIF file, matches the value returned by + RApaLsSession::GetAppCapability. + Check that this is true for all supported embeddability values + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetAppCapability for each of the following test apps: + TAppNotEmbeddable.app + TAppEmbeddable.app + TAppEmbeddableOnly.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + + @SYMTestExpectedResults + For each app, GetAppCapability should return the embeddability value + defined in the application's AIF file. + + */ +void CT_Serv2Step::DoGetAppCapability(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetAppCapability")); + + TApaAppCapabilityBuf capabilityBuf; + TInt ret; + const TInt numberOfCapabilities = 5; + TUid uidArray[numberOfCapabilities]; + uidArray[0] = KUidAppNotEmbeddable; + uidArray[1] = KUidAppEmbeddable; + uidArray[2] = KUidAppEmbeddableOnly; + uidArray[3] = KUidAppEmbeddableUiOrStandAlone; + uidArray[4] = KUidAppEmbeddableUiNotStandAlone; + + const TApaAppCapability::TEmbeddability embeddabilityArray[numberOfCapabilities] + = { TApaAppCapability::ENotEmbeddable, + TApaAppCapability::EEmbeddable, + TApaAppCapability::EEmbeddableOnly, + TApaAppCapability::EEmbeddableUiOrStandAlone, + TApaAppCapability::EEmbeddableUiNotStandAlone }; + + for (TInt ii = 0; ii < numberOfCapabilities; ii++) + { + ret = aLs.GetAppCapability(capabilityBuf, uidArray[ii]); + TEST(ret==KErrNone); + TEST(capabilityBuf().iEmbeddability == embeddabilityArray[ii]); + } + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps1 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Passing an empty filter to RApaLsSession::GetFilteredApps + should cause no apps to be returned by subsequent calls + to RApaLsSession::GetNextApp + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a default constructed filter, + followed by a single call to GetNextApp + + @SYMTestExpectedResults + GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps1(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps1")); + + TApaEmbeddabilityFilter filter; + TInt ret = aLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TEST(aLs.GetNextApp(appInfo) == RApaLsSession::ENoMoreAppsInList); + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps2 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Passing a filter specifying only ENotEmbeddable + to RApaLsSession::GetFilteredApps should cause subsequent + calls to RApaLsSession::GetNextApp to return only + applications which cannot be embedded + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a filter containing ENotEmbeddable, + followed by repeated calls to GetNextApp until something other than + KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should return app info for only the following test app: + TAppNotEmbeddable.app + and should not return app info for: + TAppEmbeddable.app + TAppEmbeddableOnly.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps2(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps2")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + TInt ret = aLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppNotEmbeddable) + bitFlags |= 0x01; + else if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableOnly) + bitFlags |= 0x04; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + else if (appInfo.iUid == KUidAppEmbeddableUiNotStandAlone) + bitFlags |= 0x10; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x01); + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps3 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + EEmbeddableUiOrStandAlone (value 5) shares a bit flag (bit 1) + with EEmbeddable (value 1). + Confirm that a filter of EEmbeddableUiOrStandAlone only returns + apps that define EEmbeddableUiOrStandAlone + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a filter containing EEmbeddableUiOrStandAlone, + followed by repeated calls to GetNextApp until something other than + KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should return app info for only the following test app: + TAppEmbeddableUiOrStandAlone.app + and should not return app info for: + TAppEmbeddable.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps3(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps3")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + TInt ret = aLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x08); + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps4 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + A filter specifying two embeddability values should + include apps of either embeddability + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a filter containing EEmbeddableUiOrStandAlone + and EEmbeddableUiNotStandAlone followed by repeated calls to GetNextApp + until something other than KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should return app info for only the following test apps: + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + and should not return app info for: + TAppNotEmbeddable.app + TAppEmbeddable.app + TAppEmbeddableOnly.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps4(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps4")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + TInt ret = aLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppNotEmbeddable) + bitFlags |= 0x01; + else if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableOnly) + bitFlags |= 0x04; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + else if (appInfo.iUid == KUidAppEmbeddableUiNotStandAlone) + bitFlags |= 0x10; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x18); + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps5 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Getting apps using a filter specifying all embeddability values + should return the same number of apps as RApaLsSession::GetAllApps() + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a filter containing all embeddability values, + and count the number of calls to GetNextApp until something other than + KErrNone is returned. + Then call GetAllApps and count the number of calls to GetNextApp until + something other than KErrNone is returned. + + @SYMTestExpectedResults + The two counts should be equal. + The last call in each sequence of calls to GetNextApp should return + RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps5(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps5")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableOnly); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + TInt ret = aLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TInt filteredCount = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + filteredCount++; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + ret = aLs.GetAllApps(); + TEST(ret==KErrNone); + + TInt allAppsCount = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + allAppsCount++; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + TEST(filteredCount == allAppsCount); + } + +/** + @SYMTestCaseID T-Serv2-DoGetFilteredApps6 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + None of the following embeddability test apps support + screen mode 1, so none of them should be returned even + if the filter specifies all embeddability types. + TAppNotEmbeddable.app + TAppEmbeddable.app + TAppEmbeddableOnly.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call GetFilteredApps passing a filter containing all embeddability values + and screen mode 1, followed by repeated calls to GetNextApp until something + other than KErrNone is returned + + @SYMTestExpectedResults + GetNextApp should not return app info for any of the following test apps: + TAppNotEmbeddable.app + TAppEmbeddable.app + TAppEmbeddableOnly.app + TAppEmbeddableUiOrStandAlone.app + TAppEmbeddableUiNotStandAlone.app + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_Serv2Step::DoGetFilteredApps6(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("DoGetFilteredApps6")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableOnly); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + const TInt screenMode1 = 1; + TInt ret = aLs.GetFilteredApps(filter, screenMode1); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = aLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppNotEmbeddable) + bitFlags |= 0x01; + else if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableOnly) + bitFlags |= 0x04; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + else if (appInfo.iUid == KUidAppEmbeddableUiNotStandAlone) + bitFlags |= 0x10; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0); + } + +/** + @SYMTestCaseID T-Serv2-DoTestEmbeddabilityFilter1 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Ensure default constructed TApaEmbeddabilityFilter object is + initialized correctly. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Construct a TApaEmbeddabilityFilter object and call + MatchesEmbeddability using each of the following embeddability values: + TApaAppCapability::ENotEmbeddable + TApaAppCapability::EEmbeddable + TApaAppCapability::EEmbeddableOnly + TApaAppCapability::EEmbeddableUiOrStandAlone + TApaAppCapability::EEmbeddableUiNotStandAlone + + @SYMTestExpectedResults + All calls to MatchesEmbeddability should return false. + + */ +void CT_Serv2Step::DoTestEmbeddabilityFilter1() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter1")); + + TApaEmbeddabilityFilter filter; + TEST(!filter.MatchesEmbeddability(TApaAppCapability::ENotEmbeddable)); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddable)); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableOnly)); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone)); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone)); + } + +/** + @SYMTestCaseID T-Serv2-DoTestEmbeddabilityFilter2 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Bit 2 is used by both EEmbeddableUiNotStandAlone and EEmbeddableOnly. + Make sure that setting the filter to only EEmbeddableUiNotStandAlone + doesn't match EEmbeddableOnly. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Construct a TApaEmbeddabilityFilter object, + set the filter to only EEmbeddableUiNotStandAloneand + and call MatchesEmbeddability passing EEmbeddableOnly + + @SYMTestExpectedResults + MatchesEmbeddability should return false. + + */ +void CT_Serv2Step::DoTestEmbeddabilityFilter2() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter2")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableOnly)); + } + +/** + @SYMTestCaseID T-Serv2-DoTestEmbeddabilityFilter3 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Bit 2 is used by both EEmbeddableUiNotStandAlone and EEmbeddableOnly. + Make sure that setting the filter to only EEmbeddableOnly + doesn't match EEmbeddableUiNotStandAlone. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Construct a TApaEmbeddabilityFilter object, + set the filter to only EEmbeddableOnly + and call MatchesEmbeddability passing EEmbeddableUiNotStandAlone + + @SYMTestExpectedResults + MatchesEmbeddability should return false. + + */ +void CT_Serv2Step::DoTestEmbeddabilityFilter3() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter3")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableOnly); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone)); + } + +/** + @SYMTestCaseID T-Serv2-DoTestEmbeddabilityFilter4 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Ensure MatchesEmbeddability returns true when the filter only contains + the embeddability being matched. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Construct a TApaEmbeddabilityFilter object, + set the filter to only EEmbeddable + and call MatchesEmbeddability passing EEmbeddable + + @SYMTestExpectedResults + MatchesEmbeddability should return true. + + */ +void CT_Serv2Step::DoTestEmbeddabilityFilter4() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter4")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + TEST(filter.MatchesEmbeddability(TApaAppCapability::EEmbeddable)); + } + +/** + @SYMTestCaseID T-Serv2-DoTestEmbeddabilityFilter5 + + @SYMPREQ PHAR-5Q4FX8 + + @SYMTestCaseDesc + Ensure MatchesEmbeddability returns true when the filter contains + a superset of the embeddability being matched. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Construct a TApaEmbeddabilityFilter object, + set the filter to both ENotEmbeddable and EEmbeddable + and call MatchesEmbeddability passing EEmbeddable + + @SYMTestExpectedResults + MatchesEmbeddability should return true. + + */ +void CT_Serv2Step::DoTestEmbeddabilityFilter5() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter5")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + TEST(filter.MatchesEmbeddability(TApaAppCapability::EEmbeddable)); + } + + +/** + @SYMTestCaseID T-Serv2Step-DoInterrogationTestsL + + @SYMPREQ + + @SYMTestCaseDesc Test interrogates the Application Architecture Server. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test Application Architecture Server's ability to:\n + (1) Retrieve list of all applications in the cache list by calling + RApaLsSession::GetAllApps().The test also calls RApaLsSession::AppCount() + to retrieve the number of applications in the list.\n + (2) Retrieve list of all embeddable applications from the cache list + by calling RApaLsSession::GetEmbeddableApps().The test also calls + RApaLsSession::EmbeddableAppCount() to retrieve the number of + embeddable applications in the list.\n + (3) Retrieve application information.\n + (4) Retrieve capability of an existing & non-existing application by + calling RApaLsSession::GetAppCapability().\n + (5) Check and retrieve Data (MIME) type information of data taken from a + specified file by calling RApaLsSession::RecognizeSpecificData(). + This is confirmed by taking data from the same file and checking + the data type information by calling RApaLsSession::RecognizeData().\n + (6) Retrieve application icon by calling RApaLsSession::GetAppIcon().\n + API Calls:\n + RApaLsSession::GetAllApps() const\n + RApaLsSession::AppCount(TInt& aCount) const\n + RApaLsSession::EmbeddableAppCount(TInt& aCount) const\n + RApaLsSession::GetEmbeddableApps() const\n + RApaLsSession::GetAppCapability(TDes8& aCapabilityBuf,TUid aAppUid) const\n + RApaLsSession::RecognizeSpecificData(const TDesC& aName, const TDesC8& aBuffer, const TDataType& aDataType, TBool& aResult) const\n + RApaLsSession::RecognizeData(const TDesC& aName, const TDesC8& aBuffer, TDataRecognitionResult& aDataType) const\n + RApaLsSession::GetAppIcon(TUid aAppUid, TInt aSize, CApaMaskedBitmap& aAppBitmap) const\n + + @SYMTestExpectedResults All tests compare the results obtained with the desired result. + + */ +void CT_Serv2Step::DoInterrogationTestsL(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("Interogating the server")); + + TInt ret = aLs.GetAllApps(); // SC - test + TEST(ret==KErrNone); + + // get the full app count + TInt count=0; + ret = aLs.AppCount(count); + TEST(ret==KErrNone); + TEST(count>=1); + + // get the embedded app count + count=0; + ret = aLs.EmbeddableAppCount(count); + TEST(ret==KErrNone); + TEST(count>=1); + + // prepare to get a list of embeddable apps + ret = aLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + DoAppInfoTests(aLs); + + // Get the capability of an app that exists + TApaAppCapabilityBuf buf; + ret = aLs.GetAppCapability(buf, KUidTestApp); + TEST(ret==KErrNone); + TApaAppCapability cap=buf(); + TEST(cap.iEmbeddability==TApaAppCapability::EEmbeddable); + TEST(!cap.iSupportsNewFile); + TEST(!cap.iAppIsHidden); + + // get the capability of a non-existant app + ret = aLs.GetAppCapability(buf, KNullUid); + TEST(ret==KErrNotFound); + + INFO_PRINTF1(_L("Checking data type information")); + TBool isText; + ret=aLs.RecognizeSpecificData(_L("a file name.txt"),_L8("Some plain text"),TDataType(_L8("text/plain")),isText); + TEST(ret==KErrNone); + TEST(isText); + TDataRecognitionResult result; + ret=aLs.RecognizeData(_L("a file name.txt"),_L8("Some plain text"),result); + TEST(ret==KErrNone); + TEST(result.iDataType==TDataType(_L8("text/plain"))); + TEST(result.iConfidence==CApaDataRecognizerType::EProbable); + isText=EFalse; + ret=aLs.RecognizeSpecificData(_L("a file name.txt"),_L8("Some plain text"),TDataType(_L8("foo/bar")),isText); + TEST(!isText); + + INFO_PRINTF1(_L("Checking icon loading by index")); + CApaMaskedBitmap* icon=CApaMaskedBitmap::NewLC(); + + TSize lastSize(0,0); + ret=aLs.GetAppIcon(KUidTestApp,0,*icon); + TEST(ret==KErrNone); + TEST(icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight > lastSize.iWidth*lastSize.iHeight); + lastSize=icon->SizeInPixels(); + + ret=aLs.GetAppIcon(KUidTestApp,1,*icon); + TEST(ret==KErrNone); + + TEST(icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight == lastSize.iWidth*lastSize.iHeight); + lastSize=icon->SizeInPixels(); + + ret=aLs.GetAppIcon(KUidTestApp,2,*icon); + TEST(ret==KErrNone); + TEST((icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight) > (lastSize.iWidth*lastSize.iHeight)); + lastSize=icon->SizeInPixels(); + + + TUid uid={9999}; + ret=aLs.GetAppIcon(uid,0,*icon); + TEST(ret==KErrNotFound); + CleanupStack::PopAndDestroy(icon); + } + + +/** + @SYMTestCaseID T-Serv2Step-DoInstallationTestL + + @SYMPREQ + + @SYMTestCaseDesc Test updating of Application list on installation of a new application. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test updating of application list on installation of a new + application. Copy the tstapp from z: drive to c: drive. Call RApaLsSession::GetAppInfo() + and test the application information obtained to verify whether the + application architecture server updates the application to reside in c: drive. + Delete the copied application and call RApaLsSession::GetAppInfo(). + Verify that the application list updates the tstapp application to reside + on z: drive.\n + API Calls:\n + RApaLsSession::GetAppInfo(TApaAppInfo& aInfo,TUid aAppUid) const\n + + @SYMTestExpectedResults The test confirms that the application architecture + server updates the application list on installation of a new application. + + */ +void CT_Serv2Step::DoInstallationTestL (RApaLsSession ls) + { + _LIT(KTestAppDestDir, "C:\\private\\10003a3f\\import\\apps\\" ); + _LIT(KTestAppSource, "Z:\\private\\10003a3f\\import\\apps\\tstapp_reg.rsc" ); + _LIT(KTestAppDest, "C:\\private\\10003a3f\\import\\apps\\tstapp_reg.rsc" ); + + _LIT(KTestWaitingForApplistUpdate,"\nWaiting %d microseconds for applist to be updated"); + const TInt KApplistUpdateTime = 8000000; + + // Copy App files around and delete them to check whether + // the app list updates and stores the cache correctly. + RFs theFs; + theFs.Connect(); + + // Remove Test app from the file system + CFileMan* fileManager = CFileMan::NewL (theFs); + + INFO_PRINTF1(_L("Copying the app to C")); + TEST(KErrNone == fileManager->Copy (KTestAppSource, KTestAppDest, CFileMan::ERecurse)); + + INFO_PRINTF2(KTestWaitingForApplistUpdate, KApplistUpdateTime); + User::After(KApplistUpdateTime); + + TApaAppInfo aInfo; + TEST(KErrNone == ls.GetAppInfo (aInfo, KUidTestApp)); + + TParsePtrC parse (aInfo.iFullName); + _LIT (KCdrive, "C:"); + INFO_PRINTF1(_L("Comparing App drive location is C:... ")); + TEST(parse.Drive ().CompareF (KCdrive) == 0); + + INFO_PRINTF1(_L("Removing the app from C")); + TTime tempTime(0); + fileManager->Attribs(KTestAppDest,0,KEntryAttReadOnly, tempTime, CFileMan::ERecurse); + TEST(KErrNone == fileManager->Delete (KTestAppDest, CFileMan::ERecurse)); + INFO_PRINTF1(_L("Removing the app dir from C")); + TEST(fileManager->RmDir(KTestAppDestDir)==KErrNone); + + INFO_PRINTF2(KTestWaitingForApplistUpdate, KApplistUpdateTime); + User::After(KApplistUpdateTime); + + // That should put the file in the right place + TEST(KErrNone == ls.GetAppInfo( aInfo, KUidTestApp)); + + TParsePtrC parse1 (aInfo.iFullName); + _LIT (KZdrive, "Z:"); + INFO_PRINTF1(_L("Comparing App drive location is Z:... ")); + TEST((parse1.Drive().CompareF(KZdrive)) == 0); + + delete fileManager; + theFs.Close(); + } + +// +// Tests the new RApaLsSession::NumberOfOwnDefinedIcons function +// See TeamTrack 'DEF037571 - Provide a better alternative to CApaAppInfoFileReader::NumberOfBitmaps' +// +void CT_Serv2Step::DoNumDefIconsTestL(RApaLsSession& aSession) + { + INFO_PRINTF1(_L("Testing RApaLsSession::NumberOfOwnDefinedIcons")); + TInt err = KErrNone; + + CArrayFixFlat* array = new(ELeave) CArrayFixFlat(4); + CleanupStack::PushL(array); + + // Test the GetAppIconSizes function, check 3 icons are returned (default icons) + INFO_PRINTF1(_L("Testing GetAppIconSizes")); + TUid appUid; + appUid.iUid = 0x12008ACE; // SimpleApparcTestApp UID + err = aSession.GetAppIconSizes(appUid, *array); + TEST(err == KErrNone); + TEST(array->Count() == 3); + + // Test the NumberOfOwnDefinedIcons function, check count is zero (no own defined icons) + INFO_PRINTF1(_L("Testing NumberOfOwnDefinedIcons (SimpleApparcTestApp)")); + TInt iconCount = -1; + err = aSession.NumberOfOwnDefinedIcons(appUid, iconCount); + TEST(err == KErrNone); + TEST(iconCount == 0); + + // Test NumberOfOwnDefinedIcons again, this time with Contacts app UID (icons defined) + INFO_PRINTF1(_L("Testing NumberOfOwnDefinedIcons (Contacts app)")); + iconCount = -1; + appUid.iUid = 0x10003a74; // Contacts app UID + + err = aSession.NumberOfOwnDefinedIcons(appUid, iconCount); + TEST(err == KErrNone); + TEST(iconCount == 3); + + INFO_PRINTF1(_L("NumberOfOwnDefinedIcons test complete")); + + CleanupStack::PopAndDestroy(array); + } + +/** Test RecognizeData() */ +void CT_Serv2Step::DoRecognizeDataL(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("Testing RApaLsSession::RecognizeData")); + + _LIT(KExistingFile, "Z:\\ApparcTest\\apparctest_t_Serv2.script"); + _LIT(KNonExistingFile, "x:\\non-existing directory\\non-existing file.any"); + _LIT(KWeirdFileName, "\\c:\\ : weird...txt"); + _LIT8(KFileContents, "just some random noice, we don't really care about the result"); + _LIT8(KTextPlainMimeType, "text/plain"); + + RFs fs; + TEST(KErrNone == fs.Connect()); + CleanupClosePushL(fs); + + // make sure KExistingFile really exists and that KNonExistingFile doesn't + TTime modificationTime; + TEST(KErrNone == fs.Modified(KExistingFile, modificationTime)); + TEST(KErrNone != fs.Modified(KNonExistingFile, modificationTime)); + + // test with existing file (result will be cached) + TDataRecognitionResult recData; + TEST(KErrNone == aLs.RecognizeData(KExistingFile, KFileContents, recData)); + TEST(0 == recData.iDataType.Des8().Compare(KTextPlainMimeType)); + + // test to get result from the cache (not possible to know if we succeed though) + TEST(KErrNone == aLs.RecognizeData(KExistingFile, KFileContents, recData)); + TEST(0 == recData.iDataType.Des8().Compare(KTextPlainMimeType)); + + //test with non-existing file (result won't be cached) + TEST(KErrNone == aLs.RecognizeData(KNonExistingFile, KFileContents, recData)); + TEST(0 == recData.iDataType.Des8().Compare(KTextPlainMimeType)); + + //test with empty file name (result won't be cached) + TEST(KErrNone == aLs.RecognizeData(KNullDesC, KFileContents, recData)); + TEST(0 == recData.iDataType.Des8().Compare(KTextPlainMimeType)); + + //test with weird file name (result won't be cached) + TEST(KErrNone == aLs.RecognizeData(KWeirdFileName, KFileContents, recData)); + TEST(0 == recData.iDataType.Des8().Compare(KTextPlainMimeType)); + + CleanupStack::PopAndDestroy(&fs); + } + +/** + @SYMTestCaseID APPFWK-APPARC-0074 + + @SYMDEF DEF099084: Apparc server's MIME type recognition cache can become out of date + + @SYMTestCaseDesc Test checks whether the MIME type recognition cache maintained by apparc server is + flushed when it receives the ECom change notification., i.e., either when a new ecom plugin is installed + or an existing ecom plugin is uninstalled. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Calls RecognizeData() to test the MIME type returned, + when + 1. When there is no existing "mime/mmr1" recognizer installed. + 2. "mime/mmr1" recognizer with EPossible confidence is installed. + 3. "mime/mmr1" recognizer is uninstalled. + It tests whether the mime type recognition cache maintained by the apparc server gets flushed + when any new ecom plugin is installed or when an existing ecom plugin is uninstalled. + + @SYMTestExpectedResults RecognizeData() returns CApaDataRecognizerType::ENotRecognized when "mime/mmr1" recognizer is not + installed. RecognizeData() returns CApaDataRecognizerType::EPossible when "mime/mmr1" recognizer with EPossible confidence is installed. + RecognizeData() returns CApaDataRecognizerType::ENotRecognized when "mime/mmr1" recognizer with EPossible confidence is uninstalled. + */ + +void CT_Serv2Step::TestRecognitionCacheL(RApaLsSession& aLs) + { + INFO_PRINTF1(_L("Testing fix for DEF099084: Apparc server's MIME type recognition cache can become out of date ")); + INFO_PRINTF1(_L("Testing MIME type recognition cache ...")); + + _LIT(KLitDocPath, "Z:\\system\\data\\TApsRecogAppTest.mmr"); + _LIT8(KMimeMmrType,"mime/mmr1"); + + TDataRecognitionResult recogResult; + TBuf8<255> buffer; + buffer.FillZ(255); + recogResult.Reset(); + + // Since recognizer for "mime\mmr1" mime type is not yet installed, call to RecognizeData() + // returns CApaDataRecognizerType::ENotRecognized. + INFO_PRINTF1(_L("MIME type recognition cache is not used...")); + User::LeaveIfError(aLs.RecognizeData(KLitDocPath, buffer, recogResult)); + TEST(recogResult.iConfidence == CApaDataRecognizerType::ENotRecognized); + + INFO_PRINTF1(_L("Installs new mime/mmr1 recognizer plugin file ")); + RSmlTestUtils fs; + CleanupClosePushL(fs); + User::LeaveIfError(fs.Connect()); + + // Ensure c:\\resource\\plugins is created, otherwise leave from this teststep + _LIT(KRecogRscTargetDir,"C:\\resource\\plugins\\"); + TInt err = fs.CreateDirectoryL(KRecogRscTargetDir); + TESTEL((err == KErrNone || err == KErrAlreadyExists), err); + + // Ensure c:\\sys\\bin is created, otherwise leave from this teststep + _LIT(KDllRecogTargetDir,"C:\\sys\\bin\\"); + err = fs.CreateDirectoryL(KDllRecogTargetDir); + TESTEL((err == KErrNone || err == KErrAlreadyExists), err); + + // Copy recmime_1.rsc from z:\\ to c:\\resource\\plugins, to trigger the rescan for plugins. + _LIT(KRecogRscSourcePath, "Z:\\system\\data\\recmime_1.rsc"); + _LIT(KRecogRscTargetPath,"C:\\resource\\plugins\\recmime_1.rsc"); + + err = fs.CopyFileL(KRecogRscSourcePath, KRecogRscTargetPath); + TEST(err == KErrNone); + + // Copy recmime_*.dll from z:\\ to c:\\sys\\bin. + _LIT(KRecogDllTargetPath, "C:\\sys\\bin\\recmime_1.dll"); + + #ifdef __WINS__ + _LIT(KRecogDllSourcePathWinscw, "Z:\\system\\data\\recmime_winscw.dll"); + err = fs.CopyFileL(KRecogDllSourcePathWinscw, KRecogDllTargetPath); + #else + _LIT(KRecogDllSourcePathArmv5, "Z:\\system\\data\\recmime_armv5.dll"); + err = fs.CopyFileL(KRecogDllSourcePathArmv5, KRecogDllTargetPath); + #endif + TEST(err == KErrNone); + + INFO_PRINTF2(_L("Waits %d seconds for new mime/mmr1 recognizer with EPossible confidence to be installed."), (4 * KOneSecondDelay)/1000000); + User::After(4 * KOneSecondDelay); + + // Without fix for DEF099084: Apparc server's MIME type recognition cache can become out of date + // RApaLsSession::RecognizeData() would return CApaDataRecognizerType::ENotRecognized (ie., Mime Recognition cache + // would not have been flushed when new recognizer is installed). + INFO_PRINTF1(_L("MIME type recognition cache is flushed when a new recogizer is installed")); + recogResult.Reset(); + User::LeaveIfError(aLs.RecognizeData(KLitDocPath, buffer, recogResult)); + TEST(recogResult.iDataType.Des8().CompareF(KMimeMmrType) == 0); + TEST(recogResult.iConfidence == CApaDataRecognizerType::EPossible); + + // Second call to RecognizeData() utilizes the Mime type Recognition cache. + INFO_PRINTF1(_L("MIME type recognition cache is used...")); + recogResult.Reset(); + User::LeaveIfError(aLs.RecognizeData(KLitDocPath, buffer, recogResult)); + TEST(recogResult.iDataType.Des8().CompareF(KMimeMmrType) == 0); + TEST(recogResult.iConfidence == CApaDataRecognizerType::EPossible); + + // Delete the plugin resource file of the recognizer with EPossible confidence which was installed during the test from z:. + TInt fileExists = EFalse; + fs.IsFilePresent(KRecogRscTargetPath, fileExists); + if (fileExists) + { + fs.ChangeFilePermissionL(KRecogRscTargetPath); // clear readonly attribute inherited from z: + err = fs.DeleteFileL(KRecogRscTargetPath); + if(err == KErrNone) + INFO_PRINTF1(_L("Removed temporary file recmime_1.rsc")); + else + INFO_PRINTF1(_L("Failed to remove temporary file recmime_1.rsc")); + } + + INFO_PRINTF2(_L("Waits %d seconds for the data recognizer list maintained by EMIME to be updated"), (10 * KOneSecondDelay)/1000000); + User::After(10 * KOneSecondDelay); + + // Since "mime/mmr1" recognizer is uninstalled, mime/mmr1 mime type is not recognized. + INFO_PRINTF1(_L("MIME type recognition cache is flushed when a existing recogizer is uninstalled")); + recogResult.Reset(); + User::LeaveIfError(aLs.RecognizeData(KLitDocPath, buffer, recogResult)); + TEST(recogResult.iConfidence == CApaDataRecognizerType::ENotRecognized); + + CleanupStack::PopAndDestroy(&fs); + } + +/** + Auxiliary Fn for the entire Test Step + + This method initiates all the tests. +*/ +TInt CT_Serv2Step::DoServComTestL() + { + INFO_PRINTF1(_L("Testing Server Com")); + + + RFs theServFs; + TInt ret = theServFs.Connect(); + TEST(ret==KErrNone); + CleanupClosePushL(theServFs); + + // Connect to the server + RTestableApaLsSession ls; + ret = ls.ConnectWithoutWaitingForListPopulation(); + TEST(ret==KErrNone); + CleanupClosePushL(ls); + + + INFO_PRINTF1(_L("Waiting applist to be generated.\n")); + TRequestStatus requeststatus; + ls.RegisterListPopulationCompleteObserver(requeststatus); + + //Testing the CancelListPopulationCompleteObserver + TEST(ls.CancelListPopulationCompleteObserver() == KErrNone); + User::WaitForRequest(requeststatus); + + ls.RegisterListPopulationCompleteObserver(requeststatus); + User::WaitForRequest(requeststatus); + TEST(requeststatus == KErrNone); + + //make sure the RFbsSession doesn't have to allocate buffer since it would change the heap + CFbsBitmap* bufferAllocator = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bufferAllocator); + TEST(bufferAllocator->Create(TSize(200,1), EColor16M) == KErrNone); + CleanupStack::PopAndDestroy(bufferAllocator); + + // + HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, DoInterrogationTestsL(ls), ls.ClearAppInfoArray(); ls.FlushRecognitionCache(); ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetAllApps(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetEmbeddableApps(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoEmbeddableAppCount(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetAppCapability(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps1(ls), NO_CLEANUP); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps2(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps3(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps4(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps5(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoGetFilteredApps6(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoTestEmbeddabilityFilter1(), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoTestEmbeddabilityFilter2(), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoTestEmbeddabilityFilter3(), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoTestEmbeddabilityFilter4(), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoTestEmbeddabilityFilter5(), ls.ClearAppInfoArray() ); + //DONT_CHECK due to file system changes + HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, TestRecognitionCacheL(ls), ls.FlushRecognitionCache()); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoRecognizeDataL(ls), ls.FlushRecognitionCache() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, LaunchAppThruCreateDocL(ls), ls.FlushRecognitionCache() ); + + + INFO_PRINTF1(_L("Checking icon loading by size - including OOM tests\n")); + ret = KErrNoMemory; + for(TInt fail=0; ret == KErrNoMemory; fail++) + { + __UHEAP_FAILNEXT(fail); + __UHEAP_MARK; + TRAP(ret, DoCheckServerIconLoadingBySizeL(ls)); + __UHEAP_SETFAIL(RHeap::ENone,0);// turn failure off + __UHEAP_MARKEND; + TEST((ret==KErrNoMemory || ret==KErrNone)); + } + + //DONT_CHECK due to app is started and that app opens up another RApaLsSession (which changes the server's heap) + HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, DoStartAppTestsL(ls), ls.FlushRecognitionCache() ); + HEAP_TEST_LS_SESSION(ls, 0, 0, DoEnquiryTestsL(ls), NO_CLEANUP); + //DONT_CHECK due to changes to file system + HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, DoInstallationTestL(ls), ls.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, DoNumDefIconsTestL(ls), ls.ClearAppInfoArray() ); + + // + // close the server session and we have done some type store reloading + CleanupStack::PopAndDestroy(2, &theServFs); + + return KErrNone; + } + +CT_Serv2Step::~CT_Serv2Step() +/** + Destructor + */ + { + } + +CT_Serv2Step::CT_Serv2Step() +/** + Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KT_Serv2Step); + } + +TVerdict CT_Serv2Step::doTestStepPreambleL() +/** + @return - TVerdict code + Override of base class virtual + */ + { + SetTestStepResult(EPass); + return TestStepResult(); + } + +TVerdict CT_Serv2Step::doTestStepPostambleL() +/** + @return - TVerdict code + Override of base class virtual + */ + { + return TestStepResult(); + } + +TVerdict CT_Serv2Step::doTestStepL() +/** + Override of base class virtual. + @return - TVerdict code + */ +{ + FbsStartup(); + TInt ret = RFbsSession::Connect(); + TEST(ret==KErrNone); + + // set up the directory structure + RFs theFs; + ret = theFs.Connect(); + TEST(ret==KErrNone); + CleanupClosePushL(theFs); + + // run the testcode (inside an alloc heaven harness) + INFO_PRINTF1(_L("About to test server in process")); + TRAP(ret,DoServComTestL()); + INFO_PRINTF2(_L(" DoServComTestL completes with %d"), ret); + TEST(ret==KErrNone); + + // Cleanup + CleanupStack::PopAndDestroy(&theFs); + + INFO_PRINTF1(_L("Test Completed!")); + return TestStepResult(); + +}