// 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 "TestMidiClientUtility.h"

#include <e32math.h>

CTestMidiClntOpenFile::CTestMidiClntOpenFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	:CTestMmfMidiClntStep(aTestName, ETestValid),

	 iPlay(aPlay)

	{

	iSectName = aSectName;

	iKeyName = aKeyName;

	}

CTestMidiClntOpenFile* CTestMidiClntOpenFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	{

	CTestMidiClntOpenFile* self = new(ELeave) CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay);

	return self;

	}

TVerdict CTestMidiClntOpenFile::DoTestStepL()

	{

	TPtrC filename;

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

		return EInconclusive;

	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

	if (!player)

		{

		ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));

		return EInconclusive;

		}

	CleanupStack::PushL(player);

	TMMFMessageDestinationPckg dummyPckg;

	TInt dummyFunc = 0; //EDevMidiOff;

	TBuf8<8> dummyBuff;

	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);

	player->OpenFile(filename);

	// Wait for initialisation callback

	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));

	CActiveScheduler::Start();

	TVerdict ret = EFail;

	// Check for errors.

	if (iError == KErrNone)

		ret = DoTestL(player);

	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));

	CleanupStack::PopAndDestroy(player);

	if(iError != KErrNone)

		ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );

	return	ret;

	}

TVerdict CTestMidiClntOpenFile::DoTestL(CMidiClientUtility* /*aMidi*/)

	{

	return EPass;

	}

//------------------------------------------------------------------

CTestMidiClntOpenDes::CTestMidiClntOpenDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	:CTestMmfMidiClntStep(aTestName, ETestValid),

	 iPlay(aPlay)

	{

	iSectName = aSectName;

	iKeyName = aKeyName;

	}

CTestMidiClntOpenDes* CTestMidiClntOpenDes::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	{

	CTestMidiClntOpenDes* self = new(ELeave) CTestMidiClntOpenDes(aTestName, aSectName, aKeyName, aPlay);

	return self;

	}

TVerdict  CTestMidiClntOpenDes::DoTestStepPreambleL()

	{

	TPtrC filename; 

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

		return EInconclusive;

	RFs fs;

	RFile file;

	TInt size = 0;

	// connect to file system and open file

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

	User::LeaveIfError(file.Open(fs,filename,EFileRead));

	CleanupClosePushL(file);

	// Set HBuf size

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

	INFO_PRINTF2(_L("size of file = %d\n"),size);

	iAudio = HBufC8::NewMaxL(size);

	// read data into Hbuf

	TPtr8 bufferDes(iAudio->Des());

	User::LeaveIfError(file.Read(bufferDes));

	CleanupStack::PopAndDestroy(); //file

	return CTestMmfMidiClntStep::DoTestStepPreambleL();

	}

TVerdict CTestMidiClntOpenDes::DoTestStepPostambleL()

	{

	delete iAudio;

	iAudio = NULL;

	return CTestMmfMidiClntStep::DoTestStepPostambleL();

	}

TVerdict CTestMidiClntOpenDes::DoTestStepL()

	{

	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

	if (!player)

		{

		ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));

		return EInconclusive;

		}

	CleanupStack::PushL(player);

	TMMFMessageDestinationPckg dummyPckg;

	TInt dummyFunc = EDevMidiOff;

	TBuf8<8> dummyBuff;

	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);

	player->OpenDes(iAudio->Des());

	// Wait for initialisation callback

	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));

	CActiveScheduler::Start();

	TVerdict ret = EFail;

	// Check for errors.

	if (iError == KErrNone)

		ret = DoTestL(player);

	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));

	CleanupStack::PopAndDestroy(player);

	if(iError != KErrNone)

		ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );

	return	ret;

	}

TVerdict CTestMidiClntOpenDes::DoTestL(CMidiClientUtility* /*aMidi*/)

	{

	return EPass;

	}

//------------------------------------------------------------------

CTestMidiClntOpenUrl::CTestMidiClntOpenUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	:CTestMmfMidiClntStep(aTestName, ETestValid),

	 iPlay(aPlay)

	{

	iSectName = aSectName;

	iKeyName = aKeyName;

	}

CTestMidiClntOpenUrl* CTestMidiClntOpenUrl::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)

	{

	CTestMidiClntOpenUrl* self = new(ELeave) CTestMidiClntOpenUrl(aTestName, aSectName, aKeyName, aPlay);

	return self;

	}

TVerdict CTestMidiClntOpenUrl::DoTestStepL()

	{

	TPtrC urlname;

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

		return EInconclusive;

	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

	if (!player)

		{

		ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));

		return EInconclusive;

		}

	CleanupStack::PushL(player);

	TMMFMessageDestinationPckg dummyPckg;

	TInt dummyFunc = EDevMidiOff;

	TBuf8<8> dummyBuff;

	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);

	player->OpenUrl(urlname);

	// Wait for initialisation callback

	INFO_PRINTF1(_L("CMidiClientUtility: Opening url"));

	CActiveScheduler::Start();

	TVerdict ret = EFail;

	// Check for errors.

	if (iError == KErrNone)

		ret = DoTestL(player);

	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));

	CleanupStack::PopAndDestroy(player);

	if(iError != KErrNone)

		ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );

	return	ret;

	}

TVerdict CTestMidiClntOpenUrl::DoTestL(CMidiClientUtility* /*aMidi*/)

	{

	return EPass;

	}

//------------------------------------------------------------------

CTestMidiClntClose::CTestMidiClntClose(const TDesC& aTestName)

	:CTestMmfMidiClntStep(aTestName, ETestValid)

	{

	}

CTestMidiClntClose* CTestMidiClntClose::NewL(const TDesC& aTestName)

	{

	CTestMidiClntClose* self = new(ELeave) CTestMidiClntClose(aTestName);

	return self;

	}

TVerdict CTestMidiClntClose::DoTestL(CMidiClientUtility* aMidi)

	{

	INFO_PRINTF1(_L("CMidiClientUtility: Closing file"));

	aMidi->Close();

	return EPass;

	}

//------------------------------------------------------------------

CTestMidiClntPlay::CTestMidiClntPlay(const TDesC& aTestName, const TTestStepType aTestType)

	:CTestMmfMidiClntStep(aTestName, aTestType)

	{

	}

CTestMidiClntPlay* CTestMidiClntPlay::NewL(const TDesC& aTestName, const TTestStepType aTestType)

	{

	CTestMidiClntPlay* self = new(ELeave) CTestMidiClntPlay(aTestName, aTestType);

	return self;

	}

TVerdict CTestMidiClntPlay::DoTestL(CMidiClientUtility* aMidi)

	{

	TInt expErr = KErrNone;

	//TTimeIntervalMicroSeconds fadeOutDuration(0);

	INFO_PRINTF1(_L("CMidiClientUtility: Play midi file"));

	// expected results

	switch(iTestType)

		{

		case ETestValid:

			expErr = KErrNone;

			break;

		case ETestNoPlugin:

			expErr = KErrNotSupported;

			break;

		case ETestInvalidState:

			expErr = KErrUnknown;

			break;

		default:

			ERR_PRINTF1(_L("Error - invalid test step type"));

			return EInconclusive;

		}

	iCurrentState = EMidiStateClosedDisengaged;

	aMidi->OpenFile(_L("c:\\DoesntExist.mid"));

	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));

	CActiveScheduler::Start();	// EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged

	if (iCurrentState != EMidiStateOpenDisengaged)

		{

		ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);

		return EFail;

		}

	aMidi->Play();

	if (expErr != iError)

		{

		ERR_PRINTF3(_L("Play gave error %d (expected %d)"),iError, expErr);

		return EFail;

		}

	else

		INFO_PRINTF3(_L("Play, %d = %d"), iError, expErr);

	return EPass;	

	}

//------------------------------------------------------------------

CTestMidiClntStop::CTestMidiClntStop(const TDesC& aTestName, const TTestStepType aTestType)

	:CTestMmfMidiClntStep(aTestName, aTestType)

	{

	}

CTestMidiClntStop* CTestMidiClntStop::NewL(const TDesC& aTestName, const TTestStepType aTestType)

	{

	CTestMidiClntStop* self = new(ELeave) CTestMidiClntStop(aTestName, aTestType);

	return self;

	}

TVerdict CTestMidiClntStop::DoTestL(CMidiClientUtility* aMidi)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

	TTimeIntervalMicroSeconds fadeOutDuration(0);

	INFO_PRINTF1(_L("CMidiClientUtility: Stop midi file"));

	// expected results

	switch(iTestType)

		{

		case ETestValid:

			expErr = KErrNone;

			fadeOutDuration = 20;

			break;

		case ETestNoPlugin:

			expErr = KErrNotSupported;

			break;

		case ETestNoResource:

			expErr = KErrNotReady;

			break;

		default:

			ERR_PRINTF1(_L("Error - invalid test step type"));

			return EInconclusive;

		}

	aMidi->Stop(fadeOutDuration);

	if (expErr != KErrNone)

		INFO_PRINTF2(_L("Stop gave error %d"),expErr);

	else

		INFO_PRINTF1(_L("Stopping midi file"));

	return ret;

	}

//------------------------------------------------------------------

CTestMidiClntGetState::CTestMidiClntGetState(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay)

	:CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay)

	{

	// NB this inherits from CTestMidiClntOpenFile, NOT from CTestMmfMidiClntStep

	// so we have to set this manually.

	iTestType = aTestType;

	}

CTestMidiClntGetState* CTestMidiClntGetState::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay)

	{

	CTestMidiClntGetState* self = new(ELeave) CTestMidiClntGetState(aTestName, aSectName, aKeyName, aTestType, aPlay);

	return self;

	}

TVerdict CTestMidiClntGetState::DoTestL(CMidiClientUtility* aMidi)

	{

	TVerdict ret = EPass;

	TMidiState expErr;

	//TTimeIntervalMicroSeconds fadeOutDuration(10);

	INFO_PRINTF1(_L("CMidiClientUtility: Get current state of midi file"));

	// expected results

	switch(iTestType)

		{

		case ETestValid:

			expErr = EMidiStateOpenDisengaged;

			break;

		case ETestNegative:

			expErr = EMidiStateClosedDisengaged;

			// Close player so we can perform negative test, get state before any initialisation has been done

			aMidi->Close();

			break;

		default:

			ERR_PRINTF1(_L("Error - invalid test step type"));

			return EInconclusive;

		}

	TMidiState state = aMidi->State();

	if (expErr != state)

		{

		ERR_PRINTF3(_L("State gave error %d (expected %d)"),state, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF3(_L("State %d = %d"),state, expErr);

	return ret;

	}

//------------------------------------------------------------------

CTestMidiClntPlayNote::CTestMidiClntPlayNote(const TDesC& aTestName, const TTestStepType aTestType)

	:CTestMmfMidiClntStep(aTestName, aTestType)

	{

	}

CTestMidiClntPlayNote* CTestMidiClntPlayNote::NewL(const TDesC& aTestName, const TTestStepType aTestType)

	{

	CTestMidiClntPlayNote* self = new(ELeave) CTestMidiClntPlayNote(aTestName, aTestType);

	return self;

	}

TVerdict CTestMidiClntPlayNote::DoTestL(CMidiClientUtility* aMidi)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

	TInt channel = 0;

	TInt note = 0;

	TTimeIntervalMicroSeconds duration(10);

	TInt noteOnVelocity = 0;

	TInt noteOffVelocity = 0;

	INFO_PRINTF1(_L("CMidiClientUtility: Play midi note"));

	// expected results

	switch(iTestType)

		{

		case ETestValid:

			expErr = KErrNone;

			break;

		case ETestZeroDurationOutOfRange:

			expErr = KErrNotSupported;

			duration = 0;

			break;

		case ETestInvalidChannelOutOfRange:

			expErr = KErrArgument;

			channel = 16;

			break;

		case ETestNoteHighOutOfRange:

			expErr = KErrArgument;

			note = 128;

			break;

		case ETestNoteLowOutOfRange:

			expErr = KErrArgument;

			note = -1;

			break;

		case ETestAttackHighOutOfRange:

			expErr = KErrArgument;

			noteOnVelocity = 128;

			break;

		case ETestAttackLowOutOfRange:

			expErr = KErrArgument;

			noteOnVelocity = -1;

			break;

		case ETestReleaseHighOutOfRange:

			expErr = KErrArgument;

			noteOffVelocity = 128;

			break;

		case ETestReleaseLowOutOfRange:

			expErr = KErrArgument;

			noteOffVelocity = -1;

			break;

		default:

			ERR_PRINTF1(_L("Error - invalid test step type"));

			return EInconclusive;

		}

	TRAPD(err, aMidi->PlayNoteL(channel, note, duration, noteOnVelocity, noteOffVelocity));

	if (expErr != err)

		{

		ERR_PRINTF3(_L("State gave error %d (expected %d)"),err, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF3(_L("PlayNoteL %d = %d"),err ,expErr);

	return ret;

	}

//------------------------------------------------------------------

CTestMidiClntStopNotes::CTestMidiClntStopNotes(const TDesC& aTestName, const TTestStepType aTestType)

	:CTestMmfMidiClntStep(aTestName, aTestType)

	{

	}

CTestMidiClntStopNotes* CTestMidiClntStopNotes::NewL(const TDesC& aTestName, const TTestStepType aTestType)

	{

	CTestMidiClntStopNotes* self = new(ELeave) CTestMidiClntStopNotes(aTestName, aTestType);

	return self;

	}

TVerdict CTestMidiClntStopNotes::DoTestL(CMidiClientUtility* aMidi)

	{

	// The framework will catch the invalid channel and no note available

	TVerdict ret = EPass;

	TInt channel = 0;

	//TInt expErr = KErrNone;

	switch(iTestType)

		{

		case ETestValid:

			break;

		case ETestInvalidChannelOutOfRange:

			channel = 16;

			break;

		case ETestNoNoteAvailable:

			break;

		default:

			ERR_PRINTF1(_L("Error - invalid test step type"));

			return EInconclusive;

		}

	INFO_PRINTF1(_L("CMidiClientUtility: Stop midi note"));

	aMidi->StopNotes(channel);