/*

 * Copyright (c) 2003-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: 

 * cafstep.cpp

 *

 */

 #include <test/testexecutelog.h>

 #include <apgcli.h>

 #include <apmstd.h>

 #include "cafserver.h"

 #include "resolver.h"

 #include "RecognizerStep.h"

 #include "CafApaRecognizer.h"

 using namespace ContentAccess;

 const TInt KCafTestMaxDataTypeLength = 255;

 const TInt KCAFTestApparcBufferSize = 100;

 /* 

  * This step starts the CAF Apparc recognizer and checks to see that it recognizes the

  * correct files

  *

  */

 CCAFRecognizeStep::~CCAFRecognizeStep()

 	{

 	}

 CCAFRecognizeStep::CCAFRecognizeStep(CCAFServer& aParent)

 : iParent(aParent)

 	{

 	SetTestStepName(KCAFRecognizeStep);

 	}

 /* Tests whether a file opened under the caf framework reports the same size as

  * RFile.  Only works for files that are owned by the f32agent which doesn't

  * change the content at all.

  */

 TVerdict CCAFRecognizeStep::doTestStepL()

 	{

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

     TBool wmdrmFlag = EFalse;     

     GetBoolFromConfig(ConfigSection(),_L("wmdrmEnabled"), wmdrmFlag);     

     if(wmdrmFlag)

         {     

         TVerdict verdict = doWmdrmTestStepL();     

         return verdict;     

         }     

 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT    

 	TBuf8 <KCAFTestApparcBufferSize> buf;

 	CAgentResolver *resolver;

 	// If we leave before our DoRecognize is complete, something must have gone seriously wrong

 	SetTestStepResult(EFail);

 	TBuf8 <KCafTestMaxDataTypeLength> ContainerMimeType;

 	TBuf8 <KCafTestMaxDataTypeLength> ContentMimeType;

 	TBool result;

 	TPtrC fileName;

 	TBool expectedresult;

 	TPtrC expectedContainerMime, expectedContentMime;

 	// Retrieve filename to analyse and expected results from INI file

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

 	GetStringFromConfig(ConfigSection(),_L("Container"),expectedContainerMime);

 	GetStringFromConfig(ConfigSection(),_L("Content"),expectedContentMime);

 	GetBoolFromConfig(ConfigSection(),_L("Recognized"),expectedresult);

 	if(expectedresult)

 		{

 		INFO_PRINTF4(_L("DoRecognize Test DRM file: %S, Container Mime Type: %S, Content Mime Type: %S"),&fileName, &expectedContainerMime, &expectedContentMime);

 		}

 	else

 		{

 		INFO_PRINTF2(_L("DoRecognize Test non DRM file: %S"), &fileName);	

 		}

 	__UHEAP_MARK;

 	// Read the first KCAFTestApparcBufferSize bytes into the buffer in the same way apparc would do

 	ReadBufferL(fileName, buf);

 	// Pass the filename and buffer to CAF DoRecognize function

 	resolver = CAgentResolver::NewLC(ETrue);

 	result = resolver->DoRecognizeL(fileName, buf, ContainerMimeType, ContentMimeType);

 	CheckResultL(result, ContainerMimeType, ContentMimeType, expectedresult, expectedContainerMime, expectedContentMime);

 	CleanupStack::PopAndDestroy(resolver); 

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 void CCAFRecognizeStep::CheckResultL(TBool aResult, TDes8& aContainerMimeType, TDes8& aContentMimeType, TBool aExpectedResult, TDesC16& aExpectedContainerMime, TDesC16& aExpectedContentMime)

 	{

 	// start off by assuming recognition was ok, then check

 	SetTestStepResult(EPass);

 	if(aResult != aExpectedResult)

 		{

 		if(aResult)

 			{

 			INFO_PRINTF1(_L("File was incorrectly recognized as DRM"));	

 			}

 		else

 			{

 			INFO_PRINTF1(_L("File was incorrectly recognized as not DRM"));	

 			}

 		SetTestStepResult(EFail);

 		return;

 		}

 	if(!aResult) // not a drm file so we don't care about the mime types

 		return;

 	TInt compare;

 	// Convert TDes16 mime types read from the INI file to TPtr8's

 	HBufC8 *container = ConvertDes16toHBufC8LC(aExpectedContainerMime);

 	TPtr8 containerptr(container->Des());

 	HBufC8 *content = ConvertDes16toHBufC8LC(aExpectedContentMime);

 	TPtr8 contentptr(content->Des());

 	// Compare expected Mime Types vs mime type

 	compare = aContainerMimeType.Compare(containerptr);

 	if(compare != 0)

 		{

 		INFO_PRINTF1(_L("Incorrect Container Mime Type recognized"));	

 		SetTestStepResult(EFail);

 		}

 	compare = aContentMimeType.Compare(contentptr);

 	if(compare != 0)

 		{

 		INFO_PRINTF1(_L("Incorrect Content Mime Type recognized"));	

 		SetTestStepResult(EFail);

 		}

 	CleanupStack::PopAndDestroy(2, container);	

 	}

 /*

  * This step starts the CAF Apparc recognizer speed test

  * Does 1000 recognitions, log file will measure the time

  *

  */

 CCAFRecognizerSpeedStep::~CCAFRecognizerSpeedStep()

 	{

 	}

 CCAFRecognizerSpeedStep::CCAFRecognizerSpeedStep(CCAFServer& aParent) : iParent(aParent)

 	{

 	SetTestStepName(KCAFRecognizerSpeedStep);

 	}

 TVerdict CCAFRecognizerSpeedStep::doTestStepL()

 	{

 	TBuf8 <KCAFTestApparcBufferSize> buf;

 	CAgentResolver *resolver;

 	// If we leave before our DoRecognize is complete, something must have gone seriously wrong

 	SetTestStepResult(EFail);

 	TBuf8 <KCafTestMaxDataTypeLength> ContainerMimeType;

 	TBuf8 <KCafTestMaxDataTypeLength> ContentMimeType;

 	TPtrC fileName;

 	TBool expectedresult;

 	TPtrC expectedContainerMime, expectedContentMime;

 	// Retrieve filename to analyse and expected results from INI file

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

 	GetStringFromConfig(ConfigSection(),_L("Container"),expectedContainerMime);

 	GetStringFromConfig(ConfigSection(),_L("Content"),expectedContentMime);

 	GetBoolFromConfig(ConfigSection(),_L("Recognized"),expectedresult);

 	if(expectedresult)

 		{

 		INFO_PRINTF4(_L("DoRecognize Speed Test DRM file: %S, Container Mime Type: %S, Content Mime Type: %S"),&fileName, &expectedContainerMime, &expectedContentMime);

 		}

 	else

 		{

 		INFO_PRINTF2(_L("DoRecognize Speed Test non DRM file: %S"), &fileName);	

 		}

 	__UHEAP_MARK;

 	// Read the first KCAFTestApparcBufferSize bytes into the buffer in the same way apparc would do

 	ReadBufferL(fileName, buf);

 	// Pass the filename and buffer to CAF DoRecognize function

 	resolver = CAgentResolver::NewLC(ETrue);

 	INFO_PRINTF1(_L("Entering measured mile"));	

 	for(TInt Count=0; Count < 1000; Count++)

 		resolver->DoRecognizeL(fileName, buf, ContainerMimeType, ContentMimeType);

 	INFO_PRINTF1(_L("passing mile marker   (1000 recognitions)"));	

     CleanupStack::PopAndDestroy(resolver); 

 	__UHEAP_MARKEND;

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 /* 

  * This step starts the CAF Apparc recognizer and checks to see that it recognizes the

  * correct files

  *

  */

 CCAFBufferSizeStep::~CCAFBufferSizeStep()

 	{

 	}

 CCAFBufferSizeStep::CCAFBufferSizeStep(CCAFServer& aParent) : iParent(aParent)

 	{

 	SetTestStepName(KCAFBufferSizeStep);

 	}

 /* Apparc uses a buffer to pass data from the start of the file into the apparc recognizer

 * to help it determine what mime type the file is.

 * In CAF this recognition task is actually handed over to the agents. Each one attempts to

 * recognize the file until one is successful or until all agents have rejected the file.

 * Each agent may have it's own preferred size for this buffer. This is configured in each

 * agent's RSS file, under the default_data tag.

 * CAgentResolver::PreferredBufferSize() will return the highest value returned by any agent.

 */

 TVerdict CCAFBufferSizeStep::doTestStepL()

 	{

 	CAgentResolver *resolver;

 	TInt expectedBufferSize;

 	TInt bufferSize=0;

 	SetTestStepResult(EFail);

 	// Find the expected max buffer size from the INI file

 	GetIntFromConfig(ConfigSection(),_L("size"),expectedBufferSize);

 	INFO_PRINTF2(_L("Expected buffer size: %d"), expectedBufferSize);

 	__UHEAP_MARK;

 	resolver = CAgentResolver::NewLC(ETrue);

 	bufferSize = resolver->PreferredBufferSize();

 	INFO_PRINTF2(_L("Caf Preferred buffer size: %d"), bufferSize);

 	if(bufferSize == expectedBufferSize)

 		{	

 		SetTestStepResult(EPass);

 		}	

 	CleanupStack::PopAndDestroy(resolver); 

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 CCAFApparcStep::~CCAFApparcStep()

 	{

 	}

 CCAFApparcStep::CCAFApparcStep(CCAFServer& aParent) : iParent(aParent)

 	{

 	SetTestStepName(KCAFApparcStep);

 	}

 /*

  * This step loads the apparc recognizer and gives it a test run by 

  * pretending to be apparc

  * 

  */

 TVerdict CCAFApparcStep::doTestStepL()

 	{

 	TDataType dataType;

 	TDataType dataType2;

 	TDataType dataType3;

 	TDataType dataTypeNull(_L8(""));	

 	TPtrC8 mimeType(KNullDesC8);

 	HBufC16 *displayMime;

 	HBufC16 *displayMime2;

 	TPtrC fileName;

 	TPtrC uri;

 	TPtrC expectedMimeType;

 	TPtrC nullFileName(KNullDesC); 

 	TUid uid = KNullUid;

 	SetTestStepResult(EInconclusive);

 	__UHEAP_MARK;

 	// Retrieve filename to analyse and expected results from INI file

 	GetStringFromConfig(ConfigSection(),_L("URI"),uri);

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

 	GetStringFromConfig(ConfigSection(),_L("CafMimeType"),expectedMimeType);

 	// Use the Application Architecture Server to find the Mime type 

 	RApaLsSession apparcSession;

 	User::LeaveIfError(apparcSession.Connect());

 	CleanupClosePushL(apparcSession);

 	User::LeaveIfError(apparcSession.AppForDocument(fileName, uid, dataType));

 	RFile fileHandle;

 	fileHandle.Open(iParent.Fs(), uri, EFileRead);

 	User::LeaveIfError(apparcSession.AppForDocument(fileHandle, uid, dataType2));

 	// Pass in a null file name to make sure it doesn't panic 

 	User::LeaveIfError(apparcSession.AppForDocument(nullFileName, uid, dataType3));

 	CleanupStack::PopAndDestroy(&apparcSession);	// close

 	// check mime type of the file (fileName)

 	mimeType.Set(dataType.Des8());

 	displayMime = ConvertDes8toHBufC16LC(mimeType);

 	TPtr16 displayPtr(displayMime->Des());

 	if(displayPtr.Compare(expectedMimeType) != 0)

 		{

 		INFO_PRINTF2(_L("CAgentResolver returned a mime type of: %S"),&displayPtr);

 		INFO_PRINTF1(_L("Please make sure the configuration file RecCafMimeTypes.txt exists for RECCAF.DLL."));

 		SetTestStepResult(EFail);

 		}

 	else

 		INFO_PRINTF3(_L("File - CAgentResolver returned a mime type of: %S, matching the expected mime type of: %S"),&displayPtr, &expectedMimeType);

 	// check mime type of the file (fileHandle)

 	mimeType.Set(dataType2.Des8());

 	displayMime2 = ConvertDes8toHBufC16LC(mimeType);

 	TPtr16 displayPtr2(displayMime2->Des());

 	if(displayPtr2.Compare(expectedMimeType) != 0)

 		{

 		INFO_PRINTF2(_L("CAgentResolver returned a mime type of: %S"),&displayPtr2);

 		INFO_PRINTF1(_L("Please make sure the configuration file RecCafMimeTypes.txt exists for RECCAF.DLL."));

 		SetTestStepResult(EFail);

 		}	

 	else

 		INFO_PRINTF3(_L("FileHandle - CAgentResolver returned a mime type of: %S, matching the expected mime type of: %S"),&displayPtr2, &expectedMimeType);

 	// Check the returned datatype is null, when a null filename is passed in  

 	if (dataType3 == dataTypeNull)

 		INFO_PRINTF1(_L("A null datatype is returned, when a null file name is passed in"));

 	else 

 		SetTestStepResult(EFail);

 	CleanupStack::PopAndDestroy(displayMime2);		

 	CleanupStack::PopAndDestroy(displayMime);

 	__UHEAP_MARKEND;

 	if (TestStepResult() != EFail)

 		{

 		SetTestStepResult(EPass);

 		}

 	return TestStepResult();

 	}

 /* 

  * This test verifies that upper case Mime types can be recognized.

  *

  * See DEF077443: Propagated:CAF should not be performing case sensitive comparisons on MIME types

  *

  */

 CCAF_DEF077443_Step::~CCAF_DEF077443_Step()

 	{

 	}

 CCAF_DEF077443_Step::CCAF_DEF077443_Step(CCAFServer& aParent) : iParent(aParent)

 	{

 	SetTestStepName(KCAF_DEF077443_Step);

 	}

 TVerdict CCAF_DEF077443_Step::doTestStepL()

 	{

 	TDataType dataType;

 	TDataType dataType2;

 	TPtrC8 mimeType(KNullDesC8);

 	HBufC16 *displayMime;

 	HBufC16 *displayMime2;

 	TPtrC upperCaseFileName;

 	TPtrC emptyFileName;

 	TPtrC expectedContentMimeType;

 	TPtrC expectedFileMimeType;

 	TUid uid = KNullUid;

 	SetTestStepResult(EInconclusive);

 	__UHEAP_MARK;

 	// Retrieve filename to analyse and expected results from INI file.

 	// The CAF resolver forces mime types retrieved from agents to lower case.

 	// When recognising the file mime type and content mine type for a file the

 	// resolver passes the request to each agent. Its possible that the agent will

 	// not use lower case for the file mime type and content mime type. To be 

 	// consistent the resolver should set the returned data to lower case as well.

 	// The test agent takes content mime type from the uppercasetest.drm file.

 	// For this case the content mime type is upper case (e.g. TEXT/PLAIN).

 	GetStringFromConfig(ConfigSection(),_L("FileName1"), upperCaseFileName);

 	GetStringFromConfig(ConfigSection(),_L("CafContentMimeType"), expectedContentMimeType);

 	// For a drm file with no recognised content the test agent sets the file mime type

 	// as APPLICATION/TESTAGENT.DRM.

 	// For this case the file emptytest.drm is used.

 	GetStringFromConfig(ConfigSection(),_L("FileName2"), emptyFileName);

 	GetStringFromConfig(ConfigSection(),_L("CafFileMimeType"), expectedFileMimeType);

 	// create empty DRM file

 	RFs fs;

 	RFile file;

 	// remove first if exists

 	Delete(emptyFileName);

 	fs.Connect();

 	TInt result = file.Create(fs, emptyFileName, EFileWrite);

 	file.Close();

 	fs.Close(); 

 	// Use the Application Architecture Server to find the Content Mime type 

 	RApaLsSession apparcSession;

 	User::LeaveIfError(apparcSession.Connect());

 	CleanupClosePushL(apparcSession);

 	User::LeaveIfError(apparcSession.AppForDocument(upperCaseFileName, uid, dataType));

 	// Use the Application Architecture Server to find the File Mime type 

 	User::LeaveIfError(apparcSession.AppForDocument(emptyFileName, uid, dataType2));

 	CleanupStack::PopAndDestroy(&apparcSession);	// close

 	// remove empty file

 	Delete(emptyFileName);

 	// check content mime type

 	mimeType.Set(dataType.Des8());

 	displayMime = ConvertDes8toHBufC16LC(mimeType);

 	TPtr16 displayPtr(displayMime->Des());

 	if(displayPtr.Compare(expectedContentMimeType) != 0)

 		{

 		INFO_PRINTF2(_L("CAgentResolver returned a content mime type of: %S"),&displayPtr);

 		INFO_PRINTF1(_L("Please make sure the configuration file RecCafMimeTypes.txt exists for RECCAF.DLL."));

 		SetTestStepResult(EFail);

 		}

 	else

 		INFO_PRINTF3(_L("Content - CAgentResolver returned a mime type of: %S, matching the expected mime type of: %S"),&displayPtr, &expectedContentMimeType);

 	// check file mime type

 	mimeType.Set(dataType2.Des8());

 	displayMime2 = ConvertDes8toHBufC16LC(mimeType);

 	TPtr16 displayPtr2(displayMime2->Des());

 	if(displayPtr2.Compare(expectedFileMimeType) != 0)

 		{

 		INFO_PRINTF2(_L("CAgentResolver returned a file mime type of: %S"),&displayPtr2);

 		INFO_PRINTF1(_L("Please make sure the configuration file RecCafMimeTypes.txt exists for RECCAF.DLL."));

 		SetTestStepResult(EFail);

 		}	

 	else

 		INFO_PRINTF3(_L("File - CAgentResolver returned a mime type of: %S, matching the expected mime type of: %S"),&displayPtr2, &expectedFileMimeType);

 	CleanupStack::PopAndDestroy(displayMime2);

 	CleanupStack::PopAndDestroy(displayMime);

 	__UHEAP_MARKEND;

 	if (TestStepResult() != EFail)

 		{

 		SetTestStepResult(EPass);

 		}

 	return TestStepResult();

 	}

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 // Tests DoRecognizeL API for WMDRM content .

 TVerdict CCAFRecognizeStep::doWmdrmTestStepL()     

     {     

     SetTestStepResult(EFail);     

     TPtrC expectedFileMimeType;     

     GetStringFromConfig(ConfigSection(),_L("filemime"), expectedFileMimeType);     

     TPtrC expectedContentMimeType;     

     GetStringFromConfig(ConfigSection(),_L("contentmime"), expectedContentMimeType);     

     TBool expectedResult;     

     GetBoolFromConfig(ConfigSection(),_L("recognized"), expectedResult);     

     __UHEAP_MARK;     

     TPtrC header;     

     HBufC8* headerData = NULL;     

     if(GetStringFromConfig(ConfigSection(),_L("header"), header))     

         {     

         headerData = ConvertDes16toHBufC8LC(header);     

         }     

     else     

         {     

         headerData = CreateWmdrmHeaderLC();      

         }     

     // Pass the WMDRM header data to CAF DoRecognize function     

     CAgentResolver* resolver = CAgentResolver::NewLC(ETrue);     

     TBuf8 <KCafTestMaxDataTypeLength> fileMimeType;     

     TBuf8 <KCafTestMaxDataTypeLength> contentMimeType;     

     TBool result = resolver->DoRecognizeL(*headerData, fileMimeType, contentMimeType);     

     CheckResultL(result, fileMimeType, contentMimeType, expectedResult, expectedFileMimeType, expectedContentMimeType);     

     CleanupStack::PopAndDestroy(2, headerData);      

     __UHEAP_MARKEND;     

     return TestStepResult();     

     }     

 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT