/*

* 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