--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/common/tools/ats/smoketest/localisation/apparchitecture/tef/T_Serv3Step.cpp Fri Nov 27 12:22:12 2009 +0000
@@ -0,0 +1,1949 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Test wrapper to Application Architecture Server.
+// Tests Application information, Data recognition and application
+// launching capabilities of the application architecture server.\n
+//
+//
+
+
+
+/**
+ @file
+ @internalComponent - Internal Symbian test code
+*/
+
+#include <f32file.h>
+#include <fbs.h>
+#include <apaid.h>
+#include <apgaplst.h>
+#include <apaflrec.h>
+#include "testableapalssession.h"
+#include <apacmdln.h>
+#include <apsserv.h>
+#include <apfrec.h>
+#include <datastor.h>
+#include <apgicnfl.h>
+#include <apasvst.h>
+#include "tstapp.h"
+//
+#include <e32test.h>
+#include "T_Serv3Step.h"
+
+#include <coemain.h>
+#include <eikenv.h>
+#include "TAppEmbedUids.h"
+#include "appfwk_test_utils.h"
+
+
+//Literals for directory and file naming
+_LIT(KMimeDir,"c:\\system\\data\\Mimepath\\");
+_LIT(KMimeFile,"c:\\system\\data\\Mimepath\\mime_content");
+_LIT(KEmptyDir,"c:\\system\\data\\Testpath\\Empty\\");
+_LIT8(KTextContent, "Never hit your mother with a shovel.\
+ It leaves a dark impression on her mind.");
+_LIT(KSuffixText, ".txt");
+_LIT(KSuffixHtml, ".html");
+_LIT8(KHtmlContent, "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.0\
+ Transitional//EN'><HTML><HEAD><TITLE>SYMBIAN Centre\
+ - 5 Day Forecast for London, United Kingdom</TITLE>\
+ <META http-equiv=Content-Type content=text/html;\
+ charset=iso-8859-1><META content='Symbian Five Day Forecast'\
+ name=type><META content='The Symbian five day forecast'\
+ name=description>");
+_LIT(KSuffixUnknown, ".canyoutell");
+
+const TInt KFixedNumWidth = 3;
+
+CT_Serv3Step::~CT_Serv3Step()
+/**
+ * Destructor
+ */
+ {
+ delete iActiveScheduler;
+ }
+
+CT_Serv3Step::CT_Serv3Step()
+/**
+ * Constructor
+ */
+ {
+ // Call base class method to set up the human readable name for logging
+ SetTestStepName(KT_Serv3Step);
+
+ //Set up active scheduler
+ iActiveScheduler= new(ELeave) CActiveScheduler;
+ CActiveScheduler::Install(iActiveScheduler);
+ }
+
+/**
+ @SYMTestCaseID T_Serv3Step_DoSyncRecognizerTest1L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3897
+
+ @SYMTestCaseDesc Test PREQ699.1.0 Validate Synchronous RecognizeFilesL function and CDataRecognitionResultArray\n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Calls RecognizeFilesL() with a folder containing two files of zero and one byte sizes. Validates
+ the returned number of files and file types. Tests CDataRecognitionResultArray by using the object.
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, CDataRecognitionResultArray& aResult);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+ CDataRecognitionResultArray::const TFileName& Path() const\n
+ CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const;\n
+ CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const\n
+
+ @SYMTestExpectedResults KErrNone and CDataRecognitionResultArray returned containing two entries, of MIME type "text/plain" \n
+
+ */
+void CT_Serv3Step::DoSyncFolderRecognizerTest1L(RApaLsSession& aLs)
+ {
+ //Synchronous Folder File Recognition Test Group 1
+
+ _LIT(KStandardDir,"z:\\system\\data\\Testpath\\");
+
+ // Copy App files around and delete them to check whether
+ // the app list updates and stores the cache correctly.
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.1.0"));
+ TInt ret=aLs.RecognizeFilesL(KStandardDir,*result);
+ TEST(ret==KErrNone);
+ User::LeaveIfError(ret);
+
+ // Test the CDataRecognitionResultArray object
+ TFileName path = result->Path(); //test: CDataRecognitionResultArray::Path()
+ TFullName standardDir(KStandardDir);
+ //Test the path created is correct
+ TEST(path==standardDir);
+
+ TUint count = result->Count(); //test: CDataRecognitionResultArray::Count()
+ TEST(count==2); //two files in directory
+
+ //get each result from the test directory. Check the MIME values against their known types
+ for(TUint i=0; i<count;i++)
+ {
+ //test: CDataRecognitionResultArray::GetDataRecognitionResultL
+ TDataRecognitionResult res;
+ result->GetDataRecognitionResultL(res, i);
+ //test: correct MIME type is returned - "text/plain"
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8()) == 0);
+
+ //test: CDataRecognitionResultArray::GetFileNameL
+ TFileName fileName;
+ result->GetFileNameL(fileName, i);
+ TEST(fileName.Compare( (i==0 ? _L("file1.txt") : _L("file2.txt")) ) == 0);
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoSyncRecognizerTest2L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Test PREQ699.2.0 and PREQ699.2.1 Validate Synchronous RecognizeFilesL function for error handling.\n
+
+ @SYMTestStatus Implemented
+
+ @SYMTestPriority High
+
+ @SYMTestActions. Test 2.0 Calls RecognizeFilesL() (without a data filter then with a data filter) using an unknown folder path.
+ Checks returned value is KErrPathNotFound.
+ Test 2.1 Calls RecognizeFilesL() (without a data filter then with a data filter) using an empty folder path.
+ Checks returned value is KErrNone and that returned array is empty.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, CDataRecognitionResultArray& aResult);\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+
+ @SYMTestExpectedResults Test 2.0 returned value is KErrPathNotFound.\n
+ Test 2.1 returned value is KErrNone and that returned array is empty.\n
+ */
+ void CT_Serv3Step::DoSyncFolderRecognizerTest2L(RApaLsSession& aLs)
+ {
+ TBufC<50> emptyDir(KEmptyDir);
+ TPtr ptrEmptyDir(emptyDir.Des());
+
+ //Synchronous Folder File Recognition Test Group
+
+ //**************
+ // Test Case 2.0 - Test Recognizer for incorrect folder path.Test both versions of synchronous RecognizeFiles
+ //**************
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.2.0"));
+ _LIT(KNotKnownDir,"z:\\system\\data\\Testpath\\NotKnown\\");
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+
+ TInt ret=aLs.RecognizeFilesL(KNotKnownDir,*result1);
+ TEST(ret==KErrPathNotFound);
+
+ ret=aLs.RecognizeFilesL(KNotKnownDir,_L8("text/plain"),*result1);
+ TEST(ret==KErrPathNotFound);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result1);//result1
+
+ // Create a directory with no files
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ CreateDirL(&utils, ptrEmptyDir);
+
+ //**************
+ // Test Case 2.1 -Test Recognizer for empty folder. Test both versions of synchronous RecognizeFiles
+ //**************
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.2.1"));
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result2);
+
+ ret=aLs.RecognizeFilesL(KEmptyDir,*result2);
+ TEST(ret==KErrNone);
+
+ TUint count = result2->Count();
+ TEST(count==0);
+
+ INFO_PRINTF1(_L("Test empty folder for filter version parameter"));
+ ret=aLs.RecognizeFilesL(KEmptyDir,_L8("text/plain"),*result2);
+ TEST(ret==KErrNone);
+
+ count = result2->Count();
+ TEST(count==0);
+
+ //Delete empty directory
+ DeleteDirL(&utils, ptrEmptyDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result2);//result2
+ CleanupStack::PopAndDestroy(&utils);//utils
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoSyncRecognizerTest3L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Validate Synchronous RecognizeFilesL data filter function using various filters.\n
+ Test 3.0 Validate Synchronous RecognizeFilesL data filter function and CDataRecognitionResultArray\n
+ Test 3.1 Validate Synchronous RecognizeFilesL functions with wildcard/MIME type validity.\n
+ Test 3.2 Validate Synchronous RecognizeFilesL functions with irregular strings.\n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Call RecognizeFilesL with three different data filters: i) standard= "text/plain"; ii) wildcard: "text*"; iii) non-valid \n
+ For each call, check the results are correct: number of files identified and the MIME types.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();\n
+ CDataRecognitionResultArray::Count() const;\n
+ CDataRecognitionResultArray::const TFileName& Path() const\n
+ CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const;\n
+ CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const\n
+
+ @SYMTestExpectedResults\n
+ Test 3.0 KErrNone and CDataRecognitionResultArray returned containing four entries, of MIME type "text/plain" \n
+ Test 3.1 KErrNone and CDataRecognitionResultArray returned containing four entries, of MIME type "text/plain" \n
+ Test 3.2 KErrNone and CDataRecognitionResultArray returned containing zero entries\n
+
+ */
+ void CT_Serv3Step::DoSyncFolderRecognizerTest3L(RApaLsSession& aLs)
+ {
+
+ //**************
+ // Test Case 3.0 - Test Recognizer filter version with datatype filter type validity.
+ // Also test CDataRecognitionResultArray::GetDataRecognitionResultL();
+ // CDataRecognitionResultArray::
+ //***************
+ //Synchronous Folder File Recognition Test Group 3;
+ _LIT(KFilterTestDir,"z:\\system\\data\\Testpath\\FilterTests\\");
+
+ CDataRecognitionResultArray* result3 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result3);
+
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.3.0"));
+ TInt ret=aLs.RecognizeFilesL(KFilterTestDir,_L8("text/plain"),*result3);
+ TEST(ret==KErrNone);
+ TUint count = result3->Count();
+ TEST(count==4);
+
+ //get each result from the test directory. Check the MIME values against known types
+ for(TUint i=0; i<count;i++)
+ {
+ TDataRecognitionResult res;
+ result3->GetDataRecognitionResultL(res, i); //the result
+ TFileName fileName;
+ result3->GetFileNameL(fileName, i); //the file we are looking at
+
+ //test for correct MIME type result
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8())==0);//report an error if not text/plain
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result3);//result
+
+ //*****************
+ // Test Case 3.1 - Test Recognizer filter version for wildcard/MIME type validity.
+ // Also test CDataRecognitionResultArray
+ //*********
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.3.1"));
+ CDataRecognitionResultArray* result4 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result4);
+ ret=aLs.RecognizeFilesL(KFilterTestDir,_L8("text*"),*result4);
+ TEST(ret==KErrNone);
+ count = result3->Count();
+ TEST(count==4);
+
+ //get each result from the test directory. Check the MIME values against some known types
+ for(TUint j=0; j<count;j++)
+ {
+ TDataRecognitionResult res;
+ result4->GetDataRecognitionResultL(res, j); //the result
+ TFileName fileName;
+ result4->GetFileNameL(fileName, j); //the file we are looking at
+
+ //test for correct MIME type result
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8())==0);//report an error if not text
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result4);//result
+
+ //*****************
+ // Test Case 3.2 -Test Recognizer filter version for with irregular strings.
+ //*********
+ INFO_PRINTF1(_L("Synchronous Folder File Recognition Test PREQ699.3.2"));
+ CDataRecognitionResultArray* result5 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result5);
+ ret=aLs.RecognizeFilesL(KFilterTestDir,_L8("&*/?|=+-"),*result5);
+ TEST(ret==KErrNone);
+ count = result5->Count();
+ TEST(count==0);
+
+ ret=aLs.RecognizeFilesL(KFilterTestDir,_L8("'/"),*result5);
+ TEST(ret==KErrNone);
+ count = result5->Count();
+ TEST(count==0);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result5);//result
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest1L
+
+ @SYMPREQ 699
+
+ @SYMREQ Non-Specific
+
+ @SYMTestCaseDesc Test PREQ699.4.0 Validate Asynchronous RecognizeFilesL (non-filtered) function and CDataRecognitionResultArray\n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Calls RecognizeFilesL() with a folder containing two files of zero and one byte sizes. Uses a Test Active Object
+ within the request. Validates the returned number of files and file types. Tests CDataRecognitionResultArray by using the object.\n
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+ CDataRecognitionResultArray::const TFileName& Path() const\n
+ CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const;\n
+ CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const\n
+
+ @SYMTestExpectedResults status= KErrNone and CDataRecognitionResultArray returned containing two entries, of MIME type "text/plain" \n
+
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest1L(RApaLsSession& aLs)
+ {
+
+ //Asynchronous folder file recognition Test Group 4
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ //Check results and Stop AS
+ _LIT(KStandardDir,"z:\\system\\data\\Testpath\\");
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.4.0"));
+ aLs.RecognizeFilesL(KStandardDir,*result,active->iStatus);
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+
+ TEST(count==2); //two files in directory
+
+ //get each result from the test directory. Check the MIME values against some known types
+ for(TUint i=0; i<count;i++)
+ {
+ TDataRecognitionResult res;
+ result->GetDataRecognitionResultL(res, i); // the result
+ //test MIME type result = "text/plain"
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8())==0);
+
+ TFileName fileName;
+ result->GetFileNameL(fileName, i); //the file we are looking at
+ TEST(fileName.Compare( (i==0 ? _L("file1.txt") : _L("file2.txt")) ) == 0);
+ }
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest2L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Test PREQ699.5.0 Validate Asynchronous RecognizeFilesL (filtered) function and CDataRecognitionResultArray\n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Call RecognizeFilesL() with a Data Type Filter (aDataType ="Text/Plain") and a Test Active Object.
+ Test that the number and data type of files returned is correct.
+ Tests CDataRecognitionResultArray by using the object.\n
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+ CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const;\n
+ CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const\n
+
+ @SYMTestExpectedResults status= KErrNone and CDataRecognitionResultArray returned containing four entries, of MIME type "text/plain" \n
+
+
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest2L(RApaLsSession& aLs)
+ {
+
+ //Asynchronous folder file recognition Test Group 5
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ _LIT(KFilterDir,"z:\\system\\data\\Testpath\\FilterTests\\");
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.5.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/plain"
+ aLs.RecognizeFilesL(KFilterDir,_L8("text/plain"), *result,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+
+ TEST(count==4); //four files in directory
+
+ //get each result from the test directory. Check the MIME values against some known types
+ for(TUint i=0; i<count;i++)
+ {
+ TDataRecognitionResult res;
+ result->GetDataRecognitionResultL(res, i); // the result
+ TFileName fileName;
+ result->GetFileNameL(fileName, i); // the file we are looking at
+
+ //test MIME type result = "text/plain"
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8())==0);
+ }
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest3L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Test PREQ699.6.0 Validate Asynchronous RecognizeFilesL function (with data filter and wildcard) \n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Call RecognizeFilesL() with a Data Type Filter and wildcard (aDataType ="Text/ *") and a Test Active Object.
+ Test that the number and data type of files returned is correct.
+ Tests CDataRecognitionResultArray by using the object.\n
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+ CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const;\n
+ CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const\n
+
+ @SYMTestExpectedResults status= KErrNone and CDataRecognitionResultArray returned containing four entries, of MIME type "text/plain" \n
+
+
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest3L(RApaLsSession& aLs)
+ {
+
+ // Asynchronous folder file recognition Test Group 6
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ _LIT(KFilterDir,"z:\\system\\data\\Testpath\\FilterTests\\");
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.6.0"));
+ aLs.RecognizeFilesL(KFilterDir,_L8("text*"), *result,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);//Test no error returned
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+
+ TEST(count==4); //four files in directory
+
+ //get each result from the test directory. Check the MIME values against some known types
+ for(TUint i=0; i<count;i++)
+ {
+ TDataRecognitionResult res;
+ result->GetDataRecognitionResultL(res, i); // the result
+ TFileName fileName;
+ result->GetFileNameL(fileName, i); //the file we are looking at
+
+ //test MIME type result="text/plain"
+ TEST(res.iDataType.Des8().Compare(TDataType(_L8("text/plain")).Des8())==0);
+ }
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest4L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Test PREQ699.7.0 Validate Asynchronous RecognizeFilesL function (with unknown and irregular data filters).
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Call RecognizeFilesL() with Data Type Filters of an irregular nature and a Test Active Object.
+ Test that no files are returned and status= KErrNone.\n
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+
+ @SYMTestExpectedResults status= KErrNone and CDataRecognitionResultArray returned containing zero entries \n
+
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest4L(RApaLsSession& aLs)
+ {
+
+ //Asynchronous folder file recognition Test Group 7
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ INFO_PRINTF1(_L("Testing Recognition of folder filtered with irregular strings"));
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ _LIT(KFilterDir,"z:\\system\\data\\Testpath\\FilterTests\\");
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.7.0"));
+ aLs.RecognizeFilesL(KFilterDir,_L8("&* /?|=+-"),*result, active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+ TEST(count==0); //no files should be found
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+
+ }
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest5L
+
+ @SYMPREQ 699
+
+ @SYMREQ Non-Specific
+
+ @SYMTestCaseDesc Test PREQ699.8.0 Validate Asynchronous RecognizeFilesL function with large directory to test Cache upperlimit. \n
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions. Call RecognizeFilesL() with a folder containing a large number of files and a Test Active Object.
+ Test that the number of files returned is correct.
+ Tests CDataRecognitionResultArray by using the object.\n
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);\n
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;\n
+
+ @SYMTestExpectedResults status= KErrNone and CDataRecognitionResultArray returned containing 550 entries. \n
+
+ */
+
+void CT_Serv3Step::DoAsyncFolderRecognizerTest5L(RApaLsSession& aLs)
+ {
+ _LIT(KLargeDir,"c:\\system\\data\\Testpath\\largeDir\\");
+ _LIT(KLargeDirRoot, "c:\\system\\data\\Testpath\\largeDir\\focus");
+
+ TBufC<50> bigDir(KLargeDir);
+ TPtr ptrBigDir (bigDir.Des());
+ TBufC<50> bigDirRoot(KLargeDirRoot);
+ TPtr ptrBigDirRoot (bigDirRoot.Des());
+
+ // Asynchronous folder file recognition Test Group 8
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ //File server and utils
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ CreateDirL(&utils, ptrBigDir);
+
+ CreateFilesL(theFS, file, ptrBigDirRoot, (TDesC&)KSuffixText, 550, KTextContent, 0);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.8.0"));
+ //Check results and Stop AS
+ aLs.RecognizeFilesL(KLargeDir,*result,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+ TEST(count==550); //550 files in directory - 500 files is thought to be cache capacity
+ }
+
+ DeleteFilesL(&utils, ptrBigDirRoot, (TDesC&)KSuffixText, 550);
+
+ DeleteDirL(&utils, ptrBigDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest6L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898 3899
+
+ @SYMTestCaseDesc Test PREQ699.9.0, PREQ699.9.1, PREQ699.9.2 Validates cache functionality with changed file mime type
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory with a filter and then change the mime type of one file.
+ Recognize the directory with a filter again and ensure that the file type change has been registered.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ 9.0 count = 1 CDataRecognitionResultArray::Count returns one entry of MIME type "text/plain"
+ status = KErrNone for file content changed to html
+ 9.1 count = 0 CDataRecognitionResultArray::Count returns no entries of MIME type "text/plain"
+ 9.2 count = 0 CDataRecognitionResultArray::Count returns no entries of MIME type "text/plain"
+
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest6L(RApaLsSession& aLs)
+ {
+
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir(mimeDir.Des());
+
+ TBufC<50> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ //Asynchronous folder file recognition Test Group 9
+
+ //Declare result arrays for storing seperate recognition results
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result3 = new(ELeave) CDataRecognitionResultArray();
+
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+ CleanupStack::PushL(result3);
+
+ //File server and utils
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+
+ aLaterTime+=(aInterval);
+
+ // Create file mime_content000.txt containing text
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixText, 1, KTextContent, time);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.9.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/plain"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/plain"), *result1 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count==1);
+ }
+
+ //Change file content to html
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixText, 1, KHtmlContent, aLaterTime);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.9.1"));
+ //Test RecognizeFilesL with a MIME type filter "text/plain"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/plain"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count==0);
+ }
+
+
+ //Delete file and recognise again
+ DeleteFilesL(&utils, ptrMimeFile, (TDesC&)KSuffixText, 1);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.9.2"));
+ aLs.RecognizeFilesL(KMimeDir, *result3,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result3->Count();
+ TEST(count==0);
+ }
+
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils); //utils
+ CleanupStack::PopAndDestroy(result3);//result1
+ CleanupStack::PopAndDestroy(result2);//result2
+ CleanupStack::PopAndDestroy(result1);//result3
+ CleanupStack::PopAndDestroy(active); //active
+
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest7L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898 3899
+
+ @SYMTestCaseDesc Test PREQ699.10.0 Validates cache functionality with changed mime type and filter (1)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory with a filter. Change the mime type of one file in the
+ directory such that it is now described by the filter. Recognize the
+ directory again with the same filter and ensure that the file type change has
+ been registered.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ count = 3 CDataRecognitionResultArray::Count returns three entries of MIME type "text/html"
+ status = KErrNone for file content changed to html
+ count = 4 CDataRecognitionResultArray::Count returns four entries of MIME type "text/html"
+ */
+ void CT_Serv3Step::DoAsyncFolderRecognizerTest7L(RApaLsSession& aLs)
+ {
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir (mimeDir.Des());
+
+ TBufC<50> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Asynchronous folder file recognition Test Group 10
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+ aLaterTime+=(aInterval);
+
+ // Create files mime_content000.canyoutell - mime_content003.canyoutell
+ // 000 with text content and 001-003 with html content
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 4, KHtmlContent, time);
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KTextContent, time);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.10.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result1 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count == 3);
+ }
+
+
+ //Change file content to html and update the timestamp
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KHtmlContent, aLaterTime);
+
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count == 4);
+ }
+
+
+ DeleteFilesL(&utils, ptrMimeFile, (TDesC&)KSuffixUnknown, 4);
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result2);//result1
+ CleanupStack::PopAndDestroy(result1);//result2
+ CleanupStack::PopAndDestroy(active);//active
+
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest8L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898 3899
+
+ @SYMTestCaseDesc Test PREQ699.11.0 Validates cache functionality with changed file mime type and filter (2)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory with a filter. Change the mime type of one file in the
+ directory such that it is now not described by the filter. Recognize the
+ directory again with the same filter and ensure that the file type change has
+ been registered.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ count = 4 CDataRecognitionResultArray::Count returns four entries of MIME type "text/html"
+ status = KErrNone for file content changed to html
+ count = 3 CDataRecognitionResultArray::Count returns three entries of MIME type "text/html"
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest8L(RApaLsSession& aLs)
+ {
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir (mimeDir.Des());
+
+ TBufC<50> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Asynchronous folder file recognition Test Group 11
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+ aLaterTime+=(aInterval);
+
+ // Create files mime_content000.canyoutell - mime_content003.canyoutell with html content
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 4, KHtmlContent, time);
+
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result1 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count == 4);
+ }
+
+
+ //Change file content to text
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KTextContent, aLaterTime);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.11.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count == 3);
+ }
+
+ DeleteFilesL(&utils, ptrMimeFile, (TDesC&)KSuffixUnknown, 4);
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result2);//result1
+ CleanupStack::PopAndDestroy(result1);//result2
+ CleanupStack::PopAndDestroy(active);//active
+
+ }
+
+ /**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest9L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898 3899
+
+ @SYMTestCaseDesc Test PREQ699.12.0 Validates cache functionality with older timestamp(1)
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory. Change the timestamp on one file to be older and alter
+ the mime type. Repeat the directory recognition and ensure that the mime type
+ has been updated..
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for html file creation
+ count = 1 CDataRecognitionResultArray::Count returns one entry of MIME type "text/html"
+ status = KErrNone for file content changed to text
+ count = 0 CDataRecognitionResultArray::Count returns zero entries of MIME type "text/html"
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest9L(RApaLsSession& aLs)
+ {
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir (mimeDir.Des());
+
+ TBufC<50> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Asynchronous folder file recognition Test Group 12
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+ aLaterTime+=(aInterval);
+
+ //Set the directory timestamp to be 'new'
+ theFS.SetModified(ptrMimeDir, aLaterTime);
+
+ // Create file mime_content000.canyoutell with html content and 'new' time
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KHtmlContent, aLaterTime);
+
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result1 ,active->iStatus);
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count == 1);
+ }
+
+
+ //Change file content to text and set the timestamp to 'old'
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KTextContent, time);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.12.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count == 0);
+ }
+
+ //Delete file
+ utils.DeleteFileL(_L("c:\\system\\data\\Mimepath\\mime_content000.canyoutell"));
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result2);//result1
+ CleanupStack::PopAndDestroy(result1);//result2
+ CleanupStack::PopAndDestroy(active);//active
+
+ }
+
+/**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest10L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898 3899
+
+ @SYMTestCaseDesc Test PREQ699.13.0 Validates cache functionality with older timestamp.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory. Change the timestamp on one file to be older and alter
+ the mime type. Change the timestamp on the directory to be newer. Repeat the
+ directory recognition and ensure that the mime type has been updated..
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for html file creation
+ count = 1 CDataRecognitionResultArray::Count returns one entry of MIME type "text/html"
+ status = KErrNone for file content changed to text
+ count = 0 CDataRecognitionResultArray::Count returns zero entries of MIME type "text/html"
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest10L(RApaLsSession& aLs)
+ {
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir (mimeDir.Des());
+
+ TBufC<50> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Asynchronous folder file recognition Test Group 13
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+ aLaterTime+=(aInterval);
+
+ //Set the directory timestamp to be 'old'
+ theFS.SetModified(ptrMimeDir, time);
+
+ // Create file mime_content000.canyoutell with html content and 'old' time
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KHtmlContent, time);
+
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result1 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count == 1);
+ }
+
+
+ //Change file content to text and set the timestamp to 'new'
+ //Change dir timestamp to 'old'
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KTextContent, aLaterTime);
+
+ //Set the directory timestamp to be 'new'
+ theFS.SetModified(ptrMimeDir, aLaterTime);
+
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.13.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count == 0);
+ }
+
+ //Delete file
+ utils.DeleteFileL(_L("c:\\system\\data\\Mimepath\\mime_content000.canyoutell"));
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result2);//result1
+ CleanupStack::PopAndDestroy(result1);//result2
+ CleanupStack::PopAndDestroy(active);//active
+
+ }
+
+/**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest11L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3989 3899
+
+ @SYMTestCaseDesc Test PREQ699.14.0 Validates cache functionality with substituted directory
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Recognize a directory. Substitute a directory of the same name with
+ different contents and repeat the recognition. Ensure that the file
+ contents are correctly listed.
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ count = 4 CDataRecognitionResultArray::Count returns four entries of MIME type "text/html"
+ status = KErrNone for file content changed to text
+ count = 2 CDataRecognitionResultArray::Count returns two entries of MIME type "text/html"
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest11L(RApaLsSession& aLs)
+ {
+ _LIT(KMimeDir1,"c:\\system\\data\\Mimepath1\\");
+ _LIT(KMimeDir2,"c:\\system\\data\\Mimepath2\\");
+
+ _LIT(KMimeDir1Html,"c:\\system\\data\\Mimepath1\\dir1_html");
+ _LIT(KMimeDir1Text,"c:\\system\\data\\Mimepath1\\dir1_text");
+ _LIT(KMimeDir2Html,"c:\\system\\data\\Mimepath2\\dir2_html");
+ _LIT(KMimeDir2Text,"c:\\system\\data\\Mimepath2\\dir2_text");
+
+ //After directory renaming
+ _LIT(KRenameHtml,"c:\\system\\data\\Mimepath1\\dir2_html");
+ _LIT(KRenameText,"c:\\system\\data\\Mimepath1\\dir2_text");
+
+ TBufC<50> mimeDir1(KMimeDir1);
+ TPtr ptrMimeDir1 (mimeDir1.Des());
+
+ TBufC<50> mimeDir2(KMimeDir2);
+ TPtr ptrMimeDir2 (mimeDir2.Des());
+
+ TBufC<50> mimeDir1Html(KMimeDir1Html);
+ TPtr ptrFile1x4(mimeDir1Html.Des());
+
+ TBufC<50> mimeDir1Text(KMimeDir1Text);
+ TPtr ptrFile1x2(mimeDir1Text.Des());
+
+ TBufC<50> mimeDir2Html(KMimeDir2Html);
+ TPtr ptrFile2x2(mimeDir2Html.Des());
+
+ TBufC<50> mimeDir2Text(KMimeDir2Text);
+ TPtr ptrFile2x4(mimeDir2Text.Des());
+
+ TBufC<50> renameText(KRenameText);
+ TPtr ptrRenameText(renameText.Des());
+
+ TBufC<50> renameHtml(KRenameHtml);
+ TPtr ptrRenameHtml(renameHtml.Des());
+
+ //"Asynchronous folder file recognition Test Group 14
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directories for test files
+ CreateDirL(&utils, ptrMimeDir1);
+ CreateDirL(&utils, ptrMimeDir2);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ TTime aLaterTime(time);
+ TTimeIntervalMinutes aInterval(1);
+ aLaterTime+=(aInterval);
+
+ // Fill the first directory with files
+ // Create files dir1_html000.html - dir1_html003.html with html content
+ // Create files dir1_text000.txt - dir1_text001.txt with text content
+ CreateFilesL(theFS, file, ptrFile1x4, (TDesC&)KSuffixHtml, 4, KHtmlContent, time);
+ CreateFilesL(theFS, file, ptrFile1x2, (TDesC&)KSuffixText, 2, KTextContent, time);
+
+ // Fill the second directory with files
+ // Create files dir2_text000.txt - dir2_text003.txt with text content
+ // Create files dir2_html001.html - dir2_html002.html with html content
+ CreateFilesL(theFS, file, ptrFile2x4, (TDesC&)KSuffixText, 4, KTextContent, time);
+ CreateFilesL(theFS, file, ptrFile2x2, (TDesC&)KSuffixHtml, 2, KHtmlContent, time);
+
+ //Test RecognizeFilesL on first directory with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir1,_L8("text/html"), *result1 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result1->Count();
+ TEST(count == 4);
+ }
+
+
+ //Delete first directory (KMimeDir1) and rename second directory to be the
+ //first (KMimeDir2 -> KMimeDir1)
+ DeleteFilesL(&utils, ptrFile1x4, (TDesC&)KSuffixHtml, 4);
+ DeleteFilesL(&utils, ptrFile1x2, (TDesC&)KSuffixText, 2);
+ DeleteDirL(&utils, ptrMimeDir1);
+ utils.RenameDirectoryL(mimeDir2, mimeDir1);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.14.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir1,_L8("text/html"), *result2 ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result2->Count();
+ TEST(count == 2);
+ }
+
+ //Bin out all the remaining created files
+ DeleteFilesL(&utils, ptrRenameText, (TDesC&)KSuffixText, 4);
+ DeleteFilesL(&utils, ptrRenameHtml, (TDesC&)KSuffixHtml, 2);
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir1);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(4, active); // utils, result2, result1, active
+
+ }
+
+/**
+ @SYMTestCaseID T_Serv3Step_DoSyncRecognizerTest4L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3898
+
+ @SYMTestCaseDesc Test PREQ699.15.0, PREQ699.15.1 Validates cache performance with a typical directory
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions 1st Recognition - Recognize a directory that has significant file content
+ with the cache enabled and log the time taken.
+ 15.0 Repeat the recognition on the directory, it should be faster than
+ the first recognition.
+ 15.1 Alter a number of files and repeat, again logging the time. The time
+ taken should be faster than the 1st recognition, but slower than test 15.0
+
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ 15.0 Time taken faster than 1st recognition
+ 15.1 Time taken faster than 1st recognition, but slower than 15.0
+ */
+void CT_Serv3Step::DoSyncFolderRecognizerTest4L(RApaLsSession& aLs)
+{
+ //Synchronous folder file recognition Test Group 15
+ _LIT(KTestAppSource, "Z:\\System\\data\\" );
+ _LIT(KTestAppDest, "C:\\System\\data\\TestPath\\" );
+ _LIT(KEmpty, "");
+
+ _LIT(KTestWaitingForApplistUpdate,"\nWaiting %d microseconds for applist to be updated");
+ const TInt KApplistUpdateTime = 8000000;
+
+ TBufC<128> fileDir(KEmpty);
+ TPtr ptrFileDir(fileDir.Des());
+
+ CDataRecognitionResultArray* result1 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result2 = new(ELeave) CDataRecognitionResultArray();
+ CDataRecognitionResultArray* result3 = new(ELeave) CDataRecognitionResultArray();
+
+ CleanupStack::PushL(result1);
+ CleanupStack::PushL(result2);
+ CleanupStack::PushL(result3);
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ // 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::EOverWrite ));
+
+ INFO_PRINTF2(KTestWaitingForApplistUpdate, KApplistUpdateTime);
+ User::After(KApplistUpdateTime);
+
+ TTime time;
+ TTime timeLater;
+
+ //1st recognition
+ time.HomeTime();
+ TInt ret=aLs.RecognizeFilesL(KTestAppDest,*result1);
+ timeLater.HomeTime();
+ TEST(ret==KErrNone);
+ User::LeaveIfError(ret);
+
+ TTimeIntervalMicroSeconds delayNoCache = timeLater.MicroSecondsFrom(time);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.15.0"));
+ time.HomeTime();
+ ret=aLs.RecognizeFilesL(KTestAppDest,*result2);
+ timeLater.HomeTime();
+ TEST(ret==KErrNone);
+ User::LeaveIfError(ret);
+
+ TTimeIntervalMicroSeconds delayCache = timeLater.MicroSecondsFrom(time);
+
+ //Modify the timestamps on a few files
+ TInt count = result1->Count();
+ for(TInt i=1; i < (count/2); i++)
+ {
+ TDataRecognitionResult res;
+ result1->GetDataRecognitionResultL(res, i);
+ TFileName fileName;
+ result1->GetFileNameL(fileName, i);
+
+ ptrFileDir.Copy(KTestAppDest);
+ ptrFileDir.Append(fileName);
+
+ time.HomeTime();
+ theFS.SetModified(ptrFileDir, time);
+ }
+
+ INFO_PRINTF2(KTestWaitingForApplistUpdate, KApplistUpdateTime);
+ User::After(KApplistUpdateTime);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.15.1"));
+ time.HomeTime();
+ ret=aLs.RecognizeFilesL(KTestAppDest,*result3);
+ timeLater.HomeTime();
+ TEST(ret==KErrNone);
+ User::LeaveIfError(ret);
+
+ TTimeIntervalMicroSeconds delayCache2 = timeLater.MicroSecondsFrom(time);
+#ifndef __WINS__
+ // On Emulator, these time related checks cannot always be ensured.
+ TEST(delayCache2 > delayCache);
+ TEST(delayCache2 < delayNoCache);
+#endif
+
+ // Cleanup
+ delete fileManager;
+ CleanupStack::PopAndDestroy(3, result1); // result3, result2, result1
+}
+
+/**
+ @SYMTestCaseID T_Serv3Step_DoAsyncRecognizerTest13L
+
+ @SYMPREQ 699
+
+ @SYMREQ 3899
+
+ @SYMTestCaseDesc Test PREQ699.17.0 Validates performance of recognition.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Not Implemented
+
+ @SYMTestActions Call RecognizeFilesL() without a filter on a directory
+ containing a text file named text.canyoutell
+
+ API Calls:\n
+ RApaLsSession::RecognizeFilesL(const TDesC& aPath,
+ const TDesC8& aDataType,
+ CDataRecognitionResultArray& aResult,
+ TRequestStatus& aStatus);
+ CDataRecognitionResultArray::CDataRecognitionResultArray();
+ CDataRecognitionResultArray::Count() const;
+
+ @SYMTestExpectedResults\n
+ status = KErrNone for file creation
+ count = 1 returned
+ */
+void CT_Serv3Step::DoAsyncFolderRecognizerTest13L(RApaLsSession& aLs)
+{
+ //Asynchronous folder file recognition Test Group 17
+ TBufC<50> mimeDir(KMimeDir);
+ TPtr ptrMimeDir (mimeDir.Des());
+
+ TBufC<350> mimeFile(KMimeFile);
+ TPtr ptrMimeFile(mimeFile.Des());
+
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ RFs theFS;
+ theFS.Connect();
+ RFile file;
+
+ RSmlTestUtils utils;
+ CleanupClosePushL(utils);
+
+ //Create directory for test files
+ CreateDirL(&utils, ptrMimeDir);
+
+ //Timestamp details for files
+ TTime time;
+ time.UniversalTime();
+
+ // Create file mime_content000.canyoutell with text content
+ CreateFilesL(theFS, file, ptrMimeFile, (TDesC&)KSuffixUnknown, 1, KHtmlContent, time);
+
+ INFO_PRINTF1(_L("Asynchronous folder file Recognition Test PREQ699.17.0"));
+ //Test RecognizeFilesL with a MIME type filter "text/html"
+ aLs.RecognizeFilesL(KMimeDir,_L8("text/html"), *result ,active->iStatus);
+
+ active->StartL();//set active
+ CActiveScheduler::Start();
+
+ TEST(active->iStatus==KErrNone);
+ if (active->iStatus==KErrNone)
+ {
+ TUint count = result->Count();
+ TEST(count == 1);
+ }
+
+ DeleteFilesL(&utils, ptrMimeFile, (TDesC&)KSuffixUnknown, 1);
+
+ //Remove test directory
+ DeleteDirL(&utils, ptrMimeDir);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(&utils);//utils
+ CleanupStack::PopAndDestroy(result);//result2
+ CleanupStack::PopAndDestroy(active);//active
+
+}
+/*
+
+@SYMTestCaseID APPFWK-APPARC-0098
+
+@SYMDEF INC125788
+
+@SYMTestCaseDesc The test verify that RApaLsSession::CancelRecognizeFiles() complete TRequestStatus with KErrCancel
+ that was passed to RApaLsSession::RecognizeFilesL() when cancelling the outstanding async recognition request.
+
+@SYMTestPriority High
+
+@SYMTestStatus Implemented
+
+@SYMTestActions
+1.RApaLsSession::RecognizeFilesL(const TDesC& aPath, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus)
+is called to get data (MIME) types for files in a specified directory.
+2.Outstanding async recognition request is cancelled using RApaLsSession::CancelRecognizeFiles().
+
+@SYMTestExpectedResults
+RApaLsSession::CancelRecognizeFiles() complete the TRequestStatus with KErrCancel.
+
+*/
+void CT_Serv3Step::DoAsyncFolderRecognizerTest14L(RApaLsSession& aLs)
+ {
+ //Setup Active Object
+ CActiveTest2* active = new(ELeave) CActiveTest2();
+ CleanupStack::PushL(active);
+
+ CDataRecognitionResultArray* result = new(ELeave) CDataRecognitionResultArray();
+ CleanupStack::PushL(result);
+
+ //Check results and Stop AS
+ _LIT(KStandardDir,"z:\\system\\data\\Testpath\\");
+
+ INFO_PRINTF1(_L("Asynchronous RecognizeFilesL Test"));
+ aLs.RecognizeFilesL(KStandardDir,*result,active->iStatus);
+ active->StartL();//set active
+ TEST(active->iStatus==KRequestPending);
+ INFO_PRINTF2(_L("RecognizeFilesL: iStatus = %d\n"), active->iStatus.Int());
+
+ aLs.CancelRecognizeFiles();
+ TEST(active->iStatus==KErrCancel);
+ INFO_PRINTF2(_L("CancelRecognizeFiles: iStatus = %d\n"), active->iStatus.Int());
+ CActiveScheduler::Start();
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(result);//result
+ CleanupStack::PopAndDestroy(active);//active
+ }
+/**
+* Auxiliary Fn for the entire Test Step
+*
+* This method initiates all the tests.
+*
+*/
+TInt CT_Serv3Step::DoServComTestL()
+ {
+ INFO_PRINTF1(_L("Testing Server Com"));
+
+ RFs theServFs;
+ TInt ret = theServFs.Connect();
+ TEST(ret==KErrNone);
+ CleanupClosePushL(theServFs);
+
+
+ RTestableApaLsSession ls;
+ ret = ls.Connect();
+ TEST(ret==KErrNone);
+ CleanupClosePushL(ls);
+
+ //wait for CExtrasAppKeyLayout to open up a RApaLsSession so it doesn't mess with our result
+ //unsure why it affects this test but not the others
+ User::After(10000000);
+
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoSyncFolderRecognizerTest1L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoSyncFolderRecognizerTest2L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoSyncFolderRecognizerTest3L(ls), ls.FlushRecognitionCache() );
+
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest1L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest2L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest3L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest4L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest5L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest6L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest7L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest8L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest9L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest10L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest11L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoSyncFolderRecognizerTest4L(ls), ls.FlushRecognitionCache() );
+ HEAP_TEST_LS_SESSION(ls, 0, 0, DoAsyncFolderRecognizerTest13L(ls), ls.FlushRecognitionCache() );
+ //DONT_CHECK Skips the heap check at server side. This heap imbalance occurs randomly in server side
+ // while canceling the outstanding async request.
+ HEAP_TEST_LS_SESSION(ls, 0, DONT_CHECK, DoAsyncFolderRecognizerTest14L(ls), ls.FlushRecognitionCache() );
+
+ CleanupStack::PopAndDestroy(&ls);
+
+ // close the server session and we have done some type store reloading
+ CleanupStack::PopAndDestroy(&theServFs);
+
+ return KErrNone;
+ }
+
+
+
+TVerdict CT_Serv3Step::doTestStepPreambleL()
+/**
+ * @return - TVerdict code
+ * Override of base class virtual
+ */
+ {
+ SetTestStepResult(EPass);
+ return TestStepResult();
+ }
+
+TVerdict CT_Serv3Step::doTestStepPostambleL()
+/**
+ * @return - TVerdict code
+ * Override of base class virtual
+ */
+ {
+ return TestStepResult();
+ }
+
+void CT_Serv3Step::CreateDirL(RSmlTestUtils* aPtrUtils, TPtr aDirName)
+ {
+ User::LeaveIfError(aPtrUtils->Connect());
+ aPtrUtils->CreateDirectoryL(aDirName);
+
+ //Delay required to prevent armv5 failure
+ const TInt KApplistUpdateTime = 800000;
+ User::After(KApplistUpdateTime);
+ }
+
+void CT_Serv3Step::CreateFilesL(RFs& aFS, RFile& aFile, TPtr aFileRoot, TDesC& aSuffix, TInt aFileNumber, const TDesC8& aFileContent, TTime aTime = 0)
+ {
+ if(aTime == 0)
+ {
+ aTime.UniversalTime();
+ }
+
+ for(TInt counter=0; counter<aFileNumber; counter++)
+ {
+ aFileRoot.AppendNumFixedWidth(counter, EDecimal, KFixedNumWidth);
+ aFileRoot.Append(aSuffix);
+
+ //Creates a file if does not already exist. If file exists,
+ //content is overwritten
+ TEST(KErrNone == aFile.Replace(aFS, aFileRoot, EFileWrite));
+
+ TEST(KErrNone == aFile.Write(aFileContent));
+ TEST(KErrNone == aFile.SetModified(aTime));
+ TEST(KErrNone == aFile.Flush());
+ aFile.Close();
+
+ TInt Length = aFileRoot.Length();
+ TInt DeleteLength = aSuffix.Length() + KFixedNumWidth;
+ aFileRoot.Delete( (Length - DeleteLength) , DeleteLength);
+ }
+
+ //Delay required to prevent armv5 failure
+ const TInt KApplistUpdateTime = 800000;
+ User::After(KApplistUpdateTime);
+ }
+
+void CT_Serv3Step::DeleteDirL(RSmlTestUtils* aPtrUtils, TPtr aDirName)
+ {
+ aPtrUtils->DeleteDirectoryL(aDirName);
+ }
+
+void CT_Serv3Step::DeleteFilesL(RSmlTestUtils* aPtrUtils, TPtr aDirName, TDesC& aSuffix, TInt aFileNumber)
+ {
+ for(TInt counter=0; counter<aFileNumber; counter++)
+ {
+ aDirName.AppendNumFixedWidth(counter, EDecimal, KFixedNumWidth);
+ aDirName.Append(aSuffix);
+ aPtrUtils->DeleteFileL(aDirName);
+ TInt Length = aDirName.Length();
+ TInt DeleteLength = aSuffix.Length() + KFixedNumWidth;
+ aDirName.Delete( (Length - DeleteLength) , DeleteLength);
+ }
+ }
+
+TVerdict CT_Serv3Step::doTestStepL()
+/**
+ * Override of base class virtual.
+ * @return - TVerdict code
+ */
+{
+ FbsStartup();
+ TInt ret = RFbsSession::Connect();
+ TEST(ret==KErrNone);
+
+ // run the testcode (inside an alloc heaven harness)
+ INFO_PRINTF1(_L("About to start tests:"));
+ TRAP(ret,DoServComTestL());
+ INFO_PRINTF2(_L(" DoServComTestL completes with %d"), ret);
+ TEST(ret==KErrNone);
+
+ INFO_PRINTF1(_L("Test Completed!"));
+ return TestStepResult();
+
+}
+
+
+/**
+*
+* Methods for Active Object Test
+*
+* Used in for Asynchronous Data Recognizer tests
+*
+*/
+
+CActiveTest2::CActiveTest2()
+ :CActive(0)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+CActiveTest2::~CActiveTest2()
+ {
+ Cancel();
+ }
+
+void CActiveTest2::DoCancel()
+ {
+ TRequestStatus* s=&iStatus;
+ User::RequestComplete(s, KErrNone);
+ }
+
+void CActiveTest2::StartL()
+ {
+ SetActive();
+ }
+
+void CActiveTest2::RunL()
+ {
+ //Stop AS
+ CActiveScheduler::Stop();
+ }