diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/mimerecognitionfw/tef/T_MimeStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericservices/mimerecognitionfw/tef/T_MimeStep.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,564 @@ +// 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 +#include +#include +#include +#include +#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); + //New tests + TInt bufSize = iData->PreferredBufSize(); + TEST(bufSize==0); + INFO_PRINTF2(_L("Val of Preferred buffer size %d"), bufSize); + INFO_PRINTF1(_L("Testing default constructor of TDataTypeWithPriority")); + TDataTypeWithPriority dataTypeWithPriority = TDataTypeWithPriority(); + 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;iiSetEcomRecognizerL(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* array=new(ELeave) CArrayFixFlat(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(); + } + +