// Copyright (c) 2004-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 "TestPlayerUtils.h"

#include "OpenFileByHandle7908.h"

#include <caf/caf.h>

/**

 * Constructor

 */

CTestMmfAclntOpenFile7908::CTestMmfAclntOpenFile7908(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

	: CTestMmfAclntOpenFile7902(aTestName, aSectName, aKeyName, aFormat, aCreateFile), iRecUtil(NULL),iPlayUtil(NULL)

	{

	}

CTestMmfAclntOpenFile7908* CTestMmfAclntOpenFile7908::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

	{

	CTestMmfAclntOpenFile7908* self = new (ELeave) CTestMmfAclntOpenFile7908(aTestName,aSectName,aKeyName,aFormat,aCreateFile);

	return self;

	}

CTestMmfAclntOpenFile7908* CTestMmfAclntOpenFile7908::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

	{

	CTestMmfAclntOpenFile7908* self = CTestMmfAclntOpenFile7908::NewL(aTestName,aSectName,aKeyName,aFormat,aCreateFile);

	CleanupStack::PushL(self);

	return self;

	}

/**

 * Open a file based clip and record, and then playback 

 * Performs alloc tests separately for each step in this test case

 * The 4 steps in this case are : 

 * 1> Create CMdaAudioRecorderUtility 

 * 2> Open CMdaAudioRecorderUtility and record a clip

 * 3> Create CMdaAudioPlayerUtility

 * 4> Open CMdaAudioRecorderUtility and playback the clip

 */

TVerdict CTestMmfAclntOpenFile7908::DoTestStepL()

	{

	INFO_PRINTF1( _L("TestRecorder : Record File"));

	TInt err = KErrNone;

	//>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<

	if( PerformTestStepL() != EPass )

		{

		err = iError;

		}

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Test error, returned error code =  %d"), err);

		User::Leave(err);

		}

	TInt failCount = 0;//total fail count for all the steps = sum of fail counts in each step

	TInt stepFailCount; //fail count in each step

	err = PerformTestStep(1, stepFailCount);

	failCount += stepFailCount;

	if (err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		return iAllocTestStepResult;

		}		

	TRAP(err, ExecuteStep1L());//Till step1 alloc tests are done, now keep the conditions ready 

							   //for performing alloc tests on step 2 i,e keep the iRecUtil 

							   //created and open for recording in this step

	if (err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		return iAllocTestStepResult;

		}								  

	err = PerformTestStep(2, stepFailCount);	

	failCount += stepFailCount;

	delete iRecUtil;// Was created in ExecuteStep1L to be used for performing alloc tests in step 2 	

	if (err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		return iAllocTestStepResult;

		}

	err = PerformTestStep(3, stepFailCount);

	failCount += stepFailCount;

	if (err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		return iAllocTestStepResult;

		}

	TRAP(err, ExecuteStep3L());//Till step3 alloc tests are done, now keep the conditions ready 

							   //for performing alloc tests on step 4 i,e keep the iPlayUtil 

							   //created and open for playback in this step

	if(err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		return iAllocTestStepResult;	

		}			

	err = PerformTestStep(4, stepFailCount);

	failCount += stepFailCount;

	delete iPlayUtil; // Was created in ExecuteStep3L to be used for performing alloc tests in step 4

	stepFailCount -= 1; // Failcount of 1 equates to 0 successful allocs, etc

	if (err != KErrNone)

		{

		iAllocTestStepResult = EFail;

		TBuf<80> format;

		format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

		Log(format);

		}

	else 

		{

		TBuf<80> format;

		format.Format(_L("  Completed OK with %d memory allocations tested\n"), failCount);

		Log(format);

		}

	return iAllocTestStepResult;

	}

/*

 * TVerdict CTestMmfAclntOpenFile7908::PerformTestStep(TInt aStepNo, TInt& aStepFailCount)

 * Performs alloc tests on the step aStepNo in this test case

 */	

TInt CTestMmfAclntOpenFile7908::PerformTestStep(TInt aStepNo, TInt& aStepFailCount)	

	{

	TBool completed;

	TInt err;

	for(aStepFailCount = 1;;)	

		{

		__UHEAP_SETFAIL(RHeap::EFailNext, aStepFailCount);

		__MM_HEAP_MARK;

//		INFO_PRINTF2(_L("CAudioRecorderUtility: Alloc Test Loop: %d"), failCount);

		//>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<

		TVerdict verdict = EFail;

		switch( aStepNo )

			{

			case 1:

				TRAP(err, verdict = ExecuteStep1L());	

				if(err == KErrNone)

					{

					delete iRecUtil; //Created in ExecuteStep1L. We dont need it open anymore 						

					}

				break; 

			case 2:

				TRAP(err, verdict = ExecuteStep2L());	

				break; 

			case 3:

				TRAP(err, verdict = ExecuteStep3L());

				if(err == KErrNone)

					{

					delete iPlayUtil; //Created in ExecuteStep3L. We dont need it open anymore 						

					}

				break; 

			case 4:

				TRAP(err, verdict = ExecuteStep4L());	

				break; 				

			}

		if (err == KErrNone && verdict != EPass)

			{

			err = iError;

			}

		completed = EFalse;

		if (err == KErrNone)

			{

			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

			if (testAlloc == NULL)

				{

				completed = ETrue;

				aStepFailCount -= 1;

				}

			else

				{

				User::Free(testAlloc);	

				}			

			}

		else if (err != KErrNoMemory) // bad error code

			{

			completed = ETrue;

			}			

		__MM_HEAP_MARKEND;

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		if (completed)

			{

			break; // exit loop

			}

		aStepFailCount++;

		}//for

		return err;	

	}

/*

 * TVerdict CTestMmfAclntOpenFile7908::ExecuteStep1L()

 * Executes the statements for step 1 of this test case

 */

TVerdict CTestMmfAclntOpenFile7908::ExecuteStep1L()

	{

	iError = KErrTimedOut;

	iRecUtil = CMdaAudioRecorderUtility::NewL(*this);

	iError = KErrNone;

	return EPass;	

	}

/*

 * TVerdict CTestMmfAclntOpenFile7908::ExecuteStep2L()

 * Executes the statements for step 2 of this test case

 */

TVerdict CTestMmfAclntOpenFile7908::ExecuteStep2L()

	{

	TVerdict ret = EFail;

	iError = KErrTimedOut;

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

	CleanupClosePushL(iFs);

	User::LeaveIfError(iFs.ShareProtected());

	if(!GetStringFromConfig(iSectName, iKeyName, iFilename))

		{

		ret = EInconclusive;

		}

	User::LeaveIfError(iFile.Replace(iFs,iFilename,EFileWrite));

	CleanupClosePushL(iFile);

	iRecUtil->OpenFileL(iFile);

	CleanupClosePushL(*iRecUtil);

	CActiveScheduler::Start();

	if(iError == KErrNone)

		{

		iError = KErrTimedOut;

		iRecUtil->RecordL();

		CActiveScheduler::Start(); // open -> record

		User::After(500000);	// 0.5 sec

		iRecUtil->Stop();

		}

	CleanupStack::PopAndDestroy(3, &iFs);	//iFs, iFile, iRecUtil

	if(iError == KErrNone)

		{

		ret = EPass;

		}		

	return ret;	

	}

/*

 * TVerdict CTestMmfAclntOpenFile7908::ExecuteStep3L()

 * Executes the statements for step 3 of this test case

 */

 TVerdict CTestMmfAclntOpenFile7908::ExecuteStep3L()

	{

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	iPlayUtil = CMdaAudioPlayerUtility::NewL(*this);

	iError = KErrNone;

	ret = EPass;

	return ret;

	}

/*

 * TVerdict CTestMmfAclntOpenFile7908::ExecuteStep4L()

 * Executes the statements for step 4 of this test case

 */

TVerdict CTestMmfAclntOpenFile7908::ExecuteStep4L()

	{

	TVerdict ret = EFail;

	iError = KErrTimedOut;	

	TRAPD(err, iPlayUtil->OpenFileL(iFilename));

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error opening file for playback err = %d"), err);

		ret = EFail;

		}

	CActiveScheduler::Start();

	if (iError != KErrNone)

		{

		INFO_PRINTF2(_L("Error opening file for playback iError = %d"), iError);

		ret = EFail;

		}

	if( iError == KErrNone )

		{

		iPlayUtil->Play();

		CActiveScheduler::Start();

		}

	iPlayUtil->Close();		

	if (iError != KErrNone)

		{

		INFO_PRINTF2(_L("Error during playback of recorded file iError=%d"), iError);

		ret = EFail;

		}	

	if( iError == KErrNone ) 

		{

		RFile file;

		TInt size = 0;

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

		CleanupClosePushL(iFs);

		User::LeaveIfError(iFs.ShareProtected());

		User::LeaveIfError(file.Open(iFs,iFilename,EFileRead));

		CleanupClosePushL(file);

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

		if(size > 0)

			{

			ret = EPass;

			}

		CleanupStack::PopAndDestroy(2, &iFs); //iFile, iFs

		}

	ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );

	if(iError == KErrNone)

		{

		User::After(500000);	

		}

	return	ret;

	}