--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contentmgmt/referencedrmagent/tcaf/source/RecognizerStep.cpp	Mon Oct 12 10:17:04 2009 +0300
@@ -0,0 +1,555 @@
+/*
+* 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 
+