/*

 * 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 "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

  @internalComponent - Internal Symbian test code 

 */

 #include "trecogstep.h"

 // Literals & Constants

 _LIT(KCompleted, "Completed.");

 _LIT(KMethodName, "byName");

 _LIT(KMethodHandle, "byHandle");

 _LIT(KMethodBuffer, "byBuffer");

 _LIT8(KEmptyBuffer8,"");

 class RDeletefile

 	{

 public:

 	RDeletefile(RFs &aFs, TDesC &aFileName)

 		: iFs(aFs),

 		  iFileName(aFileName)

 		{

 		}

 	void Close()

 		{

 		(void) iFs.Delete(iFileName);

 		}

 private:

 	RFs &iFs;

 	TDesC &iFileName;

 	};

 void CRecogStep::TestRecognizeDataL()

 	{

 	TDataRecognitionResult recogResult;

 	TPtrC tmp;

 	GetStringFromConfig(ConfigSection(), _L("fileName"), tmp);

 	iFileName = tmp;

 	TPtrC expectedDataType16;

 	GetStringFromConfig(ConfigSection(), _L("expectedDataType"), expectedDataType16);

 	HBufC8 *expectedDataBuf8 = ConvertDes16toHBufC8LC(expectedDataType16);

 	TInt expectedConfidence;

 	GetIntFromConfig(ConfigSection(), _L("expectedConfidence"), expectedConfidence);

 	TInt maxDataBufSize;

 	if (GetIntFromConfig(ConfigSection(), _L("maxDataBufSize"), maxDataBufSize))

 		{

 		iLs.SetMaxDataBufSize(maxDataBufSize);

 		}

 	TPtrC method;

 	GetStringFromConfig(ConfigSection(), _L("method"), method);

 	TBool checkSpecific = EFalse;

 	TBool matchedSpecificMimeType = EFalse;

 	TPtrC specificMimeType;

 	if (method == KMethodHandle)

 		{		

 		checkSpecific = GetStringFromConfig(ConfigSection(), _L("checkSpecificMimeType"), specificMimeType);

 		}

 	TInt usePrivateFile = 0;

 	GetIntFromConfig(ConfigSection(), _L("usePrivateFile"), usePrivateFile);

 	RDeletefile deletefile(iTheFs, iFileName);

 	if(!usePrivateFile)

 		{

 		// Tweak file modification time to defeat the apparch recognizer result cache....

 		TTime time;

 		User::LeaveIfError(iTheFs.Modified(iFileName, time));

 		time += TTimeIntervalSeconds(1);

 		User::LeaveIfError(iTheFs.SetModified(iFileName, time));

 		}

 	else

 		{

 		// Copy file to private dir, this will make it inaccesible to the recognizer code (except via handle).

 		ConvertFileToPrivateL();	

 		CleanupClosePushL(deletefile);

 		}

 	if (method == KMethodName)

 		{

 		INFO_PRINTF2(_L("Test Recognizing %S by File Name"), &iFileName);

 	    User::LeaveIfError(iLs.RecognizeData(iFileName, KEmptyBuffer8, recogResult));

 		}

 	else if((method == KMethodHandle) || (method == KMethodBuffer))

 		{

 		RFile fileToRead;	

 		User::LeaveIfError(fileToRead.Open(iTheFs, iFileName, EFileShareReadersOrWriters | EFileRead | EFileStream));

 		CleanupClosePushL(fileToRead);

 		if(method == KMethodHandle)

 			{

 			if (checkSpecific)

 				{

 				HBufC8* specificMimeType8 = ConvertDes16toHBufC8LC(specificMimeType);

 				TDataType mime(*specificMimeType8);																					

 				INFO_PRINTF2(_L("Test matching specific mime-type %S by Handle"), &iFileName);		

 				User::LeaveIfError(iLs.RecognizeSpecificData(fileToRead, mime, matchedSpecificMimeType));

 				CleanupStack::PopAndDestroy(specificMimeType8);

 				}

 			else 

 				{

 				INFO_PRINTF2(_L("Test Recognizing %S by Handle"), &iFileName);		

 			    User::LeaveIfError(iLs.RecognizeData(fileToRead, recogResult));				

 				}

 			}

 		else

 			{

 			INFO_PRINTF2(_L("Test Recognizing %S by Buffer"), &iFileName);		

 			TInt size;

 			User::LeaveIfError(fileToRead.Size(size));

 			TInt maxBufferSize;

 			if(GetIntFromConfig(ConfigSection(), _L("maxBufferSize"), maxBufferSize))

 				{

 				if(size > maxBufferSize)

 					{

 					size = maxBufferSize;

 					}

 				}

 			HBufC8* memForFile = HBufC8::NewLC(size);

 			TPtr8 fileContent(memForFile->Des());		

 			User::LeaveIfError(fileToRead.Read(fileContent, size));

 			User::LeaveIfError(iLs.RecognizeData(iFileName, fileContent, recogResult));

 			CleanupStack::PopAndDestroy(); //memForFile,

 			}

 		CleanupStack::PopAndDestroy(&fileToRead);

 		}

 	else

 		{

 		ERR_PRINTF1(_L("method not set correctly"));		

 		User::Leave(KErrArgument);

 		}

 	if (checkSpecific)

 		{

 		if (matchedSpecificMimeType)

 			{

 			INFO_PRINTF2(_L("Specific type '%S' matched\n"), &specificMimeType);

 			SetTestStepResult(EPass);			

 			}

 		else 

 			{

 			INFO_PRINTF2(_L("Specific type '%S' not matched\n"), &specificMimeType);

 			SetTestStepResult(EFail);			

 			}

 		}

     else 

     	{

     	TPtrC result16 = recogResult.iDataType.Des();

     	if (// Expected failure

 		((expectedConfidence == CApaDataRecognizerType::ENotRecognized) && 

 		 (recogResult.iDataType != expectedDataBuf8->Des())) ||

 		// Expected success

 		((recogResult.iConfidence == expectedConfidence) && 

 		 (recogResult.iDataType == expectedDataBuf8->Des())))

 		    {

 			INFO_PRINTF3(_L("PASSED - type '%S' confidence=%d\n"), 

 						 &result16,

 						 recogResult.iConfidence);		

 		    SetTestStepResult(EPass);	

 		    }

 		else

 			{

 			ERR_PRINTF5(_L("FAILED - expected '%S', got type '%S' - expected confidence=%d got confidence %d\n"), 

 						&expectedDataType16,

 						&result16,

 						expectedConfidence,

 						recogResult.iConfidence);		

 			SetTestStepResult(EFail);		

 			}

     	}

 	if(usePrivateFile)

 		{

 		CleanupStack::PopAndDestroy(&deletefile);

 		}

 	CleanupStack::PopAndDestroy(expectedDataBuf8);

 	INFO_PRINTF1(KCompleted);

    	}

 HBufC8* CRecogStep::ConvertDes16toHBufC8LC(TDesC& source)

 	{

 	HBufC8 *buf = HBufC8::NewL(source.Length());

 	CleanupStack::PushL(buf);

 	TPtr8 ptr=buf->Des();

 	CCnvCharacterSetConverter *converter = CCnvCharacterSetConverter::NewLC();

 	converter->PrepareToConvertToOrFromL(KCharacterSetIdentifierAscii, iTheFs);

 	converter->ConvertFromUnicode(ptr, source);

 	CleanupStack::PopAndDestroy(converter);

 	return buf;

 	}

 void CRecogStep::RunTestCasesL()

 	{

 	__UHEAP_MARK;

 	TRAPD(r,TestRecognizeDataL());

 	TEST(r==KErrNone);

 	__UHEAP_MARKEND;

 	}

 /**

    Destructor

  */

 CRecogStep::~CRecogStep()

 	{

 	iTheFs.Close();

 	iLs.Close();

 	}

 /**

    Constructor

  */

 CRecogStep::CRecogStep()

 	{

 	TInt ret=iTheFs.Connect();

 	TEST(ret==KErrNone);

 	iTheFs.ShareProtected();

 	ret = iLs.Connect();

 	TEST(ret==KErrNone);

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KRecogStep);

 	}

 /**

    @return - TVerdict code

    Override of base class virtual

  */

 TVerdict CRecogStep::doTestStepPreambleL()

 	{

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 /**

    @return - TVerdict code

    Override of base class virtual

  */

 TVerdict CRecogStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}

 TVerdict CRecogStep::doTestStepL()

 	{

 	TRAPD(ret,RunTestCasesL())

 	TEST(ret==KErrNone);

 	return TestStepResult();

 	}

 void CRecogStep::ConvertFileToPrivateL()

 	{

 	// Read source file

 	RFile fromFile;	

 	User::LeaveIfError(fromFile.Open(iTheFs, iFileName, EFileShareReadersOrWriters | EFileRead | EFileStream));

 	CleanupClosePushL(fromFile);

 	TInt size;

 	User::LeaveIfError(fromFile.Size(size));

 	HBufC8* memForFileContents = HBufC8::NewLC(size);

 	TPtr8 fileContents(memForFileContents->Des());		

 	User::LeaveIfError(fromFile.Read(fileContents, size));

 	// Create destination path

 	TDriveUnit sysDrive = RFs::GetSystemDrive();

 	(void)iTheFs.CreatePrivatePath(static_cast<TInt> (sysDrive));

 	TFileName newFileName;

 	User::LeaveIfError(iTheFs.PrivatePath(newFileName));

 	newFileName.Insert(0, sysDrive.Name());

 	TParsePtr parseFrom(iFileName);

 	newFileName.Append(parseFrom.NameAndExt());

 	// Make sure destination does not already exist.

 	(void) iTheFs.Delete(newFileName);

 	// Copy file to private location

 	RFile toFile;

 	User::LeaveIfError(toFile.Create(iTheFs, newFileName, EFileShareExclusive | EFileWrite | EFileStream));

 	CleanupClosePushL(toFile);

 	User::LeaveIfError(toFile.Write(fileContents));

 	// Update iFileName

 	iFileName = newFileName;

 	// Cleanup

 	CleanupStack::PopAndDestroy(&toFile);

 	CleanupStack::PopAndDestroy(memForFileContents);

 	CleanupStack::PopAndDestroy(&fromFile);

 	}

 // End of file