--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/Recogniser/tsu_mmf_mmruf_step.cpp	Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,405 @@
+// 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:
+//
+
+#include <f32file.h>
+#include "tsu_mmf_mmruf_step.h"
+
+static const TInt KTestStepNameSize = 22; // MM-MMF-MMRUF-U-xxxx-HP
+
+/*
+**
+*/
+RMMRUFTestStep::RMMRUFTestStep(const TTestSpec* aTestSpec)
+ : 	iTestSpec(aTestSpec)
+	{
+	ASSERT(iTestSpec != NULL);
+
+	_LIT(KTestStep, "MM-MMF-MMRUF-U-%04d-HP");
+
+	TBuf<KTestStepNameSize> temp;
+	temp.Zero();
+	temp.AppendFormat(KTestStep, iTestSpec->iTestNumber);
+	iTestStepName = temp;
+	}
+
+/*
+**
+*/
+RMMRUFTestStep::~RMMRUFTestStep()
+	{
+	Close();
+	}
+
+/*
+**
+*/
+RMMRUFTestStep* RMMRUFTestStep::NewL(const TTestSpec* aTestSpec)
+	{
+	return new(ELeave) RMMRUFTestStep(aTestSpec);
+	}
+
+/*
+**
+*/
+TVerdict RMMRUFTestStep::DoTestStepPreambleL()
+	{
+	User::LeaveIfError(iAppArc.Connect());
+	return EPass;
+	}
+	
+/*
+**
+*/
+TVerdict RMMRUFTestStep::DoTestStepPostambleL()
+	{
+	iAppArc.Close();
+	return EPass;
+	}
+
+/*
+**
+*/
+TVerdict RMMRUFTestStep::DoTestStepL()
+	{
+	iTestStepResult = EFail;
+	TPtrC filename(iTestSpec->iFileName);
+	INFO_PRINTF2(_L("Testing file: %S"), &filename);
+	
+	RFile file;
+	TInt err = file.Open(iAppArc.FileServer(), filename, EFileRead | EFileShareAny);
+	if (err != KErrNone)
+		{
+		INFO_PRINTF3(_L("RFile.Open(\"%S\") failed: %d"), &filename, err);
+		User::Leave(err);
+		}
+	
+	CleanupClosePushL(file);
+	TDataRecognitionResult dataType;
+	err = iAppArc.Recognise(file, dataType);
+	if (err != KErrNone)
+		{
+		iTestStepResult = EInconclusive;
+		INFO_PRINTF2(_L("RApaLsSession.RecognizeData() failed: %d"), err);
+		User::Leave(err);
+		}
+	
+	CleanupStack::Pop(); // file
+		
+	// Check the results.
+	TPtrC8 resMime(dataType.iDataType.Des8());
+	TPtrC8 expectedMime(iTestSpec->iExpectedMimeType);
+	
+	if (expectedMime.Compare(resMime) == 0)
+		{
+		if (iTestSpec->iTestNumber >= 600)
+			{
+			//  Negative testing above 600
+			//	These are negative tests. So Mime type must be empty
+			if (resMime.Compare(_L8("")) == 0)
+				{
+				iTestStepResult = EPass;
+				return iTestStepResult;
+				}
+			}
+		// DEF129505 - MMRuf incorrectly recognises unicode text files as MP3 files
+		else if (iTestSpec->iTestNumber == 500)
+			{
+			iTestStepResult = EPass;
+			return iTestStepResult;
+			}
+						
+		// Set the result to EFail initially and change it to EPass
+		// further down in the code after checking the expected confidence.
+		iTestStepResult = EFail;
+		TBuf<64> confidence;
+		switch (dataType.iConfidence)
+			{
+			case KConfCertain:
+				confidence.Copy(_L("KConfCertain"));
+				break;
+			case KConfProbable:
+				confidence.Copy(_L("KConfProbable"));
+				break;
+			case KConfPossible:
+				confidence.Copy(_L("KConfPossible"));
+				break;
+			case KConfNotRecognised:
+				confidence.Copy(_L("KConfNotRecognised"));
+				break;
+			default:
+				// Safe Guard: This will never happen
+				break;	
+			}
+		
+		// #############################################################
+		// SPECIAL CASES: There are some formats that are never recognised
+		// with confidence = ECertain. Deal with these here.
+		switch (iTestSpec->iTestNumber)
+			{
+			case 55:	// RAM.
+			case 115:	// SDP
+			case 116:	// SDP
+			case 117:	// SDP
+			case 118:	// SDP
+			case 119:	// SDP
+			case 120:	// SDP
+			case 121:	// SDP
+			case 122:	// SDP
+				if (dataType.iConfidence != KConfProbable)
+					{
+					INFO_PRINTF2(_L("Bad confidence level: %S, expected KConfProbable"), &confidence);
+					}
+				else
+					{
+					iTestStepResult = EPass;
+					}
+					
+				return iTestStepResult;
+				
+			default:
+				// Deliberate fall-through.
+				break;
+			}
+			
+
+		// Mod of 3 cos there are 3 test cases for each format
+		TInt res = iTestSpec->iTestNumber % 3;
+		switch (res)
+			{
+			case 1:
+				// 1st test
+				// Buffer Data and file extension are correct.
+				if (dataType.iConfidence == KConfCertain)
+					{
+					iTestStepResult = EPass;
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfCertain"), &confidence);
+					}	
+				break;
+				
+			case 2:
+				// 2nd test
+				// Buffer data is correct, but the file extension is incorrect.
+				if (dataType.iConfidence >= KConfProbable)
+					{
+					iTestStepResult = EPass;
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfProbable"), &confidence);
+					}		
+				break;
+				
+			case 0:
+				// 3rd test	
+				// Buffer data is unknown and file extension exists.
+				if (dataType.iConfidence >= KConfPossible)
+					{
+					iTestStepResult = EPass;
+					}
+				else
+					{
+					INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfPossible"), &confidence);
+					}		
+				break;
+
+			default:
+				// Safe Guard: This must never happen
+				break;
+			}
+		}
+	else
+		{
+		TBuf<KMaxDataTypeLength> returned;
+		returned.Copy(dataType.iDataType.Des());
+		INFO_PRINTF2(_L("- wrong returned MIME-type: %S"), &returned);
+		iTestStepResult = EFail;
+		}
+	return iTestStepResult;
+	}
+
+
+//
+// OOM Tests
+//
+
+/*
+**
+*/
+RTestStepMMRUFOOM* RTestStepMMRUFOOM::NewL(const TTestSpec* aTestSpec)
+	{
+	return new(ELeave) RTestStepMMRUFOOM(aTestSpec);
+	}
+
+/*
+**
+*/
+RTestStepMMRUFOOM::RTestStepMMRUFOOM(const TTestSpec* aTestSpec)
+	:iTestSpec(aTestSpec)
+	{
+	ASSERT(iTestSpec != NULL);
+
+	_LIT(KAllocTestStep, "MM-MMF-MMRUF-U-%04d-CP");
+
+	TBuf<KTestStepNameSize> temp;
+	temp.Zero();
+	temp.AppendFormat(KAllocTestStep, iTestSpec->iTestNumber);
+	iTestStepName = temp;
+	}
+	
+/*
+**
+*/
+TVerdict RTestStepMMRUFOOM::DoTestStepPreambleL()
+	{
+	User::LeaveIfError(iAppArc.Connect());
+	return EPass;
+	}
+
+/*
+**
+*/
+TVerdict RTestStepMMRUFOOM::DoTestStepPostambleL()
+	{
+	iAppArc.Close();
+	return EPass;
+	}
+
+/*
+**
+*/
+TVerdict RTestStepMMRUFOOM::DoTestStepL()
+	{
+    TInt err;
+	TDataRecognitionResult dataType;
+	TPtrC filename(iTestSpec->iFileName);
+	RFile file;
+	TInt failCount = 1;
+	TBool completed;
+	TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging
+	
+	
+	iTestStepResult = EFail;
+	err = file.Open(iAppArc.FileServer(), filename, EFileRead | EFileShareAny);
+	if (err != KErrNone)
+		{
+		INFO_PRINTF2(_L("RFile.Open() failed: %d"), err);
+		User::Leave(err);
+		}
+	CleanupClosePushL(file);
+		
+	FOREVER
+		{
+		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);
+
+		iTestStepResult = EFail;
+		// We will check 1000 Allocations as this is a non leaving function.
+		err = iAppArc.Recognise(file, dataType);
+		if (err != KErrNone)
+			{
+			INFO_PRINTF2(_L("RApaLsSession.RecognizeData() failed: %d"), err);
+			iTestStepResult = EInconclusive;
+			}
+
+		completed = EFalse;
+		if (err == KErrNone)
+			{
+			if (iTestStepResult == EPass)
+				{
+				TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test
+				if (testAlloc==NULL)
+					{
+					reachedEnd = ETrue;
+					failCount--; // -= 1;
+					}
+				else
+					{
+					User::Free(testAlloc);
+					}
+				completed = reachedEnd;
+				}
+			else
+				{
+				// the test failed but we have already proved above
+				// that the required plugins are present
+				// therefore we assume that the interface returned
+				// a NULL pointer and so we can continue to test
+				// until the timeout or the fail count exceeds
+				completed = EFalse;
+				}
+			}
+		else if (err == KErrNotSupported)
+			{
+			// the test has returned not supported but we already
+			// know that the interface *is* supported so we assume
+			// that the interface creation failed due to lack of
+			// memory and so we continue to test until the timeout
+			// or we exceed the fail count
+			completed = EFalse;
+			}
+		else if (err != KErrNoMemory) // bad error code
+			{
+			completed = ETrue;
+			}
+				
+		__UHEAP_SETFAIL(RHeap::ENone ,0);
+
+		// if we have completed successfully or we have exceeded
+		// a 1000 failed ALLOC attempts then quit
+		if (completed || failCount > 1000)
+			{
+			break; // exit loop
+			}
+
+		failCount++;
+		}
+
+	// finished with test
+	CleanupStack::Pop(); //file
+	
+	if (err != KErrNone)
+		{
+		INFO_PRINTF3(_L("  Error(%d) with %d memory allocations tested"), err, failCount);
+		User::LeaveIfError(err);
+		}
+	else 
+		{
+		INFO_PRINTF2(_L("  Completed OK with %d memory allocations tested"), failCount);
+		iTestStepResult = EPass;
+		}
+	
+	TPtrC8 resMime(dataType.iDataType.Des8());
+	TPtrC8 expectedMime(iTestSpec->iExpectedMimeType);
+	
+	TBuf<KMaxDataTypeLength> returned;
+	returned.Copy(dataType.iDataType.Des());
+		
+	if (expectedMime.Compare(resMime) == 0)
+		{
+		INFO_PRINTF2(_L("Matched Expected MIME-type: %S"), &returned);
+		iTestStepResult = EPass;
+		}
+	else 
+		{
+		INFO_PRINTF2(_L("- wrong returned MIME-type: %S"), &returned);
+		iTestStepResult = EFail;
+		}
+	INFO_PRINTF1(_L("finished with this test step"));
+	// test steps return a result
+	return iTestStepResult;
+	}
+