// 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);

	//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;ii<listCount;ii++)

		{

		testRecognizer((*tempListOfRecognizers)[ii]);

		}

	CleanupStack::PopAndDestroy(1); // tmpListOfRecogniszers

	//New test

	INFO_PRINTF1(_L("Testing index([]) operator"));

	const CApaScanningDataRecognizer::TRecognizer& testDataRecognizer=(*iRecognizer)[0];

	TUid uid1 =  testDataRecognizer.iUid;

	TUid uid2 = ((*iRecognizer)[0]).iUid;

	TEST(uid1==uid2);

//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();

	}