--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/mimerecognitionfw/tef/T_MimeStep.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,552 @@
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+
+#include <e32uid.h>
+#include <f32file.h>
+#include <bautils.h>
+#include <apmrec.h>
+#include <ecom/ecom.h>
+#include "T_MimeStep.h"
+
+
+//
+_LIT8(KTextPlainData,"text/plain");
+_LIT(KTextFile,"z:\\system\\data\\emime\\testrec.text");
+_LIT(KTxtFile,"z:\\system\\data\\emime\\testrec.txt");
+_LIT(KWordFile,"z:\\system\\data\\emime\\word.doc");
+_LIT(KLeavingRecognizer,"TLEAVINGRECOGNIZER");
+
+const TUid KWordAppUid={0x10003A64};
+
+const TUid KLeavingRecogniserUid={0x1d1F75EB};
+const TUid KTestEcomDataRecognizerUid={0x101F7DA1};
+const TInt KTestDataRecognizerError=-420; // some random number for test error code
+_LIT(KDeceptiveRecognizerToken, "c:\\test\\appfwk\\emime\\deceptive_recognizer.token");
+//
+
+/* Construction of CTestDataRecognitionType Object*/
+
+CTestDataRecognizerType* CTestDataRecognizerType::NewDataRecogTypeL(RFs &aIfs)
+ {
+ CTestDataRecognizerType *dataRecogTypeObj=new(ELeave)CTestDataRecognizerType(aIfs);
+ CleanupStack::PushL(dataRecogTypeObj);
+ CleanupStack::Pop(dataRecogTypeObj);
+ return dataRecogTypeObj;
+
+ }
+/* Constructor*/
+
+CTestDataRecognizerType::CTestDataRecognizerType (RFs &aIfs)
+ :CApaDataRecognizer(aIfs)
+ {
+
+
+ }
+
+CTestDataRecognizerType::~CTestDataRecognizerType()
+ {
+
+ }
+/**
+ Auxiliary Fn for Test Case ID T-MimeStep-testScanningMimeTheRecognizerL
+
+ This method is used to verify the functionality of Locking and Unlocking the recognizer
+ with the UID of the recognizer .Whenever the Recognizer is Locked the return value of
+ Locked() function should be a value greater than zero. And When the recognizer is tried to
+ Unload , the unloading operation would fail with return code KErrLocked.
+ When the recognizer is in Unlocked condition the return value of Locked() is zero.
+ And Function to Unload the Recognizer is called again after unlocking the recognizer , and the
+ Recognizer is unloaded without any Error.And the return code will be KErrNone.
+
+ This method is also used to verify the return values of Mimetype() and Confidence(),
+ When the recognizer is not added . And hence the values are default when the
+ Recognizers are not added.
+
+*/
+void CT_MimeStep::ChkLockAndUnlockL(RFs &aIfs)
+ {
+
+ CTestDataRecognizerType *testLockAndUnLock=CTestDataRecognizerType::NewDataRecogTypeL(aIfs);
+ CleanupStack::PushL(testLockAndUnLock);
+ TRAPD(ret,testLockAndUnLock->AddDataL(iData));
+ INFO_PRINTF2(_L("Val of AddDataL %d"), ret);
+
+ TInt valBeforeLock=iData->Locked();
+ INFO_PRINTF2(_L("Val of Lock Before %d"), valBeforeLock);
+ TEST(valBeforeLock==0);
+
+ iData->Lock();
+ TInt valAfterLock=iData->Locked();
+ INFO_PRINTF2(_L("Val of Lock %d"), valAfterLock);
+ TEST(valAfterLock > 0);
+
+ TInt remDataAfterLock=testLockAndUnLock->RemoveData(iData);
+ TEST(remDataAfterLock==KErrLocked);
+ INFO_PRINTF2(_L("Val of remDataAfterLock %d"), remDataAfterLock);
+
+ TRAP(ret,testLockAndUnLock->UpdateDataTypesL());
+ TEST(ret==KErrNone);
+
+ iData->Unlock();
+ TInt valAfterUnlock=iData->Locked();
+ INFO_PRINTF2(_L("Val of Loc k %d"), valAfterUnlock);
+ TEST(valAfterUnlock==0);
+
+ TInt remDataAfterUnLock=testLockAndUnLock->RemoveData(iData);
+ TEST(remDataAfterUnLock==KErrNone);
+ INFO_PRINTF2(_L("Val of remDataAfterLock %d"), remDataAfterUnLock);
+
+
+ CleanupStack::PopAndDestroy(testLockAndUnLock);
+ }
+/**
+ Auxiliary Fn for Test Case ID T-MimeStep-testScanningMimeTheRecognizerL
+
+ This method is used to verify the return values of Mimetype() and Confidence(),
+ When the recognizer is not added . And hence the values are default when the
+ Recognizers are not added. */
+
+
+void CT_MimeStep::ChkConfAndMimeL(RFs &aIfs,const TUid &aUid)
+{
+ CTestDataRecognizerType *confAndMimeDataRec=CTestDataRecognizerType::NewDataRecogTypeL(aIfs);
+ CleanupStack::PushL(confAndMimeDataRec);
+ TRAPD(ret,iData=CApaDataRecognizerType::CreateDataRecognizerL(aUid));
+ TEST(ret==KErrNone);
+ TDataType dataType= iData->MimeType();
+ TInt confidenceVal=iData->Confidence();
+ TEST(dataType.Uid().iUid==0);
+ TEST(confidenceVal==0);
+ INFO_PRINTF2(_L("Val of confidence %d"), confidenceVal);
+ CleanupStack::PopAndDestroy(confAndMimeDataRec);
+}
+
+
+/**
+ Auxiliary Fn for Test Case ID T-MimeStep-testScanningMimeTheRecognizerL
+
+ This function checks a return value, and prints it in an Error return value.
+
+*/
+void CT_MimeStep::DoTest(TInt aReturnValue)
+ {
+ if (aReturnValue!=KErrNone)
+INFO_PRINTF2(_L("\nError: %D\n"),aReturnValue);
+ TEST(aReturnValue==KErrNone);
+ }
+
+
+/**
+ Auxiliary Fn for Test Case ID T-MimeStep-testScanningMimeTheRecognizerL
+
+ This function checks the integrity of a Recognizer.
+
+*/
+void CT_MimeStep::testRecognizer(const CApaScanningDataRecognizer::TRecognizer& aRec)
+ {
+ _LIT(KRecText,"RECTXT");
+ _LIT(KRecWeb,"RECWEB");
+ _LIT(KRecApp2,"RECAPP2");
+ _LIT(KRecJar,"RECJAR");
+ _LIT(KBookMarkRec,"EBOOKMARKREC");
+ _LIT(KRecMda,"RECMDA");
+ _LIT(KRecOffice,"RECOFFICE");
+ _LIT(KRecWap,"RECWAP");
+ _LIT(KRVersit,"RVERSIT");
+ _LIT(KWebUrlRec,"WEBURLREC");
+ _LIT(TTestEcomDataRec,"TTESTECOMDATAREC");
+
+ if (aRec.iUid.iUid==0x100012FB)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecText)==0);
+ }
+ else if (aRec.iUid.iUid==0x10001315)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecWeb)==0);
+ }
+ else if (aRec.iUid.iUid==0x1000415F)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecApp2)==0);
+ }
+ else if (aRec.iUid.iUid==0x1000967A)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecJar)==0);
+ }
+ else if (aRec.iUid.iUid==0x10008ED4)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KBookMarkRec)==0);
+ }
+ else if (aRec.iUid.iUid==0x10005617)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecMda)==0);
+ }
+ else if (aRec.iUid.iUid==0x10008A2F)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecOffice)==0);
+ }
+ else if (aRec.iUid.iUid==0x1000515E)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRecWap)==0);
+ }
+ else if (aRec.iUid.iUid==0x100047EB)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KRVersit)==0);
+ }
+ else if (aRec.iUid.iUid==0x100064DE)
+ {
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KWebUrlRec)==0);
+ }
+ else if (aRec.iUid==KLeavingRecogniserUid)
+ {
+INFO_PRINTF1(_L("Testing a recogniser(TLEAVINGRECOGNIZER) with >12 chars length"));
+ TEST(aRec.iDrive==25);
+ TEST(aRec.Name().CompareF(KLeavingRecognizer)==0);
+ }
+ else if(aRec.iUid.iUid==0x101F7DA0)
+ {
+ TEST(aRec.Name().CompareF(KRecText)==0);
+ }
+ else if(aRec.iUid.iUid==0x101F7D9F)
+ {
+ TEST(aRec.Name().CompareF(KRecApp2)==0);
+ }
+ else if(aRec.iUid==KTestEcomDataRecognizerUid)
+ {
+INFO_PRINTF1(_L("Testing the presence of ecom style TTESTECOMDATAREC recognizer"));
+ TEST(aRec.Name().CompareF(TTestEcomDataRec)==0);
+ }
+ }
+
+
+ /**
+ @SYMTestCaseID T-MimeStep-testScanningMimeTheRecognizerL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Tests the Scanning File-Recognizer
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The test verifies the Scannig File-Recognizer by testing
+ the getter and setter functions. It creates a temporal list of recognizers to
+ check the getter function, and then goes through the whole list of recognizers
+ testing each one.\n
+ Also, the setter function is checked, by adding a recognizer that's already
+ added, and adding one that doesn't exist, and verifying that correct return
+ value. Finally, it is checked if specific recognizers are loaded or not.\n
+ This test Also checks for the functionality of the Locking and Unlocking
+ Mechanism of the recognizer and checks that the When the recognizers are not
+ added in CAPARecognizertype class , The properties of the Recognizer will be
+ the defaulted.
+ API Calls:\n
+ CApaScanningDataRecognizer::NewL(RFs& aFs) \n
+ CApaScanningDataRecognizer::TRecognizer(HBufC* aName) \n
+ CApaScanningDataRecognizer::RecognizerListLC() \n
+ CApaScanningDataRecognizer::RecognizerCount() \n
+ CApaScanningDataRecognizer::UpdateCounter() const \n
+ CApaScanningDataRecognizer::SetRecognizerL() \n
+ CApaScanningDataRecognizer::SetEcomRecognizerL() \n
+ CApaDataRecognizerType::MimeType() \n
+ CApaDataRecognizerType::Confidence() \n
+ CApaDataRecognizerType::Lock() \n
+ CApaDataRecognizerType::Unlock() \n
+ @SYMTestExpectedResults Test should complete without any panic.
+
+ */
+void CT_MimeStep::testScanningMimeTheRecognizerL()
+ {
+INFO_PRINTF1(_L("Testing the Scanning File-Recognizer"));
+ //
+ // construct - this scans for TheRecognizer plug-ins
+ TRAPD(ret, iRecognizer=CApaScanningDataRecognizer::NewL(iFs) );
+ DoTest(ret);
+ TEST(iRecognizer->RecognizerCount()>=3);
+ TEST(iRecognizer->UpdateCounter()>=3);
+ //
+INFO_PRINTF1(_L("Testing the getter and setter functions"));
+ //
+ // check the getter function
+ CApaScanningDataRecognizer::CRecognizerArray* tempListOfRecognizers = iRecognizer->RecognizerListLC();
+ TInt listCount = tempListOfRecognizers->Count();
+
+ for (TInt ii=0;ii<listCount;ii++)
+ {
+ testRecognizer((*tempListOfRecognizers)[ii]);
+ }
+
+ CleanupStack::PopAndDestroy(1); // tmpListOfRecogniszers
+
+//for testing ecom style plugin
+INFO_PRINTF1(_L("Testing the ecom style TTESTECOMDATAREC recognizer is loaded or not"));
+ CApaScanningDataRecognizer::TRecognizer testEcomDataRecognizer;
+ testEcomDataRecognizer.iUid=KTestEcomDataRecognizerUid;
+ testEcomDataRecognizer.iDrive=25;
+ TRAP(ret,iRecognizer->SetEcomRecognizerL(testEcomDataRecognizer));
+ TEST(ret==KErrNone);
+// for testing Lock() ,Unlock of the recognizers.
+INFO_PRINTF1(_L("Test Confidence and MimeType APIs of CApaDataRecognizerType "));
+ TRAP(ret,ChkConfAndMimeL(iFs,testEcomDataRecognizer.iUid));
+ TEST(ret==KErrNone);
+
+INFO_PRINTF1(_L("Test Lock And Unlock APIs of CApaDataRecognizerType "));
+ TRAP(ret,ChkLockAndUnlockL(iFs));
+ TEST(ret==KErrNone);
+
+INFO_PRINTF1(_L("Testing the TECOMLEAVINGRECOGNIZER recogniser is loaded or not"));
+ CApaScanningDataRecognizer::TRecognizer ecomLeavingRecognizer;
+ ecomLeavingRecognizer.iUid.iUid = 0x10203630;
+ ecomLeavingRecognizer.iDrive = 25;
+ TRAP(ret,iRecognizer->SetEcomRecognizerL(ecomLeavingRecognizer));
+ TEST(ret==KErrNone);
+ TEST(iRecognizer->UpdateCounter()>=3);
+ }
+
+
+ /**
+ @SYMTestCaseID T-MimeStep-testTDataTypeL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Test TDataType structure by creating new automatic variables
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The test creates new TDataType automatic variables.
+ It creates a first TDataType using the constructor taking a UID. The data
+ type must be a native Symbian data type, with an associated UID equal
+ to the original UID from which the UID was constructed.\n
+ A second TDataType is created using a pointer descriptor to the data
+ type previously created. Also, the data type must be a native Symbian data
+ type, with the same associated UID than the previously data type created.\n
+ API Calls:\n
+ TDataType::TDataType() \n
+ TDataType::TDataType(const TDesC8& aDataType) \n
+ TDataType::IsNative() \n
+ TDataType::Uid() \n
+
+ @SYMTestExpectedResults Test should complete without any panic.
+
+ */
+void CT_MimeStep::testTDataTypeL()
+// check TDataType constructors
+ {
+ TUid uid={0x12345678};
+ TDataType dataType(uid);
+ TEST(dataType.IsNative());
+ TEST(dataType.Uid()==uid);
+ TDataType secondType(dataType.Des8());
+ TEST(secondType==dataType);
+ TEST(secondType.IsNative());
+ TEST(secondType.Uid()==uid);
+ }
+
+
+ /**
+ @SYMTestCaseID T-MimeStep-testRecognizersL
+
+ @SYMPREQ
+
+ @SYMTestCaseDesc Tests file recognizers using RecognizerL function
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions The test uses the RecognizeL function to recognize the
+ data type of the data in the files, corresponding to three types of file formats:\n
+ (1) .text file, containing plain text. The recognized data type must be
+ equal to a plain text TDataType. When no TDataType is defined, the error must
+ be propagated accordingly.\n
+ (2) .txt file, containing plain text. The recognized data type must be equal to
+ a plain text TDataType.\n
+ (3) Word file (.doc format). The recognized data type must be equal to
+ a word file TDataType.\n
+ API Calls:\n
+ CApaScanningDataRecognizer::RecognizeL(const TDesC& aName, const TDesC8& aBuffer)\n
+
+ @SYMTestExpectedResults Test should complete without any panic.
+
+ */
+void CT_MimeStep::testRecognizersL()
+ {
+ //
+ // do other stuff...
+
+INFO_PRINTF1(_L("Testing the text file recognizer"));
+ CArrayFixFlat<TDataType>* array=new(ELeave) CArrayFixFlat<TDataType>(5);
+ CleanupStack::PushL(array);
+ iRecognizer->DataTypeL(*array);
+
+ TInt minNumDataTypes = 1; // txt/plain
+ minNumDataTypes++; // dodgy/app
+
+ TEST(array->Count()>=minNumDataTypes);
+ CleanupStack::PopAndDestroy(); // array
+ // I don't know what order these will be in - I can't test them
+
+ TInt bufSize=iRecognizer->PreferredBufSize();
+ HBufC8* buf=HBufC8::NewLC(bufSize);
+ RFile rfile;
+ TInt err=rfile.Open(iFs,KTextFile,EFileShareReadersOnly);
+ TEST(err==KErrNone);
+ TPtr8 des=buf->Des();
+ if (err==KErrNone)
+ {
+ err=rfile.Read(des);
+ if (err!=KErrNone)
+ des.SetLength(0);
+ }
+ rfile.Close();
+ TDataType textplain(KTextPlainData);
+ // recognizes the plain text
+ TEST(iRecognizer->RecognizeL(KTextFile, des).iDataType==textplain);
+ // test by passing a empty file name
+ TEST(iRecognizer->RecognizeL(TPtrC(), des).iDataType==textplain);
+
+ //Test the propagation of error (leave) occured in a recognizer,
+ //if there is no probable data type matched.
+ // There is a V1 version and a V2 (ECom) version of this recognizer.
+ INFO_PRINTF1(_L("Propagates error if a recognizer leaves with no probable data type found"));
+ TDataType dataType;
+ des.SetLength(0);
+ TRAPD(ret,dataType=iRecognizer->RecognizeL(KTextFile, des).iDataType);
+ TEST(dataType==TDataType());
+ INFO_PRINTF2(_L("Propagated error:%d, it should should be equal to KTestDataRecognizerError(-420)"), ret);
+ TEST(ret==KTestDataRecognizerError);
+
+ err=rfile.Open(iFs,KTxtFile,EFileShareReadersOnly);
+ TEST(err==KErrNone);
+ des=buf->Des();
+ if (err==KErrNone)
+ {
+ err=rfile.Read(des);
+ if (err!=KErrNone)
+ des.SetLength(0);
+ }
+ rfile.Close();
+
+ TRAP(ret,dataType=iRecognizer->RecognizeL(KTxtFile, des).iDataType);
+ TEST(dataType==textplain);
+ TEST(err==KErrNone);
+
+ des.SetLength(0);
+ TRAP(ret,dataType=iRecognizer->RecognizeL(KTxtFile, des).iDataType);
+ TEST(dataType==textplain);
+ TEST(err==KErrNone);
+
+ INFO_PRINTF1(_L("Testing the EIKON app recognizer"));
+ des.SetLength(0);
+ err=rfile.Open(iFs,KWordFile,EFileShareReadersOnly);
+ TEST(err==KErrNone);
+ des=buf->Des();
+ if (err==KErrNone)
+ {
+ err=rfile.Read(des);
+ if (err!=KErrNone)
+ des.SetLength(0);
+ }
+
+ rfile.Close();
+ TRAP(ret,dataType=iRecognizer->RecognizeL(KWordFile, des).iDataType);
+ TEST(dataType==TDataType(KWordAppUid));
+ TEST(err==KErrNone);
+ CleanupStack::PopAndDestroy(buf); // buf
+
+ delete iRecognizer;
+ }
+
+CT_MimeStep::~CT_MimeStep()
+/**
+ Destructor
+ */
+ {
+ }
+
+CT_MimeStep::CT_MimeStep()
+/**
+ Constructor
+ */
+ {
+ // Call base class method to set up the human readable name for logging
+ SetTestStepName(KT_MimeStep);
+ }
+
+
+TVerdict CT_MimeStep::doTestStepL()
+ {
+ INFO_PRINTF1(_L("Test Started - Testing the APMIME dll"));
+
+ // set up the directory structure
+ User::LeaveIfError(iFs.Connect());
+
+
+ INFO_PRINTF1(_L("Create token file for deceptive leaving recognizer activation"));
+ RFile file;
+ CleanupClosePushL(file);
+ TInt r = iFs.MkDirAll(KDeceptiveRecognizerToken);
+ TEST(r == KErrNone || r == KErrAlreadyExists);
+ TEST(file.Create(iFs, KDeceptiveRecognizerToken, EFileWrite|EFileShareExclusive) == KErrNone);
+ CleanupStack::PopAndDestroy(&file);
+
+ // run the testcode (inside an alloc heaven harness)
+ __UHEAP_MARK;
+
+ CActiveScheduler* pS=new(ELeave) CActiveScheduler;
+ TEST(pS!=NULL);
+ CActiveScheduler::Install(pS);
+ TRAP(r,CT_MimeStep::testScanningMimeTheRecognizerL());
+ TEST(r==KErrNone);
+ TRAP(r,CT_MimeStep::testRecognizersL());
+ TEST(r==KErrNone);
+ TRAP(r,CT_MimeStep::testTDataTypeL());
+ TEST(r==KErrNone);
+
+ delete pS;
+ REComSession::FinalClose();
+ __UHEAP_MARKEND;
+
+
+ // Removes token file for deceptive leaving recognizer
+ INFO_PRINTF1(_L("Remove token file for deceptive leaving recognizer deactivation"));
+ TEST(iFs.Delete(KDeceptiveRecognizerToken) == KErrNone);
+
+ iFs.Close();
+
+ INFO_PRINTF1(_L("Test Finished"));
+ return TestStepResult();
+ }
+
+