diff -r e8c1ea2c6496 -r 8758140453c0 localisation/apparchitecture/tef/T_RApaLsSessionStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/localisation/apparchitecture/tef/T_RApaLsSessionStep.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,2461 @@ +// 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: +// + + + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "..\apparc\apadll.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "tstapp.h" +#include + +#include "T_RApaLsSessionStep.h" +#include "appfwk_test_AppUi.h" +#include "TRApaLsSessionStartAppTest.h" +#include "TIconLoaderAndIconArrayForLeaks.h" + +#if !defined(__E32TEST_H__) +#include +#endif + +// Literals & Constants +_LIT(KCompleted, "Completed."); +const TUint KBytesToRead=100; + + +/**************************************** + Auxiliary functions used by test cases +*****************************************/ +void CT_RApaLsSessionTestStep::setup() + { +#if defined(__EPOC32__) + + TFullName filePath=_L("c:\\docs\\tstapp.doc"); + TFullName tempPath=_L("c:\\system\\temp\\"); + // if we're on the rack create the directories we need + TParse parser; + parser.Set(filePath,NULL,NULL); + iFs.MkDirAll(parser.DriveAndPath()); + parser.Set(tempPath,NULL,NULL); + iFs.MkDirAll(parser.DriveAndPath()); +#endif + } + + +//////////////////////////// +// Might actually be tests...... +///////////////////////////// + +void CT_RApaLsSessionTestStep::TestAppListInfoDataInterrogationSetupL() + { + // + INFO_PRINTF1(_L("Initialising App List Cache using GetAllApps.....")); + TInt ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + INFO_PRINTF1(KCompleted); + +// get the full app count + INFO_PRINTF1(_L("Getting AppCount.....")); + TInt count=0; + ret = iLs.AppCount(count); + TEST(ret==KErrNone); + TEST(count>=1); + INFO_PRINTF1(KCompleted); + +// prepare to get a list of embeddable apps + INFO_PRINTF1(_L("Initialising embeddable app list cache using GetEmbeddableApps.....")); + ret = iLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + INFO_PRINTF1(KCompleted); + +// get the embedded app count + INFO_PRINTF1(_L("Initialising embeddable app list cache using EmbeddableAppCount.....")); + count=0; + ret = iLs.EmbeddableAppCount(count); + TEST(ret==KErrNone); + TEST(count>=1); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppInfo1 + + @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_RApaLsSessionTestStep::TestAppInfo1() + { + + INFO_PRINTF1(_L("Testing RApaLsSession::ENoMoreAppsInList....attempt to get an app")); + //Go to end of Applist for next test... + TApaAppInfo info; + TInt ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + + do + { + ret=iLs.GetNextApp(info); + } + while (ret != RApaLsSession::ENoMoreAppsInList); + + //try to get another app (there arn't any more) + ret = iLs.GetNextApp(info); + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppInfo2 + + @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_RApaLsSessionTestStep::TestAppInfo2() + { + INFO_PRINTF1(_L("Testing RApaLsSession::GetNextApps() return info....")); + _LIT(KLitAppPath,"z:\\sys\\bin\\tstapp.exe"); + TFullName appPath(KLitAppPath); + + TApaAppInfo info; + TInt ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + + do + { + iLs.GetNextApp(info); + } + while (ret==KErrNone && info.iUid!=KUidTestApp); + + TEST(ret==KErrNone); + TEST(info.iUid==KUidTestApp); + info.iFullName.LowerCase(); + TEST(info.iFullName.Compare(appPath) == 0); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppInfo3 + + @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_RApaLsSessionTestStep::TestAppInfo3() + { + INFO_PRINTF1(_L("Testing RApaLsSession::GetAppInfo()....")); + _LIT(KLitAppPath,"z:\\sys\\bin\\tstapp.exe"); + TFullName appPath(KLitAppPath); + // Get info for an app that exists + TApaAppInfo info; + TInt ret = iLs.GetAppInfo(info,KUidTestApp); + TEST(ret==KErrNone); + TEST(info.iUid==KUidTestApp); + info.iFullName.LowerCase(); + TEST(info.iFullName.Compare(appPath) == 0); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppInfo4 + + @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_RApaLsSessionTestStep::TestAppInfo4() + { + INFO_PRINTF1(_L("Testing RApaLsSession::GetAppInfo()....non-existent app")); + + TApaAppInfo info; + TInt ret = iLs.GetAppInfo(info,KNullUid); + TEST(ret==KErrNotFound); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestServerIconSizeCountL + + @SYMPREQ + + @SYMTestCaseDesc Test Get the number of icon sizes for testapp app. + + @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. + Check that it is non zero, i.e. that a number of icon sizes has been retreived + for testapp.\n + API Calls:\n + RApaLsSession::GetAppIconSizes(TUid aAppUid, CArrayFixFlat& aArrayToFill) const\n + + @SYMTestExpectedResults aTestIconSizeArray->Count() is greater than 0. + + */ +void CT_RApaLsSessionTestStep::TestServerIconSizeCountL(CArrayFixFlat& aTestIconSizeArray) + { + INFO_PRINTF1(_L("Test RApaLsSession::GetAppIconSizes...")); + + TInt ret=iLs.GetAppIconSizes(KUidTestApp,aTestIconSizeArray); + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNone); + TEST(aTestIconSizeArray.Count()!=0); + + INFO_PRINTF1(KCompleted); + } + + + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestServerIconLoadingBySize1L + + @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().\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_RApaLsSessionTestStep::TestServerIconLoadingBySize1L(CArrayFixFlat& aTestIconSizeArray) + { + INFO_PRINTF1(_L("Test RApaLsSession::GetAppIcon....Compare icon sizes")); + + for(TInt i=0;iSizeInPixels()==aTestIconSizeArray[i]); + CleanupStack::PopAndDestroy(iconBySize); + } + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestServerIconLoadingBySize2L + + @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. + Test calling RApaLsSession::GetAppIcon() by specifying reduced size than + the actual icon size. Since no match would be found, KErrNotFound should be + returned.\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_RApaLsSessionTestStep::TestServerIconLoadingBySize2L(CArrayFixFlat& aTestIconSizeArray) + { + INFO_PRINTF1(_L("Test RApaLsSession::GetAppIcon....Compare icon sizes that don't match")); + + // now try non exact sizes + CApaMaskedBitmap* iconBySize=CApaMaskedBitmap::NewLC(); + TInt ret=iLs.GetAppIcon(KUidTestApp,(aTestIconSizeArray[0])+TSize(-5,-5),*iconBySize); //by Size + if(ret==KErrNoMemory) + User::Leave(KErrNoMemory); + TEST(ret==KErrNotFound); + CleanupStack::PopAndDestroy(iconBySize); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestServerIconLoadingBySize3L + + @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. + 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_RApaLsSessionTestStep::TestServerIconLoadingBySize3L(CArrayFixFlat& aTestIconSizeArray) + { + INFO_PRINTF1(_L("Test RApaLsSession::GetAppIcon....Compare icon sizes that don't match.")); + for(TInt ii=0;iiSizeInPixels()==aTestIconSizeArray[ii]); // should get size below always!!! + CleanupStack::PopAndDestroy(iconBySize); + } + INFO_PRINTF1(KCompleted); + } + + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppListInvalidL() + + @SYMPREQ + + @SYMTestCaseDesc Test . + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test RApaLsSession::AppForDocument() to recognize data type & + applications that can handle the data type of data stored in the specified + file. The test is performed on files of one byte and zero byte sizes. + Observe that on both occasions the API returns Uid of an application that + can handle text \ plain data type.\n + Test RApaLsSession::AppForDataType() to recognize Uid of an application + that can handle a specified data type. To do this the test calls + RApaLsSession::RecognizeData() which gets the data type for data taken + from a specified file. The test is performed on files of one byte and zero + byte sizes. The test ensures that RApaLsSession::AppForDataType() doesn't + return KNullUid for both sizes of the file.\n + API Calls:\n + RApaLsSession::AppForDocument(const TDesC& aFileName, TUid& aUid, TDataType& aDataType) const\n + RApaLsSession::RecognizeData(const TDesC& aName, const TDesC8& aBuffer, TDataRecognitionResult& aDataType) const\n + RApaLsSession::AppForDataType(const TDataType& aDataType, TUid& aAppUid) const\n + + @SYMTestExpectedResults Test ensures that the data recognition functions identify the data type of + data in a file and the application capable of handling the specified + data type. + + */ +void CT_RApaLsSessionTestStep::TestAppListInvalidL() + { + __UHEAP_MARK; + TestAppListInvalidSetupL(); + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test RApaLsSession::GetNextApp() never returns RApaLsSession::EAppListInvalid.")); + + TApaAppInfo info; + TInt ret=0; + while(ret==KErrNone) + { + ret=iLs.GetNextApp(info); + } + + //tests GetNextApp() never returns RApaLsSession::EAppListInvalid + TEST(ret!=RApaLsSession::EAppListInvalid); + TEST(ret==RApaLsSession::ENoMoreAppsInList); + INFO_PRINTF1(KCompleted); + } + + +void CT_RApaLsSessionTestStep::TestAppListInvalidSetupL() + { + INFO_PRINTF1(_L("Setting up Applist invalid test.")); + + _LIT(KTempAppDir, "C:\\private\\10003a3f\\import\\apps\\"); + _LIT(KTempRegPath, "C:\\private\\10003a3f\\import\\apps\\tstapp_reg.rsc"); + TFullName regPath=_L("z:\\private\\10003a3f\\import\\apps\\tstapp_reg.rsc"); + + CFileMan* iAppListInvalidTestFileMan = CFileMan::NewL (iFs); + CleanupStack::PushL(iAppListInvalidTestFileMan); + + INFO_PRINTF1(_L("Copy tstapp files to C: drive.......")); + TInt rtn=iFs.MkDir(KTempAppDir); + TEST(rtn==KErrNone||rtn==KErrAlreadyExists); + TEST(iAppListInvalidTestFileMan->Copy(regPath, KTempRegPath)==KErrNone); //Just to start the idle update. + + INFO_PRINTF1(_L("Get app list.......")); + TInt ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + + INFO_PRINTF1(_L("Remove temp files from C: drive.......")); + TRequestStatus status; + TTime tempTime(0); // added tempTime to avoid asynch CFileMan::Attribs request completing with KErrArgument + TEST(iAppListInvalidTestFileMan->Attribs(KTempAppDir,0,KEntryAttReadOnly, tempTime, CFileMan::ERecurse, status)==KErrNone); + + User::WaitForRequest(status); + TEST(status.Int() == KErrNone); + INFO_PRINTF1(_L("Deleting Reg file.......")); + TEST(iAppListInvalidTestFileMan->Delete(KTempRegPath)==KErrNone); //Just to start the idle update. + INFO_PRINTF1(_L("Removing App dir.......")); + TEST(iAppListInvalidTestFileMan->RmDir(KTempAppDir)==KErrNone); + CleanupStack::PopAndDestroy(iAppListInvalidTestFileMan); + + INFO_PRINTF1(KCompleted); + } + + + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppListRecognizeDataL + + @SYMPREQ + + @SYMTestCaseDesc Test data recognition functions of RApaLsSession. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test RApaLsSession::AppForDocument() to recognize data type & + applications that can handle the data type of data stored in the specified + file. The test is performed on files of one byte and zero byte sizes. + Observe that on both occasions the API returns Uid of an application that + can handle text \ plain data type.\n + Test RApaLsSession::AppForDataType() to recognize Uid of an application + that can handle a specified data type. To do this the test calls + RApaLsSession::RecognizeData() which gets the data type for data taken + from a specified file. The test is performed on files of one byte and zero + byte sizes. The test ensures that RApaLsSession::AppForDataType() doesn't + return KNullUid for both sizes of the file.\n + API Calls:\n + RApaLsSession::AppForDocument(const TDesC& aFileName, TUid& aUid, TDataType& aDataType) const\n + RApaLsSession::RecognizeData(const TDesC& aName, const TDesC8& aBuffer, TDataRecognitionResult& aDataType) const\n + RApaLsSession::AppForDataType(const TDataType& aDataType, TUid& aAppUid) const\n + + @SYMTestExpectedResults Test ensures that the data recognition functions identify the data type of + data in a file and the application capable of handling the specified + data type. + + */ +void CT_RApaLsSessionTestStep::TestAppListRecognizeDataL() + { + // The following tests will only succeed if the text recogniser and an app which likes text files are both installed + // The tests check that file recognisers work for zero and non zero length files. + INFO_PRINTF1(_L("Testing AppForDocument(), RecognizeData() and AppForDataType()")); + TInt ret; + TUid appUid=KNullUid; + TDataType dataType; + INFO_PRINTF1(_L("Testing 1 byte text file recognition")); + ret = iLs.AppForDocument(_L("z:\\system\\data\\one_byte.txt"), appUid,dataType); + TEST(ret==KErrNone); + TEST(appUid!=KNullUid); + INFO_PRINTF1(KCompleted); + + appUid=KNullUid; + INFO_PRINTF1(_L("Testing zero byte text file recognition")); + ret = iLs.AppForDocument(_L("z:\\system\\data\\zero_len.txt"), appUid,dataType); + TEST(ret==KErrNone); + TEST(appUid!=KNullUid); + INFO_PRINTF1(KCompleted); + + // this following exihibits a defect which was fixed for Release 6 is fixed. + // KNullUid was recognized for zero length text files using this method before the fix. + appUid=KNullUid; + TBuf8<255> buffer; + buffer.FillZ(255); + buffer[0] = 'a'; // We used to fill it entirely with zeroes but an ICL recognizer know interferes + // with this, so we added an 'a' + TDataRecognitionResult recogResult; + + appUid=KNullUid; + INFO_PRINTF1(_L("Testing 1 byte text file recognition - lengthy method")); + ret = iLs.RecognizeData(_L("z:\\system\\data\\one_byte.txt"),buffer,recogResult); + TEST(ret==KErrNone); + ret = iLs.AppForDataType(recogResult.iDataType,appUid); + TEST(ret==KErrNone); + TEST(appUid!=KNullUid); + INFO_PRINTF1(KCompleted); + + appUid=KNullUid; + INFO_PRINTF1(_L("Testing zero byte text file recognition -lengthy method")); + ret = iLs.RecognizeData(_L("z:\\system\\data\\zero_len.txt"),buffer,recogResult); + TEST(ret==KErrNone); + ret = iLs.AppForDataType(recogResult.iDataType,appUid); + TEST(ret==KErrNone); + TEST(appUid!=KNullUid); + INFO_PRINTF1(KCompleted); + + // the following attempts to open a file of an unknown mime type with extension .UnrecognisableExtention + + INFO_PRINTF1(_L("Testing RecognizeData() with unrecognizable file type...")); + buffer.FillZ(255); + _LIT8(KLitUnRecog,""); + iLs.FlushRecognitionCache(); + recogResult.Reset(); + //First call to RecognizeData() does not utilize the cache + User::LeaveIfError(iLs.RecognizeData(_L("z:\\system\\data\\FileWithUnknownMimeType.UnrecognisableExtention"),buffer,recogResult)); + TEST(recogResult.iDataType.Des8().CompareF(KLitUnRecog)==0); + recogResult.Reset(); + //Second call to RecognizeData() utilizes the cache + User::LeaveIfError(iLs.RecognizeData(_L("z:\\system\\data\\FileWithUnknownMimeType.UnrecognisableExtention"),buffer,recogResult)); + TEST(recogResult.iDataType.Des8().CompareF(KLitUnRecog)==0); + INFO_PRINTF1(_L("Completed Testing unrecognizable file type...")); + + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppListRecognizeDataBufferOnlyL + + @SYMPREQ INC064138 + + @SYMTestCaseDesc Test data recognition functions of RApaLsSession without a filename. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + + @SYMTestExpectedResults Test ensures that the data recognition functions identify the data type of + data in a file. + */ +void CT_RApaLsSessionTestStep::TestAppListRecognizeDataBufferOnlyL() + { + INFO_PRINTF1(_L("Testing recognition without filename")); + + TDataRecognitionResult rr; + _LIT8(KTestBuffer, "Text_TestRecognizer"); + rr.Reset(); + TInt error = iLs.RecognizeData(KNullDesC, KTestBuffer, rr); + if (rr.iConfidence != CApaDataRecognizerType::ECertain) + { + INFO_PRINTF1(_L("Error: confidence should be ECertain")); + TEST(EFalse); + } + + _LIT8(KAnotherBuffer, "AnotherText"); + rr.Reset(); + error = iLs.RecognizeData(KNullDesC, KAnotherBuffer, rr); + if (rr.iConfidence != CApaDataRecognizerType::EProbable) + { + INFO_PRINTF1(_L("Error: confidence should be EProbable")); + TEST(EFalse); + } + + INFO_PRINTF1(KCompleted); + } + +/** + @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_RApaLsSessionTestStep::TestSetGetAcceptedConfidenceL() + { + INFO_PRINTF1(_L("Test SetAcceptedConfidence....")); + + TInt temp=1234; + TInt ret=iLs.SetAcceptedConfidence(temp); + TSecurityInfo info; + info.Set(RProcess()); + + info.iCaps.HasCapability(ECapabilityWriteDeviceData) ? TEST(ret==KErrNone) : TEST(ret==KErrPermissionDenied); + INFO_PRINTF1(KCompleted); + + INFO_PRINTF1(_L("Test GetAcceptedConfidence....")); + temp=0; + ret=iLs.GetAcceptedConfidence(temp); + TEST(ret==KErrNone); + TEST(temp==1234); + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::TestSetGetMaxDataBufSizeL() + { + INFO_PRINTF1(_L("Test SetMaxDataBufSize....")); + + TInt temp=1234; + TInt ret=iLs.SetMaxDataBufSize(temp); + TEST(ret==KErrNone); + INFO_PRINTF1(KCompleted); + + INFO_PRINTF1(_L("Test GetMaxDataBufSize....")); + temp=0; + ret=iLs.GetMaxDataBufSize(temp); + TEST(ret==KErrNone); + TEST(temp==1234); + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::TestGetSupportedDataTypesL() +{ + INFO_PRINTF1(_L("Test GetSupportedDataTypes....")); + + CDataTypeArray* dataTypes=new(ELeave) CDataTypeArray(5); + CleanupStack::PushL(dataTypes); + + TInt ret=iLs.GetSupportedDataTypesL(*dataTypes); + TEST(ret==KErrNone); + TEST(dataTypes->Count()>=4); + CleanupStack::PopAndDestroy(); // dataTypes + + INFO_PRINTF1(KCompleted); + } + + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.exe + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetAllApps() + { + INFO_PRINTF1(_L("DoGetAllApps")); + + TInt ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.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); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.dll + TAppEmbeddableOnly.dll + and should not return app info for: + TAppNotEmbeddable.exe + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetEmbeddableApps() + { + INFO_PRINTF1(_L("DoGetEmbeddableApps")); + + TInt ret = iLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.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); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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_RApaLsSessionTestStep::DoEmbeddableAppCount() + { + INFO_PRINTF1(_L("DoEmbeddableAppCount")); + + TInt ret = iLs.GetEmbeddableApps(); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TInt count1 = 0; + while ((ret = iLs.GetNextApp(appInfo)) == KErrNone) + { + count1 ++; + }; + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + TInt count2 = 0; + ret = iLs.EmbeddableAppCount(count2); + TEST(ret==KErrNone); + TEST(count1 == count2); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.exe + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + + @SYMTestExpectedResults + For each app, GetAppCapability should return the embeddability value + defined in the application's AIF file. + + */ +void CT_RApaLsSessionTestStep::DoGetAppCapability() + { + INFO_PRINTF1(_L("DoGetAppCapability")); + + 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++) + { + INFO_PRINTF2(_L("Testing embeddability value, %d"), uidArray[ii]); + TApaAppCapabilityBuf capabilityBuf; + TInt ret = iLs.GetAppCapability(capabilityBuf, uidArray[ii]); + TEST(ret==KErrNone); + TEST(capabilityBuf().iEmbeddability == embeddabilityArray[ii]); + } + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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_RApaLsSessionTestStep::DoGetFilteredApps1() + { + INFO_PRINTF1(_L("DoGetFilteredApps1")); + + TApaEmbeddabilityFilter filter; + TInt ret = iLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TEST(iLs.GetNextApp(appInfo) == RApaLsSession::ENoMoreAppsInList); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.exe + and should not return app info for: + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetFilteredApps2() + { + INFO_PRINTF1(_L("DoGetFilteredApps2")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + TInt ret = iLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.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); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.dll + and should not return app info for: + TAppEmbeddable.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetFilteredApps3() + { + INFO_PRINTF1(_L("DoGetFilteredApps3")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + TInt ret = iLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.GetNextApp(appInfo)) == KErrNone) + { + if (appInfo.iUid == KUidAppEmbeddable) + bitFlags |= 0x02; + else if (appInfo.iUid == KUidAppEmbeddableUiOrStandAlone) + bitFlags |= 0x08; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + TEST(bitFlags == 0x08); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.dll + TAppEmbeddableUiNotStandAlone.dll + and should not return app info for: + TAppNotEmbeddable.exe + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetFilteredApps4() + { + INFO_PRINTF1(_L("DoGetFilteredApps4")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiOrStandAlone); + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + TInt ret = iLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.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); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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_RApaLsSessionTestStep::DoGetFilteredApps5() + { + 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 = iLs.GetFilteredApps(filter); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TInt filteredCount = 0; + while ((ret = iLs.GetNextApp(appInfo)) == KErrNone) + { + filteredCount++; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + ret = iLs.GetAllApps(); + TEST(ret==KErrNone); + + TInt allAppsCount = 0; + while ((ret = iLs.GetNextApp(appInfo)) == KErrNone) + { + allAppsCount++; + } + TEST(ret==RApaLsSession::ENoMoreAppsInList); + + TEST(filteredCount == allAppsCount); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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.exe + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + + @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.exe + TAppEmbeddable.dll + TAppEmbeddableOnly.dll + TAppEmbeddableUiOrStandAlone.dll + TAppEmbeddableUiNotStandAlone.dll + The last call to GetNextApp should return RApaLsSession::ENoMoreAppsInList + + */ +void CT_RApaLsSessionTestStep::DoGetFilteredApps6(/*RApaLsSession& iLs*/) + { + 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 = iLs.GetFilteredApps(filter, screenMode1); + TEST(ret==KErrNone); + + TApaAppInfo appInfo; + TUint bitFlags = 0; + while ((ret = iLs.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); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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 fiLse. + + */ +void CT_RApaLsSessionTestStep::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)); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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 fiLse. + + */ +void CT_RApaLsSessionTestStep::DoTestEmbeddabilityFilter2() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter2")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableOnly)); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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 fiLse. + + */ +void CT_RApaLsSessionTestStep::DoTestEmbeddabilityFilter3() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter3")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddableOnly); + TEST(!filter.MatchesEmbeddability(TApaAppCapability::EEmbeddableUiNotStandAlone)); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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_RApaLsSessionTestStep::DoTestEmbeddabilityFilter4() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter4")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + TEST(filter.MatchesEmbeddability(TApaAppCapability::EEmbeddable)); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-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_RApaLsSessionTestStep::DoTestEmbeddabilityFilter5() + { + INFO_PRINTF1(_L("DoTestEmbeddabilityFilter5")); + + TApaEmbeddabilityFilter filter; + filter.AddEmbeddability(TApaAppCapability::ENotEmbeddable); + filter.AddEmbeddability(TApaAppCapability::EEmbeddable); + TEST(filter.MatchesEmbeddability(TApaAppCapability::EEmbeddable)); + INFO_PRINTF1(KCompleted); + } + + /** + @SYMTestCaseID T-RApaLsSessionTestStep-TestGetAppCapabilityL + + @SYMPREQ + + @SYMTestCaseDesc Test interrogates the Application Architecture Server. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + 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_RApaLsSessionTestStep::TestGetAppCapabilityL() + { + TApaAppCapabilityBuf buf; + INFO_PRINTF1(_L("Checking GetAppCapability from Test App Uid...")); + TInt ret = iLs.GetAppCapability(buf,KUidTestApp); + TEST(ret==KErrNone); + TApaAppCapability cap=buf(); + TEST(cap.iEmbeddability==TApaAppCapability::EEmbeddable); + TEST(!cap.iSupportsNewFile); + TEST(!cap.iAppIsHidden); + INFO_PRINTF1(KCompleted); + + INFO_PRINTF1(_L("Checking GetAppCapability Null Id returns KErrNotFound...")); + ret = iLs.GetAppCapability(buf,KNullUid); + TEST(ret==KErrNotFound); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T_RApaLsSessionTestStep_TestRecognizeSpecificData + + @SYMPREQ + + @SYMTestCaseDesc Test interrogates the Application Architecture Server. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + 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_RApaLsSessionTestStep::TestRecognizeSpecificData() +{ + INFO_PRINTF1(_L("Checking data type information")); + INFO_PRINTF1(_L("Checking RecognizeSpecificData...")); + TBool isText=EFalse; + TInt ret=iLs.RecognizeSpecificData(_L("a file name.txt"),_L8("Some plain text"),TDataType(_L8("text/plain")),isText); + TEST(ret==KErrNone); + TEST(isText); + + INFO_PRINTF1(_L("Checking RecognizeData...")); + TDataRecognitionResult result; + ret=iLs.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; + INFO_PRINTF1(_L("Checking RecognizeSpecificData...unknown data type...")); + ret=iLs.RecognizeSpecificData(_L("a file name.txt"),_L8("Some plain text"),TDataType(_L8("foo/bar")),isText); + TEST(!isText); + INFO_PRINTF1(KCompleted); +} + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestGetAppIconL + + @SYMPREQ + + @SYMTestCaseDesc Test interrogates the Application Architecture Server. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestExpectedResults All tests compare the results obtained with the desired result. + + */ +void CT_RApaLsSessionTestStep::TestGetAppIconL() + { + INFO_PRINTF1(_L("Checking icon loading by index")); + CApaMaskedBitmap* icon=CApaMaskedBitmap::NewLC(); + TSize lastSize(0,0); + + INFO_PRINTF1(_L("Checking index 0")); + TInt ret=iLs.GetAppIcon(KUidTestApp,0,*icon); + TEST(ret==KErrNone); + TEST(icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight > lastSize.iWidth*lastSize.iHeight); + lastSize=icon->SizeInPixels(); + + INFO_PRINTF1(_L("Checking icon index 1")); + ret=iLs.GetAppIcon(KUidTestApp,1,*icon); + TEST(ret==KErrNone); + TEST(icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight == lastSize.iWidth*lastSize.iHeight); + lastSize=icon->SizeInPixels(); + + INFO_PRINTF1(_L("Checking icon index 2")); + ret=iLs.GetAppIcon(KUidTestApp,2,*icon); + TEST(ret==KErrNone); + TEST((icon->SizeInPixels().iWidth*icon->SizeInPixels().iHeight) > (lastSize.iWidth*lastSize.iHeight)); + lastSize=icon->SizeInPixels(); + + INFO_PRINTF1(_L("Checking icon loading unknown Uid....")); + TUid uid={9999}; + ret=iLs.GetAppIcon(uid,0,*icon); + TEST(ret==KErrNotFound); + CleanupStack::PopAndDestroy(icon); + INFO_PRINTF1(KCompleted); + } +/** + @SYMTestCaseID APPFWK-APPARC-0085 + + @SYMDEF PDEF113054: Apparc fails to detect the presence of localized MBM files + + @SYMTestCaseDesc + Negative Test: Test an icon file with an extension which is not supported. + + + @SYMTestPriority High + + @SYMTestStatus Implemented + + Call GetAppViewIcon API on an App which has a localized MBM icon file associated with it with an invalid extension. + GetAppViewIcon returns KErrNotSupported + + @SYMTestExpectedResults RApaLsSession::GetAppViewIcon should return KErrNotSupported when + the view icon file is an invalid icon file + */ +void CT_RApaLsSessionTestStep::TestGetAppIcon2L() + { + CApaAppViewArray* appViews = new(ELeave) CApaAppViewArray(4); + CleanupStack::PushL(appViews); + TInt ret = iLs.GetAppViews(*appViews, KUidTestApp); + TEST(ret==KErrNone); + + INFO_PRINTF1(_L("Negative test- checking for file extension which is not supported")); + //the third view icon is not a valid mbm file + const TApaAppViewInfo& viewInfo=(*appViews)[2]; + TEST(viewInfo.iUid != KNullUid); + TEST(viewInfo.iViewCaption.Length() > 0); + TEST(viewInfo.iScreenMode == 0x00); + CApaMaskedBitmap* viewBitmap = CApaMaskedBitmap::NewLC(); + ret = iLs.GetAppViewIcon(KUidTestApp, viewInfo.iUid, TSize(50,50), *viewBitmap); + TEST(ret==KErrNotSupported); + INFO_PRINTF2(_L("The View icon's UID is - %d"), viewInfo.iUid); + + HBufC* fullIconFileName = NULL; + ret = iLs.GetAppViewIcon(KUidTestApp, viewInfo.iUid, fullIconFileName); + TEST(ret == KErrNone); + TEST(fullIconFileName != NULL); + if (fullIconFileName != NULL) + { + TEST(fullIconFileName->Length() > 0); + INFO_PRINTF2(_L("Invalid View's icon file name is - %S"), fullIconFileName); + } + delete fullIconFileName; + fullIconFileName = NULL; + + CleanupStack::PopAndDestroy(viewBitmap); + CleanupStack::PopAndDestroy(appViews); + + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID APPFWK-APPARC-0073 + + @SYMDEF INC098717: support for scalable midlet icons is missing + + @SYMTestCaseDesc Test interrogates the Application Architecture Server's GetAppIcon API . + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Call GetAppIcon API on an app which has an icon file associated with it. + Again Call GetAppIcon API on an app which does not have an icon file associated with it. + Again Call GetAppIcon with an invalid app uid. Do it for SVG and MBM icon file. + + @SYMTestExpectedResults RApaLsSession::GetAppIcon should return KErrNotFound when + an invalid app uid is passed, KErrNotFound when application does not have an icon + file, KErrNone and an open file handle to the application's icon file if application + has an icon file. + */ +void CT_RApaLsSessionTestStep::TestGetAppIcon1L() + { + TestGetAppIconForMBMIconsL(); + TestGetAppIconForSVGIconsL(); + + //Generic tests for both MBM and SVG icon files + RFile iconFile; + CleanupClosePushL(iconFile); + //Testing GetAppIcon for native app without an icon file. + INFO_PRINTF1(_L("Testing GetAppIcon API for an app that does not have an icon file")); + const TUint KGroupNameApp = 0x10208185; //T_groupNametest app, does not have an icon file. + TInt err = iLs.GetAppIcon(TUid::Uid(KGroupNameApp), iconFile); + TEST(err == KErrNotFound); + + //Checking the iconfile name when the icon file is not a physical file on the file system. + CApaAppViewArray* appViews = new(ELeave) CApaAppViewArray(4); + CleanupStack::PushL(appViews); + TInt ret = iLs.GetAppViews(*appViews, TUid::Uid(KGroupNameApp)); + TEST(ret==KErrNone); + TEST(appViews->Count() > 0); + + const TApaAppViewInfo& viewInfo=(*appViews)[0]; + TEST(viewInfo.iUid != KNullUid); + + HBufC* fullIconFileName = NULL; + ret = iLs.GetAppViewIcon(TUid::Uid(KGroupNameApp), viewInfo.iUid, fullIconFileName); + TEST(ret == KErrNone); + TEST(fullIconFileName != NULL); + INFO_PRINTF2(_L("The View icon's UID is - %X"), viewInfo.iUid); + TEST(!fullIconFileName->Compare(_L("file:///c/resource/apps/tcheckiconapp.xyz"))); + INFO_PRINTF2(_L("View's icon file name is - %S"), fullIconFileName); + + delete fullIconFileName; + CleanupStack::PopAndDestroy(appViews); + + //Testing GetAppIcon with an invalid app UID. + INFO_PRINTF1(_L("Testing GetAppIcon API with unknown app uid")); + TUid invalidAppUid = {9999}; + err = iLs.GetAppIcon(invalidAppUid, iconFile); + TEST(err == KErrNotFound); + + //Close icon file + CleanupStack::PopAndDestroy(&iconFile); + + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::TestGetAppIconForMBMIconsL() + { + //Testing GetAppIcon for native app with MBM icon file. + INFO_PRINTF1(_L("Testing GetAppIcon API for an app to retrieve an open file handle to an MBM icon file")); + const TUint KTestApp = 10; //Tstapp app, has MBM icon file + + RFile mbmIconFile; + CleanupClosePushL(mbmIconFile); + + TInt err = iLs.GetAppIcon(TUid::Uid(KTestApp), mbmIconFile); + TEST(err == KErrNone); + + _LIT(KMBMIconFileName, "z:\\resource\\apps\\tstapp.mbm"); + //Get the name of the icon file + TBuf mbmIconFileName; + mbmIconFile.FullName(mbmIconFileName); + TEST(mbmIconFileName.Length() != 0); + if (mbmIconFileName.Length() != 0) + { + mbmIconFileName.LowerCase(); + TEST(mbmIconFileName.Compare(KMBMIconFileName) == 0); + } + + //Try to write into the MBM icon file whose handle was returned. + INFO_PRINTF1(_L("..writing into the MBM icon file whose handle was returned.")); + _LIT8(KSomeText, "It would not be written into the file"); + err = mbmIconFile.Write(KSomeText); + TEST(err == KErrAccessDenied); + + //Try to read from the MBM icon file whose handle was returned. + INFO_PRINTF1(_L("..reading from the MBM icon file whose handle was returned.")); + TBuf8 buffer; //buffer to read first KBytesToRead bytes of the mbm icon file. + err = mbmIconFile.Read(buffer); + TEST(err == KErrNone); + + //Close icon files. + CleanupStack::PopAndDestroy(&mbmIconFile); + + //First KBytesToRead bytes of the icon file, this should be same as in mbm file. + RFile tempFile; + CleanupClosePushL(tempFile); + err = tempFile.Open(iFs, KMBMIconFileName, EFileShareReadersOnly); + TEST(err == KErrNone); + TBuf8 buffer1; + err = tempFile.Read(buffer1); + TEST(err == KErrNone); + TEST(buffer == buffer1); + CleanupStack::PopAndDestroy(&tempFile); + } + +void CT_RApaLsSessionTestStep::TestGetAppIconForSVGIconsL() + { + //Testing GetAppIcon for native app with SVG icon file. + RFile svgIconFile; + CleanupClosePushL(svgIconFile); + INFO_PRINTF1(_L("Testing GetAppIcon API for an app to retrieve an open file handle to an SVG icon file")); + const TUint KApparcTestApp = 0x100048F3; //Tstapp app, has SVG icon file + TInt err = iLs.GetAppIcon(TUid::Uid(KApparcTestApp), svgIconFile); + TEST(err == KErrNone); + + _LIT(KSVGIconFileName, "z:\\resource\\apps\\svg_icon.svg"); + //Get the name of the icon file + TBuf svgIconFileName; + svgIconFile.FullName(svgIconFileName); + TEST(svgIconFileName.Length() != 0); + if (svgIconFileName.Length() != 0) + { + svgIconFileName.LowerCase(); + TEST(svgIconFileName.Compare(KSVGIconFileName) == 0); + } + + //Try to write into the icon file whose handle was returned. + INFO_PRINTF1(_L("..writing into the SVG icon file whose handle was returned.")); + _LIT8(KSomeText, "It would not be written into the file"); + err = svgIconFile.Write(KSomeText); + TEST(err == KErrAccessDenied); + + //Try to read from the icon file whose handle was returned. + INFO_PRINTF1(_L("..reading from the SVG icon file whose handle was returned.")); + TBuf8 svgBuffer; //buffer to read first KBytesToRead bytes of the icon file. + err = svgIconFile.Read(svgBuffer); + TEST(err == KErrNone); + + //Close icon file + CleanupStack::PopAndDestroy(&svgIconFile); + + //First KBytesToRead bytes of the icon file, this should be same as in mbm file. + RFile tempFile; + CleanupClosePushL(tempFile); + err = tempFile.Open(iFs, KSVGIconFileName, EFileRead); + TEST(err == KErrNone); + TBuf8 buffer1; + err = tempFile.Read(buffer1); + TEST(err == KErrNone); + TEST(svgBuffer == buffer1); + CleanupStack::PopAndDestroy(&tempFile); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppListInstallationL + + @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: import\apps folder to c: import\apps folder. + 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. It also confirms that + if UID of an application which is present on import\apps folder on any non-ROM drive, is same + as UID of an existing application present on z: import\apps folder then the apparc server + updates the applist and uses the application residing on non-ROM drive's import\apps folder. + + */ +void CT_RApaLsSessionTestStep::TestAppListInstallationL() + { + _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,"Waiting %d microseconds for applist to be updated"); + const TInt KApplistUpdateTime = 10000000; + + // 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 == iLs.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")); + TRequestStatus status; + TTime tempTime(0); // added tempTime to avoid asynch CFileMan::Attribs request completing with KErrArgument + TEST(fileManager->Attribs(KTestAppDest,0,KEntryAttReadOnly, tempTime, CFileMan::ERecurse, status)==KErrNone); + User::WaitForRequest(status); + TEST(status.Int() == KErrNone); + 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 == iLs.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(); + + INFO_PRINTF1(_L("Test TestAppListInstallationL completed")); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppListInstallation1L + + @SYMDEF DEF055654: Platform-security loop-hole for "import-directory" applications + + @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 SimpleApparcTestApp from z:\private\10003a3f\apps folder to c:\private\10003a3f\import\apps + folder. Call RApaLsSession::GetAppInfo() and test the application information obtained to + verify that apparc server does not update the application to reside in c: drive + but on z drive. Delete the copied application and call RApaLsSession::GetAppInfo(). + Verify that the application list does not update app list again.\n + API Calls:\n + RApaLsSession::GetAppInfo(TApaAppInfo& aInfo,TUid aAppUid) const\n + + @SYMTestExpectedResults The test confirms that the scanning order of apparc server + for applications is 'apps' folder for all ROM drives and then 'import\apps' folder + for all other drives. It also confirms that if UID of an application which is present in + import\apps folder on any non-ROM drive, is same as UID of an existing application present + on z: apps folder then the apparc server does not update app list and uses the application + residing on z drive. + + */ +void CT_RApaLsSessionTestStep::TestAppListInstallation1L() + { + _LIT(KTestAppDestDir, "C:\\private\\10003a3f\\import\\apps\\" ); + _LIT(KTestAppSource, "Z:\\private\\10003a3f\\apps\\SimpleApparcTestApp_reg.rsc" ); + _LIT(KTestAppDest, "C:\\private\\10003a3f\\import\\apps\\SimpleApparcTestApp_reg.rsc" ); + + _LIT(KTestWaitingForApplistUpdate,"Waiting %d microseconds for applist to be updated"); + const TInt KApplistUpdateTime=10000000; + + // Copy reg files around and delete them to check the app list does not update. + RFs theFS; + User::LeaveIfError(theFS.Connect()); + CleanupClosePushL(theFS); + + // Remove simple app from the file system + CFileMan* fileManager=CFileMan::NewL(theFS); + CleanupStack::PushL(fileManager); + + INFO_PRINTF1(_L("Copying the app to C \\import\\apps folder")); + TEST(KErrNone==fileManager->Copy(KTestAppSource,KTestAppDest,CFileMan::ERecurse)); + + INFO_PRINTF2(KTestWaitingForApplistUpdate,KApplistUpdateTime); + User::After(KApplistUpdateTime); + + TApaAppInfo appInfo; + const TUid KUidSimpleApparcTestApp={0x12008ACE}; + TEST(KErrNone==iLs.GetAppInfo(appInfo,KUidSimpleApparcTestApp)); + + TParsePtrC parse(appInfo.iFullName); + _LIT (KZdrive,"Z:"); + INFO_PRINTF1(_L("After copying app to C:, there should not be any update in app list:... ")); + INFO_PRINTF1(_L("Comparing App drive location is Z:... ")); + TEST(parse.Drive().CompareF(KZdrive)==0); + + INFO_PRINTF1(_L("Removing the app from C")); + TRequestStatus status; + TTime tempTime(0); // added tempTime to avoid asynch CFileMan::Attribs request completing with KErrArgument + TEST(fileManager->Attribs(KTestAppDest,0,KEntryAttReadOnly,tempTime,CFileMan::ERecurse,status)==KErrNone); + User::WaitForRequest(status); + TEST(status.Int()==KErrNone); + 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); + + TEST(KErrNone==iLs.GetAppInfo(appInfo,KUidSimpleApparcTestApp)); + + TParsePtrC parse1(appInfo.iFullName); + INFO_PRINTF1(_L("After removing app from C:, there should not be any update in app list:... ")); + INFO_PRINTF1(_L("Comparing App drive location is Z:... ")); + TEST((parse1.Drive().CompareF(KZdrive))==0); + + CleanupStack::PopAndDestroy(2, &theFS); + + INFO_PRINTF1(_L("Test TestAppListInstallation1L completed")); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-TestAppFolderNonRomDrivesL + + @SYMDEF DEF055654: Platform-security loop-hole for "import-directory" applications + + @SYMTestCaseDesc Test scanning of app folder for non-ROM drives. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Test scanning of app folder for non-ROM drives. + Copy a new application AAA_reg from z:\Apparctest folder to c:\private\10003a3f\apps folder. + Call RApaLsSession::GetAppInfo() and test application architecture server does not + populate the new application in app list. Delete the copied application.\n + API Calls:\n + RApaLsSession::GetAppInfo(TApaAppInfo& aInfo,TUid aAppUid) const\n + + @SYMTestExpectedResults The test confirms that the application architecture server does not + scans applications residing in 'apps' folder for all non-ROM drives. + */ +void CT_RApaLsSessionTestStep::TestAppFolderNonRomDrivesL() + { + _LIT(KTestAppDestDir, "C:\\private\\10003a3f\\apps\\" ); + _LIT(KTestAppSource, "Z:\\Apparctest\\AAA_reg.rsc" ); + _LIT(KTestAppDest, "C:\\private\\10003a3f\\apps\\AAA_reg.rsc" ); + + _LIT(KTestWaitingForApplistUpdate,"Waiting %d microseconds for applist to be updated"); + const TInt KApplistUpdateTime=10000000; + + INFO_PRINTF1(_L("Test scanning of app folder for non-ROM drives")); + // Copy reg files around and delete them to check + // the app list does not update. + RFs theFS; + User::LeaveIfError(theFS.Connect()); + CleanupClosePushL(theFS); + + // Remove simple app from the file system + CFileMan* fileManager=CFileMan::NewL(theFS); + CleanupStack::PushL(fileManager); + + INFO_PRINTF1(_L("Copying AAA app to C apps folder")); + TEST(KErrNone==fileManager->Copy(KTestAppSource,KTestAppDest,CFileMan::ERecurse)); + + INFO_PRINTF2(KTestWaitingForApplistUpdate,KApplistUpdateTime); + User::After(KApplistUpdateTime); + + TApaAppInfo appInfo; + // UID of AAA app is 0x10207f74 + const TUid KUidSimpleApp={0x10207f74}; + INFO_PRINTF1(_L("Finding AAA app in app list... ")); + TEST(KErrNotFound==iLs.GetAppInfo(appInfo,KUidSimpleApp)); + + INFO_PRINTF1(_L("Removing AAA app from C apps folder")); + TRequestStatus status; + TTime tempTime(0); // added tempTime to avoid asynch CFileMan::Attribs request completing with KErrArgument + TEST(fileManager->Attribs(KTestAppDest,0,KEntryAttReadOnly,tempTime,CFileMan::ERecurse,status)==KErrNone); + User::WaitForRequest(status); + TEST(status.Int()==KErrNone); + 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); + + INFO_PRINTF1(_L("Finding AAA app in app list... ")); + TEST(KErrNotFound==iLs.GetAppInfo(appInfo,KUidSimpleApp)); + + CleanupStack::PopAndDestroy(2, &theFS); + + INFO_PRINTF1(_L("Test scanning of app folder for non-ROM drives completed")); + } + +/** + @SYMTestCaseID T-RApaLsSessionTestStep-DoNumDefIconsTestL + + @SYMDEF DEF037571 - Provide a better alternative to CApaAppInfoFileReader::NumberOfBitmaps' + + @SYMTestCaseDesc + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + API Calls:\n + RApaLsSession::GetAppIconSizes() \n + RApaLsSession::NumberOfOwnDefinedIcons(appUid, iconCount) + @SYMTestExpectedResults + + */ +void CT_RApaLsSessionTestStep::DoNumDefIconsTestL() + { + INFO_PRINTF1(_L("Testing RApaLsSession::NumberOfOwnDefinedIcons")); + + 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 + TInt err = iLs.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 = iLs.NumberOfOwnDefinedIcons(appUid, iconCount); + TEST(err == KErrNone); + TEST(iconCount == 0); + + // Test NumberOfOwnDefinedIcons again, this time with Agenda app UID (icons defined) + INFO_PRINTF1(_L("Testing NumberOfOwnDefinedIcons (Paint app)")); + iconCount = -1; + appUid.iUid = 0x10003A5C;//agenda app UID + err = iLs.NumberOfOwnDefinedIcons(appUid, iconCount); + TEST(err == KErrNone); + TEST(iconCount == 3); + + CleanupStack::PopAndDestroy(array); + + INFO_PRINTF1(_L("NumberOfOwnDefinedIcons test complete")); + } + + +void CT_RApaLsSessionTestStep::TestMatchesSecurityPolicy() + { + TUid appUid; + appUid.iUid=0X10009f9a; + TBool matches; + + //Testing with valid TSecurityPolicy + INFO_PRINTF1(_L("Testing MatchesSecurityPolicy with valid TSecurityPolicy")); + iLs.MatchesSecurityPolicy(matches, appUid, TSecurityPolicy(TVendorId(0x70000001))); + TEST(matches); + INFO_PRINTF1(KCompleted); + + //Testing with invalid TSecurityPolicy + INFO_PRINTF1(_L("Testing MatchesSecurityPolicy with invalid TSecurityPolicy")); + APPFWK_NEGATIVE_PLATSEC_START; + iLs.MatchesSecurityPolicy(matches, appUid, TSecurityPolicy(TVendorId(0x70000002))); + APPFWK_NEGATIVE_PLATSEC_FINISH; + TEST(!matches); + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::TestGetAppViewsL() + { + INFO_PRINTF1(_L("Testing RApaLsSession::GetAppViews() with a valid app uid")); + + CApaAppViewArray* appViews = new(ELeave) CApaAppViewArray(4); + CleanupStack::PushL(appViews); + + TInt ret = iLs.GetAppViews(*appViews, KUidTestApp); + TEST(ret==KErrNone); + + // check appviews contain entries + const TInt count=appViews->Count(); + TEST(count > 0); + TInt testNumberOfIcons = count-1; + //the last view is invalid. Hence it checks till count-1 + for (TInt ii=0; ii 0); + TEST(viewInfo.iScreenMode == 0x00); + + // check icons in the views + CApaMaskedBitmap* viewBitmap = CApaMaskedBitmap::NewLC(); + ret = iLs.GetAppViewIcon(KUidTestApp, viewInfo.iUid, TSize(50,50), *viewBitmap); + TEST(ret==KErrNone); + CleanupStack::PopAndDestroy(viewBitmap); + + HBufC* fullFileName = NULL; + ret = iLs.GetAppViewIcon(KUidTestApp, viewInfo.iUid, fullFileName); + TEST(ret == KErrNone); + TEST(fullFileName != NULL); + if (fullFileName != NULL) + { + TEST(fullFileName->Length() > 0); + } + delete fullFileName; + fullFileName = NULL; + } + + CleanupStack::PopAndDestroy(appViews); + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::TestGetAppViewsFailureL() + { + INFO_PRINTF1(_L("Testing RApaLsSession::GetAppViews() with an invalid app uid")); + + const TUid appUid={10000}; // invalid uid + CApaAppViewArray* appViews = new(ELeave) CApaAppViewArray(2); + CleanupStack::PushL(appViews); + + //Create App View array + TInt ret = iLs.GetAppViews(*appViews, appUid); + TEST(ret=KErrNotFound); + + CleanupStack::PopAndDestroy(appViews); + INFO_PRINTF1(KCompleted); + } + +void CT_RApaLsSessionTestStep::IconLoadingTestCasesL() + { + CArrayFixFlat* testIconSizeArray; + testIconSizeArray=new(ELeave) CArrayFixFlat(3); + CleanupStack::PushL(testIconSizeArray); + TestServerIconSizeCountL(*testIconSizeArray); + TestServerIconLoadingBySize1L(*testIconSizeArray); + TestServerIconLoadingBySize2L(*testIconSizeArray); + TestServerIconLoadingBySize3L(*testIconSizeArray); + CleanupStack::PopAndDestroy(testIconSizeArray); + } + +void CT_RApaLsSessionTestStep::AppInfoTestCasesL() + { + TestAppListInfoDataInterrogationSetupL(); + + TestAppInfo1(); + TestAppInfo2(); + TestAppInfo3(); + TestAppInfo4(); + + TestGetAppCapabilityL(); + TestRecognizeSpecificData(); + + TestSetGetAcceptedConfidenceL(); + TestSetGetMaxDataBufSizeL(); + + TestGetSupportedDataTypesL(); + TestGetAppIconL(); + TestGetAppIcon1L(); + TestGetAppIcon2L(); + + TestGetAppViewsL(); + TestGetAppViewsFailureL(); + } + +void CT_RApaLsSessionTestStep::EmbeddedAppsTestCases() + { + DoGetAllApps(); + DoGetEmbeddableApps(); + DoEmbeddableAppCount(); + DoGetAppCapability(); + DoGetFilteredApps1(); + DoGetFilteredApps2(); + DoGetFilteredApps3(); + DoGetFilteredApps4(); + DoGetFilteredApps5(); + DoGetFilteredApps6(); + DoTestEmbeddabilityFilter1(); + DoTestEmbeddabilityFilter2(); + DoTestEmbeddabilityFilter3(); + DoTestEmbeddabilityFilter4(); + DoTestEmbeddabilityFilter5(); + } + +void CT_RApaLsSessionTestStep::TestNotifyOnDataMappingChangeL() + { + INFO_PRINTF1(_L("Test RApaLsSession::TestNotifyOnDataMappingChangeL()")); + RApaLsSession lsMappingChange; + lsMappingChange.Connect(); + CleanupClosePushL(lsMappingChange); + TRequestStatus status; + lsMappingChange.NotifyOnDataMappingChange(status); + //Test for TestCancelNotifyOnDataMappingChange + lsMappingChange.CancelNotifyOnDataMappingChange(); + User::WaitForRequest(status); + TEST( status ==KErrCancel); + //Test for TestNotifyOnDataMappingChangeL + lsMappingChange.NotifyOnDataMappingChange(status); + const TUid KTestUidValue1={10101010}; + const TDataType dataType(_L8("sonew/else")); + iLs.InsertDataMapping(dataType,KDataTypePriorityHigh,KTestUidValue1); + User::WaitForRequest(status); + TEST(status==KErrNone); + TEST(KErrNone == iLs.DeleteDataMapping(dataType)); + CleanupStack::PopAndDestroy(&lsMappingChange); + INFO_PRINTF1(KCompleted); + } + +/** + @SYMTestCaseID T_RApaLsSessionTestStep_TestDataPriorityForUnTrustedApps + + @SYMDEF DEF063982 + + @SYMTestCaseDesc Tests the Un-Trusted Apps Datatypepriority assigned through + RApaLsSession::InsertDataMapping(const TDataType& aDataType, TDataTypePriority aPriority, TUid aUid)\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestExpectedResults All tests compare the results obtained with the desired result. +*/ +void CT_RApaLsSessionTestStep::TestDataPriorityForUnTrustedApps() + { + INFO_PRINTF1(_L("TestDataPriorityForUnTrustedApps about to start...")); + const TUid KUidUnTrustedApp = {0x10207f8C}; + const TUid KUidTrustedApp = {0x10207f8D}; + TInt ret; + TBool insertVal = EFalse; + //There is no restriction for the Trusted Apps datapriority + TDataTypePriority KTrustedAppPriority = {KDataTypeUnTrustedPriorityThreshold+1}; + //The data priority for UnTrusted Apps is greater than the Threshold + TDataTypePriority KUnTrustedAppPriority = {KDataTypeUnTrustedPriorityThreshold+10}; + _LIT8(KLitMimeTypeTestData,"test/data"); + ret = iLs.InsertDataMapping(TDataType(KLitMimeTypeTestData),KTrustedAppPriority,KUidTrustedApp); + //UnTrusted Apps data priority will be reduced to Security Threshold if it is greater than it. + ret = iLs.InsertDataMappingIfHigher(TDataType(KLitMimeTypeTestData),KUnTrustedAppPriority,KUidUnTrustedApp,insertVal); + TUid testUid; + ret = iLs.AppForDataType(TDataType(KLitMimeTypeTestData),testUid); + TEST(ret == KErrNone); + TEST(testUid == KUidTrustedApp); + INFO_PRINTF1(_L("Completed")); + } + +/** + @SYMTestCaseID T_RApaLsSessionTestStep_TestDataPriorityForUnTrustedAppsRegFile + + @SYMDEF DEF063982 + + @SYMTestCaseDesc Tests the UnTrusted Apps Datatypepriority assigned through the registration files + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestExpectedResults All tests compare the results obtained with the desired result. + */ +void CT_RApaLsSessionTestStep::TestDataPriorityForUnTrustedAppsRegFile() + { + INFO_PRINTF1(_L("TestDataPriorityForUnTrustedAppsRegFile about to start...")); + const TUid KUidRegTrustedApp = {0x10207f8F}; + _LIT8(KLitMimeTypeTestData,"text/html"); + TUid testUid; + TInt ret; + //The datatype priority of UnTrusted Apps is reduced to Threshold. + ret = iLs.AppForDataType(TDataType(KLitMimeTypeTestData),testUid); + TEST(ret == KErrNone); + TEST(testUid == KUidRegTrustedApp); + INFO_PRINTF1(_L("Completed")); + } + +/** + @SYMTestCaseID T_RApaLsSessionTestStep_TestIconLoaderAndIconArrayMemoryLeaksL + + @SYMDEF PDEF104113 + + @SYMTestCaseDesc Checks there's no memory leaks when a CApaAppIconArray oject + is created and deleted + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions It creates an object of CApaAppIconArray class and deletes it. + Then test there is no memory leak from the creation to destory the object. + + @SYMTestExpectedResults There should be no memory leak checked by __UHEAP_MARK + and __UHEAP_MARKEND. + */ +void CT_RApaLsSessionTestStep::TestIconLoaderAndIconArrayMemoryLeaksL() + { + INFO_PRINTF1(_L("Test TestIconLoaderAndIconArrayMemoryLeaksL")); + __UHEAP_MARK; + TIconLoaderAndIconArrayForLeaks::TestIconLoaderAndIconArrayL(); + __UHEAP_MARKEND; + INFO_PRINTF1(_L("Completed")); + } + +void CT_RApaLsSessionTestStep::RunTestCasesL() + { + //make sure the RFbsSession doesn't have to allocate buffer since it would change the heap + CFbsBitmap* bufferAllocator = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bufferAllocator); + bufferAllocator->Create(TSize(200,1), EColor16M); + CleanupStack::PopAndDestroy(bufferAllocator); + + + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestAppListInvalidL(), iLs.ClearAppInfoArray() ); + //DONT_CHECK due to file system changes + HEAP_TEST_LS_SESSION(iLs, 0, DONT_CHECK, TestAppListInstallationL(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, DONT_CHECK, TestAppListInstallation1L(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, DONT_CHECK, TestAppFolderNonRomDrivesL(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, IconLoadingTestCasesL(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, AppInfoTestCasesL(), iLs.ClearAppInfoArray(); NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, EmbeddedAppsTestCases(), iLs.ClearAppInfoArray() ); + HEAP_TEST_LS_SESSION(iLs, 0, DONT_CHECK, DoNumDefIconsTestL(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestMatchesSecurityPolicy(), NO_CLEANUP); + //DONT_CHECK since there's a new typestore + HEAP_TEST_LS_SESSION(iLs, 0, DONT_CHECK, TestNotifyOnDataMappingChangeL(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestAppListRecognizeDataBufferOnlyL(), iLs.FlushRecognitionCache() ); + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestAppListRecognizeDataL(), iLs.FlushRecognitionCache() ); + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestDataPriorityForUnTrustedApps(), NO_CLEANUP); + HEAP_TEST_LS_SESSION(iLs, 0, 0, TestDataPriorityForUnTrustedAppsRegFile(), NO_CLEANUP); + TestIconLoaderAndIconArrayMemoryLeaksL(); + } + +/** + Destructor + */ +CT_RApaLsSessionTestStep::~CT_RApaLsSessionTestStep() + { + RFbsSession::Disconnect(); + iFs.Close(); + iLs.Close(); + } + +/** + Constructor + */ +CT_RApaLsSessionTestStep::CT_RApaLsSessionTestStep() + { + FbsStartup(); + TInt ret=RFbsSession::Connect(); + TEST(ret==KErrNone); + + ret=iFs.Connect(); + TEST(ret==KErrNone); + + setup(); + + ret = iLs.Connect(); + TEST(ret==KErrNone); + + // Call base class method to set up the human readable name for logging + SetTestStepName(KT_RApaLsSessionStep); + } + +/** + @return - TVerdict code + Override of base class virtual + */ +TVerdict CT_RApaLsSessionTestStep::doTestStepPreambleL() + { + SetTestStepResult(EPass); + return TestStepResult(); + } + +/** + @return - TVerdict code + Override of base class virtual + */ +TVerdict CT_RApaLsSessionTestStep::doTestStepPostambleL() + { + return TestStepResult(); + } + + +TVerdict CT_RApaLsSessionTestStep::doTestStepL() + { + INFO_PRINTF1(_L("Testing Apparc...T_RApaLsSession Test Cases Running...")); + + TRAPD(ret,RunTestCasesL()) + TEST(ret==KErrNone); + + INFO_PRINTF1(_L("...T_RApaLsSession Test Cases Completed.")); + + return TestStepResult(); + } +