Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/MidiClnt/TestMidiClientUtility.cpp@260cb5ec6c19 (annotated)

sl@0	1
sl@0	2	// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	3	// All rights reserved.
sl@0	4	// This component and the accompanying materials are made available
sl@0	5	// under the terms of "Eclipse Public License v1.0"
sl@0	6	// which accompanies this distribution, and is available
sl@0	7	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	8	//
sl@0	9	// Initial Contributors:
sl@0	10	// Nokia Corporation - initial contribution.
sl@0	11	//
sl@0	12	// Contributors:
sl@0	13	//
sl@0	14	// Description:
sl@0	15	//
sl@0	16
sl@0	17	#include "TestMidiClientUtility.h"
sl@0	18	#include <e32math.h>
sl@0	19
sl@0	20
sl@0	21	CTestMidiClntOpenFile::CTestMidiClntOpenFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	22	:CTestMmfMidiClntStep(aTestName, ETestValid),
sl@0	23	iPlay(aPlay)
sl@0	24	{
sl@0	25	iSectName = aSectName;
sl@0	26	iKeyName = aKeyName;
sl@0	27	}
sl@0	28
sl@0	29	CTestMidiClntOpenFile* CTestMidiClntOpenFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	30	{
sl@0	31	CTestMidiClntOpenFile* self = new(ELeave) CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay);
sl@0	32	return self;
sl@0	33	}
sl@0	34
sl@0	35	TVerdict CTestMidiClntOpenFile::DoTestStepL()
sl@0	36	{
sl@0	37	TPtrC filename;
sl@0	38	if(!GetStringFromConfig(iSectName,iKeyName,filename))
sl@0	39	return EInconclusive;
sl@0	40
sl@0	41	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
sl@0	42	if (!player)
sl@0	43	{
sl@0	44	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	45	return EInconclusive;
sl@0	46	}
sl@0	47	CleanupStack::PushL(player);
sl@0	48
sl@0	49	TMMFMessageDestinationPckg dummyPckg;
sl@0	50	TInt dummyFunc = 0; //EDevMidiOff;
sl@0	51	TBuf8<8> dummyBuff;
sl@0	52	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);
sl@0	53
sl@0	54	player->OpenFile(filename);
sl@0	55
sl@0	56	// Wait for initialisation callback
sl@0	57	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));
sl@0	58	CActiveScheduler::Start();
sl@0	59
sl@0	60	TVerdict ret = EFail;
sl@0	61
sl@0	62	// Check for errors.
sl@0	63	if (iError == KErrNone)
sl@0	64	ret = DoTestL(player);
sl@0	65
sl@0	66	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
sl@0	67	CleanupStack::PopAndDestroy(player);
sl@0	68
sl@0	69	if(iError != KErrNone)
sl@0	70	ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
sl@0	71
sl@0	72	return ret;
sl@0	73	}
sl@0	74
sl@0	75	TVerdict CTestMidiClntOpenFile::DoTestL(CMidiClientUtility* /aMidi/)
sl@0	76	{
sl@0	77	return EPass;
sl@0	78	}
sl@0	79
sl@0	80	//------------------------------------------------------------------
sl@0	81
sl@0	82	CTestMidiClntOpenDes::CTestMidiClntOpenDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	83	:CTestMmfMidiClntStep(aTestName, ETestValid),
sl@0	84	iPlay(aPlay)
sl@0	85	{
sl@0	86	iSectName = aSectName;
sl@0	87	iKeyName = aKeyName;
sl@0	88	}
sl@0	89
sl@0	90	CTestMidiClntOpenDes* CTestMidiClntOpenDes::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	91	{
sl@0	92	CTestMidiClntOpenDes* self = new(ELeave) CTestMidiClntOpenDes(aTestName, aSectName, aKeyName, aPlay);
sl@0	93	return self;
sl@0	94	}
sl@0	95
sl@0	96	TVerdict CTestMidiClntOpenDes::DoTestStepPreambleL()
sl@0	97	{
sl@0	98	TPtrC filename;
sl@0	99	if(!GetStringFromConfig(iSectName, iKeyName, filename))
sl@0	100	return EInconclusive;
sl@0	101
sl@0	102	RFs fs;
sl@0	103	RFile file;
sl@0	104	TInt size = 0;
sl@0	105
sl@0	106	// connect to file system and open file
sl@0	107	User::LeaveIfError(fs.Connect());
sl@0	108	User::LeaveIfError(file.Open(fs,filename,EFileRead));
sl@0	109	CleanupClosePushL(file);
sl@0	110
sl@0	111	// Set HBuf size
sl@0	112	User::LeaveIfError(file.Size(size));
sl@0	113	INFO_PRINTF2(_L("size of file = %d\n"),size);
sl@0	114
sl@0	115	iAudio = HBufC8::NewMaxL(size);
sl@0	116
sl@0	117	// read data into Hbuf
sl@0	118	TPtr8 bufferDes(iAudio->Des());
sl@0	119	User::LeaveIfError(file.Read(bufferDes));
sl@0	120
sl@0	121	CleanupStack::PopAndDestroy(); //file
sl@0	122	return CTestMmfMidiClntStep::DoTestStepPreambleL();
sl@0	123	}
sl@0	124
sl@0	125	TVerdict CTestMidiClntOpenDes::DoTestStepPostambleL()
sl@0	126	{
sl@0	127	delete iAudio;
sl@0	128	iAudio = NULL;
sl@0	129	return CTestMmfMidiClntStep::DoTestStepPostambleL();
sl@0	130	}
sl@0	131
sl@0	132	TVerdict CTestMidiClntOpenDes::DoTestStepL()
sl@0	133	{
sl@0	134	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
sl@0	135	if (!player)
sl@0	136	{
sl@0	137	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	138	return EInconclusive;
sl@0	139	}
sl@0	140
sl@0	141	CleanupStack::PushL(player);
sl@0	142
sl@0	143	TMMFMessageDestinationPckg dummyPckg;
sl@0	144	TInt dummyFunc = EDevMidiOff;
sl@0	145	TBuf8<8> dummyBuff;
sl@0	146	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);
sl@0	147
sl@0	148	player->OpenDes(iAudio->Des());
sl@0	149
sl@0	150	// Wait for initialisation callback
sl@0	151	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));
sl@0	152	CActiveScheduler::Start();
sl@0	153
sl@0	154	TVerdict ret = EFail;
sl@0	155
sl@0	156	// Check for errors.
sl@0	157	if (iError == KErrNone)
sl@0	158	ret = DoTestL(player);
sl@0	159
sl@0	160	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
sl@0	161	CleanupStack::PopAndDestroy(player);
sl@0	162
sl@0	163	if(iError != KErrNone)
sl@0	164	ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
sl@0	165
sl@0	166	return ret;
sl@0	167	}
sl@0	168
sl@0	169	TVerdict CTestMidiClntOpenDes::DoTestL(CMidiClientUtility* /aMidi/)
sl@0	170	{
sl@0	171	return EPass;
sl@0	172	}
sl@0	173
sl@0	174	//------------------------------------------------------------------
sl@0	175
sl@0	176	CTestMidiClntOpenUrl::CTestMidiClntOpenUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	177	:CTestMmfMidiClntStep(aTestName, ETestValid),
sl@0	178	iPlay(aPlay)
sl@0	179	{
sl@0	180	iSectName = aSectName;
sl@0	181	iKeyName = aKeyName;
sl@0	182	}
sl@0	183
sl@0	184	CTestMidiClntOpenUrl* CTestMidiClntOpenUrl::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	185	{
sl@0	186	CTestMidiClntOpenUrl* self = new(ELeave) CTestMidiClntOpenUrl(aTestName, aSectName, aKeyName, aPlay);
sl@0	187	return self;
sl@0	188	}
sl@0	189
sl@0	190	TVerdict CTestMidiClntOpenUrl::DoTestStepL()
sl@0	191	{
sl@0	192	TPtrC urlname;
sl@0	193	if(!GetStringFromConfig(iSectName,iKeyName,urlname))
sl@0	194	return EInconclusive;
sl@0	195
sl@0	196	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
sl@0	197	if (!player)
sl@0	198	{
sl@0	199	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	200	return EInconclusive;
sl@0	201	}
sl@0	202
sl@0	203	CleanupStack::PushL(player);
sl@0	204
sl@0	205	TMMFMessageDestinationPckg dummyPckg;
sl@0	206	TInt dummyFunc = EDevMidiOff;
sl@0	207	TBuf8<8> dummyBuff;
sl@0	208	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);
sl@0	209
sl@0	210	player->OpenUrl(urlname);
sl@0	211
sl@0	212	// Wait for initialisation callback
sl@0	213	INFO_PRINTF1(_L("CMidiClientUtility: Opening url"));
sl@0	214	CActiveScheduler::Start();
sl@0	215
sl@0	216	TVerdict ret = EFail;
sl@0	217
sl@0	218	// Check for errors.
sl@0	219	if (iError == KErrNone)
sl@0	220	ret = DoTestL(player);
sl@0	221
sl@0	222	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
sl@0	223	CleanupStack::PopAndDestroy(player);
sl@0	224
sl@0	225	if(iError != KErrNone)
sl@0	226	ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
sl@0	227
sl@0	228	return ret;
sl@0	229	}
sl@0	230
sl@0	231	TVerdict CTestMidiClntOpenUrl::DoTestL(CMidiClientUtility* /aMidi/)
sl@0	232	{
sl@0	233	return EPass;
sl@0	234	}
sl@0	235
sl@0	236	//------------------------------------------------------------------
sl@0	237
sl@0	238	CTestMidiClntClose::CTestMidiClntClose(const TDesC& aTestName)
sl@0	239	:CTestMmfMidiClntStep(aTestName, ETestValid)
sl@0	240	{
sl@0	241	}
sl@0	242
sl@0	243	CTestMidiClntClose* CTestMidiClntClose::NewL(const TDesC& aTestName)
sl@0	244	{
sl@0	245	CTestMidiClntClose* self = new(ELeave) CTestMidiClntClose(aTestName);
sl@0	246	return self;
sl@0	247	}
sl@0	248
sl@0	249	TVerdict CTestMidiClntClose::DoTestL(CMidiClientUtility* aMidi)
sl@0	250	{
sl@0	251	INFO_PRINTF1(_L("CMidiClientUtility: Closing file"));
sl@0	252	aMidi->Close();
sl@0	253	return EPass;
sl@0	254	}
sl@0	255
sl@0	256	//------------------------------------------------------------------
sl@0	257
sl@0	258	CTestMidiClntPlay::CTestMidiClntPlay(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	259	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	260	{
sl@0	261	}
sl@0	262
sl@0	263	CTestMidiClntPlay* CTestMidiClntPlay::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	264	{
sl@0	265	CTestMidiClntPlay* self = new(ELeave) CTestMidiClntPlay(aTestName, aTestType);
sl@0	266	return self;
sl@0	267	}
sl@0	268
sl@0	269	TVerdict CTestMidiClntPlay::DoTestL(CMidiClientUtility* aMidi)
sl@0	270	{
sl@0	271	TInt expErr = KErrNone;
sl@0	272	//TTimeIntervalMicroSeconds fadeOutDuration(0);
sl@0	273
sl@0	274	INFO_PRINTF1(_L("CMidiClientUtility: Play midi file"));
sl@0	275	// expected results
sl@0	276	switch(iTestType)
sl@0	277	{
sl@0	278	case ETestValid:
sl@0	279	expErr = KErrNone;
sl@0	280	break;
sl@0	281	case ETestNoPlugin:
sl@0	282	expErr = KErrNotSupported;
sl@0	283	break;
sl@0	284	case ETestInvalidState:
sl@0	285	expErr = KErrUnknown;
sl@0	286	break;
sl@0	287	default:
sl@0	288	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	289	return EInconclusive;
sl@0	290	}
sl@0	291
sl@0	292	iCurrentState = EMidiStateClosedDisengaged;
sl@0	293	aMidi->OpenFile(_L("c:\\DoesntExist.mid"));
sl@0	294	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	295	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged
sl@0	296	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	297	{
sl@0	298	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	299	return EFail;
sl@0	300	}
sl@0	301
sl@0	302	aMidi->Play();
sl@0	303	if (expErr != iError)
sl@0	304	{
sl@0	305	ERR_PRINTF3(_L("Play gave error %d (expected %d)"),iError, expErr);
sl@0	306	return EFail;
sl@0	307	}
sl@0	308	else
sl@0	309	INFO_PRINTF3(_L("Play, %d = %d"), iError, expErr);
sl@0	310
sl@0	311	return EPass;
sl@0	312	}
sl@0	313
sl@0	314	//------------------------------------------------------------------
sl@0	315
sl@0	316
sl@0	317	CTestMidiClntStop::CTestMidiClntStop(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	318	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	319	{
sl@0	320	}
sl@0	321
sl@0	322	CTestMidiClntStop* CTestMidiClntStop::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	323	{
sl@0	324	CTestMidiClntStop* self = new(ELeave) CTestMidiClntStop(aTestName, aTestType);
sl@0	325	return self;
sl@0	326	}
sl@0	327
sl@0	328	TVerdict CTestMidiClntStop::DoTestL(CMidiClientUtility* aMidi)
sl@0	329	{
sl@0	330	TVerdict ret = EPass;
sl@0	331	TInt expErr = KErrNone;
sl@0	332	TTimeIntervalMicroSeconds fadeOutDuration(0);
sl@0	333
sl@0	334	INFO_PRINTF1(_L("CMidiClientUtility: Stop midi file"));
sl@0	335	// expected results
sl@0	336	switch(iTestType)
sl@0	337	{
sl@0	338	case ETestValid:
sl@0	339	expErr = KErrNone;
sl@0	340	fadeOutDuration = 20;
sl@0	341	break;
sl@0	342	case ETestNoPlugin:
sl@0	343	expErr = KErrNotSupported;
sl@0	344	break;
sl@0	345	case ETestNoResource:
sl@0	346	expErr = KErrNotReady;
sl@0	347	break;
sl@0	348	default:
sl@0	349	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	350	return EInconclusive;
sl@0	351	}
sl@0	352
sl@0	353	aMidi->Stop(fadeOutDuration);
sl@0	354	if (expErr != KErrNone)
sl@0	355	INFO_PRINTF2(_L("Stop gave error %d"),expErr);
sl@0	356	else
sl@0	357	INFO_PRINTF1(_L("Stopping midi file"));
sl@0	358
sl@0	359	return ret;
sl@0	360	}
sl@0	361
sl@0	362	//------------------------------------------------------------------
sl@0	363
sl@0	364
sl@0	365	CTestMidiClntGetState::CTestMidiClntGetState(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay)
sl@0	366	:CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay)
sl@0	367	{
sl@0	368	// NB this inherits from CTestMidiClntOpenFile, NOT from CTestMmfMidiClntStep
sl@0	369	// so we have to set this manually.
sl@0	370	iTestType = aTestType;
sl@0	371	}
sl@0	372
sl@0	373	CTestMidiClntGetState* CTestMidiClntGetState::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay)
sl@0	374	{
sl@0	375	CTestMidiClntGetState* self = new(ELeave) CTestMidiClntGetState(aTestName, aSectName, aKeyName, aTestType, aPlay);
sl@0	376	return self;
sl@0	377	}
sl@0	378
sl@0	379	TVerdict CTestMidiClntGetState::DoTestL(CMidiClientUtility* aMidi)
sl@0	380	{
sl@0	381	TVerdict ret = EPass;
sl@0	382	TMidiState expErr;
sl@0	383	//TTimeIntervalMicroSeconds fadeOutDuration(10);
sl@0	384
sl@0	385	INFO_PRINTF1(_L("CMidiClientUtility: Get current state of midi file"));
sl@0	386	// expected results
sl@0	387	switch(iTestType)
sl@0	388	{
sl@0	389	case ETestValid:
sl@0	390	expErr = EMidiStateOpenDisengaged;
sl@0	391	break;
sl@0	392	case ETestNegative:
sl@0	393	expErr = EMidiStateClosedDisengaged;
sl@0	394	// Close player so we can perform negative test, get state before any initialisation has been done
sl@0	395	aMidi->Close();
sl@0	396	break;
sl@0	397	default:
sl@0	398	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	399	return EInconclusive;
sl@0	400	}
sl@0	401
sl@0	402	TMidiState state = aMidi->State();
sl@0	403	if (expErr != state)
sl@0	404	{
sl@0	405	ERR_PRINTF3(_L("State gave error %d (expected %d)"),state, expErr);
sl@0	406	ret = EFail;
sl@0	407	}
sl@0	408	else
sl@0	409	INFO_PRINTF3(_L("State %d = %d"),state, expErr);
sl@0	410
sl@0	411	return ret;
sl@0	412	}
sl@0	413
sl@0	414	//------------------------------------------------------------------
sl@0	415
sl@0	416	CTestMidiClntPlayNote::CTestMidiClntPlayNote(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	417	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	418	{
sl@0	419	}
sl@0	420
sl@0	421	CTestMidiClntPlayNote* CTestMidiClntPlayNote::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	422	{
sl@0	423	CTestMidiClntPlayNote* self = new(ELeave) CTestMidiClntPlayNote(aTestName, aTestType);
sl@0	424	return self;
sl@0	425	}
sl@0	426
sl@0	427	TVerdict CTestMidiClntPlayNote::DoTestL(CMidiClientUtility* aMidi)
sl@0	428	{
sl@0	429	TVerdict ret = EPass;
sl@0	430	TInt expErr = KErrNone;
sl@0	431	TInt channel = 0;
sl@0	432	TInt note = 0;
sl@0	433	TTimeIntervalMicroSeconds duration(10);
sl@0	434	TInt noteOnVelocity = 0;
sl@0	435	TInt noteOffVelocity = 0;
sl@0	436
sl@0	437	INFO_PRINTF1(_L("CMidiClientUtility: Play midi note"));
sl@0	438	// expected results
sl@0	439	switch(iTestType)
sl@0	440	{
sl@0	441	case ETestValid:
sl@0	442	expErr = KErrNone;
sl@0	443	break;
sl@0	444	case ETestZeroDurationOutOfRange:
sl@0	445	expErr = KErrNotSupported;
sl@0	446	duration = 0;
sl@0	447	break;
sl@0	448	case ETestInvalidChannelOutOfRange:
sl@0	449	expErr = KErrArgument;
sl@0	450	channel = 16;
sl@0	451	break;
sl@0	452	case ETestNoteHighOutOfRange:
sl@0	453	expErr = KErrArgument;
sl@0	454	note = 128;
sl@0	455	break;
sl@0	456	case ETestNoteLowOutOfRange:
sl@0	457	expErr = KErrArgument;
sl@0	458	note = -1;
sl@0	459	break;
sl@0	460	case ETestAttackHighOutOfRange:
sl@0	461	expErr = KErrArgument;
sl@0	462	noteOnVelocity = 128;
sl@0	463	break;
sl@0	464	case ETestAttackLowOutOfRange:
sl@0	465	expErr = KErrArgument;
sl@0	466	noteOnVelocity = -1;
sl@0	467	break;
sl@0	468	case ETestReleaseHighOutOfRange:
sl@0	469	expErr = KErrArgument;
sl@0	470	noteOffVelocity = 128;
sl@0	471	break;
sl@0	472	case ETestReleaseLowOutOfRange:
sl@0	473	expErr = KErrArgument;
sl@0	474	noteOffVelocity = -1;
sl@0	475	break;
sl@0	476	default:
sl@0	477	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	478	return EInconclusive;
sl@0	479	}
sl@0	480	TRAPD(err, aMidi->PlayNoteL(channel, note, duration, noteOnVelocity, noteOffVelocity));
sl@0	481
sl@0	482	if (expErr != err)
sl@0	483	{
sl@0	484	ERR_PRINTF3(_L("State gave error %d (expected %d)"),err, expErr);
sl@0	485	ret = EFail;
sl@0	486	}
sl@0	487	else
sl@0	488	INFO_PRINTF3(_L("PlayNoteL %d = %d"),err ,expErr);
sl@0	489
sl@0	490	return ret;
sl@0	491	}
sl@0	492
sl@0	493	//------------------------------------------------------------------
sl@0	494
sl@0	495	CTestMidiClntStopNotes::CTestMidiClntStopNotes(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	496	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	497	{
sl@0	498	}
sl@0	499
sl@0	500	CTestMidiClntStopNotes* CTestMidiClntStopNotes::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	501	{
sl@0	502	CTestMidiClntStopNotes* self = new(ELeave) CTestMidiClntStopNotes(aTestName, aTestType);
sl@0	503	return self;
sl@0	504	}
sl@0	505
sl@0	506	TVerdict CTestMidiClntStopNotes::DoTestL(CMidiClientUtility* aMidi)
sl@0	507	{
sl@0	508	// The framework will catch the invalid channel and no note available
sl@0	509	TVerdict ret = EPass;
sl@0	510	TInt channel = 0;
sl@0	511	//TInt expErr = KErrNone;
sl@0	512
sl@0	513	switch(iTestType)
sl@0	514	{
sl@0	515	case ETestValid:
sl@0	516	break;
sl@0	517	case ETestInvalidChannelOutOfRange:
sl@0	518	channel = 16;
sl@0	519	break;
sl@0	520	case ETestNoNoteAvailable:
sl@0	521	break;
sl@0	522	default:
sl@0	523	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	524	return EInconclusive;
sl@0	525	}
sl@0	526
sl@0	527	INFO_PRINTF1(_L("CMidiClientUtility: Stop midi note"));
sl@0	528	aMidi->StopNotes(channel);
sl@0	529	return ret;
sl@0	530	}
sl@0	531
sl@0	532	//------------------------------------------------------------------
sl@0	533
sl@0	534
sl@0	535	CTestMidiClntNoteOn::CTestMidiClntNoteOn(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	536	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	537	{
sl@0	538	}
sl@0	539
sl@0	540	CTestMidiClntNoteOn* CTestMidiClntNoteOn::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	541	{
sl@0	542	CTestMidiClntNoteOn* self = new(ELeave) CTestMidiClntNoteOn(aTestName, aTestType);
sl@0	543	return self;
sl@0	544	}
sl@0	545
sl@0	546	TVerdict CTestMidiClntNoteOn::DoTestL(CMidiClientUtility* aMidi)
sl@0	547	{
sl@0	548	TVerdict ret = EPass;
sl@0	549	TInt expErr = KErrNone;
sl@0	550	TInt channel = 0;
sl@0	551	TInt note = 0;
sl@0	552	TInt velocity = 0;
sl@0	553
sl@0	554	INFO_PRINTF1(_L("CMidiClientUtility: Midi note on"));
sl@0	555	// expected results
sl@0	556	switch(iTestType)
sl@0	557	{
sl@0	558	case ETestValid:
sl@0	559	expErr = KErrNone;
sl@0	560	channel = 1;
sl@0	561	note = 2;
sl@0	562	velocity = 10;
sl@0	563	break;
sl@0	564	case ETestNoNoteAvailable:
sl@0	565	expErr = KErrArgument;
sl@0	566	break;
sl@0	567	case ETestInvalidChannelOutOfRange:
sl@0	568	expErr = KErrArgument;
sl@0	569	channel = 16;
sl@0	570	break;
sl@0	571	case ETestNoteHighOutOfRange:
sl@0	572	expErr = KErrArgument;
sl@0	573	note = 128;
sl@0	574	break;
sl@0	575	case ETestNoteLowOutOfRange:
sl@0	576	expErr = KErrArgument;
sl@0	577	note = -1;
sl@0	578	break;
sl@0	579	case ETestVelocityHighOutOfRange:
sl@0	580	expErr = KErrArgument;
sl@0	581	velocity = 128;
sl@0	582	break;
sl@0	583	case ETestVelocityLowOutOfRange:
sl@0	584	expErr = KErrArgument;
sl@0	585	velocity = -1;
sl@0	586	break;
sl@0	587	default:
sl@0	588	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	589	return EInconclusive;
sl@0	590	}
sl@0	591
sl@0	592	TRAPD(err, aMidi->NoteOnL(channel,note,velocity));
sl@0	593	if (expErr != err)
sl@0	594	{
sl@0	595	ERR_PRINTF3(_L("NoteOnL gave error %d (expected %d)"),err, expErr);
sl@0	596	ret = EFail;
sl@0	597	}
sl@0	598	else
sl@0	599	INFO_PRINTF3(_L("NoteOnL %d = %d"),err ,expErr);
sl@0	600
sl@0	601	return ret;
sl@0	602	}
sl@0	603
sl@0	604	//------------------------------------------------------------------
sl@0	605
sl@0	606
sl@0	607	CTestMidiClntNoteOff::CTestMidiClntNoteOff(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	608	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	609	{
sl@0	610	}
sl@0	611
sl@0	612	CTestMidiClntNoteOff* CTestMidiClntNoteOff::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	613	{
sl@0	614	CTestMidiClntNoteOff* self = new(ELeave) CTestMidiClntNoteOff(aTestName, aTestType);
sl@0	615	return self;
sl@0	616	}
sl@0	617
sl@0	618	TVerdict CTestMidiClntNoteOff::DoTestL(CMidiClientUtility* aMidi)
sl@0	619	{
sl@0	620	TVerdict ret = EPass;
sl@0	621	TInt expErr = KErrNone;
sl@0	622	TInt channel = 0;
sl@0	623	TInt note = 0;
sl@0	624	TInt velocity = 0;
sl@0	625
sl@0	626	// Play Midi Note on channel=0, note=1, velocity=50
sl@0	627	TRAPD(err, aMidi->NoteOnL(0,1,50));
sl@0	628	if (expErr != err)
sl@0	629	{
sl@0	630	ERR_PRINTF3(_L("NoteOnL gave error %d (expected %d)"),err, expErr);
sl@0	631	ret = EFail;
sl@0	632	}
sl@0	633	else
sl@0	634	INFO_PRINTF3(_L("NoteOnL %d = %d"),err ,expErr);
sl@0	635
sl@0	636	INFO_PRINTF1(_L("CMidiClientUtility: Midi note off"));
sl@0	637	// expected results
sl@0	638	switch(iTestType)
sl@0	639	{
sl@0	640	case ETestValid:
sl@0	641	expErr = KErrNone;
sl@0	642	channel = 1;
sl@0	643	note = 2;
sl@0	644	velocity = 10;
sl@0	645	break;
sl@0	646	case ETestNoNoteAvailable:
sl@0	647	expErr = KErrNone; // No error is raised, as per specification
sl@0	648	break;
sl@0	649	case ETestInvalidChannelOutOfRange:
sl@0	650	expErr = KErrArgument;
sl@0	651	channel = 16;
sl@0	652	break;
sl@0	653	case ETestDifferentNoteVelocity:
sl@0	654	expErr = KErrArgument;
sl@0	655	note = 1;
sl@0	656	velocity = 127;
sl@0	657	break;
sl@0	658	default:
sl@0	659	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	660	return EInconclusive;
sl@0	661	}
sl@0	662
sl@0	663	TRAPD(err2, aMidi->NoteOffL(channel,note,velocity));
sl@0	664	if (expErr != err2)
sl@0	665	{
sl@0	666	ERR_PRINTF3(_L("NoteOffL gave error %d (expected %d)"),err2, expErr);
sl@0	667	ret = EFail;
sl@0	668	}
sl@0	669	else
sl@0	670	INFO_PRINTF3(_L("NoteOffL %d = %d"),err2 ,expErr);
sl@0	671
sl@0	672	return ret;
sl@0	673	}
sl@0	674
sl@0	675	//------------------------------------------------------------------
sl@0	676
sl@0	677
sl@0	678	CTestMidiClntReturnPlaybackRate::CTestMidiClntReturnPlaybackRate(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	679	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	680	{
sl@0	681	}
sl@0	682
sl@0	683	CTestMidiClntReturnPlaybackRate* CTestMidiClntReturnPlaybackRate::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	684	{
sl@0	685	CTestMidiClntReturnPlaybackRate* self = new(ELeave) CTestMidiClntReturnPlaybackRate(aTestName, aTestType);
sl@0	686	return self;
sl@0	687	}
sl@0	688
sl@0	689	TVerdict CTestMidiClntReturnPlaybackRate::DoTestL(CMidiClientUtility* aMidi)
sl@0	690	{
sl@0	691	TVerdict ret = EPass;
sl@0	692	TInt expErr = KErrNone;
sl@0	693
sl@0	694	INFO_PRINTF1(_L("CMidiClientUtility: Check playback rate"));
sl@0	695
sl@0	696	// expected results
sl@0	697	switch (iTestType)
sl@0	698	{
sl@0	699	case ETestValid:
sl@0	700	expErr = KErrNone;
sl@0	701	break;
sl@0	702	case ETestNoResource:
sl@0	703	expErr = KErrNotReady;
sl@0	704	break;
sl@0	705	default:
sl@0	706	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	707	return EInconclusive;
sl@0	708	}
sl@0	709	// TInt rate = 0; // fixes warning
sl@0	710
sl@0	711	// TRAPD(err, rate = aMidi->PlaybackRateL());
sl@0	712	TRAPD(err, aMidi->PlaybackRateL()); // EABI warning removal
sl@0	713	if(expErr != err)
sl@0	714	{
sl@0	715	ERR_PRINTF3( _L("PlaybackRateL gave error %d (expected %d)"),err, expErr);
sl@0	716	ret = EFail;
sl@0	717	}
sl@0	718	else
sl@0	719	INFO_PRINTF3(_L("PlaybackRateL %d = %d"), err, expErr);
sl@0	720
sl@0	721	return ret;
sl@0	722	}
sl@0	723
sl@0	724	//------------------------------------------------------------------
sl@0	725
sl@0	726
sl@0	727	CTestMidiClntSetPlaybackRate::CTestMidiClntSetPlaybackRate(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	728	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	729	{
sl@0	730	}
sl@0	731
sl@0	732	CTestMidiClntSetPlaybackRate* CTestMidiClntSetPlaybackRate::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	733	{
sl@0	734	CTestMidiClntSetPlaybackRate* self = new(ELeave) CTestMidiClntSetPlaybackRate(aTestName, aTestType);
sl@0	735	return self;
sl@0	736	}
sl@0	737
sl@0	738	TVerdict CTestMidiClntSetPlaybackRate::DoTestL(CMidiClientUtility* aMidi)
sl@0	739	{
sl@0	740	TVerdict ret = EPass;
sl@0	741	TInt expErr = KErrNone;
sl@0	742	TInt playbackRate = 0;
sl@0	743
sl@0	744	INFO_PRINTF1(_L("CMidiClientUtility: Set playback rate"));
sl@0	745
sl@0	746	switch (iTestType)
sl@0	747	{
sl@0	748	case ETestValid:
sl@0	749	expErr = KErrNone;
sl@0	750	break;
sl@0	751	case ETestNoResource:
sl@0	752	expErr = KErrNotReady;
sl@0	753	break;
sl@0	754	case ETestOutOfRangeHigh:
sl@0	755	// high limit on playback rate is dependant on controller
sl@0	756	// when have a proper controller the value below should be changed
sl@0	757	// to a value higher than the upper limit
sl@0	758	playbackRate = -1;
sl@0	759	expErr = KErrNotSupported;
sl@0	760	break;
sl@0	761	case ETestOutOfRangeLow:
sl@0	762	playbackRate = -1; // negative values not supported
sl@0	763	expErr = KErrNotSupported;
sl@0	764	break;
sl@0	765	default:
sl@0	766	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	767	return EInconclusive;
sl@0	768	}
sl@0	769
sl@0	770	TRAPD(err, aMidi->SetPlaybackRateL(playbackRate));
sl@0	771	if(expErr != err)
sl@0	772	{
sl@0	773	ERR_PRINTF3( _L("SetPlaybackRateL gave error %d (expected %d)"),err, expErr);
sl@0	774	ret = EFail;
sl@0	775	}
sl@0	776	else
sl@0	777	INFO_PRINTF3(_L("SetPlaybackRateL %d = %d"), err, expErr);
sl@0	778
sl@0	779	return ret;
sl@0	780	}
sl@0	781
sl@0	782	//------------------------------------------------------------------
sl@0	783
sl@0	784
sl@0	785	CTestMidiClntReturnMaxPlayRate::CTestMidiClntReturnMaxPlayRate(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	786	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	787	{
sl@0	788	}
sl@0	789
sl@0	790	CTestMidiClntReturnMaxPlayRate* CTestMidiClntReturnMaxPlayRate::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	791	{
sl@0	792	CTestMidiClntReturnMaxPlayRate* self = new(ELeave) CTestMidiClntReturnMaxPlayRate(aTestName, aTestType);
sl@0	793	return self;
sl@0	794	}
sl@0	795
sl@0	796	TVerdict CTestMidiClntReturnMaxPlayRate::DoTestL(CMidiClientUtility* aMidi)
sl@0	797	{
sl@0	798	TVerdict ret = EPass;
sl@0	799	TInt expErr = KErrNone;
sl@0	800
sl@0	801	INFO_PRINTF1(_L("CMidiClientUtility: Check the max play rate"));
sl@0	802
sl@0	803	// expected results
sl@0	804	switch (iTestType)
sl@0	805	{
sl@0	806	case ETestValid:
sl@0	807	expErr = KErrNone;
sl@0	808	break;
sl@0	809	case ETestNoResource:
sl@0	810	expErr = KErrNotReady;
sl@0	811	break;
sl@0	812	default:
sl@0	813	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	814	return EInconclusive;
sl@0	815	}
sl@0	816	// TInt rate = 0; // fixes warning
sl@0	817	// TRAPD(err, rate = aMidi->MaxPlaybackRateL());
sl@0	818	TRAPD(err, aMidi->MaxPlaybackRateL()); // EABI warning removal
sl@0	819	if(expErr != err)
sl@0	820	{
sl@0	821	ERR_PRINTF3( _L("MaxPlayRateL gave error %d (expected %d)"),err, expErr);
sl@0	822	ret = EFail;
sl@0	823	}
sl@0	824	else
sl@0	825	INFO_PRINTF3(_L("MaxPlayRateL %d = %d"), err, expErr);
sl@0	826
sl@0	827	return ret;
sl@0	828	}
sl@0	829
sl@0	830	//------------------------------------------------------------------
sl@0	831
sl@0	832
sl@0	833	CTestMidiClntReturnMinPlayRate::CTestMidiClntReturnMinPlayRate(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	834	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	835	{
sl@0	836	}
sl@0	837
sl@0	838	CTestMidiClntReturnMinPlayRate* CTestMidiClntReturnMinPlayRate::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	839	{
sl@0	840	CTestMidiClntReturnMinPlayRate* self = new(ELeave) CTestMidiClntReturnMinPlayRate(aTestName, aTestType);
sl@0	841	return self;
sl@0	842	}
sl@0	843
sl@0	844	TVerdict CTestMidiClntReturnMinPlayRate::DoTestL(CMidiClientUtility* aMidi)
sl@0	845	{
sl@0	846	TVerdict ret = EPass;
sl@0	847	TInt expErr = KErrNone;
sl@0	848
sl@0	849	INFO_PRINTF1(_L("CMidiClientUtility: Check the min play rate"));
sl@0	850
sl@0	851	// expected results
sl@0	852	switch (iTestType)
sl@0	853	{
sl@0	854	case ETestValid:
sl@0	855	expErr = KErrNone;
sl@0	856	break;
sl@0	857	case ETestNoResource:
sl@0	858	expErr = KErrNotReady;
sl@0	859	break;
sl@0	860	default:
sl@0	861	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	862	return EInconclusive;
sl@0	863	}
sl@0	864
sl@0	865	// TInt rate = 0; // fixes warning
sl@0	866	// TRAPD(err, rate = aMidi->MinPlaybackRateL());
sl@0	867	TRAPD(err, aMidi->MinPlaybackRateL()); // EABI warning removal
sl@0	868	if(expErr != err)
sl@0	869	{
sl@0	870	ERR_PRINTF3( _L("MinPlayRateL gave error %d (expected %d)"),err, expErr);
sl@0	871	ret = EFail;
sl@0	872	}
sl@0	873	else
sl@0	874	INFO_PRINTF3(_L("MinPlayRateL %d = %d"), err, expErr);
sl@0	875
sl@0	876	return ret;
sl@0	877	}
sl@0	878
sl@0	879	//------------------------------------------------------------------
sl@0	880
sl@0	881
sl@0	882	CTestMidiClntTempoMicroBeatsPerMinute::CTestMidiClntTempoMicroBeatsPerMinute(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	883	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	884	{
sl@0	885	}
sl@0	886
sl@0	887	CTestMidiClntTempoMicroBeatsPerMinute* CTestMidiClntTempoMicroBeatsPerMinute::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	888	{
sl@0	889	CTestMidiClntTempoMicroBeatsPerMinute* self = new(ELeave) CTestMidiClntTempoMicroBeatsPerMinute(aTestName, aTestType);
sl@0	890	return self;
sl@0	891	}
sl@0	892
sl@0	893	TVerdict CTestMidiClntTempoMicroBeatsPerMinute::DoTestL(CMidiClientUtility* aMidi)
sl@0	894	{
sl@0	895	TVerdict ret = EPass;
sl@0	896	TInt expErr = KErrNone;
sl@0	897	// TInt microBeatsPerMinute = 0; // EABI warning removal
sl@0	898
sl@0	899	INFO_PRINTF1(_L("CMidiClientUtility: Return the tempo micro beats per minute"));
sl@0	900	// expected results
sl@0	901	switch(iTestType)
sl@0	902	{
sl@0	903	case ETestValid:
sl@0	904	expErr = KErrNone;
sl@0	905	break;
sl@0	906	case ETestNoResource:
sl@0	907	expErr = KErrNotReady;
sl@0	908	break;
sl@0	909	default:
sl@0	910	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	911	return EInconclusive;
sl@0	912	}
sl@0	913
sl@0	914	// TRAPD(err, microBeatsPerMinute = aMidi->TempoMicroBeatsPerMinuteL());
sl@0	915	TRAPD(err, aMidi->TempoMicroBeatsPerMinuteL()); // EABI warning removal
sl@0	916	if (expErr != err)
sl@0	917	{
sl@0	918	ERR_PRINTF3(_L("TempoMicroBeatsPerMinuteL gave error %d (expected %d)"),err, expErr);
sl@0	919	ret = EFail;
sl@0	920	}
sl@0	921	else
sl@0	922	INFO_PRINTF3(_L("TempoMicroBeatsPerMinuteL %d = %d"),err ,expErr);
sl@0	923
sl@0	924	return ret;
sl@0	925	}
sl@0	926
sl@0	927	//------------------------------------------------------------------
sl@0	928
sl@0	929
sl@0	930	CTestMidiClntSetTempo::CTestMidiClntSetTempo(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	931	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	932	{
sl@0	933	}
sl@0	934
sl@0	935	CTestMidiClntSetTempo* CTestMidiClntSetTempo::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	936	{
sl@0	937	CTestMidiClntSetTempo* self = new(ELeave) CTestMidiClntSetTempo(aTestName, aTestType);
sl@0	938	return self;
sl@0	939	}
sl@0	940
sl@0	941	TVerdict CTestMidiClntSetTempo::DoTestL(CMidiClientUtility* aMidi)
sl@0	942	{
sl@0	943	TVerdict ret = EPass;
sl@0	944	TInt expErr = KErrNone;
sl@0	945	TInt microBeatsPerMinute = 0;
sl@0	946
sl@0	947	INFO_PRINTF1(_L("CMidiClientUtility: Set the tempo micro beats per minute"));
sl@0	948	// expected results
sl@0	949	switch(iTestType)
sl@0	950	{
sl@0	951	case ETestValid:
sl@0	952	expErr = KErrNone;
sl@0	953	microBeatsPerMinute = 60*1000000;
sl@0	954	break;
sl@0	955	case ETestNoResource:
sl@0	956	expErr = KErrNotReady;
sl@0	957	microBeatsPerMinute = 80*1000000;
sl@0	958	break;
sl@0	959	case ETestBeatsLowOutOfRange:
sl@0	960	expErr = KErrArgument;
sl@0	961	microBeatsPerMinute = -1*1000000;
sl@0	962	break;
sl@0	963	case ETestBeatsHighOutOfRange:
sl@0	964	expErr = KErrArgument;
sl@0	965	//microBeatsPerMinute = 1000001*1000000; XXX overflow warning
sl@0	966	microBeatsPerMinute = 1000001;
sl@0	967	break;
sl@0	968	default:
sl@0	969	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	970	return EInconclusive;
sl@0	971	}
sl@0	972
sl@0	973	TRAPD(err, aMidi->SetTempoL(microBeatsPerMinute));
sl@0	974	if (expErr != err)
sl@0	975	{
sl@0	976	ERR_PRINTF3(_L("SetTempoL gave error %d (expected %d)"),err, expErr);
sl@0	977	ret = EFail;
sl@0	978	}
sl@0	979	else
sl@0	980	INFO_PRINTF3(_L("SetTempoL %d = %d"),err ,expErr);
sl@0	981
sl@0	982	return ret;
sl@0	983	}
sl@0	984
sl@0	985	//------------------------------------------------------------------
sl@0	986
sl@0	987
sl@0	988	CTestMidiClntGetPitchTranspositionCents::CTestMidiClntGetPitchTranspositionCents(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	989	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	990	{
sl@0	991	}
sl@0	992
sl@0	993	CTestMidiClntGetPitchTranspositionCents* CTestMidiClntGetPitchTranspositionCents::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	994	{
sl@0	995	CTestMidiClntGetPitchTranspositionCents* self = new(ELeave) CTestMidiClntGetPitchTranspositionCents(aTestName, aTestType);
sl@0	996	return self;
sl@0	997	}
sl@0	998
sl@0	999	TVerdict CTestMidiClntGetPitchTranspositionCents::DoTestL(CMidiClientUtility* aMidi)
sl@0	1000	{
sl@0	1001	TVerdict ret = EPass;
sl@0	1002	TInt expErr = KErrNone;
sl@0	1003
sl@0	1004	INFO_PRINTF1(_L("CMidiClientUtility: Set the pitch transposition"));
sl@0	1005	// expected results
sl@0	1006
sl@0	1007	switch (iTestType)
sl@0	1008	{
sl@0	1009	case ETestValid:
sl@0	1010	expErr = KErrNone;
sl@0	1011	break;
sl@0	1012	case ETestNoResource:
sl@0	1013	expErr = KErrNotReady;
sl@0	1014	break;
sl@0	1015	default:
sl@0	1016	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1017	return EInconclusive;
sl@0	1018	}
sl@0	1019
sl@0	1020	// TInt pitch = 0; // fixes warning
sl@0	1021	// TRAPD(err, pitch = aMidi->PitchTranspositionCentsL());
sl@0	1022	TRAPD(err, aMidi->PitchTranspositionCentsL()); // EABI warning removal - "I see trouble ahead..."
sl@0	1023	if(expErr != err)
sl@0	1024	{
sl@0	1025	ERR_PRINTF3( _L("PitchTranspositionCentsL gave error %d (expected %d)"),err, expErr);
sl@0	1026	ret = EFail;
sl@0	1027	}
sl@0	1028	else
sl@0	1029	INFO_PRINTF3(_L("PitchTranspositionCentsL %d = %d"), err, expErr);
sl@0	1030
sl@0	1031	return ret;
sl@0	1032	}
sl@0	1033
sl@0	1034	//------------------------------------------------------------------
sl@0	1035
sl@0	1036
sl@0	1037	CTestMidiClntSetPitchTransposition::CTestMidiClntSetPitchTransposition(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1038	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1039	{
sl@0	1040	}
sl@0	1041
sl@0	1042	CTestMidiClntSetPitchTransposition* CTestMidiClntSetPitchTransposition::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1043	{
sl@0	1044	CTestMidiClntSetPitchTransposition* self = new(ELeave) CTestMidiClntSetPitchTransposition(aTestName, aTestType);
sl@0	1045	return self;
sl@0	1046	}
sl@0	1047
sl@0	1048	TVerdict CTestMidiClntSetPitchTransposition::DoTestL(CMidiClientUtility* aMidi)
sl@0	1049	{
sl@0	1050	TVerdict ret = EPass;
sl@0	1051	TInt expErr = KErrNone;
sl@0	1052	TInt pitchTrans = 1200; // one octave
sl@0	1053
sl@0	1054	INFO_PRINTF1(_L("CMidiClientUtility: Set the pitch transposition"));
sl@0	1055	// expected results
sl@0	1056
sl@0	1057	switch (iTestType)
sl@0	1058	{
sl@0	1059	case ETestValid:
sl@0	1060	expErr = KErrNone;
sl@0	1061	break;
sl@0	1062	case ETestNoResource:
sl@0	1063	expErr = KErrNotReady;
sl@0	1064	break;
sl@0	1065	//According to GM2 spec, the minimum value can be -6499 cents, or at least -1299 cents.
sl@0	1066	case ETestOutOfRangeHigh:
sl@0	1067	// high limit on pitch transposition is dependant on controller
sl@0	1068	// when have a proper controller the value below should be changed
sl@0	1069	// to a value higher than the upper limit
sl@0	1070	pitchTrans = -6499; //KErrArgument expect by a real controller implementation if out-of-range
sl@0	1071	expErr = KErrNone;
sl@0	1072	break;
sl@0	1073	/*This test has been removed by AD as it was not valid - negative values ARE allowed by MIDI spec
sl@0	1074	According to GM2 spec, the minimum value can be -6499 cents, or at least -1299 cents.
sl@0	1075	case ETestOutOfRangeLow:
sl@0	1076	pitchTrans = -1; // negative values not supported
sl@0	1077	expErr = KErrNotSupported;
sl@0	1078	break;
sl@0	1079	*/
sl@0	1080	default:
sl@0	1081	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1082	return EInconclusive;
sl@0	1083	}
sl@0	1084
sl@0	1085	TRAPD(err, aMidi->SetPitchTranspositionL(pitchTrans));
sl@0	1086	if(expErr != err)
sl@0	1087	{
sl@0	1088	ERR_PRINTF3( _L("SetPitchTranspositionL gave error %d (expected %d)"),err, expErr);
sl@0	1089	ret = EFail;
sl@0	1090	}
sl@0	1091	else
sl@0	1092	INFO_PRINTF3(_L("SetPitchTranspositionL %d = %d"), err, expErr);
sl@0	1093
sl@0	1094	return ret;
sl@0	1095	}
sl@0	1096
sl@0	1097	//------------------------------------------------------------------
sl@0	1098
sl@0	1099
sl@0	1100	CTestMidiClntDurationMicroSeconds::CTestMidiClntDurationMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1101	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1102	{
sl@0	1103	}
sl@0	1104
sl@0	1105	CTestMidiClntDurationMicroSeconds* CTestMidiClntDurationMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1106	{
sl@0	1107	CTestMidiClntDurationMicroSeconds* self = new(ELeave) CTestMidiClntDurationMicroSeconds(aTestName, aTestType);
sl@0	1108	return self;
sl@0	1109	}
sl@0	1110
sl@0	1111	TVerdict CTestMidiClntDurationMicroSeconds::DoTestL(CMidiClientUtility* aMidi)
sl@0	1112	{
sl@0	1113	TVerdict ret = EPass;
sl@0	1114	TInt expErr = KErrNone;
sl@0	1115	TTimeIntervalMicroSeconds durationMicroSeconds(0);
sl@0	1116
sl@0	1117	INFO_PRINTF1(_L("CMidiClientUtility: Get duration in micro seconds"));
sl@0	1118	// expected results
sl@0	1119	switch(iTestType)
sl@0	1120	{
sl@0	1121	case ETestValid:
sl@0	1122	expErr = KErrNone;
sl@0	1123	break;
sl@0	1124	case ETestNoResource:
sl@0	1125	expErr = KErrNotReady;
sl@0	1126	break;
sl@0	1127	default:
sl@0	1128	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1129	return EInconclusive;
sl@0	1130	}
sl@0	1131
sl@0	1132	TRAPD(err, durationMicroSeconds = aMidi->DurationMicroSecondsL());
sl@0	1133	if (expErr != err)
sl@0	1134	{
sl@0	1135	ERR_PRINTF3(_L("DurationMicroSecondsL gave error %d (expected %d)"),err, expErr);
sl@0	1136	ret = EFail;
sl@0	1137	}
sl@0	1138	else
sl@0	1139	INFO_PRINTF3(_L("DurationMicroSecondsL %d = %d"),err ,expErr);
sl@0	1140
sl@0	1141	return ret;
sl@0	1142	}
sl@0	1143
sl@0	1144	//------------------------------------------------------------------
sl@0	1145
sl@0	1146
sl@0	1147	CTestMidiClntDurationMicroBeats::CTestMidiClntDurationMicroBeats(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1148	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1149	{
sl@0	1150	}
sl@0	1151
sl@0	1152	CTestMidiClntDurationMicroBeats* CTestMidiClntDurationMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1153	{
sl@0	1154	CTestMidiClntDurationMicroBeats* self = new(ELeave) CTestMidiClntDurationMicroBeats(aTestName, aTestType);
sl@0	1155	return self;
sl@0	1156	}
sl@0	1157
sl@0	1158	TVerdict CTestMidiClntDurationMicroBeats::DoTestL(CMidiClientUtility* aMidi)
sl@0	1159	{
sl@0	1160	TVerdict ret = EPass;
sl@0	1161	TInt expErr = KErrNone;
sl@0	1162	//TTimeIntervalMicroSeconds durationMicroSeconds(0);
sl@0	1163
sl@0	1164	INFO_PRINTF1(_L("CMidiClientUtility: Get duration in micro beats"));
sl@0	1165	// expected results
sl@0	1166	switch(iTestType)
sl@0	1167	{
sl@0	1168	case ETestValid:
sl@0	1169	expErr = KErrNone;
sl@0	1170	break;
sl@0	1171	case ETestNoResource:
sl@0	1172	expErr = KErrNotReady;
sl@0	1173	break;
sl@0	1174	default:
sl@0	1175	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1176	return EInconclusive;
sl@0	1177	}
sl@0	1178	TRAPD(err, aMidi->DurationMicroBeatsL());
sl@0	1179	if (expErr != err)
sl@0	1180	{
sl@0	1181	ERR_PRINTF3(_L("DurationMicroBeatsL gave error %d (expected %d)"),err, expErr);
sl@0	1182	ret = EFail;
sl@0	1183	}
sl@0	1184	else
sl@0	1185	INFO_PRINTF3(_L("DurationMicroBeatsL %d = %d"),err ,expErr);
sl@0	1186
sl@0	1187	return ret;
sl@0	1188	}
sl@0	1189
sl@0	1190	//------------------------------------------------------------------
sl@0	1191
sl@0	1192
sl@0	1193	CTestMidiClntNumTracks::CTestMidiClntNumTracks(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1194	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1195	{
sl@0	1196	}
sl@0	1197
sl@0	1198	CTestMidiClntNumTracks* CTestMidiClntNumTracks::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1199	{
sl@0	1200	CTestMidiClntNumTracks* self = new(ELeave) CTestMidiClntNumTracks(aTestName, aTestType);
sl@0	1201	return self;
sl@0	1202	}
sl@0	1203
sl@0	1204	TVerdict CTestMidiClntNumTracks::DoTestL(CMidiClientUtility* aMidi)
sl@0	1205	{
sl@0	1206	TVerdict ret = EPass;
sl@0	1207	TInt expErr = KErrNone;
sl@0	1208
sl@0	1209	INFO_PRINTF1(_L("CMidiClientUtility: Get current number of tracks"));
sl@0	1210	// expected results
sl@0	1211	switch(iTestType)
sl@0	1212	{
sl@0	1213	case ETestValid:
sl@0	1214	expErr = KErrNone;
sl@0	1215	break;
sl@0	1216	default:
sl@0	1217	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1218	return EInconclusive;
sl@0	1219	}
sl@0	1220	// TInt numOfTracks = 0;
sl@0	1221	// TRAPD(err, numOfTracks = aMidi->NumTracksL());
sl@0	1222	TRAPD(err, aMidi->NumTracksL()); // EABI warning removal
sl@0	1223	if (expErr != err)
sl@0	1224	{
sl@0	1225	ERR_PRINTF3(_L("NumTracksL gave error %d (expected %d)"),err, expErr);
sl@0	1226	ret = EFail;
sl@0	1227	}
sl@0	1228	else
sl@0	1229	INFO_PRINTF3(_L("NumTracksL %d = %d"),err ,expErr);
sl@0	1230
sl@0	1231	return ret;
sl@0	1232	}
sl@0	1233
sl@0	1234	//------------------------------------------------------------------
sl@0	1235
sl@0	1236
sl@0	1237	CTestMidiClntSetTrackMute::CTestMidiClntSetTrackMute(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1238	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1239	{
sl@0	1240	}
sl@0	1241
sl@0	1242	CTestMidiClntSetTrackMute* CTestMidiClntSetTrackMute::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1243	{
sl@0	1244	CTestMidiClntSetTrackMute* self = new(ELeave) CTestMidiClntSetTrackMute(aTestName, aTestType);
sl@0	1245	return self;
sl@0	1246	}
sl@0	1247
sl@0	1248	TVerdict CTestMidiClntSetTrackMute::DoTestL(CMidiClientUtility* aMidi)
sl@0	1249	{
sl@0	1250	TVerdict ret = EPass;
sl@0	1251	TInt expErr = KErrNone;
sl@0	1252	TInt track = 0;
sl@0	1253	TBool muted = ETrue;
sl@0	1254
sl@0	1255	INFO_PRINTF1(_L("CMidiClientUtility: Set track mute"));
sl@0	1256	// expected results
sl@0	1257	switch(iTestType)
sl@0	1258	{
sl@0	1259	case ETestValid:
sl@0	1260	expErr = KErrNone;
sl@0	1261	break;
sl@0	1262	case ETestNoResource:
sl@0	1263	expErr = KErrNotReady;
sl@0	1264	TRAP_IGNORE(track = aMidi->NumTracksL()+1);
sl@0	1265	break;
sl@0	1266	case ETestInvalidTrack:
sl@0	1267	expErr = KErrArgument;
sl@0	1268	TRAP_IGNORE(track = aMidi->NumTracksL()+1);
sl@0	1269	break;
sl@0	1270	default:
sl@0	1271	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1272	return EInconclusive;
sl@0	1273	}
sl@0	1274
sl@0	1275	TRAPD(err, aMidi->SetTrackMuteL(track, muted));
sl@0	1276
sl@0	1277	// check correct result
sl@0	1278	if (iTestType == ETestValid)
sl@0	1279	{
sl@0	1280	TBool currMuted = EFalse;
sl@0	1281
sl@0	1282	// until real MIDI controller IsTrackMuteL is always TRUE
sl@0	1283	TRAPD(err2, currMuted = aMidi->IsTrackMuteL(track));
sl@0	1284
sl@0	1285	if(err2 != KErrNone)
sl@0	1286	{
sl@0	1287	ERR_PRINTF2(_L("IsTrackMuteL() returned %d"), err2);
sl@0	1288	ret = EInconclusive;
sl@0	1289	return ret;
sl@0	1290	}
sl@0	1291
sl@0	1292	if(currMuted != muted)
sl@0	1293	{
sl@0	1294	ERR_PRINTF2(_L("Error : expected %d"), muted);
sl@0	1295	ret = EFail;
sl@0	1296	return ret;
sl@0	1297	}
sl@0	1298	}
sl@0	1299
sl@0	1300	if (expErr != err)
sl@0	1301	{
sl@0	1302	ERR_PRINTF3(_L("SetTrackMuteL gave error %d (expected %d)"),err, expErr);
sl@0	1303	ret = EFail;
sl@0	1304	}
sl@0	1305	else
sl@0	1306	INFO_PRINTF3(_L("SetTrackMuteL %d = %d"),err ,expErr);
sl@0	1307
sl@0	1308	return ret;
sl@0	1309	}
sl@0	1310
sl@0	1311	//------------------------------------------------------------------
sl@0	1312
sl@0	1313
sl@0	1314	CTestMidiClntMimeType::CTestMidiClntMimeType(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1315	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1316	{
sl@0	1317	}
sl@0	1318
sl@0	1319	CTestMidiClntMimeType* CTestMidiClntMimeType::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1320	{
sl@0	1321	CTestMidiClntMimeType* self = new(ELeave) CTestMidiClntMimeType(aTestName, aTestType);
sl@0	1322	return self;
sl@0	1323	}
sl@0	1324
sl@0	1325	TVerdict CTestMidiClntMimeType::DoTestL(CMidiClientUtility* aMidi)
sl@0	1326	{
sl@0	1327	TVerdict ret = EPass;
sl@0	1328	TInt expErr = KErrNone;
sl@0	1329
sl@0	1330	INFO_PRINTF1(_L("CMidiClientUtility: Get mime type"));
sl@0	1331	// expected results
sl@0	1332	switch(iTestType)
sl@0	1333	{
sl@0	1334	case ETestValid:
sl@0	1335	expErr = KErrNone;
sl@0	1336	break;
sl@0	1337	case ETestNoResource:
sl@0	1338	expErr = KErrNotReady;
sl@0	1339	break;
sl@0	1340	default:
sl@0	1341	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1342	return EInconclusive;
sl@0	1343	}
sl@0	1344
sl@0	1345	//TRAPD(err, TDesC8 mimeType = aMidi->MimeTypeL());//XXX: TDesC8 mimeType has to be define above
sl@0	1346	TRAPD(err, aMidi->MimeTypeL());//XXX: TDesC8 mimeType has to be define above
sl@0	1347	if (expErr != err)
sl@0	1348	{
sl@0	1349	ERR_PRINTF3(_L("MimeTypeL gave error %d (expected %d)"),err, expErr);
sl@0	1350	ret = EFail;
sl@0	1351	}
sl@0	1352	else
sl@0	1353	INFO_PRINTF3(_L("MimeTypeL %d = %d"),err ,expErr);
sl@0	1354
sl@0	1355	return ret;
sl@0	1356	}
sl@0	1357
sl@0	1358	//------------------------------------------------------------------
sl@0	1359
sl@0	1360
sl@0	1361	CTestMidiClntReturnPositionMicroSeconds::CTestMidiClntReturnPositionMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1362	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1363	{
sl@0	1364	}
sl@0	1365
sl@0	1366	CTestMidiClntReturnPositionMicroSeconds* CTestMidiClntReturnPositionMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1367	{
sl@0	1368	CTestMidiClntReturnPositionMicroSeconds* self = new(ELeave) CTestMidiClntReturnPositionMicroSeconds(aTestName, aTestType);
sl@0	1369	return self;
sl@0	1370	}
sl@0	1371
sl@0	1372	TVerdict CTestMidiClntReturnPositionMicroSeconds::DoTestL(CMidiClientUtility* aMidi)
sl@0	1373	{
sl@0	1374	TVerdict ret = EPass;
sl@0	1375	TInt expErr = KErrNone;
sl@0	1376
sl@0	1377	INFO_PRINTF1(_L("CMidiClientUtility: Get position in micro seconds"));
sl@0	1378	// expected results
sl@0	1379	switch(iTestType)
sl@0	1380	{
sl@0	1381	case ETestValid:
sl@0	1382	expErr = KErrNone;
sl@0	1383	break;
sl@0	1384	case ETestNoResource:
sl@0	1385	expErr = KErrNotReady;
sl@0	1386	break;
sl@0	1387	case ETestNoResourcePlaying:
sl@0	1388	expErr = KErrNotReady;
sl@0	1389	break;
sl@0	1390	default:
sl@0	1391	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1392	return EInconclusive;
sl@0	1393	}
sl@0	1394	TTimeIntervalMicroSeconds positionMicroSeconds(0);
sl@0	1395	TRAPD(err, positionMicroSeconds = aMidi->PositionMicroSecondsL());
sl@0	1396	if (expErr != err)
sl@0	1397	{
sl@0	1398	if (KErrNotReady != err)
sl@0	1399	{
sl@0	1400	ERR_PRINTF3(_L("Get PositionMicroSecondsL gave error %d (expected %d)"),err, expErr);
sl@0	1401	ret = EFail;
sl@0	1402	}
sl@0	1403	else
sl@0	1404	{
sl@0	1405	ret = EPass;
sl@0	1406	}
sl@0	1407	}
sl@0	1408	else
sl@0	1409	INFO_PRINTF3(_L("Get PositionMicroSecondsL %d = %d"),err ,expErr);
sl@0	1410
sl@0	1411	return ret;
sl@0	1412	}
sl@0	1413
sl@0	1414	//------------------------------------------------------------------
sl@0	1415
sl@0	1416
sl@0	1417	CTestMidiClntSetPositionMicroSeconds::CTestMidiClntSetPositionMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1418	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1419	{
sl@0	1420	}
sl@0	1421
sl@0	1422	CTestMidiClntSetPositionMicroSeconds* CTestMidiClntSetPositionMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1423	{
sl@0	1424	CTestMidiClntSetPositionMicroSeconds* self = new(ELeave) CTestMidiClntSetPositionMicroSeconds(aTestName, aTestType);
sl@0	1425	return self;
sl@0	1426	}
sl@0	1427
sl@0	1428	TVerdict CTestMidiClntSetPositionMicroSeconds::DoTestL(CMidiClientUtility* aMidi)
sl@0	1429	{
sl@0	1430	TVerdict ret = EPass;
sl@0	1431	TInt expErr = KErrNone;
sl@0	1432	TTimeIntervalMicroSeconds position(0);;
sl@0	1433
sl@0	1434	INFO_PRINTF1(_L("CMidiClientUtility: Set position in micro seconds"));
sl@0	1435	// expected results
sl@0	1436	switch(iTestType)
sl@0	1437	{
sl@0	1438	case ETestValid:
sl@0	1439	expErr = KErrNone;
sl@0	1440	break;
sl@0	1441	case ETestNoResource:
sl@0	1442	expErr = KErrNotReady;
sl@0	1443	break;
sl@0	1444	case ETestMicrosecondsHighOutOfRange:
sl@0	1445	expErr = KErrNotSupported;
sl@0	1446	position = 1008;
sl@0	1447	break;
sl@0	1448	case ETestMicrosecondsLowOutOfRange:
sl@0	1449	expErr = KErrNotSupported;
sl@0	1450	position = -1;
sl@0	1451	break;
sl@0	1452	default:
sl@0	1453	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1454	return EInconclusive;
sl@0	1455	}
sl@0	1456
sl@0	1457	TRAPD(err, aMidi->SetPositionMicroSecondsL(position));
sl@0	1458	if (expErr != err)
sl@0	1459	{
sl@0	1460	ERR_PRINTF3(_L("Set PositionMicroSecondsL gave error %d (expected %d)"),err, expErr);
sl@0	1461	ret = EFail;
sl@0	1462	}
sl@0	1463	else
sl@0	1464	INFO_PRINTF3(_L("Set PositionMicroSecondsL %d = %d"),err ,expErr);
sl@0	1465
sl@0	1466	return ret;
sl@0	1467	}
sl@0	1468
sl@0	1469	//------------------------------------------------------------------
sl@0	1470
sl@0	1471
sl@0	1472	CTestMidiClntReturnsPositionMicroBeats::CTestMidiClntReturnsPositionMicroBeats(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1473	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1474	{
sl@0	1475	}
sl@0	1476
sl@0	1477	CTestMidiClntReturnsPositionMicroBeats* CTestMidiClntReturnsPositionMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1478	{
sl@0	1479	CTestMidiClntReturnsPositionMicroBeats* self = new(ELeave) CTestMidiClntReturnsPositionMicroBeats(aTestName, aTestType);
sl@0	1480	return self;
sl@0	1481	}
sl@0	1482
sl@0	1483	TVerdict CTestMidiClntReturnsPositionMicroBeats::DoTestL(CMidiClientUtility* aMidi)
sl@0	1484	{
sl@0	1485	TVerdict ret = EPass;
sl@0	1486	TInt expErr = KErrNone;
sl@0	1487
sl@0	1488	INFO_PRINTF1(_L("CMidiClientUtility: Return position in micro beats"));
sl@0	1489	// expected results
sl@0	1490	switch(iTestType)
sl@0	1491	{
sl@0	1492	case ETestValid:
sl@0	1493	expErr = KErrNone;
sl@0	1494	break;
sl@0	1495	case ETestNoResource:
sl@0	1496	expErr = KErrNotReady;
sl@0	1497	break;
sl@0	1498	case ETestNoResourcePlaying:
sl@0	1499	expErr = KErrNotReady;
sl@0	1500	break;
sl@0	1501	default:
sl@0	1502	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1503	return EInconclusive;
sl@0	1504	}
sl@0	1505	TRAPD(err, aMidi->PositionMicroBeatsL());
sl@0	1506	if (expErr != err)
sl@0	1507	{
sl@0	1508	ERR_PRINTF3(_L("PositionMicroBeatsL gave error %d (expected %d)"),err, expErr);
sl@0	1509	ret = EFail;
sl@0	1510	}
sl@0	1511	else
sl@0	1512	INFO_PRINTF3(_L("PositionMicroBeatsL %d = %d"),err ,expErr);
sl@0	1513
sl@0	1514	return ret;
sl@0	1515	}
sl@0	1516
sl@0	1517	//------------------------------------------------------------------
sl@0	1518
sl@0	1519
sl@0	1520	CTestMidiClntSetPositionMicroBeats::CTestMidiClntSetPositionMicroBeats(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1521	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1522	{
sl@0	1523	}
sl@0	1524
sl@0	1525	CTestMidiClntSetPositionMicroBeats* CTestMidiClntSetPositionMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1526	{
sl@0	1527	CTestMidiClntSetPositionMicroBeats* self = new(ELeave) CTestMidiClntSetPositionMicroBeats(aTestName, aTestType);
sl@0	1528	return self;
sl@0	1529	}
sl@0	1530
sl@0	1531	TVerdict CTestMidiClntSetPositionMicroBeats::DoTestL(CMidiClientUtility* aMidi)
sl@0	1532	{
sl@0	1533	TVerdict ret = EPass;
sl@0	1534	TInt expErr = KErrNone;
sl@0	1535	TInt64 microBeats = 0;
sl@0	1536
sl@0	1537	INFO_PRINTF1(_L("CMidiClientUtility: Set position in micro beats"));
sl@0	1538	// expected results
sl@0	1539	switch(iTestType)
sl@0	1540	{
sl@0	1541	case ETestValid:
sl@0	1542	expErr = KErrNone;
sl@0	1543	break;
sl@0	1544	case ETestNoResource:
sl@0	1545	expErr = KErrNotReady;
sl@0	1546	break;
sl@0	1547	case ETestMicrobeatsHighOutOfRange:
sl@0	1548	expErr = KErrNotSupported;
sl@0	1549	microBeats = 1000000;
sl@0	1550	break;
sl@0	1551	case ETestMicrobeatsLowOutOfRange:
sl@0	1552	expErr = KErrNotSupported;
sl@0	1553	microBeats = -1;
sl@0	1554	break;
sl@0	1555	default:
sl@0	1556	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1557	return EInconclusive;
sl@0	1558	}
sl@0	1559
sl@0	1560	TRAPD(err, aMidi->SetPositionMicroBeatsL(microBeats));
sl@0	1561	if (expErr != err)
sl@0	1562	{
sl@0	1563	ERR_PRINTF3(_L("SetPositionMicroBeatsL gave error %d (expected %d)"),err, expErr);
sl@0	1564	ret = EFail;
sl@0	1565	}
sl@0	1566	else
sl@0	1567	INFO_PRINTF3(_L("SetPositionMicroBeatsL %d = %d"),err ,expErr);
sl@0	1568
sl@0	1569	return ret;
sl@0	1570	}
sl@0	1571
sl@0	1572	//------------------------------------------------------------------
sl@0	1573
sl@0	1574
sl@0	1575	CTestSetSyncUpdateCallbackInterval::CTestSetSyncUpdateCallbackInterval(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1576	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1577	{
sl@0	1578	}
sl@0	1579
sl@0	1580	CTestSetSyncUpdateCallbackInterval* CTestSetSyncUpdateCallbackInterval::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	1581	{
sl@0	1582	CTestSetSyncUpdateCallbackInterval* self = new(ELeave) CTestSetSyncUpdateCallbackInterval(aTestName, aTestType);
sl@0	1583	return self;
sl@0	1584	}
sl@0	1585
sl@0	1586	TVerdict CTestSetSyncUpdateCallbackInterval::DoTestL(CMidiClientUtility* aMidi)
sl@0	1587	{
sl@0	1588	TVerdict ret = EPass;
sl@0	1589	TInt expErr = KErrNone;
sl@0	1590	TTimeIntervalMicroSeconds microSeconds(0);
sl@0	1591	TInt64 microBeats = 0;
sl@0	1592
sl@0	1593	INFO_PRINTF1(_L("CMidiClientUtility: Set update call back interval"));
sl@0	1594	// expected results
sl@0	1595	switch(iTestType)
sl@0	1596	{
sl@0	1597	case ETestValid:
sl@0	1598	expErr = KErrNone;
sl@0	1599	break;
sl@0	1600	case ETestMicrosecondsMicrobeatsZero:
sl@0	1601	microSeconds = 0;
sl@0	1602	microBeats = 0;
sl@0	1603	expErr = KErrNotReady;
sl@0	1604	break;
sl@0	1605	case ETestMicrosecondsLowOutOfRange:
sl@0	1606	expErr = KErrArgument;
sl@0	1607	microSeconds = -1;
sl@0	1608	break;
sl@0	1609	case ETestMicrobeatsHighOutOfRange:
sl@0	1610	expErr = KErrArgument;
sl@0	1611	microBeats = 1000000;
sl@0	1612	break;
sl@0	1613	case ETestMicrobeatsLowOutOfRange:
sl@0	1614	expErr = KErrArgument;
sl@0	1615	microBeats = -1;
sl@0	1616	break;
sl@0	1617	default:
sl@0	1618	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1619	return EInconclusive;
sl@0	1620	}
sl@0	1621
sl@0	1622	TRAPD(err, aMidi->SetSyncUpdateCallbackIntervalL(microSeconds, microBeats));
sl@0	1623	if (expErr != err)
sl@0	1624	{
sl@0	1625	ERR_PRINTF3(_L("SetSyncUpdateCallbackIntervalL gave error %d (expected %d)"),err, expErr);
sl@0	1626	ret = EFail;
sl@0	1627	}
sl@0	1628	else
sl@0	1629	INFO_PRINTF3(_L("SetSyncUpdateCallbackIntervalL %d = %d"),err ,expErr);
sl@0	1630
sl@0	1631	return ret;
sl@0	1632	}
sl@0	1633
sl@0	1634	CTestSendMessage::CTestSendMessage(const TDesC& aTestName,
sl@0	1635	const TTestStepType aTestType, const TDesC8& aMessage)
sl@0	1636	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1637	{
sl@0	1638	iMessage = aMessage;
sl@0	1639	}
sl@0	1640
sl@0	1641	CTestSendMessage* CTestSendMessage::NewL(const TDesC& aTestName,
sl@0	1642	const TTestStepType aTestType, const TDesC8& aMessage)
sl@0	1643	{
sl@0	1644	CTestSendMessage* self = new (ELeave) CTestSendMessage(aTestName,
sl@0	1645	aTestType, aMessage);
sl@0	1646	return self;
sl@0	1647	}
sl@0	1648
sl@0	1649	TVerdict CTestSendMessage::DoTestL(CMidiClientUtility* aMidi)
sl@0	1650	{
sl@0	1651	INFO_PRINTF1(_L("CMidiClientUtility: Send Message"));
sl@0	1652
sl@0	1653	TVerdict ret = EPass;
sl@0	1654	TInt expErr = KErrNone;
sl@0	1655
sl@0	1656	// expected results
sl@0	1657	switch(iTestType)
sl@0	1658	{
sl@0	1659	case ETestValid:
sl@0	1660	expErr = KErrNone;
sl@0	1661	break;
sl@0	1662	case ETestNullMessage:
sl@0	1663	expErr = KErrArgument;
sl@0	1664	break;
sl@0	1665	case ETestUnsupported:
sl@0	1666	expErr = KErrNotSupported;
sl@0	1667	break;
sl@0	1668	case ETestCorrupt:
sl@0	1669	expErr = KErrCorrupt;
sl@0	1670	break;
sl@0	1671	default:
sl@0	1672	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1673	return EInconclusive;
sl@0	1674	}
sl@0	1675
sl@0	1676	// TInt byteProcessed;
sl@0	1677	// TRAPD(err1, byteProcessed = aMidi->SendMessageL(iMessage));
sl@0	1678	TRAPD(err1, aMidi->SendMessageL(iMessage)); // EABI warning removal
sl@0	1679	if(err1 != expErr)
sl@0	1680	{
sl@0	1681	ERR_PRINTF3(_L("SendMessageL(iMessage) gave error %d (expected %d)"), err1, expErr);
sl@0	1682	ret = EFail;
sl@0	1683	}
sl@0	1684
sl@0	1685	TTimeIntervalMicroSeconds startTime(105);
sl@0	1686	// TRAPD(err2, byteProcessed = aMidi->SendMessageL(iMessage, startTime));
sl@0	1687	TRAPD(err2, aMidi->SendMessageL(iMessage, startTime)); // EABI warning removal
sl@0	1688	if(err2 != expErr)
sl@0	1689	{
sl@0	1690	ERR_PRINTF3(_L("SendMessageL(iMessage, startTime) gave error %d (expected %d)"), err1, expErr);
sl@0	1691	ret = EFail;
sl@0	1692	}
sl@0	1693
sl@0	1694	return ret;
sl@0	1695	}
sl@0	1696
sl@0	1697	//------------------------------------------------------------------
sl@0	1698
sl@0	1699
sl@0	1700	// CTestSendMessageTime incorporated into CTestSendMessage
sl@0	1701
sl@0	1702	//------------------------------------------------------------------
sl@0	1703
sl@0	1704	// aTestType as follows :
sl@0	1705	// 0115 : valid
sl@0	1706	// 0116 : invalid device ID - REMOVED, API has changed
sl@0	1707	// 0117 : null
sl@0	1708	// 0118 : unsupported
sl@0	1709	// 0119 : unsupported - REMOVED, duplicate
sl@0	1710	// 0120 : corrupt
sl@0	1711
sl@0	1712	CTestSendMipMessage::CTestSendMipMessage(const TDesC& aTestName,
sl@0	1713	const TTestStepType aTestType)
sl@0	1714	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1715	{
sl@0	1716	}
sl@0	1717
sl@0	1718	CTestSendMipMessage* CTestSendMipMessage::NewL(const TDesC& aTestName,
sl@0	1719	const TTestStepType aTestType)
sl@0	1720	{
sl@0	1721	CTestSendMipMessage* self = new (ELeave) CTestSendMipMessage(aTestName,
sl@0	1722	aTestType);
sl@0	1723	return self;
sl@0	1724	}
sl@0	1725
sl@0	1726	TVerdict CTestSendMipMessage::DoTestL(CMidiClientUtility* aMidi)
sl@0	1727	{
sl@0	1728	INFO_PRINTF1(_L("CMidiClientUtility: Send Mip Message"));
sl@0	1729
sl@0	1730	TVerdict ret = EPass;
sl@0	1731	TInt expErr = KErrNone;
sl@0	1732
sl@0	1733	RArray<TMipMessageEntry> mipArray;
sl@0	1734	TMipMessageEntry mipEntry1;
sl@0	1735	TMipMessageEntry mipEntry2;
sl@0	1736
sl@0	1737	// expected results
sl@0	1738	switch(iTestType)
sl@0	1739	{
sl@0	1740	case ETestValid:
sl@0	1741	expErr = KErrNone;
sl@0	1742	break;
sl@0	1743	case ETestNullMessage:
sl@0	1744	expErr = KErrArgument;
sl@0	1745	break;
sl@0	1746	case ETestUnsupported:
sl@0	1747	expErr = KErrNotSupported;
sl@0	1748	break;
sl@0	1749	case ETestCorrupt:
sl@0	1750	expErr = KErrCorrupt;
sl@0	1751	break;
sl@0	1752	default:
sl@0	1753	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1754	return EInconclusive;
sl@0	1755	}
sl@0	1756
sl@0	1757	switch(iTestType)
sl@0	1758	{
sl@0	1759	case ETestValid:
sl@0	1760	mipEntry1.iChannel = 10;
sl@0	1761	mipEntry1.iMIPValue = 20;
sl@0	1762	mipEntry2.iChannel = 11;
sl@0	1763	mipEntry2.iMIPValue = 21;
sl@0	1764
sl@0	1765	mipArray.Append(mipEntry1);
sl@0	1766	mipArray.Append(mipEntry2);
sl@0	1767	break;
sl@0	1768
sl@0	1769	case ETestNullMessage:
sl@0	1770	// leave array empty
sl@0	1771	// *** NB this will cause a problem in debug mode - causes a server panic!
sl@0	1772	break;
sl@0	1773
sl@0	1774	case ETestUnsupported:
sl@0	1775	// XXX : values defined as unsupported?
sl@0	1776	mipEntry1.iChannel = 0;
sl@0	1777	mipEntry1.iMIPValue = 0;
sl@0	1778	mipEntry2.iChannel = 0;
sl@0	1779	mipEntry2.iMIPValue = 0;
sl@0	1780
sl@0	1781	mipArray.Append(mipEntry1);
sl@0	1782	mipArray.Append(mipEntry2);
sl@0	1783	break;
sl@0	1784
sl@0	1785	case ETestCorrupt:
sl@0	1786	// XXX : values defined as corrupt?
sl@0	1787	mipEntry1.iChannel = -1;
sl@0	1788	mipEntry1.iMIPValue = -1;
sl@0	1789	mipEntry2.iChannel = -1;
sl@0	1790	mipEntry2.iMIPValue = -1;
sl@0	1791
sl@0	1792	mipArray.Append(mipEntry1);
sl@0	1793	mipArray.Append(mipEntry2);
sl@0	1794	break;
sl@0	1795	}
sl@0	1796
sl@0	1797	TRAPD(err1, aMidi->SendMipMessageL(mipArray));
sl@0	1798	if(err1 != expErr)
sl@0	1799	{
sl@0	1800	ERR_PRINTF3(_L("SendMipMessageL(iMessage) gave error %d (expected %d)"), err1, expErr);
sl@0	1801	ret = EFail;
sl@0	1802	}
sl@0	1803
sl@0	1804	mipArray.Close();
sl@0	1805	return ret;
sl@0	1806	}
sl@0	1807
sl@0	1808	//------------------------------------------------------------------
sl@0	1809
sl@0	1810
sl@0	1811	CTestNumberOfBanks::CTestNumberOfBanks(const TDesC& aTestName,
sl@0	1812	const TTestStepType aTestType)
sl@0	1813	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1814	{
sl@0	1815	}
sl@0	1816
sl@0	1817	CTestNumberOfBanks* CTestNumberOfBanks::NewL(const TDesC& aTestName,
sl@0	1818	const TTestStepType aTestType)
sl@0	1819	{
sl@0	1820	CTestNumberOfBanks* self = new (ELeave) CTestNumberOfBanks(aTestName,
sl@0	1821	aTestType);
sl@0	1822	return self;
sl@0	1823	}
sl@0	1824
sl@0	1825	TVerdict CTestNumberOfBanks::DoTestL(CMidiClientUtility* aMidi)
sl@0	1826	{
sl@0	1827	// to do : test for standard & custom banks
sl@0	1828
sl@0	1829	// currently using ETestOverflow to simulate no banks
sl@0	1830
sl@0	1831	TVerdict ret = EPass;
sl@0	1832	TInt expErr = KErrNone;
sl@0	1833
sl@0	1834	// expected results
sl@0	1835	switch(iTestType)
sl@0	1836	{
sl@0	1837	case ETestValid:
sl@0	1838	expErr = KErrNone;
sl@0	1839	break;
sl@0	1840	case ETestNegative:
sl@0	1841	expErr = KErrArgument;
sl@0	1842	break;
sl@0	1843	default:
sl@0	1844	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1845	return EInconclusive;
sl@0	1846	}
sl@0	1847
sl@0	1848	TInt numBanks = 0;
sl@0	1849	TRAPD(err1, numBanks = aMidi->NumberOfBanksL(EFalse));
sl@0	1850	if(err1 != expErr)
sl@0	1851	{
sl@0	1852	ERR_PRINTF3(_L("NumberOfBanksL(EFalse) gave error %d (expected %d)"), err1, expErr);
sl@0	1853	ret = EFail;
sl@0	1854	}
sl@0	1855	else
sl@0	1856	INFO_PRINTF2(_L("Number of Banks (standard) = %d"), numBanks);
sl@0	1857
sl@0	1858
sl@0	1859	TRAPD(err2, numBanks = aMidi->NumberOfBanksL(ETrue));
sl@0	1860	if(err1 != expErr)
sl@0	1861	{
sl@0	1862	ERR_PRINTF3(_L("NumberOfBanksL(ETrue) gave error %d (expected %d)"), err2, expErr);
sl@0	1863	ret = EFail;
sl@0	1864	}
sl@0	1865	else
sl@0	1866	INFO_PRINTF2(_L("Number of Banks (custom) = %d"), numBanks);
sl@0	1867
sl@0	1868	return ret;
sl@0	1869	}
sl@0	1870
sl@0	1871	//------------------------------------------------------------------
sl@0	1872
sl@0	1873
sl@0	1874	CTestGetBankId::CTestGetBankId(const TDesC& aTestName,
sl@0	1875	const TTestStepType aTestType)
sl@0	1876	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1877	{
sl@0	1878	}
sl@0	1879
sl@0	1880	CTestGetBankId* CTestGetBankId::NewL(const TDesC& aTestName,
sl@0	1881	const TTestStepType aTestType)
sl@0	1882	{
sl@0	1883	CTestGetBankId* self = new (ELeave) CTestGetBankId(aTestName,
sl@0	1884	aTestType);
sl@0	1885	return self;
sl@0	1886	}
sl@0	1887
sl@0	1888	TVerdict CTestGetBankId::DoTestL(CMidiClientUtility* aMidi)
sl@0	1889	{
sl@0	1890	// currently using ETestOverflow to simulate no banks
sl@0	1891	TVerdict ret = EPass;
sl@0	1892	TInt expErr;
sl@0	1893	TInt bankNum;
sl@0	1894
sl@0	1895	// expected results
sl@0	1896	switch(iTestType)
sl@0	1897	{
sl@0	1898	case ETestValid:
sl@0	1899	expErr = KErrNone;
sl@0	1900	bankNum = 54;
sl@0	1901	break;
sl@0	1902	case ETestNegative:
sl@0	1903	expErr = KErrArgument;
sl@0	1904	bankNum = -1;
sl@0	1905	break;
sl@0	1906	case ETestOverflow:
sl@0	1907	expErr = KErrArgument;
sl@0	1908	bankNum = 12000;
sl@0	1909	break;
sl@0	1910	default:
sl@0	1911	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1912	return EInconclusive;
sl@0	1913	}
sl@0	1914
sl@0	1915	TInt bankId = 0;
sl@0	1916	TRAPD(err1, bankId = aMidi->GetBankIdL(EFalse, bankNum));
sl@0	1917	if(err1 != expErr)
sl@0	1918	{
sl@0	1919	ERR_PRINTF4(_L("GetBankIdL(EFalse, %d) gave error %d (expected %d)"), bankNum, err1, expErr);
sl@0	1920	ret = EFail;
sl@0	1921	}
sl@0	1922	else
sl@0	1923	INFO_PRINTF3(_L("GetBankIdL(EFalse, %d) = %d"), bankNum, bankId);
sl@0	1924
sl@0	1925	TRAPD(err2, bankId = aMidi->GetBankIdL(ETrue, bankNum));
sl@0	1926	if(err2 != expErr)
sl@0	1927	{
sl@0	1928	ERR_PRINTF4(_L("GetBankIdL(ETrue, %d) gave error %d (expected %d)"), bankNum, err2, expErr);
sl@0	1929	ret = EFail;
sl@0	1930	}
sl@0	1931	else
sl@0	1932	INFO_PRINTF3(_L("GetBankIdL(ETrue, %d) = %d"), bankNum, bankId);
sl@0	1933
sl@0	1934	return ret;
sl@0	1935	}
sl@0	1936
sl@0	1937	//------------------------------------------------------------------
sl@0	1938
sl@0	1939
sl@0	1940	CTestLoadCustomBank::CTestLoadCustomBank(const TDesC& aTestName,
sl@0	1941	const TTestStepType aTestType)
sl@0	1942	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	1943	{
sl@0	1944	}
sl@0	1945
sl@0	1946	CTestLoadCustomBank* CTestLoadCustomBank::NewL(const TDesC& aTestName,
sl@0	1947	const TTestStepType aTestType)
sl@0	1948	{
sl@0	1949	CTestLoadCustomBank* self = new (ELeave) CTestLoadCustomBank(aTestName,
sl@0	1950	aTestType);
sl@0	1951	return self;
sl@0	1952	}
sl@0	1953
sl@0	1954	TVerdict CTestLoadCustomBank::DoTestL(CMidiClientUtility* aMidi)
sl@0	1955	{
sl@0	1956	TVerdict ret = EPass;
sl@0	1957	TInt expErr;
sl@0	1958	TFileName bankFileName;
sl@0	1959
sl@0	1960	_LIT8(KBankFileName, "Bank file name");
sl@0	1961	_LIT8(KBankFileNameInvalid, "Invalid file name");
sl@0	1962	_LIT8(KBankFileNameUnsupported, "Unsupported file name");
sl@0	1963
sl@0	1964	// expected results
sl@0	1965	switch(iTestType)
sl@0	1966	{
sl@0	1967	case ETestValid:
sl@0	1968	expErr = KErrNone;
sl@0	1969	bankFileName.Copy(KBankFileName);
sl@0	1970	break;
sl@0	1971	case ETestNullMessage:
sl@0	1972	expErr = KErrArgument;
sl@0	1973	bankFileName.Copy(KNullDesC16);
sl@0	1974	break;
sl@0	1975	case ETestInvalidMessage:
sl@0	1976	expErr = KErrArgument;
sl@0	1977	bankFileName.Copy(KBankFileNameInvalid);
sl@0	1978	break;
sl@0	1979	case ETestUnsupported:
sl@0	1980	expErr = KErrNotSupported;
sl@0	1981	bankFileName.Copy(KBankFileNameUnsupported);
sl@0	1982	break;
sl@0	1983	default:
sl@0	1984	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	1985	return EInconclusive;
sl@0	1986	}
sl@0	1987
sl@0	1988	TInt bankId = 0;
sl@0	1989
sl@0	1990	TRAPD(err1, aMidi->LoadCustomBankL(bankFileName, bankId));
sl@0	1991	INFO_PRINTF3(_L("LoadCustomBankL gave error %d (expected %d)"), err1, expErr);
sl@0	1992	if(err1 != expErr)
sl@0	1993	{
sl@0	1994	ret = EFail;
sl@0	1995	return ret;
sl@0	1996	}
sl@0	1997	// see if it's loaded
sl@0	1998	TBool loaded = EFalse;
sl@0	1999	TRAP(err1, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2000	if(err1 != KErrNone)
sl@0	2001	{
sl@0	2002	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err1);
sl@0	2003	ret = EFail;
sl@0	2004	return ret;
sl@0	2005	}
sl@0	2006	if(iTestType == ETestValid)
sl@0	2007	{
sl@0	2008	if(!loaded)
sl@0	2009	{
sl@0	2010	ERR_PRINTF1(_L("CustomBankLoadedL returned false"));
sl@0	2011	ret = EFail;
sl@0	2012	}
sl@0	2013	}
sl@0	2014	else
sl@0	2015	{
sl@0	2016	if(loaded)
sl@0	2017	{
sl@0	2018	ERR_PRINTF1(_L("CustomBankLoadedL returned true"));
sl@0	2019	ret = EFail;
sl@0	2020	}
sl@0	2021	}
sl@0	2022
sl@0	2023	return ret;
sl@0	2024	}
sl@0	2025
sl@0	2026	//------------------------------------------------------------------
sl@0	2027
sl@0	2028
sl@0	2029	CTestUnloadCustomBank::CTestUnloadCustomBank(const TDesC& aTestName,
sl@0	2030	const TTestStepType aTestType)
sl@0	2031	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2032	{
sl@0	2033	}
sl@0	2034
sl@0	2035	CTestUnloadCustomBank* CTestUnloadCustomBank::NewL(const TDesC& aTestName,
sl@0	2036	const TTestStepType aTestType)
sl@0	2037	{
sl@0	2038	CTestUnloadCustomBank* self = new (ELeave) CTestUnloadCustomBank(aTestName,
sl@0	2039	aTestType);
sl@0	2040	return self;
sl@0	2041	}
sl@0	2042
sl@0	2043	TVerdict CTestUnloadCustomBank::DoTestL(CMidiClientUtility* aMidi)
sl@0	2044	{
sl@0	2045	TVerdict ret = EPass;
sl@0	2046	TInt expErr;
sl@0	2047	TFileName bankFileName;
sl@0	2048
sl@0	2049	_LIT8(KBankFileName, "Bank file name");
sl@0	2050	bankFileName.Copy(KBankFileName);
sl@0	2051
sl@0	2052	// expected results
sl@0	2053	switch(iTestType)
sl@0	2054	{
sl@0	2055	case ETestValid:
sl@0	2056	expErr = KErrNone;
sl@0	2057	break;
sl@0	2058	case ETestNegative:
sl@0	2059	expErr = KErrNotFound;
sl@0	2060	break;
sl@0	2061	default:
sl@0	2062	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2063	return EInconclusive;
sl@0	2064	}
sl@0	2065
sl@0	2066	TInt bankId = 0;
sl@0	2067
sl@0	2068	// load a known bank
sl@0	2069	TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId));
sl@0	2070	if(err != KErrNone)
sl@0	2071	{
sl@0	2072	ERR_PRINTF2(_L("LoadCustomBankL gave error %d"), err);
sl@0	2073	ret = EInconclusive;
sl@0	2074	return ret;
sl@0	2075	}
sl@0	2076
sl@0	2077	// ensure it's loaded
sl@0	2078	TBool loaded = EFalse;
sl@0	2079	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2080	if(err != KErrNone)
sl@0	2081	{
sl@0	2082	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2083	ret = EInconclusive;
sl@0	2084	return ret;
sl@0	2085	}
sl@0	2086	if(!loaded)
sl@0	2087	{
sl@0	2088	ERR_PRINTF1(_L("CustomBankLoadedL returned false"));
sl@0	2089	ret = EInconclusive;
sl@0	2090	return ret;
sl@0	2091	}
sl@0	2092
sl@0	2093	// unload the bank we know is loaded
sl@0	2094	TRAP(err, aMidi->UnloadCustomBankL(bankId));
sl@0	2095	if(err != KErrNone)
sl@0	2096	{
sl@0	2097	ERR_PRINTF2(_L("UnloadCustomBankL gave error %d"), err);
sl@0	2098	ret = EFail;
sl@0	2099	return ret;
sl@0	2100	}
sl@0	2101
sl@0	2102	// ensure it's not loaded
sl@0	2103	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2104	if(err != KErrNone)
sl@0	2105	{
sl@0	2106	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2107	ret = EInconclusive;
sl@0	2108	return ret;
sl@0	2109	}
sl@0	2110	if(loaded)
sl@0	2111	{
sl@0	2112	ERR_PRINTF1(_L("CustomBankLoadedL returned true -> bank not unloaded"));
sl@0	2113	ret = EFail;
sl@0	2114	return ret;
sl@0	2115	}
sl@0	2116
sl@0	2117	// if negative test, try and unload the same bank again
sl@0	2118	if(iTestType == ETestValid)
sl@0	2119	return ret;
sl@0	2120	else
sl@0	2121	{
sl@0	2122	TRAP(err, aMidi->UnloadCustomBankL(bankId));
sl@0	2123	INFO_PRINTF3(_L("UnloadCustomBankL gave error %d (expected %d)"), err, expErr);
sl@0	2124	if(err != expErr)
sl@0	2125	ret = EFail;
sl@0	2126	}
sl@0	2127
sl@0	2128	return ret;
sl@0	2129	}
sl@0	2130
sl@0	2131	//------------------------------------------------------------------
sl@0	2132
sl@0	2133
sl@0	2134	CTestUnloadAllCustomBanks::CTestUnloadAllCustomBanks(const TDesC& aTestName,
sl@0	2135	const TTestStepType aTestType)
sl@0	2136	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2137	{
sl@0	2138	}
sl@0	2139
sl@0	2140	CTestUnloadAllCustomBanks* CTestUnloadAllCustomBanks::NewL(const TDesC& aTestName,
sl@0	2141	const TTestStepType aTestType)
sl@0	2142	{
sl@0	2143	CTestUnloadAllCustomBanks* self = new (ELeave) CTestUnloadAllCustomBanks(aTestName,
sl@0	2144	aTestType);
sl@0	2145	return self;
sl@0	2146	}
sl@0	2147
sl@0	2148	TVerdict CTestUnloadAllCustomBanks::DoTestL(CMidiClientUtility* aMidi)
sl@0	2149	{
sl@0	2150	TVerdict ret = EPass;
sl@0	2151	TInt expErr;
sl@0	2152	TFileName bankFileName;
sl@0	2153
sl@0	2154	_LIT8(KBankFileName, "Bank file name");
sl@0	2155	bankFileName.Copy(KBankFileName);
sl@0	2156
sl@0	2157	// expected results
sl@0	2158	switch(iTestType)
sl@0	2159	{
sl@0	2160	case ETestValid:
sl@0	2161	expErr = KErrNone;
sl@0	2162	break;
sl@0	2163	case ETestNegative:
sl@0	2164	expErr = KErrNotFound;
sl@0	2165	break;
sl@0	2166	default:
sl@0	2167	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2168	return EInconclusive;
sl@0	2169	}
sl@0	2170
sl@0	2171	TInt bankId = 0;
sl@0	2172
sl@0	2173	// load a known bank
sl@0	2174	TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId));
sl@0	2175	if(err != KErrNone)
sl@0	2176	{
sl@0	2177	ERR_PRINTF2(_L("LoadCustomBankL gave error %d"), err);
sl@0	2178	ret = EInconclusive;
sl@0	2179	return ret;
sl@0	2180	}
sl@0	2181
sl@0	2182	// ensure it's loaded
sl@0	2183	TBool loaded = EFalse;
sl@0	2184	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2185	if(err != KErrNone)
sl@0	2186	{
sl@0	2187	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2188	ret = EInconclusive;
sl@0	2189	return ret;
sl@0	2190	}
sl@0	2191	if(!loaded)
sl@0	2192	{
sl@0	2193	ERR_PRINTF1(_L("CustomBankLoadedL returned false"));
sl@0	2194	ret = EInconclusive;
sl@0	2195	return ret;
sl@0	2196	}
sl@0	2197
sl@0	2198	// unload all
sl@0	2199	TRAP(err, aMidi->UnloadAllCustomBanksL());
sl@0	2200	if(err != KErrNone)
sl@0	2201	{
sl@0	2202	ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err);
sl@0	2203	ret = EFail;
sl@0	2204	return ret;
sl@0	2205	}
sl@0	2206
sl@0	2207	loaded = EFalse;
sl@0	2208	// ensure our bank is not loaded
sl@0	2209	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2210	if(err != KErrNone)
sl@0	2211	{
sl@0	2212	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2213	ret = EInconclusive;
sl@0	2214	return ret;
sl@0	2215	}
sl@0	2216	if(loaded)
sl@0	2217	{
sl@0	2218	ERR_PRINTF1(_L("CustomBankLoadedL returned true -> bank not unloaded"));
sl@0	2219	ret = EFail;
sl@0	2220	return ret;
sl@0	2221	}
sl@0	2222
sl@0	2223	// if negative test, try and unload again
sl@0	2224	if(iTestType == ETestValid)
sl@0	2225	return ret;
sl@0	2226	else
sl@0	2227	{
sl@0	2228	TRAP(err, aMidi->UnloadAllCustomBanksL());
sl@0	2229	INFO_PRINTF3(_L("UnloadAllCustomBanksL gave error %d (expected %d)"), err, expErr);
sl@0	2230	if(err != expErr)
sl@0	2231	ret = EFail;
sl@0	2232	}
sl@0	2233
sl@0	2234	return ret;
sl@0	2235	}
sl@0	2236
sl@0	2237	//------------------------------------------------------------------
sl@0	2238
sl@0	2239
sl@0	2240	CTestNumberOfInstruments::CTestNumberOfInstruments(const TDesC& aTestName,
sl@0	2241	const TTestStepType aTestType)
sl@0	2242	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2243	{
sl@0	2244	}
sl@0	2245
sl@0	2246	CTestNumberOfInstruments* CTestNumberOfInstruments::NewL(const TDesC& aTestName,
sl@0	2247	const TTestStepType aTestType)
sl@0	2248	{
sl@0	2249	CTestNumberOfInstruments* self = new (ELeave) CTestNumberOfInstruments(aTestName,
sl@0	2250	aTestType);
sl@0	2251	return self;
sl@0	2252	}
sl@0	2253
sl@0	2254	TVerdict CTestNumberOfInstruments::DoTestL(CMidiClientUtility* aMidi)
sl@0	2255	{
sl@0	2256	// TO DO : situation where no standard banks exist
sl@0	2257
sl@0	2258	TVerdict ret = EPass;
sl@0	2259	TInt expErr;
sl@0	2260	TFileName bankFileName;
sl@0	2261
sl@0	2262	_LIT8(KBankFileName, "Bank file name");
sl@0	2263	bankFileName.Copy(KBankFileName);
sl@0	2264	TInt bankId = 0;
sl@0	2265	TInt numInstruments = 0;
sl@0	2266
sl@0	2267	// expected results
sl@0	2268	switch(iTestType)
sl@0	2269	{
sl@0	2270	case ETestValid:
sl@0	2271	expErr = KErrNone;
sl@0	2272	bankId = 0;
sl@0	2273	break;
sl@0	2274	case ETestNegative:
sl@0	2275	expErr = KErrNotFound;
sl@0	2276	bankId = 0;
sl@0	2277	break;
sl@0	2278	case ETestInvalidId:
sl@0	2279	expErr = KErrArgument;
sl@0	2280	bankId = -2;
sl@0	2281	break;
sl@0	2282	default:
sl@0	2283	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2284	return EInconclusive;
sl@0	2285	}
sl@0	2286
sl@0	2287	// check a known bank - standard
sl@0	2288	// *** TO DO : this will cause a failure with ETestNegative. To be re-done
sl@0	2289	// for no standard banks present
sl@0	2290	TRAPD(err, numInstruments = aMidi->NumberOfInstrumentsL(bankId, EFalse));
sl@0	2291	if(err != expErr)
sl@0	2292	{
sl@0	2293	ERR_PRINTF3(_L("NumberOfInstrumentsL(bankId, EFalse) gave error %d (expected %d)"), err, expErr);
sl@0	2294	ret = EFail;
sl@0	2295	return ret;
sl@0	2296	}
sl@0	2297	INFO_PRINTF2(_L("NumberOfInstrumentsL(bankId, EFalse) = %d"), numInstruments);
sl@0	2298
sl@0	2299	if(iTestType != ETestInvalidMessage)
sl@0	2300	{
sl@0	2301	// load a known bank - custom
sl@0	2302	TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId));
sl@0	2303	if(err != KErrNone)
sl@0	2304	{
sl@0	2305	ERR_PRINTF2(_L("LoadCustomBankL left with error %d"), err);
sl@0	2306	ret = EInconclusive;
sl@0	2307	return ret;
sl@0	2308	}
sl@0	2309	// ensure it's loaded
sl@0	2310	TBool loaded = EFalse;
sl@0	2311	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2312	if(err != KErrNone)
sl@0	2313	{
sl@0	2314	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2315	ret = EInconclusive;
sl@0	2316	return ret;
sl@0	2317	}
sl@0	2318	if(!loaded)
sl@0	2319	{
sl@0	2320	ERR_PRINTF1(_L("CustomBankLoadedL returned false -> bank not loaded"));
sl@0	2321	ret = EInconclusive;
sl@0	2322	return ret;
sl@0	2323	}
sl@0	2324	}
sl@0	2325
sl@0	2326	// check the custom bank
sl@0	2327	// NB if test type is InvalidId then we haven't bothered to load anything
sl@0	2328	TRAP(err, aMidi->NumberOfInstrumentsL(bankId, ETrue));
sl@0	2329	if(err != expErr)
sl@0	2330	{
sl@0	2331	ERR_PRINTF2(_L("NumberOfInstrumentsL(bankId, ETrue) gave error %d"), err);
sl@0	2332	ret = EFail;
sl@0	2333	return ret;
sl@0	2334	}
sl@0	2335	INFO_PRINTF2(_L("NumberOfInstrumentsL(bankId, ETrue) = %d"), numInstruments);
sl@0	2336
sl@0	2337	if(iTestType == ETestNegative)
sl@0	2338	{
sl@0	2339	// negative test :- unload all, then check it again
sl@0	2340	TRAP(err, aMidi->UnloadAllCustomBanksL());
sl@0	2341	if(err != KErrNone)
sl@0	2342	{
sl@0	2343	ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err);
sl@0	2344	ret = EInconclusive;
sl@0	2345	return ret;
sl@0	2346	}
sl@0	2347	// check it. it should leave
sl@0	2348	TRAP(err, aMidi->NumberOfInstrumentsL(bankId, ETrue));
sl@0	2349	if(err != expErr)
sl@0	2350	{
sl@0	2351	ERR_PRINTF3(_L("NumberOfInstrumentsL gave error %d (expected %d)"), err, expErr);
sl@0	2352	ret = EFail;
sl@0	2353	return ret;
sl@0	2354	}
sl@0	2355	}
sl@0	2356
sl@0	2357	return ret;
sl@0	2358	}
sl@0	2359
sl@0	2360	//------------------------------------------------------------------
sl@0	2361
sl@0	2362
sl@0	2363	CTestGetInstrumentId::CTestGetInstrumentId(const TDesC& aTestName,
sl@0	2364	const TTestStepType aTestType)
sl@0	2365	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2366	{
sl@0	2367	}
sl@0	2368
sl@0	2369	CTestGetInstrumentId* CTestGetInstrumentId::NewL(const TDesC& aTestName,
sl@0	2370	const TTestStepType aTestType)
sl@0	2371	{
sl@0	2372	CTestGetInstrumentId* self = new (ELeave) CTestGetInstrumentId(aTestName,
sl@0	2373	aTestType);
sl@0	2374	return self;
sl@0	2375	}
sl@0	2376
sl@0	2377	TVerdict CTestGetInstrumentId::DoTestL(CMidiClientUtility* aMidi)
sl@0	2378	{
sl@0	2379	// TO DO : situation where no standard banks exist
sl@0	2380
sl@0	2381	TVerdict ret = EPass;
sl@0	2382	TInt expErr;
sl@0	2383	TFileName bankFileName;
sl@0	2384
sl@0	2385	_LIT8(KBankFileName, "Bank file name");
sl@0	2386	bankFileName.Copy(KBankFileName);
sl@0	2387	TInt bankId = 0;
sl@0	2388	TInt instrIndex = 0;
sl@0	2389	TInt instrId = 0;
sl@0	2390
sl@0	2391	// expected results
sl@0	2392	switch(iTestType)
sl@0	2393	{
sl@0	2394	case ETestValid:
sl@0	2395	expErr = KErrNone;
sl@0	2396	bankId = 0;
sl@0	2397	instrIndex = 0;
sl@0	2398	break;
sl@0	2399	case ETestNegative:
sl@0	2400	expErr = KErrNotFound;
sl@0	2401	bankId = 0;
sl@0	2402	instrIndex = 0;
sl@0	2403	break;
sl@0	2404	case ETestInvalidId:
sl@0	2405	expErr = KErrArgument;
sl@0	2406	bankId = -2;
sl@0	2407	instrIndex = 0;
sl@0	2408	break;
sl@0	2409	case ETestInvalidIndex:
sl@0	2410	expErr = KErrArgument;
sl@0	2411	bankId = 0;
sl@0	2412	instrIndex = -2;
sl@0	2413	break;
sl@0	2414	default:
sl@0	2415	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2416	return EInconclusive;
sl@0	2417	}
sl@0	2418
sl@0	2419	// check a known bank - standard
sl@0	2420	// *** TO DO : this will cause a failure with ETestNegative. To be re-done
sl@0	2421	// for no standard banks present
sl@0	2422	TRAPD(err, instrId = aMidi->GetInstrumentIdL(bankId, EFalse, instrIndex));
sl@0	2423	if(err != expErr)
sl@0	2424	{
sl@0	2425	ERR_PRINTF3(_L("GetInstrumentIdL(bankId, EFalse, instrIndex) gave error %d (expected %d)"), err, expErr);
sl@0	2426	ret = EFail;
sl@0	2427	return ret;
sl@0	2428	}
sl@0	2429	INFO_PRINTF2(_L("GetInstrumentIdL(bankId, EFalse, instrIndex) = %d"), instrId);
sl@0	2430
sl@0	2431	if(iTestType != ETestInvalidId && iTestType != ETestInvalidIndex)
sl@0	2432	{
sl@0	2433	// load a known bank - custom
sl@0	2434	TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId));
sl@0	2435	if(err != KErrNone)
sl@0	2436	{
sl@0	2437	ERR_PRINTF2(_L("LoadCustomBankL left with error %d"), err);
sl@0	2438	ret = EInconclusive;
sl@0	2439	return ret;
sl@0	2440	}
sl@0	2441	// ensure it's loaded
sl@0	2442	TBool loaded = EFalse;
sl@0	2443	TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId));
sl@0	2444	if(err != KErrNone)
sl@0	2445	{
sl@0	2446	ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err);
sl@0	2447	ret = EInconclusive;
sl@0	2448	return ret;
sl@0	2449	}
sl@0	2450	if(!loaded)
sl@0	2451	{
sl@0	2452	ERR_PRINTF1(_L("CustomBankLoadedL returned false -> bank not loaded"));
sl@0	2453	ret = EInconclusive;
sl@0	2454	return ret;
sl@0	2455	}
sl@0	2456	}
sl@0	2457
sl@0	2458	// check the custom bank
sl@0	2459	// NB if test type is InvalidId/Index then we haven't bothered to load anything
sl@0	2460	TRAP(err, instrId = aMidi->GetInstrumentIdL(bankId, ETrue, instrIndex));
sl@0	2461	if(err != expErr)
sl@0	2462	{
sl@0	2463	ERR_PRINTF2(_L("GetInstrumentIdL(bankId, ETrue, instrIndex) gave error %d"), err);
sl@0	2464	ret = EFail;
sl@0	2465	return ret;
sl@0	2466	}
sl@0	2467	INFO_PRINTF2(_L("GetInstrumentIdL(bankId, ETrue, instrIndex) = %d"), instrId);
sl@0	2468
sl@0	2469	if(iTestType == ETestNegative)
sl@0	2470	{
sl@0	2471	// negative test :- unload all, then check it again
sl@0	2472	TRAP(err, aMidi->UnloadAllCustomBanksL());
sl@0	2473	if(err != KErrNone)
sl@0	2474	{
sl@0	2475	ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err);
sl@0	2476	ret = EInconclusive;
sl@0	2477	return ret;
sl@0	2478	}
sl@0	2479	// check it. it should leave
sl@0	2480	TRAP(err, instrId = aMidi->GetInstrumentIdL(bankId, ETrue, instrIndex));
sl@0	2481	if(err != expErr)
sl@0	2482	{
sl@0	2483	ERR_PRINTF3(_L("GetInstrumentIdL gave error %d (expected %d)"), err, expErr);
sl@0	2484	ret = EFail;
sl@0	2485	return ret;
sl@0	2486	}
sl@0	2487	}
sl@0	2488
sl@0	2489	return ret;
sl@0	2490	}
sl@0	2491
sl@0	2492	//Check this
sl@0	2493	//Change it to return EFail for failing negative test
sl@0	2494	//------------------------------------------------------------------
sl@0	2495	CTestReturnsInstrumentName::CTestReturnsInstrumentName(const TDesC& aTestName,
sl@0	2496	const TTestStepType aTestType)
sl@0	2497	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2498	{
sl@0	2499	}
sl@0	2500
sl@0	2501	CTestReturnsInstrumentName* CTestReturnsInstrumentName::NewL(const TDesC& aTestName,
sl@0	2502	const TTestStepType aTestType)
sl@0	2503	{
sl@0	2504	CTestReturnsInstrumentName* self = new (ELeave) CTestReturnsInstrumentName(aTestName,
sl@0	2505	aTestType);
sl@0	2506	return self;
sl@0	2507	}
sl@0	2508
sl@0	2509	TVerdict CTestReturnsInstrumentName::DoTestL(CMidiClientUtility* aMidi)
sl@0	2510	{
sl@0	2511	TVerdict ret = EPass;
sl@0	2512	TInt expErr;
sl@0	2513	//TFileName bankFileName;
sl@0	2514
sl@0	2515	TInt bankId = 0;
sl@0	2516	TInt instrId = 0;
sl@0	2517	HBufC* instrName = NULL;
sl@0	2518
sl@0	2519	// expected results
sl@0	2520	switch(iTestType)
sl@0	2521	{
sl@0	2522	case ETestValid:
sl@0	2523	expErr = KErrNone;
sl@0	2524	bankId = 0;
sl@0	2525	instrId = 89;
sl@0	2526	break;
sl@0	2527	case ETestNegative:
sl@0	2528	expErr = KErrArgument;
sl@0	2529	bankId = 0;
sl@0	2530	instrId = -241;
sl@0	2531	break;
sl@0	2532	default:
sl@0	2533	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2534	return EInconclusive;
sl@0	2535	}
sl@0	2536
sl@0	2537	// check a known bank - standard
sl@0	2538	// *** TO DO : custom?
sl@0	2539
sl@0	2540	TRAPD(err, instrName = aMidi->InstrumentNameL(bankId, EFalse, instrId));
sl@0	2541	INFO_PRINTF3(_L("InstrumentNameL(bankId, EFalse, instrId) gave error %d (expected %d)"), err, expErr);
sl@0	2542	if(err != expErr)
sl@0	2543	{
sl@0	2544	//ret = EInconclusive;
sl@0	2545	ret = EFail;
sl@0	2546	return ret;
sl@0	2547	}
sl@0	2548	// don't try and do this for negative test! it'll panic
sl@0	2549	if(iTestType == ETestValid)
sl@0	2550	INFO_PRINTF2(_L("InstrumentNameL(bankId, EFalse, instrId) = \'%S\'"), instrName);
sl@0	2551
sl@0	2552	delete instrName;
sl@0	2553	return ret;
sl@0	2554	}
sl@0	2555
sl@0	2556
sl@0	2557
sl@0	2558	//------------------------------------------------------------------
sl@0	2559	// Tests that the GetInstrumentL() doesn't return KErrArgument when the
sl@0	2560	// channel value is between 0 and 15, but it will return KErrArgument
sl@0	2561	// when the channel value is out of range
sl@0	2562
sl@0	2563	CTestGetInstrument::CTestGetInstrument(const TDesC& aTestName,
sl@0	2564	const TTestStepType aTestType)
sl@0	2565	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2566	{
sl@0	2567	}
sl@0	2568
sl@0	2569	CTestGetInstrument* CTestGetInstrument::NewL(const TDesC& aTestName,
sl@0	2570	const TTestStepType aTestType)
sl@0	2571	{
sl@0	2572	CTestGetInstrument* self = new (ELeave) CTestGetInstrument(aTestName,
sl@0	2573	aTestType);
sl@0	2574	return self;
sl@0	2575	}
sl@0	2576
sl@0	2577	TVerdict CTestGetInstrument::DoTestL(CMidiClientUtility* aMidi)
sl@0	2578	{
sl@0	2579	TVerdict ret = EPass;
sl@0	2580	TInt instrumentId = 0;
sl@0	2581	TInt bankId = 0;
sl@0	2582	TInt validChannelId = 0;
sl@0	2583	TInt invalidChannelId = 16;
sl@0	2584
sl@0	2585	TRAPD(err, aMidi->GetInstrumentL(validChannelId, instrumentId, bankId));
sl@0	2586
sl@0	2587	if(err == KErrArgument)
sl@0	2588	{
sl@0	2589	ERR_PRINTF2(_L("GetInstrumentL(validChannelId, ...) gave an error = %d"), err);
sl@0	2590	ret = EFail;
sl@0	2591	return ret;
sl@0	2592	}
sl@0	2593
sl@0	2594	TRAPD(err1, aMidi->GetInstrumentL(invalidChannelId, instrumentId, bankId));
sl@0	2595
sl@0	2596	if(err1 != KErrArgument)
sl@0	2597	{
sl@0	2598	ERR_PRINTF2(_L("GetInstrumentL(invalidChannelId, ...) gave an error = %d"), err);
sl@0	2599	ret = EFail;
sl@0	2600	return ret;
sl@0	2601	}
sl@0	2602
sl@0	2603	return ret;
sl@0	2604	}
sl@0	2605
sl@0	2606	//------------------------------------------------------------------
sl@0	2607
sl@0	2608	CTestSetInstrument::CTestSetInstrument(const TDesC& aTestName,
sl@0	2609	const TTestStepType aTestType)
sl@0	2610	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2611	{
sl@0	2612	}
sl@0	2613
sl@0	2614	CTestSetInstrument* CTestSetInstrument::NewL(const TDesC& aTestName,
sl@0	2615	const TTestStepType aTestType)
sl@0	2616	{
sl@0	2617	CTestSetInstrument* self = new (ELeave) CTestSetInstrument(aTestName,
sl@0	2618	aTestType);
sl@0	2619	return self;
sl@0	2620	}
sl@0	2621
sl@0	2622	TVerdict CTestSetInstrument::DoTestL(CMidiClientUtility* aMidi)
sl@0	2623	{
sl@0	2624	TVerdict ret = EPass;
sl@0	2625	TInt expErr;
sl@0	2626	//TFileName bankFileName;
sl@0	2627
sl@0	2628	TInt bankId = 0;
sl@0	2629	TInt channelId = 0;
sl@0	2630	TInt instrId = 0;
sl@0	2631
sl@0	2632	// expected results
sl@0	2633	switch(iTestType)
sl@0	2634	{
sl@0	2635	case ETestValid:
sl@0	2636	expErr = KErrNone;
sl@0	2637	bankId = 0;
sl@0	2638	channelId = 0;
sl@0	2639	instrId = 89;
sl@0	2640	break;
sl@0	2641	case ETestInvalidChannel:
sl@0	2642	expErr = KErrNotFound;
sl@0	2643	bankId = 0;
sl@0	2644	channelId = -2;
sl@0	2645	instrId = 89;
sl@0	2646	break;
sl@0	2647	case ETestInvalidId:
sl@0	2648	expErr = KErrNotFound;
sl@0	2649	bankId = 0;
sl@0	2650	channelId = 0;
sl@0	2651	instrId = -241;
sl@0	2652	break;
sl@0	2653	default:
sl@0	2654	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2655	return EInconclusive;
sl@0	2656	}
sl@0	2657
sl@0	2658	// *** TO DO : custom?
sl@0	2659
sl@0	2660	TRAPD(err, aMidi->SetInstrumentL(channelId, bankId, instrId));
sl@0	2661	INFO_PRINTF3(_L("SetInstrumentL(channelId, bankId, instrId) gave error %d (expected %d)"), err, expErr);
sl@0	2662	if(err != expErr)
sl@0	2663	{
sl@0	2664	ret = EFail;
sl@0	2665	return ret;
sl@0	2666	}
sl@0	2667
sl@0	2668	return ret;
sl@0	2669	}
sl@0	2670
sl@0	2671	//------------------------------------------------------------------
sl@0	2672
sl@0	2673
sl@0	2674	CTestLoadCustomInstrument::CTestLoadCustomInstrument(const TDesC& aTestName,
sl@0	2675	const TTestStepType aTestType)
sl@0	2676	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2677	{
sl@0	2678	}
sl@0	2679
sl@0	2680	CTestLoadCustomInstrument* CTestLoadCustomInstrument::NewL(const TDesC& aTestName,
sl@0	2681	const TTestStepType aTestType)
sl@0	2682	{
sl@0	2683	CTestLoadCustomInstrument* self = new (ELeave) CTestLoadCustomInstrument(aTestName,
sl@0	2684	aTestType);
sl@0	2685	return self;
sl@0	2686	}
sl@0	2687
sl@0	2688	TVerdict CTestLoadCustomInstrument::DoTestL(CMidiClientUtility* aMidi)
sl@0	2689	{
sl@0	2690	// TO DO : need instrument file which we can load, with known bank and instrument IDs
sl@0	2691	// Negative tests to be done properly.
sl@0	2692
sl@0	2693	TVerdict ret = EPass;
sl@0	2694	TInt expErr;
sl@0	2695
sl@0	2696	_LIT(KInstrumentFile, "Instrument File Name"); // *** to change
sl@0	2697	_LIT(KBadInstrumentFile, "Bad Instrument File Name"); // *** to change
sl@0	2698	TFileName instFileName;
sl@0	2699
sl@0	2700	TInt fileBankId = 90;
sl@0	2701	TInt fileInstrId = 91;
sl@0	2702	TInt bankId = 92;
sl@0	2703	TInt instrId = 93;
sl@0	2704
sl@0	2705	// expected results
sl@0	2706	switch(iTestType)
sl@0	2707	{
sl@0	2708	case ETestValid:
sl@0	2709	expErr = KErrNone;
sl@0	2710	instFileName.Copy(KInstrumentFile);
sl@0	2711	break;
sl@0	2712	case ETestInvalidId:
sl@0	2713	expErr = KErrArgument;
sl@0	2714	instFileName.Copy(KInstrumentFile);
sl@0	2715	fileBankId = -2;
sl@0	2716	break;
sl@0	2717	case ETestAlreadyLoaded:
sl@0	2718	// ** to do : load once and attempt to load again.
sl@0	2719	// when instrument data files are available, this will work
sl@0	2720	instFileName.Copy(KInstrumentFile);
sl@0	2721	expErr = KErrInUse;
sl@0	2722	break;
sl@0	2723	case ETestUnsupported: // ** to define test data for this
sl@0	2724	instFileName.Copy(KBadInstrumentFile);
sl@0	2725	expErr = KErrNotSupported;
sl@0	2726	break;
sl@0	2727	default:
sl@0	2728	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2729	return EInconclusive;
sl@0	2730	}
sl@0	2731
sl@0	2732	// if testing already loaded, preload the instrument here
sl@0	2733	if(iTestType == ETestAlreadyLoaded)
sl@0	2734	{
sl@0	2735	TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId));
sl@0	2736	INFO_PRINTF2(_L("Preload : LoadCustomInstrumentL gave error %d"), err);
sl@0	2737	if(err != KErrNone)
sl@0	2738	{
sl@0	2739	ret = EInconclusive;
sl@0	2740	return ret;
sl@0	2741	}
sl@0	2742	}
sl@0	2743
sl@0	2744	// load the instrument for real
sl@0	2745	TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId));
sl@0	2746	INFO_PRINTF3(_L("LoadCustomInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	2747	if(err != expErr)
sl@0	2748	{
sl@0	2749	ret = EFail;
sl@0	2750	return ret;
sl@0	2751	}
sl@0	2752
sl@0	2753	return ret;
sl@0	2754	}
sl@0	2755
sl@0	2756
sl@0	2757	//------------------------------------------------------------------
sl@0	2758
sl@0	2759	CTestUnloadCustomInstrument::CTestUnloadCustomInstrument(const TDesC& aTestName,
sl@0	2760	const TTestStepType aTestType)
sl@0	2761	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2762	{
sl@0	2763	}
sl@0	2764
sl@0	2765	CTestUnloadCustomInstrument* CTestUnloadCustomInstrument::NewL(const TDesC& aTestName,
sl@0	2766	const TTestStepType aTestType)
sl@0	2767	{
sl@0	2768	CTestUnloadCustomInstrument* self = new (ELeave) CTestUnloadCustomInstrument(aTestName,
sl@0	2769	aTestType);
sl@0	2770	return self;
sl@0	2771	}
sl@0	2772
sl@0	2773	TVerdict CTestUnloadCustomInstrument::DoTestL(CMidiClientUtility* aMidi)
sl@0	2774	{
sl@0	2775	TVerdict ret = EPass;
sl@0	2776	TInt expErr;
sl@0	2777
sl@0	2778	_LIT(KInstrumentFile, "Instrument File Name"); // *** to change
sl@0	2779	TFileName instFileName;
sl@0	2780
sl@0	2781	TInt fileBankId = 90;
sl@0	2782	TInt fileInstrId = 91;
sl@0	2783	TInt bankId = 92;
sl@0	2784	TInt instrId = 93;
sl@0	2785
sl@0	2786	// expected results
sl@0	2787	switch(iTestType)
sl@0	2788	{
sl@0	2789	case ETestValid:
sl@0	2790	expErr = KErrNone;
sl@0	2791	instFileName.Copy(KInstrumentFile);
sl@0	2792	break;
sl@0	2793	case ETestInvalidId:
sl@0	2794	expErr = KErrNotFound;
sl@0	2795	instFileName.Copy(KInstrumentFile);
sl@0	2796	bankId = -2;
sl@0	2797	break;
sl@0	2798	case ETestNotLoaded:
sl@0	2799	expErr = KErrNotFound;
sl@0	2800	instFileName.Copy(KInstrumentFile);
sl@0	2801	break;
sl@0	2802	case ETestNotUnloadable: // ** TO DO : define test data for this
sl@0	2803	expErr = KErrNotSupported;
sl@0	2804	break;
sl@0	2805	default:
sl@0	2806	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2807	return EInconclusive;
sl@0	2808	}
sl@0	2809
sl@0	2810	// preload the instrument here
sl@0	2811	if(iTestType == ETestValid)
sl@0	2812	{
sl@0	2813	TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId));
sl@0	2814	INFO_PRINTF2(_L("Preload : LoadCustomInstrumentL gave error %d"), err);
sl@0	2815	if(err != KErrNone)
sl@0	2816	{
sl@0	2817	ret = EInconclusive;
sl@0	2818	return ret;
sl@0	2819	}
sl@0	2820	}
sl@0	2821
sl@0	2822	// now unload it
sl@0	2823	TRAPD(err, aMidi->UnloadCustomInstrumentL(bankId, instrId));
sl@0	2824	INFO_PRINTF3(_L("UnloadCustomInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	2825	if(err != expErr)
sl@0	2826	{
sl@0	2827	ret = EFail;
sl@0	2828	return ret;
sl@0	2829	}
sl@0	2830
sl@0	2831	return ret;
sl@0	2832	}
sl@0	2833
sl@0	2834	//------------------------------------------------------------------
sl@0	2835
sl@0	2836
sl@0	2837	CTestPercussionKeyName::CTestPercussionKeyName(const TDesC& aTestName,
sl@0	2838	const TTestStepType aTestType)
sl@0	2839	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2840	{
sl@0	2841	}
sl@0	2842
sl@0	2843	CTestPercussionKeyName* CTestPercussionKeyName::NewL(const TDesC& aTestName,
sl@0	2844	const TTestStepType aTestType)
sl@0	2845	{
sl@0	2846	CTestPercussionKeyName* self = new (ELeave) CTestPercussionKeyName(aTestName,
sl@0	2847	aTestType);
sl@0	2848	return self;
sl@0	2849	}
sl@0	2850
sl@0	2851	TVerdict CTestPercussionKeyName::DoTestL(CMidiClientUtility* aMidi)
sl@0	2852	{
sl@0	2853	// *** NB the actual arguments do not match those in the current API or test specs
sl@0	2854	TVerdict ret = EPass;
sl@0	2855	TInt expErr;
sl@0	2856	//TFileName bankFileName;
sl@0	2857
sl@0	2858	TInt bankId = 0;
sl@0	2859	TInt instrId = 89;
sl@0	2860	TInt keyId = 0;
sl@0	2861	HBufC* keyName = NULL;
sl@0	2862
sl@0	2863	// expected results
sl@0	2864	switch(iTestType)
sl@0	2865	{
sl@0	2866	case ETestValid:
sl@0	2867	expErr = KErrNone;
sl@0	2868	break;
sl@0	2869	case ETestInvalidId:
sl@0	2870	expErr = KErrNotFound;
sl@0	2871	keyId = -2;
sl@0	2872	break;
sl@0	2873	default:
sl@0	2874	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2875	return EInconclusive;
sl@0	2876	}
sl@0	2877
sl@0	2878	// check a known bank - standard
sl@0	2879	// *** TO DO : custom?
sl@0	2880
sl@0	2881	TRAPD(err, keyName = aMidi->PercussionKeyNameL(keyId, bankId, EFalse, instrId));
sl@0	2882	INFO_PRINTF3(_L("PercussionKeyNameL gave error %d (expected %d)"), err, expErr);
sl@0	2883	if(err != expErr)
sl@0	2884	{
sl@0	2885	ret = EFail;
sl@0	2886	return ret;
sl@0	2887	}
sl@0	2888	// don't try and do this for negative test! it'll panic
sl@0	2889	if(iTestType == ETestValid)
sl@0	2890	INFO_PRINTF2(_L("PercussionKeyNameL(keyId, bankId, EFalse, instrId) = \'%S\'"), keyName);
sl@0	2891
sl@0	2892	delete keyName;
sl@0	2893	return ret;
sl@0	2894	}
sl@0	2895
sl@0	2896	//Check this//
sl@0	2897	//Not sure how to implement 'no opened resource'
sl@0	2898	//------------------------------------------------------------------
sl@0	2899	CTestStopTime::CTestStopTime(const TDesC& aTestName,
sl@0	2900	const TTestStepType aTestType)
sl@0	2901	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2902	{
sl@0	2903	}
sl@0	2904
sl@0	2905	CTestStopTime* CTestStopTime::NewL(const TDesC& aTestName,
sl@0	2906	const TTestStepType aTestType)
sl@0	2907	{
sl@0	2908	CTestStopTime* self = new (ELeave) CTestStopTime(aTestName,
sl@0	2909	aTestType);
sl@0	2910	return self;
sl@0	2911	}
sl@0	2912
sl@0	2913	TVerdict CTestStopTime::DoTestL(CMidiClientUtility* aMidi)
sl@0	2914	{
sl@0	2915	TVerdict ret = EPass;
sl@0	2916	TInt expErr;
sl@0	2917	TTimeIntervalMicroSeconds stopTime(0);
sl@0	2918
sl@0	2919	// expected results
sl@0	2920	switch(iTestType)
sl@0	2921	{
sl@0	2922	case ETestValid:
sl@0	2923	expErr = KErrNone;
sl@0	2924	break;
sl@0	2925
sl@0	2926	// NB no negative test specified
sl@0	2927	//Not sure how to implement 'no opened resource'
sl@0	2928	case ETestNoResource:
sl@0	2929	expErr = KErrNotReady;
sl@0	2930	break;
sl@0	2931
sl@0	2932	default:
sl@0	2933	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2934	return EInconclusive;
sl@0	2935	}
sl@0	2936
sl@0	2937	TRAPD(err, aMidi->StopTimeL(stopTime));
sl@0	2938	INFO_PRINTF3(_L("StopTimeL gave error %d (expected %d)"), err, expErr);
sl@0	2939	if(err != expErr)
sl@0	2940	{
sl@0	2941	ret = EFail;
sl@0	2942	return ret;
sl@0	2943	}
sl@0	2944	INFO_PRINTF2(_L("StopTime = %ld"), I64INT(stopTime.Int64()));
sl@0	2945	return ret;
sl@0	2946	}
sl@0	2947
sl@0	2948
sl@0	2949	//------------------------------------------------------------------
sl@0	2950
sl@0	2951
sl@0	2952	CTestSetStopTime::CTestSetStopTime(const TDesC& aTestName,
sl@0	2953	const TTestStepType aTestType)
sl@0	2954	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	2955	{
sl@0	2956	}
sl@0	2957
sl@0	2958	CTestSetStopTime* CTestSetStopTime::NewL(const TDesC& aTestName,
sl@0	2959	const TTestStepType aTestType)
sl@0	2960	{
sl@0	2961	CTestSetStopTime* self = new (ELeave) CTestSetStopTime(aTestName,
sl@0	2962	aTestType);
sl@0	2963	return self;
sl@0	2964	}
sl@0	2965
sl@0	2966	TVerdict CTestSetStopTime::DoTestL(CMidiClientUtility* aMidi)
sl@0	2967	{
sl@0	2968	TVerdict ret = EPass;
sl@0	2969	TInt expErr;
sl@0	2970	TTimeIntervalMicroSeconds stopTime(999);
sl@0	2971
sl@0	2972	// expected results
sl@0	2973	switch(iTestType)
sl@0	2974	{
sl@0	2975	case ETestValid:
sl@0	2976	expErr = KErrNone;
sl@0	2977	break;
sl@0	2978	case ETestOutOfRangeHigh:
sl@0	2979	stopTime = 999999999;
sl@0	2980	expErr = KErrArgument;
sl@0	2981	break;
sl@0	2982	case ETestOutOfRangeLow:
sl@0	2983	stopTime = -1;
sl@0	2984	expErr = KErrArgument;
sl@0	2985	break;
sl@0	2986	default:
sl@0	2987	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	2988	return EInconclusive;
sl@0	2989	}
sl@0	2990
sl@0	2991	TRAPD(err, aMidi->SetStopTimeL(stopTime));
sl@0	2992	INFO_PRINTF3(_L("SetStopTimeL gave error %d (expected %d)"), err, expErr);
sl@0	2993	if(err != expErr)
sl@0	2994	{
sl@0	2995	ret = EFail;
sl@0	2996	return ret;
sl@0	2997	}
sl@0	2998
sl@0	2999	// check set correctly if a valid test
sl@0	3000	if (iTestType == ETestValid)
sl@0	3001	{
sl@0	3002	TTimeIntervalMicroSeconds newStopTime(999);
sl@0	3003	TRAP(err, aMidi->StopTimeL(newStopTime));
sl@0	3004	INFO_PRINTF3(_L("StopTimeL gave error %d (expected %d)"), err, expErr);
sl@0	3005
sl@0	3006	if(err != expErr)
sl@0	3007	{
sl@0	3008	ret = EInconclusive;
sl@0	3009	return ret;
sl@0	3010	}
sl@0	3011	INFO_PRINTF2(_L("StopTime = %ld"), I64INT(newStopTime.Int64()));
sl@0	3012
sl@0	3013	if(newStopTime != stopTime)
sl@0	3014	{
sl@0	3015	ERR_PRINTF2(_L("Error : expected %ld"), I64INT(stopTime.Int64()));
sl@0	3016	ret = EFail;
sl@0	3017	return ret;
sl@0	3018	}
sl@0	3019	}
sl@0	3020
sl@0	3021	return ret;
sl@0	3022	}
sl@0	3023
sl@0	3024	//------------------------------------------------------------------
sl@0	3025
sl@0	3026
sl@0	3027	CTestSetRepeats::CTestSetRepeats(const TDesC& aTestName,
sl@0	3028	const TTestStepType aTestType)
sl@0	3029	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3030	{
sl@0	3031	}
sl@0	3032
sl@0	3033	CTestSetRepeats* CTestSetRepeats::NewL(const TDesC& aTestName,
sl@0	3034	const TTestStepType aTestType)
sl@0	3035	{
sl@0	3036	CTestSetRepeats* self = new (ELeave) CTestSetRepeats(aTestName,
sl@0	3037	aTestType);
sl@0	3038	return self;
sl@0	3039	}
sl@0	3040
sl@0	3041	TVerdict CTestSetRepeats::DoTestL(CMidiClientUtility* aMidi)
sl@0	3042	{
sl@0	3043	TVerdict ret = EPass;
sl@0	3044	TInt expErr;
sl@0	3045	TInt repeats = 0;
sl@0	3046	TTimeIntervalMicroSeconds silentTime(1000000);
sl@0	3047
sl@0	3048	// expected results
sl@0	3049	switch(iTestType)
sl@0	3050	{
sl@0	3051	case ETestValid:
sl@0	3052	expErr = KErrNone;
sl@0	3053	break;
sl@0	3054	// ** NB these are testing ONE out-of-range argument at a time. Suggest
sl@0	3055	// we modify the test spec to go with this?
sl@0	3056	case ETestOutOfRange:
sl@0	3057	expErr = KErrArgument;
sl@0	3058	//repeats = 9999; // ** XXX : max. range of repeats?
sl@0	3059	repeats = -1;
sl@0	3060	silentTime = 1000000;
sl@0	3061	break;
sl@0	3062	default:
sl@0	3063	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3064	return EInconclusive;
sl@0	3065	}
sl@0	3066
sl@0	3067	TRAPD(err, aMidi->SetRepeatsL(repeats, silentTime));
sl@0	3068
sl@0	3069	// check set correctly if a valid test
sl@0	3070	if (iTestType == ETestValid)
sl@0	3071	{
sl@0	3072	// check the repeats value
sl@0	3073	TInt currRepeats = -1;
sl@0	3074	currRepeats = aMidi->GetRepeats();
sl@0	3075
sl@0	3076	INFO_PRINTF2(_L("Repeats = %d"), currRepeats);
sl@0	3077
sl@0	3078	if(currRepeats != repeats)
sl@0	3079	{
sl@0	3080	ERR_PRINTF2(_L("Error : expected %d"), currRepeats);
sl@0	3081	ret = EFail;
sl@0	3082	return ret;
sl@0	3083	}
sl@0	3084	}
sl@0	3085
sl@0	3086	INFO_PRINTF3(_L("SetRepeatsL gave error %d (expected %d)"), err, expErr);
sl@0	3087	if(err != expErr)
sl@0	3088	{
sl@0	3089	ret = EFail;
sl@0	3090	return ret;
sl@0	3091	}
sl@0	3092
sl@0	3093	return ret;
sl@0	3094	}
sl@0	3095
sl@0	3096	//------------------------------------------------------------------
sl@0	3097	// This test case has two steps:
sl@0	3098	// 1. High Polyphony Song vs. Low Polyphony Midi Utility
sl@0	3099	// - a test file has exactly 57 voices from beginning to end
sl@0	3100	// - during the instantiation of utility, the Maximum Polyphony is default to 48 implicitly.
sl@0	3101	// For this case:
sl@0	3102	// MaxPolyphonyL() return value is 48
sl@0	3103	// PolyphonyL() return value is 48 (number of active voice the engine is playing now,
sl@0	3104	// this is being limited by the MaxPolyphonyL() number)
sl@0	3105	//
sl@0	3106	//
sl@0	3107	// 2. Low Polyphony Song vs. High Polyphony Midi Utility
sl@0	3108	// - a test file has exactly 57 voices from beginning to end
sl@0	3109	// - during the instantiation of utility, the Maximum Polyphony is default to 60 implicitly
sl@0	3110	// For this case:
sl@0	3111	// MaxPolyphonyL() return value is 60
sl@0	3112	// PolyphonyL() return value is 57
sl@0	3113
sl@0	3114	// constants for the test case
sl@0	3115	const TUint8 KMaxPolyphonyValue1 = 48;
sl@0	3116	const TUint8 KMaxPolyphonyValue2 = 60;
sl@0	3117	const TUint8 KPolyphonyValue = 57;
sl@0	3118
sl@0	3119	CTestPolyphony::CTestPolyphony(const TDesC& aTestName,
sl@0	3120	const TTestStepType aTestType)
sl@0	3121	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3122	{
sl@0	3123	}
sl@0	3124
sl@0	3125	CTestPolyphony* CTestPolyphony::NewL(const TDesC& aTestName,
sl@0	3126	const TTestStepType aTestType)
sl@0	3127	{
sl@0	3128	CTestPolyphony* self = new (ELeave) CTestPolyphony(aTestName,
sl@0	3129	aTestType);
sl@0	3130	return self;
sl@0	3131	}
sl@0	3132
sl@0	3133	TVerdict CTestPolyphony::DoTestL(CMidiClientUtility* aMidi)
sl@0	3134	{
sl@0	3135	TVerdict ret = EPass;
sl@0	3136	TInt poly = 0;
sl@0	3137	TInt maxPoly = 0;
sl@0	3138	TInt expErr = 0;
sl@0	3139
sl@0	3140	// expected results
sl@0	3141	switch(iTestType)
sl@0	3142	{
sl@0	3143	case ETestValid:
sl@0	3144	expErr = KErrNone;
sl@0	3145	break;
sl@0	3146	// NB no negative test specified
sl@0	3147	default:
sl@0	3148	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3149	return EInconclusive;
sl@0	3150	}
sl@0	3151
sl@0	3152	// set the maxPolyphony to KMaxPolyphponyValue1
sl@0	3153	TRAPD(err, aMidi->SetMaxPolyphonyL(KMaxPolyphonyValue1));
sl@0	3154	if (err != expErr)
sl@0	3155	{
sl@0	3156	INFO_PRINTF2(_L("SetMaxPolyphonyL failed (error = %d)"), err);
sl@0	3157	ret = EFail;
sl@0	3158	return ret;
sl@0	3159	}
sl@0	3160
sl@0	3161	// verify that the maxPolyphony value was correctly set
sl@0	3162	TRAPD(err1, maxPoly = aMidi->MaxPolyphonyL());
sl@0	3163	if (err1 != expErr)
sl@0	3164	{
sl@0	3165	INFO_PRINTF2(_L("MaxPolyphonyL failed (error = %d)"), err);
sl@0	3166	ret = EFail;
sl@0	3167	return ret;
sl@0	3168	}
sl@0	3169	INFO_PRINTF3(_L("The maximum number of simultaneous voices the engine can handle : %d (expected %d)"), maxPoly, KMaxPolyphonyValue1);
sl@0	3170
sl@0	3171	// get the number of the currently active voices. This value is set as
sl@0	3172	// KPolyphonyValue, but because the max number of voices that can be handled by the
sl@0	3173	// engine is smaller than the currently active voce, PolyphonyL() will
sl@0	3174	// return the MaxPolyphony() value
sl@0	3175	TRAPD(err2, poly = aMidi->PolyphonyL());
sl@0	3176
sl@0	3177	if (err2 != expErr)
sl@0	3178	{
sl@0	3179	INFO_PRINTF2(_L("PolyphonyL failed (error = %d)"), err);
sl@0	3180	ret = EFail;
sl@0	3181	return ret;
sl@0	3182	}
sl@0	3183
sl@0	3184	INFO_PRINTF3(_L("The number of currently active voices is: %d (expected %d)"), poly, KMaxPolyphonyValue1);
sl@0	3185	INFO_PRINTF1(_L("----------------------------------------------------------"));
sl@0	3186
sl@0	3187	// set the maxPolyphony to KMaxPolyphonyValue2
sl@0	3188	TRAPD(err3, aMidi->SetMaxPolyphonyL(KMaxPolyphonyValue2));
sl@0	3189	if (err3 != expErr)
sl@0	3190	{
sl@0	3191	INFO_PRINTF2(_L("SetMaxPolyphonyL failed (error = %d)"), err);
sl@0	3192	ret = EFail;
sl@0	3193	return ret;
sl@0	3194	}
sl@0	3195
sl@0	3196	// verify that the maxPolyphony value was correctly set
sl@0	3197	TRAPD(err4, maxPoly = aMidi->MaxPolyphonyL());
sl@0	3198	if (err4 != expErr)
sl@0	3199	{
sl@0	3200	INFO_PRINTF2(_L("MaxPolyphonyL failed (error = %d)"), err);
sl@0	3201	ret = EFail;
sl@0	3202	return ret;
sl@0	3203	}
sl@0	3204	INFO_PRINTF3(_L("The maximum number of simultaneous voices the engine can handle : %d (expected %d)"), maxPoly, KMaxPolyphonyValue2);
sl@0	3205
sl@0	3206	// get the number of the currently active voices. This value is set as
sl@0	3207	// KPolyphonyValue, but because the max number of voices that can be handled by the
sl@0	3208	// engine is smaller than the currently active voce, PolyphonyL() will
sl@0	3209	// return the MaxPolyphony() value
sl@0	3210	TRAPD(err5, poly = aMidi->PolyphonyL());
sl@0	3211	if (err5 != expErr)
sl@0	3212	{
sl@0	3213	INFO_PRINTF2(_L("PolyphonyL failed (error = %d)"), err);
sl@0	3214	ret = EFail;
sl@0	3215	return ret;
sl@0	3216	}
sl@0	3217	INFO_PRINTF3(_L("The number of currently active voices is: %d (expected %d)"), poly, KPolyphonyValue);
sl@0	3218
sl@0	3219	return ret;
sl@0	3220	}
sl@0	3221
sl@0	3222	//Check this (0086) //
sl@0	3223	//Not sure how to implement 'no opened resource'
sl@0	3224	//------------------------------------------------------------------
sl@0	3225
sl@0	3226
sl@0	3227	CTestChannelsSupported::CTestChannelsSupported(const TDesC& aTestName,
sl@0	3228	const TTestStepType aTestType)
sl@0	3229	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3230	{
sl@0	3231	}
sl@0	3232
sl@0	3233	CTestChannelsSupported* CTestChannelsSupported::NewL(const TDesC& aTestName,
sl@0	3234	const TTestStepType aTestType)
sl@0	3235	{
sl@0	3236	CTestChannelsSupported* self = new (ELeave) CTestChannelsSupported(aTestName,
sl@0	3237	aTestType);
sl@0	3238	return self;
sl@0	3239	}
sl@0	3240
sl@0	3241	TVerdict CTestChannelsSupported::DoTestL(CMidiClientUtility* aMidi)
sl@0	3242	{
sl@0	3243	TVerdict ret = EPass;
sl@0	3244	TInt expErr;
sl@0	3245	TInt numChannels = 0;
sl@0	3246
sl@0	3247	// expected results
sl@0	3248	switch(iTestType)
sl@0	3249	{
sl@0	3250	case ETestValid:
sl@0	3251	expErr = KErrNone;
sl@0	3252	break;
sl@0	3253
sl@0	3254	// NB no negative test specified
sl@0	3255
sl@0	3256	//Not sure how to implement 'no opened resource'
sl@0	3257	case ETestNoResource:
sl@0	3258	expErr = KErrNotReady;
sl@0	3259	break;
sl@0	3260
sl@0	3261	default:
sl@0	3262	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3263	return EInconclusive;
sl@0	3264	}
sl@0	3265
sl@0	3266	TRAPD(err, numChannels = aMidi->ChannelsSupportedL());
sl@0	3267	INFO_PRINTF3(_L("ChannelsSupportedL gave error %d (expected %d)"), err, expErr);
sl@0	3268	if(err != expErr)
sl@0	3269	{
sl@0	3270	ret = EFail;
sl@0	3271	return ret;
sl@0	3272	}
sl@0	3273	INFO_PRINTF2(_L("Channels supported = %d"), numChannels);
sl@0	3274	return ret;
sl@0	3275	}
sl@0	3276
sl@0	3277	//------------------------------------------------------------------
sl@0	3278	// Checks the ChannelVolumeL(...) method behaivior
sl@0	3279	// - if the argument passed in is a valid channel, the test should
sl@0	3280	// not return any error code, but should return the expected volume
sl@0	3281	// value
sl@0	3282	// - if the argument passed in is an invalid channel, the test should
sl@0	3283	// return KErrArgument
sl@0	3284
sl@0	3285	CTestReturnChannelVolume::CTestReturnChannelVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3286	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3287	{
sl@0	3288	}
sl@0	3289
sl@0	3290	CTestReturnChannelVolume* CTestReturnChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3291	{
sl@0	3292	CTestReturnChannelVolume* self = new(ELeave) CTestReturnChannelVolume(aTestName, aTestType);
sl@0	3293	return self;
sl@0	3294	}
sl@0	3295
sl@0	3296	TVerdict CTestReturnChannelVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3297	{
sl@0	3298	TInt channel = 2;
sl@0	3299	TInt volume = 0;
sl@0	3300
sl@0	3301	INFO_PRINTF1(_L("CMidiClientUtility: Return channel volume"));
sl@0	3302
sl@0	3303	// positive test
sl@0	3304	if (iTestType == ETestValid)
sl@0	3305	{
sl@0	3306	// if the test is valid check that the value returned for the
sl@0	3307	// volume is correct
sl@0	3308	TInt chanVolume = aMidi->MaxChannelVolumeL() - 10;
sl@0	3309	TRAPD(err1, aMidi->SetChannelVolumeL(channel, chanVolume));
sl@0	3310	if (err1 != KErrNone)
sl@0	3311	{
sl@0	3312	ERR_PRINTF2(_L("SetChannelVolumeL gave error %d"),err1);
sl@0	3313	return EFail;
sl@0	3314	}
sl@0	3315
sl@0	3316	TRAPD(err, volume = aMidi->ChannelVolumeL(channel));
sl@0	3317	if (err != KErrNone)
sl@0	3318	{
sl@0	3319	ERR_PRINTF2(_L("ChannelVolumeL gave error %d (expected KErrNone)"),err);
sl@0	3320	return EFail;
sl@0	3321	}
sl@0	3322
sl@0	3323	if (volume != chanVolume)
sl@0	3324	{
sl@0	3325	ERR_PRINTF3(_L("ChannelVolumeL retrieve volume value %d (expected %d)"),volume, chanVolume);
sl@0	3326	return EFail;
sl@0	3327	}
sl@0	3328	return EPass;
sl@0	3329	}
sl@0	3330
sl@0	3331	// negative test
sl@0	3332	if (iTestType == ETestInvalidChannel)
sl@0	3333	{
sl@0	3334	channel = -1;
sl@0	3335	TRAPD(err, aMidi->ChannelVolumeL(channel));
sl@0	3336	if (err != KErrArgument)
sl@0	3337	{
sl@0	3338	ERR_PRINTF2(_L("ChannelVolumeL gave error %d (expected KErrArgument)"),err);
sl@0	3339	return EFail;
sl@0	3340	}
sl@0	3341	return EPass;
sl@0	3342	}
sl@0	3343
sl@0	3344	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3345	return EInconclusive;
sl@0	3346	}
sl@0	3347
sl@0	3348
sl@0	3349	//Check This//
sl@0	3350	//------------------------------------------------------------------
sl@0	3351	CTestMaxChannelVolume::CTestMaxChannelVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3352	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3353	{
sl@0	3354	}
sl@0	3355
sl@0	3356	CTestMaxChannelVolume* CTestMaxChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3357	{
sl@0	3358	CTestMaxChannelVolume* self = new(ELeave) CTestMaxChannelVolume(aTestName, aTestType);
sl@0	3359	return self;
sl@0	3360	}
sl@0	3361
sl@0	3362	TVerdict CTestMaxChannelVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3363	{
sl@0	3364	TVerdict ret = EPass;
sl@0	3365	TInt expErr = KErrNone;
sl@0	3366
sl@0	3367	INFO_PRINTF1(_L("CMidiClientUtility: Return Maximum channel volume"));
sl@0	3368	// expected results
sl@0	3369	switch(iTestType)
sl@0	3370	{
sl@0	3371	case ETestValid:
sl@0	3372	expErr = KErrNone;
sl@0	3373	break;
sl@0	3374
sl@0	3375	default:
sl@0	3376	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3377	return EInconclusive;
sl@0	3378	}
sl@0	3379	// TReal32 volume = 0;
sl@0	3380	// TRAPD(err, volume = aMidi->MaxChannelVolumeL() );
sl@0	3381	TRAPD(err, aMidi->MaxChannelVolumeL() ); // EABI warning removal
sl@0	3382
sl@0	3383	if (expErr != err)
sl@0	3384	{
sl@0	3385	ERR_PRINTF3(_L("MaxChannelVolumeL gave error %d (expected %d)"),err, expErr);
sl@0	3386	ret = EFail;
sl@0	3387	}
sl@0	3388	else
sl@0	3389	INFO_PRINTF3(_L("MaxChannelVolumeL %d = %d "),err ,expErr);
sl@0	3390
sl@0	3391	return ret;
sl@0	3392	}
sl@0	3393
sl@0	3394	//------------------------------------------------------------------
sl@0	3395
sl@0	3396	CTestSetChannelVolume::CTestSetChannelVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3397	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3398	{
sl@0	3399	}
sl@0	3400
sl@0	3401	CTestSetChannelVolume* CTestSetChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3402	{
sl@0	3403	CTestSetChannelVolume* self = new(ELeave) CTestSetChannelVolume(aTestName, aTestType);
sl@0	3404	return self;
sl@0	3405	}
sl@0	3406
sl@0	3407	TVerdict CTestSetChannelVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3408	{
sl@0	3409	TVerdict ret = EPass;
sl@0	3410	TInt expErr = KErrNone;
sl@0	3411	TInt channel = 0;
sl@0	3412	TReal32 volume = 0;
sl@0	3413
sl@0	3414	INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume"));
sl@0	3415	// expected results
sl@0	3416	switch(iTestType)
sl@0	3417	{
sl@0	3418	case ETestValid:
sl@0	3419	expErr = KErrNone;
sl@0	3420	break;
sl@0	3421	case ETestInvalidChannelOutOfRange:
sl@0	3422	expErr = KErrArgument;
sl@0	3423	channel = 16;
sl@0	3424	volume = 10;
sl@0	3425	break;
sl@0	3426	case ETestVolumeHighOutOfRange:
sl@0	3427	expErr = KErrArgument;
sl@0	3428	channel = 0;
sl@0	3429	volume = aMidi->MaxChannelVolumeL()+1;
sl@0	3430	break;
sl@0	3431	case ETestVolumeLowOutOfRange:
sl@0	3432	expErr = KErrNone; //real controller may return KErrArgument if out of range
sl@0	3433	channel = 0;
sl@0	3434	volume = -1;
sl@0	3435	break;
sl@0	3436	default:
sl@0	3437	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3438	return EInconclusive;
sl@0	3439	}
sl@0	3440
sl@0	3441	TRAPD(err, aMidi->SetChannelVolumeL(channel, volume));
sl@0	3442	if (expErr != err)
sl@0	3443	{
sl@0	3444	ERR_PRINTF3(_L("SetChannelVolumeL gave error %d (expected %d)"),err, expErr);
sl@0	3445	ret = EFail;
sl@0	3446	}
sl@0	3447	else
sl@0	3448	INFO_PRINTF3(_L("SetChannelVolumeL %d = %d"),err ,expErr);
sl@0	3449
sl@0	3450	return ret;
sl@0	3451	}
sl@0	3452
sl@0	3453	//Check this
sl@0	3454	//------------------------------------------------------------------
sl@0	3455	CTestSetChannelMute::CTestSetChannelMute(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3456	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3457	{
sl@0	3458	}
sl@0	3459
sl@0	3460	CTestSetChannelMute* CTestSetChannelMute::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3461	{
sl@0	3462	CTestSetChannelMute* self = new(ELeave) CTestSetChannelMute(aTestName, aTestType);
sl@0	3463	return self;
sl@0	3464	}
sl@0	3465
sl@0	3466	TVerdict CTestSetChannelMute::DoTestL(CMidiClientUtility* aMidi)
sl@0	3467	{
sl@0	3468	TVerdict ret = EPass;
sl@0	3469	TInt expErr = KErrNone;
sl@0	3470	TInt channel = 0;
sl@0	3471	TBool muted = ETrue;
sl@0	3472
sl@0	3473	INFO_PRINTF1(_L("CMidiClientUtility: Set channel mute"));
sl@0	3474	// expected results
sl@0	3475	switch(iTestType)
sl@0	3476	{
sl@0	3477	case ETestValid:
sl@0	3478	expErr = KErrNone;
sl@0	3479	break;
sl@0	3480	case ETestInvalidChannelOutOfRange:
sl@0	3481	expErr = KErrArgument;
sl@0	3482	channel = 16;
sl@0	3483	break;
sl@0	3484
sl@0	3485	default:
sl@0	3486	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3487	return EInconclusive;
sl@0	3488	}
sl@0	3489
sl@0	3490	TRAPD(err, aMidi->SetChannelMuteL(channel, muted));
sl@0	3491
sl@0	3492	// check correct result
sl@0	3493	if (iTestType == ETestValid)
sl@0	3494	{
sl@0	3495	TBool currMuted = EFalse;
sl@0	3496
sl@0	3497	// until real MIDI controller IsChannelMuteL is always TRUE
sl@0	3498	TRAPD(err2, currMuted = aMidi->IsChannelMuteL(channel));
sl@0	3499
sl@0	3500	if(err2 != KErrNone)
sl@0	3501	{
sl@0	3502	ERR_PRINTF2(_L("IsChannelMuteL() returned %d"), err2);
sl@0	3503	ret = EInconclusive;
sl@0	3504	return ret;
sl@0	3505	}
sl@0	3506
sl@0	3507	if(currMuted != muted)
sl@0	3508	{
sl@0	3509	ERR_PRINTF2(_L("Error : expected %d"), muted);
sl@0	3510	ret = EFail;
sl@0	3511	return ret;
sl@0	3512	}
sl@0	3513	}
sl@0	3514
sl@0	3515
sl@0	3516	if (expErr != err)
sl@0	3517	{
sl@0	3518	ERR_PRINTF3(_L("SetChannelMuteL gave error %d (expected %d)"),err, expErr);
sl@0	3519	ret = EFail;
sl@0	3520	}
sl@0	3521	else
sl@0	3522	INFO_PRINTF3(_L("SetChannelMuteL %d = %d"),err ,expErr);
sl@0	3523
sl@0	3524	return ret;
sl@0	3525	}
sl@0	3526
sl@0	3527	//------------------------------------------------------------------
sl@0	3528
sl@0	3529	CTestReturnVolume::CTestReturnVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3530	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3531	{
sl@0	3532	}
sl@0	3533
sl@0	3534	CTestReturnVolume* CTestReturnVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3535	{
sl@0	3536
sl@0	3537	CTestReturnVolume* self = new(ELeave) CTestReturnVolume(aTestName, aTestType);
sl@0	3538	return self;
sl@0	3539	}
sl@0	3540
sl@0	3541	TVerdict CTestReturnVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3542	{
sl@0	3543	TVerdict ret = EPass;
sl@0	3544	TInt expErr = KErrNone;
sl@0	3545
sl@0	3546	INFO_PRINTF1(_L("CMidiClientUtility: Return channel volume"));
sl@0	3547	// expected results
sl@0	3548	switch(iTestType)
sl@0	3549	{
sl@0	3550	case ETestValid:
sl@0	3551	expErr = KErrNone;
sl@0	3552	break;
sl@0	3553	default:
sl@0	3554	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3555	return EInconclusive;
sl@0	3556	}
sl@0	3557	// TInt volume = 0;
sl@0	3558	// TRAPD(err, volume = aMidi->VolumeL());
sl@0	3559	TRAPD(err, aMidi->VolumeL()); // EABI warning removal
sl@0	3560	if (expErr != err)
sl@0	3561	{
sl@0	3562	ERR_PRINTF3(_L("VolumeL gave error %d (expected %d)"),err, expErr);
sl@0	3563	ret = EFail;
sl@0	3564	}
sl@0	3565	else
sl@0	3566	INFO_PRINTF3(_L("VolumeL %d = %d"),err ,expErr);
sl@0	3567
sl@0	3568	return ret;
sl@0	3569	}
sl@0	3570
sl@0	3571	//------------------------------------------------------------------
sl@0	3572
sl@0	3573	CTestReturnMaxVolume::CTestReturnMaxVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3574	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3575	{
sl@0	3576	}
sl@0	3577
sl@0	3578	CTestReturnMaxVolume* CTestReturnMaxVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3579	{
sl@0	3580	CTestReturnMaxVolume* self = new(ELeave) CTestReturnMaxVolume(aTestName, aTestType);
sl@0	3581	return self;
sl@0	3582	}
sl@0	3583
sl@0	3584	TVerdict CTestReturnMaxVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3585	{
sl@0	3586	TVerdict ret = EPass;
sl@0	3587	TInt expErr = KErrNone;
sl@0	3588
sl@0	3589	INFO_PRINTF1(_L("CMidiClientUtility: Return max channel volume"));
sl@0	3590	// expected results
sl@0	3591	switch(iTestType)
sl@0	3592	{
sl@0	3593	case ETestValid:
sl@0	3594	expErr = KErrNone;
sl@0	3595	break;
sl@0	3596	default:
sl@0	3597	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3598	return EInconclusive;
sl@0	3599	}
sl@0	3600	// TInt volume = 0;
sl@0	3601	// TRAPD(err, volume = aMidi->MaxVolumeL());
sl@0	3602	TRAPD(err, aMidi->MaxVolumeL()); // EABI warning removal
sl@0	3603	if (expErr != err)
sl@0	3604	{
sl@0	3605	ERR_PRINTF3(_L("MaxVolumeL gave error %d (expected %d)"),err, expErr);
sl@0	3606	ret = EFail;
sl@0	3607	}
sl@0	3608	else
sl@0	3609	INFO_PRINTF3(_L("MaxVolumeL %d = %d"),err ,expErr);
sl@0	3610
sl@0	3611	return ret;
sl@0	3612	}
sl@0	3613
sl@0	3614	//------------------------------------------------------------------
sl@0	3615
sl@0	3616	CTestSetVolume::CTestSetVolume(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3617	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3618	{
sl@0	3619	}
sl@0	3620
sl@0	3621	CTestSetVolume* CTestSetVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3622	{
sl@0	3623	CTestSetVolume* self = new(ELeave) CTestSetVolume(aTestName, aTestType);
sl@0	3624	return self;
sl@0	3625	}
sl@0	3626
sl@0	3627	TVerdict CTestSetVolume::DoTestL(CMidiClientUtility* aMidi)
sl@0	3628	{
sl@0	3629	TVerdict ret = EPass;
sl@0	3630	TInt expErr = KErrNone;
sl@0	3631	TInt volume = 0;
sl@0	3632
sl@0	3633	INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume"));
sl@0	3634	// expected results
sl@0	3635	switch(iTestType)
sl@0	3636	{
sl@0	3637	case ETestValid:
sl@0	3638	expErr = KErrNone;
sl@0	3639	volume = 10;
sl@0	3640	break;
sl@0	3641	case ETestVolumeHighOutOfRange:
sl@0	3642	expErr = KErrNotSupported;
sl@0	3643	volume = 9999999;
sl@0	3644	break;
sl@0	3645	case ETestVolumeLowOutOfRange:
sl@0	3646	expErr = KErrNotSupported;
sl@0	3647	volume = -9999999;
sl@0	3648	break;
sl@0	3649	default:
sl@0	3650	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3651	return EInconclusive;
sl@0	3652	}
sl@0	3653
sl@0	3654	TRAPD(err, aMidi->SetVolumeL(volume));
sl@0	3655	if (expErr != err)
sl@0	3656	{
sl@0	3657	ERR_PRINTF3(_L("SetVolumeL gave error %d (expected %d)"),err, expErr);
sl@0	3658	ret = EFail;
sl@0	3659	}
sl@0	3660	else
sl@0	3661	INFO_PRINTF3(_L("SetVolumeL %d = %d"),err ,expErr);
sl@0	3662
sl@0	3663	return ret;
sl@0	3664	}
sl@0	3665
sl@0	3666	//------------------------------------------------------------------
sl@0	3667
sl@0	3668	CTestSetVolumeRamp::CTestSetVolumeRamp(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3669	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3670	{
sl@0	3671	}
sl@0	3672
sl@0	3673	CTestSetVolumeRamp* CTestSetVolumeRamp::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3674	{
sl@0	3675	CTestSetVolumeRamp* self = new(ELeave) CTestSetVolumeRamp(aTestName, aTestType);
sl@0	3676	return self;
sl@0	3677	}
sl@0	3678
sl@0	3679	TVerdict CTestSetVolumeRamp::DoTestL(CMidiClientUtility* aMidi)
sl@0	3680	{
sl@0	3681	TVerdict ret = EPass;
sl@0	3682	TInt expErr = KErrNone;
sl@0	3683	TTimeIntervalMicroSeconds rampDuration;
sl@0	3684
sl@0	3685	INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume ramp"));
sl@0	3686	// expected results
sl@0	3687	switch(iTestType)
sl@0	3688	{
sl@0	3689	case ETestValid:
sl@0	3690	expErr = KErrNone;
sl@0	3691	break;
sl@0	3692	case ETestRampDurationHighOutOfRange:
sl@0	3693	expErr = KErrNotSupported;
sl@0	3694	rampDuration = 9999999;
sl@0	3695	break;
sl@0	3696	case ETestRampDurationLowOutOfRange:
sl@0	3697	expErr = KErrNotSupported;
sl@0	3698	rampDuration = -9999999;
sl@0	3699	break;
sl@0	3700	default:
sl@0	3701	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3702	return EInconclusive;
sl@0	3703	}
sl@0	3704
sl@0	3705	TRAPD(err, aMidi->SetVolumeRampL(rampDuration));
sl@0	3706	if (expErr != err)
sl@0	3707	{
sl@0	3708	ERR_PRINTF3(_L("SetVolumeRampL gave error %d (expected %d)"),err, expErr);
sl@0	3709	ret = EFail;
sl@0	3710	}
sl@0	3711	else
sl@0	3712	INFO_PRINTF3(_L("SetVolumeL %d = %d"),err ,expErr);
sl@0	3713
sl@0	3714	return ret;
sl@0	3715	}
sl@0	3716
sl@0	3717	//------------------------------------------------------------------
sl@0	3718
sl@0	3719	CTestGetBalance::CTestGetBalance(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3720	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3721	{
sl@0	3722	}
sl@0	3723
sl@0	3724	CTestGetBalance* CTestGetBalance::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3725	{
sl@0	3726	CTestGetBalance* self = new(ELeave) CTestGetBalance(aTestName, aTestType);
sl@0	3727	return self;
sl@0	3728	}
sl@0	3729
sl@0	3730	TVerdict CTestGetBalance::DoTestL(CMidiClientUtility* aMidi)
sl@0	3731	{
sl@0	3732	TVerdict ret = EPass;
sl@0	3733	TInt expErr = KErrNone;
sl@0	3734	//TTimeIntervalMicroSeconds rampDuration;
sl@0	3735
sl@0	3736	INFO_PRINTF1(_L("CMidiClientUtility: Get balance"));
sl@0	3737	// expected results
sl@0	3738	switch(iTestType)
sl@0	3739	{
sl@0	3740	case ETestValid:
sl@0	3741	expErr = KErrNone;
sl@0	3742	break;
sl@0	3743	case ETestUnsupported:
sl@0	3744	expErr = KErrNotSupported;
sl@0	3745	break;
sl@0	3746	default:
sl@0	3747	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3748	return EInconclusive;
sl@0	3749	}
sl@0	3750	// TInt getBalance = 0;
sl@0	3751	// TRAPD(err, getBalance = aMidi->GetBalanceL());
sl@0	3752	TRAPD(err, aMidi->GetBalanceL()); // EABI warning removal
sl@0	3753
sl@0	3754	if (expErr != err)
sl@0	3755	{
sl@0	3756	ERR_PRINTF3(_L("GetBalanceL gave error %d (expected %d)"),err, expErr);
sl@0	3757	ret = EFail;
sl@0	3758	}
sl@0	3759	else
sl@0	3760	INFO_PRINTF3(_L("GetBalanceL %d = %d"),err ,expErr);
sl@0	3761
sl@0	3762	return ret;
sl@0	3763	}
sl@0	3764
sl@0	3765	//------------------------------------------------------------------
sl@0	3766
sl@0	3767	CTestSetBalance::CTestSetBalance(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3768	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3769	{
sl@0	3770	}
sl@0	3771
sl@0	3772	CTestSetBalance* CTestSetBalance::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3773	{
sl@0	3774	CTestSetBalance* self = new(ELeave) CTestSetBalance(aTestName, aTestType);
sl@0	3775	return self;
sl@0	3776	}
sl@0	3777
sl@0	3778	TVerdict CTestSetBalance::DoTestL(CMidiClientUtility* aMidi)
sl@0	3779	{
sl@0	3780	TVerdict ret = EPass;
sl@0	3781	TInt expErr = KErrNone;
sl@0	3782	// TInt balance = 0; // EABI warning removal
sl@0	3783
sl@0	3784	INFO_PRINTF1(_L("CMidiClientUtility: Set balance"));
sl@0	3785	// expected results
sl@0	3786	switch(iTestType)
sl@0	3787	{
sl@0	3788	case ETestValid:
sl@0	3789	expErr = KErrNone;
sl@0	3790	break;
sl@0	3791	case ETestUnsupported:
sl@0	3792	expErr = KErrNotSupported;
sl@0	3793	break;
sl@0	3794	case ETestBalanceHighOutOfRange:
sl@0	3795	expErr = KErrNotSupported;
sl@0	3796	// balance = 101; // EABI warning removal
sl@0	3797	break;
sl@0	3798	case ETestBalanceLowOutOfRange:
sl@0	3799	expErr = KErrNotSupported;
sl@0	3800	// balance = -101; // EABI warning removal
sl@0	3801	break;
sl@0	3802	default:
sl@0	3803	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3804	return EInconclusive;
sl@0	3805	}
sl@0	3806
sl@0	3807	TRAPD(err, aMidi->SetBalanceL());
sl@0	3808	if (expErr != err)
sl@0	3809	{
sl@0	3810	ERR_PRINTF3(_L("SetBalanceL gave error %d (expected %d)"),err, expErr);
sl@0	3811	ret = EFail;
sl@0	3812	}
sl@0	3813	else
sl@0	3814	INFO_PRINTF3(_L("SetBalanceL %d = %d"),err ,expErr);
sl@0	3815
sl@0	3816	return ret;
sl@0	3817	}
sl@0	3818
sl@0	3819	//------------------------------------------------------------------
sl@0	3820
sl@0	3821	CTestSetPriority::CTestSetPriority(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3822	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3823	{
sl@0	3824	}
sl@0	3825
sl@0	3826	CTestSetPriority* CTestSetPriority::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3827	{
sl@0	3828	CTestSetPriority* self = new(ELeave) CTestSetPriority(aTestName, aTestType);
sl@0	3829	return self;
sl@0	3830	}
sl@0	3831
sl@0	3832	TVerdict CTestSetPriority::DoTestL(CMidiClientUtility* aMidi)
sl@0	3833	{
sl@0	3834	TVerdict ret = EPass;
sl@0	3835	TInt expErr = KErrNone;
sl@0	3836	TInt priority = 0;
sl@0	3837	TMdaPriorityPreference pref = EMdaPriorityPreferenceNone;
sl@0	3838
sl@0	3839	INFO_PRINTF1(_L("CMidiClientUtility: Set priority"));
sl@0	3840	// expected results
sl@0	3841	switch(iTestType)
sl@0	3842	{
sl@0	3843	case ETestValid:
sl@0	3844	expErr = KErrNone;
sl@0	3845	break;
sl@0	3846	case ETestPreferenceConflictsCannotBeResolved:
sl@0	3847	expErr = KErrNotSupported;
sl@0	3848	break;
sl@0	3849	default:
sl@0	3850	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3851	return EInconclusive;
sl@0	3852	}
sl@0	3853	// TMdaPriorityPreference aPref Priority preference to use if there should be contention with another client.
sl@0	3854	// We need this to confict and cause PreferenceConflictsCannotBeResolved
sl@0	3855	TRAPD(err, aMidi->SetPriorityL(priority, pref));
sl@0	3856	if (expErr != err)
sl@0	3857	{
sl@0	3858	ERR_PRINTF3(_L("SetPriorityL gave error %d (expected %d)"),err, expErr);
sl@0	3859	ret = EFail;
sl@0	3860	}
sl@0	3861	else
sl@0	3862	INFO_PRINTF3(_L("SetPriorityL %d = %d"),err ,expErr);
sl@0	3863
sl@0	3864	return ret;
sl@0	3865	}
sl@0	3866
sl@0	3867	//------------------------------------------------------------------
sl@0	3868
sl@0	3869	CTestNumberOfXmfMetaDataEntries::CTestNumberOfXmfMetaDataEntries(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3870	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3871	{
sl@0	3872	}
sl@0	3873
sl@0	3874	CTestNumberOfXmfMetaDataEntries* CTestNumberOfXmfMetaDataEntries::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3875	{
sl@0	3876	CTestNumberOfXmfMetaDataEntries* self = new(ELeave) CTestNumberOfXmfMetaDataEntries(aTestName, aTestType);
sl@0	3877	return self;
sl@0	3878	}
sl@0	3879
sl@0	3880	TVerdict CTestNumberOfXmfMetaDataEntries::DoTestL(CMidiClientUtility* aMidi)
sl@0	3881	{
sl@0	3882	TVerdict ret = EPass;
sl@0	3883	TInt expErr = KErrNone;
sl@0	3884
sl@0	3885	INFO_PRINTF1(_L("CMidiClientUtility: Number Of Xmf Meta Data Entries"));
sl@0	3886	// expected results
sl@0	3887	switch(iTestType)
sl@0	3888	{
sl@0	3889	case ETestValid:
sl@0	3890	expErr = KErrNone;
sl@0	3891	break;
sl@0	3892	case ETestUnsupported:
sl@0	3893	expErr = KErrNotSupported;
sl@0	3894	break;
sl@0	3895	default:
sl@0	3896	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3897	return EInconclusive;
sl@0	3898	}
sl@0	3899	// TInt numberOfXmfMetaDataEntriesL = 0;
sl@0	3900	// TRAPD(err, numberOfXmfMetaDataEntriesL = aMidi->NumberOfMetaDataEntriesL());
sl@0	3901	TRAPD(err, aMidi->NumberOfMetaDataEntriesL()); // EABI warning removal
sl@0	3902	if (expErr != err)
sl@0	3903	{
sl@0	3904	ERR_PRINTF3(_L("NumberOfXmfMetaDataEntriesL gave error %d (expected %d)"),err, expErr);
sl@0	3905	ret = EFail;
sl@0	3906	}
sl@0	3907	else
sl@0	3908	INFO_PRINTF3(_L("NumberOfXmfMetaDataEntriesL %d = %d"),err ,expErr);
sl@0	3909
sl@0	3910	return ret;
sl@0	3911	}
sl@0	3912
sl@0	3913	//------------------------------------------------------------------
sl@0	3914
sl@0	3915	CTestGetXmfMetaDataEntry::CTestGetXmfMetaDataEntry(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3916	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3917	{
sl@0	3918	}
sl@0	3919
sl@0	3920	CTestGetXmfMetaDataEntry* CTestGetXmfMetaDataEntry::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	3921	{
sl@0	3922	CTestGetXmfMetaDataEntry* self = new(ELeave) CTestGetXmfMetaDataEntry(aTestName, aTestType);
sl@0	3923	return self;
sl@0	3924	}
sl@0	3925
sl@0	3926	TVerdict CTestGetXmfMetaDataEntry::DoTestL(CMidiClientUtility* /aMidi/)
sl@0	3927	{
sl@0	3928	TVerdict ret = EPass;
sl@0	3929	TInt err = KErrNone;
sl@0	3930
sl@0	3931	TInt expErr = KErrNone;
sl@0	3932	// TInt metaDataIndex = 1; // EABI warning removal
sl@0	3933
sl@0	3934	INFO_PRINTF1(_L("CMidiClientUtility: Get Xmf Meta Data Entry"));
sl@0	3935	// expected results
sl@0	3936	switch(iTestType)
sl@0	3937	{
sl@0	3938	case ETestValid:
sl@0	3939	expErr = KErrNone;
sl@0	3940	break;
sl@0	3941	case ETestUnsupported:
sl@0	3942	expErr = KErrNotSupported;
sl@0	3943	break;
sl@0	3944	case ETestMetaDataIndexInvalid:
sl@0	3945	// metaDataIndex = -1; // EABI warning removal
sl@0	3946	break;
sl@0	3947	default:
sl@0	3948	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	3949	return EInconclusive;
sl@0	3950	}
sl@0	3951
sl@0	3952	// Default constructor. Returns a blank meta data object. To be used when internalizing data into the object.
sl@0	3953	// CMMFMetaDataEntry* getXmfMetaDataEntry = CMMFMetaDataEntry::NewL();
sl@0	3954
sl@0	3955	// Causes Access Violation
sl@0	3956	// TRAPD(err, CMMFMetaDataEntry* getXmfMetaDataEntry = aMidi->GetMetaDataEntryL(metaDataIndex));
sl@0	3957	if (expErr != err)
sl@0	3958	{
sl@0	3959	ERR_PRINTF3(_L("GetXmfMetaDataEntry gave error %d (expected %d)"), err, expErr);
sl@0	3960	ret = EFail;
sl@0	3961	}
sl@0	3962	else
sl@0	3963	INFO_PRINTF3(_L("GetXmfMetaDataEntry %d = %d"),err ,expErr);
sl@0	3964
sl@0	3965	return ret;
sl@0	3966	}
sl@0	3967
sl@0	3968	//------------------------------------------------------------------
sl@0	3969
sl@0	3970
sl@0	3971	//------------------------------------------------------------------
sl@0	3972
sl@0	3973	CTestLoadCustomInstrumentData::CTestLoadCustomInstrumentData(const TDesC& aTestName,
sl@0	3974	const TTestStepType aTestType)
sl@0	3975	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	3976	{
sl@0	3977	}
sl@0	3978
sl@0	3979	CTestLoadCustomInstrumentData* CTestLoadCustomInstrumentData::NewL(const TDesC& aTestName,
sl@0	3980	const TTestStepType aTestType)
sl@0	3981	{
sl@0	3982	CTestLoadCustomInstrumentData* self = new (ELeave) CTestLoadCustomInstrumentData(aTestName,
sl@0	3983	aTestType);
sl@0	3984	return self;
sl@0	3985	}
sl@0	3986
sl@0	3987
sl@0	3988	TVerdict CTestLoadCustomInstrumentData::DoTestL(CMidiClientUtility* aMidi)
sl@0	3989	{
sl@0	3990	// N.B. Until there is a MIDI controller there is no sense in having any
sl@0	3991	// invalid tests since at present LoadCustomInstrumentDataL always returns
sl@0	3992	// ETrue [it doesn't actually attempt a load]. When we actually have a
sl@0	3993	// proper MIDI instrument this test can be modified to load this instead of
sl@0	3994	// the NULL descriptor below. NJ
sl@0	3995
sl@0	3996	TVerdict ret = EPass;
sl@0	3997	TInt expErr;
sl@0	3998
sl@0	3999	TInt memBankId = 90;
sl@0	4000	TInt memInstrId = 91;
sl@0	4001	TInt bankId = 92;
sl@0	4002	TInt instrId = 93;
sl@0	4003
sl@0	4004	// change these to real descriptors when we have a MIDI instruments
sl@0	4005	const TDesC8* ptrInstrument = &KNullDesC8;
sl@0	4006	const TDesC8* ptrBadInstrument = &KNullDesC8;
sl@0	4007
sl@0	4008	// XXX::When we have a MIDI instrument / controller load the instrument
sl@0	4009	// into the descriptor here.
sl@0	4010
sl@0	4011	// expected results
sl@0	4012	switch(iTestType)
sl@0	4013	{
sl@0	4014	case ETestValid:
sl@0	4015	expErr = KErrNone;
sl@0	4016	break;
sl@0	4017	case ETestInvalidId:
sl@0	4018	expErr = KErrArgument;
sl@0	4019	bankId = -2;
sl@0	4020	break;
sl@0	4021	case ETestAlreadyLoaded:
sl@0	4022	// ** to do : load once and attempt to load again.
sl@0	4023	// when instrument data files are available, this will work
sl@0	4024	expErr = KErrInUse;
sl@0	4025	break;
sl@0	4026	case ETestUnsupported: // ** to define test data for this
sl@0	4027	expErr = KErrNotSupported;
sl@0	4028	break;
sl@0	4029
sl@0	4030	default:
sl@0	4031	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	4032	return EInconclusive;
sl@0	4033	}
sl@0	4034	TInt err = KErrNone;
sl@0	4035
sl@0	4036	// bad descriptor test
sl@0	4037	if (iTestType == ETestUnsupported)
sl@0	4038	{
sl@0	4039	// load the bad / unsupported instrument
sl@0	4040	TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrBadInstrument, bankId, instrId, memBankId, memInstrId));
sl@0	4041	}
sl@0	4042	else
sl@0	4043	{
sl@0	4044	// if testing already loaded, preload the instrument here
sl@0	4045	if(iTestType == ETestAlreadyLoaded)
sl@0	4046	{
sl@0	4047	TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrInstrument, bankId, instrId, memBankId, memInstrId));
sl@0	4048	INFO_PRINTF2(_L("Preload : LoadCustomInstrumentDataL gave error %d"), err);
sl@0	4049	if(err != KErrNone)
sl@0	4050	{
sl@0	4051	ret = EInconclusive;
sl@0	4052	return ret;
sl@0	4053	}
sl@0	4054	}
sl@0	4055
sl@0	4056	// load the instrument
sl@0	4057	TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrInstrument, bankId, instrId, memBankId, memInstrId));
sl@0	4058	}
sl@0	4059
sl@0	4060	INFO_PRINTF3(_L("LoadCustomInstrumentDataL gave error %d (expected %d)"), err, expErr);
sl@0	4061	if(err != expErr)
sl@0	4062	{
sl@0	4063	ret = EFail;
sl@0	4064	return ret;
sl@0	4065	}
sl@0	4066
sl@0	4067	return ret;
sl@0	4068	}
sl@0	4069
sl@0	4070
sl@0	4071	//------------------------------------------------------------------
sl@0	4072
sl@0	4073
sl@0	4074	//------------------------------------------------------------------
sl@0	4075
sl@0	4076	_LIT(KMidiClntChunk, "MidiClntChunk");
sl@0	4077	_LIT(KMidiClntSemaphore, "MidiClntSemaphore");
sl@0	4078
sl@0	4079	CTestCheckInterface::CTestCheckInterface(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	4080	:CTestMmfMidiClntStep(aTestName,aTestType)
sl@0	4081	{
sl@0	4082	}
sl@0	4083
sl@0	4084	CTestCheckInterface* CTestCheckInterface::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	4085	{
sl@0	4086	CTestCheckInterface* self = new (ELeave) CTestCheckInterface(aTestName, aTestType);
sl@0	4087	CleanupStack::PushL(self);
sl@0	4088	self->ConstructL();
sl@0	4089	CleanupStack::Pop(self);
sl@0	4090	return self;
sl@0	4091	}
sl@0	4092
sl@0	4093	void CTestCheckInterface::ConstructL()
sl@0	4094	{
sl@0	4095	User::LeaveIfError(iChunk.CreateGlobal(KMidiClntChunk,20,20));
sl@0	4096	User::LeaveIfError(iSemaphore.CreateGlobal(KMidiClntSemaphore, 0));
sl@0	4097
sl@0	4098	}
sl@0	4099
sl@0	4100	CTestCheckInterface::~CTestCheckInterface()
sl@0	4101	{
sl@0	4102	}
sl@0	4103
sl@0	4104	void CTestCheckInterface::Close()
sl@0	4105	{
sl@0	4106	iChunk.Close();
sl@0	4107	iSemaphore.Close();
sl@0	4108	}
sl@0	4109
sl@0	4110
sl@0	4111	TVerdict CTestCheckInterface::DoTestL(CMidiClientUtility* aMidi)
sl@0	4112	{
sl@0	4113
sl@0	4114	TVerdict ret = EPass;
sl@0	4115	TInt expErr = KErrNone;
sl@0	4116	TInt err = KErrNone;
sl@0	4117
sl@0	4118	//
sl@0	4119	//PlayNoteL//
sl@0	4120	//
sl@0	4121	TRAP_IGNORE(aMidi->PlayNoteL(0,0,TTimeIntervalMicroSeconds(0),0,0));
sl@0	4122	err = CompareInterface( _L8("PlayNoteL"));
sl@0	4123	INFO_PRINTF3(_L("Check interface PlayNoteL gave error %d (expected %d)"), err, expErr);
sl@0	4124	if(err != expErr)
sl@0	4125	{
sl@0	4126	ret = EFail;
sl@0	4127	return ret;
sl@0	4128	}
sl@0	4129
sl@0	4130	//
sl@0	4131	//PlayNoteL(WithStartTime)//
sl@0	4132	//
sl@0	4133	TRAP_IGNORE(aMidi->PlayNoteL(0,0,TTimeIntervalMicroSeconds(0),TTimeIntervalMicroSeconds(0),0,0));
sl@0	4134	err = CompareInterface(_L8("PlayNoteWithStartTime"));
sl@0	4135	INFO_PRINTF3(_L("Check interface PlayNoteL (WithStartTime) gave error %d (expected %d)"), err, expErr);
sl@0	4136	if(err != expErr)
sl@0	4137	{
sl@0	4138	ret = EFail;
sl@0	4139	return ret;
sl@0	4140	}
sl@0	4141
sl@0	4142	//
sl@0	4143	//StopNotes//
sl@0	4144	//
sl@0	4145	aMidi->StopNotes(0);
sl@0	4146	err = CompareInterface(_L8("StopNotes"));
sl@0	4147	INFO_PRINTF3(_L("Check interface StopNotes gave error %d (expected %d)"), err, expErr);
sl@0	4148	if(err != expErr)
sl@0	4149	{
sl@0	4150	ret = EFail;
sl@0	4151	return ret;
sl@0	4152	}
sl@0	4153
sl@0	4154	//
sl@0	4155	//NoteOnL//
sl@0	4156	//
sl@0	4157	TRAP_IGNORE(aMidi->NoteOnL(0,0,0));
sl@0	4158	err = CompareInterface(_L8("NoteOnL"));
sl@0	4159	INFO_PRINTF3(_L("Check interface NoteOnL gave error %d (expected %d)"), err, expErr);
sl@0	4160	if(err != expErr)
sl@0	4161	{
sl@0	4162	ret = EFail;
sl@0	4163	return ret;
sl@0	4164	}
sl@0	4165
sl@0	4166	//
sl@0	4167	//NoteOffL//
sl@0	4168	//
sl@0	4169	TRAP_IGNORE(aMidi->NoteOffL(0,0,0));
sl@0	4170	err = CompareInterface(_L8("NoteOffL"));
sl@0	4171	INFO_PRINTF3(_L("Check interface NoteOffL gave error %d (expected %d)"), err, expErr);
sl@0	4172	if(err != expErr)
sl@0	4173	{
sl@0	4174	ret = EFail;
sl@0	4175	return ret;
sl@0	4176	}
sl@0	4177
sl@0	4178	//
sl@0	4179	//PlaybackRateL//
sl@0	4180	//
sl@0	4181	TRAP_IGNORE(aMidi->PlaybackRateL());
sl@0	4182	err = CompareInterface(_L8("PlaybackRateL"));
sl@0	4183	INFO_PRINTF3(_L("Check interface PlaybackRateL gave error %d (expected %d)"), err, expErr);
sl@0	4184	if(err != expErr)
sl@0	4185	{
sl@0	4186	ret = EFail;
sl@0	4187	return ret;
sl@0	4188	}
sl@0	4189
sl@0	4190	//
sl@0	4191	//SetPlaybackRateL//
sl@0	4192	//
sl@0	4193	TRAP_IGNORE(aMidi->SetPlaybackRateL(0));
sl@0	4194	err = CompareInterface(_L8("SetPlaybackRateL"));
sl@0	4195	INFO_PRINTF3(_L("Check interface SetPlaybackRateL gave error %d (expected %d)"), err, expErr);
sl@0	4196	if(err != expErr)
sl@0	4197	{
sl@0	4198	ret = EFail;
sl@0	4199	return ret;
sl@0	4200	}
sl@0	4201
sl@0	4202	//
sl@0	4203	//MaxPlaybackRateL//
sl@0	4204	//
sl@0	4205	TRAP_IGNORE(aMidi->MaxPlaybackRateL());
sl@0	4206	err = CompareInterface(_L8("MaxPlaybackRateL"));
sl@0	4207	INFO_PRINTF3(_L("Check interface MaxPlaybackRateL gave error %d (expected %d)"), err, expErr);
sl@0	4208	if(err != expErr)
sl@0	4209	{
sl@0	4210	ret = EFail;
sl@0	4211	return ret;
sl@0	4212	}
sl@0	4213
sl@0	4214	//
sl@0	4215	//MinPlaybackRateL//
sl@0	4216	//
sl@0	4217	TRAP_IGNORE(aMidi->MinPlaybackRateL());
sl@0	4218	err = CompareInterface(_L8("MinPlaybackRateL"));
sl@0	4219	INFO_PRINTF3(_L("Check interface MinPlaybackRateL gave error %d (expected %d)"), err, expErr);
sl@0	4220	if(err != expErr)
sl@0	4221	{
sl@0	4222	ret = EFail;
sl@0	4223	return ret;
sl@0	4224	}
sl@0	4225
sl@0	4226	//
sl@0	4227	//TempoMicroBeatsPerMinuteL//
sl@0	4228	//
sl@0	4229	TRAP_IGNORE(aMidi->TempoMicroBeatsPerMinuteL());
sl@0	4230	err = CompareInterface(_L8("TempoMicroBeatsPerMinuteL"));
sl@0	4231	INFO_PRINTF3(_L("Check interface TempoMicroBeatsPerMinuteL gave error %d (expected %d)"), err, expErr);
sl@0	4232	if(err != expErr)
sl@0	4233	{
sl@0	4234	ret = EFail;
sl@0	4235	return ret;
sl@0	4236	}
sl@0	4237
sl@0	4238	//
sl@0	4239	//SetTempoL//
sl@0	4240	//
sl@0	4241	TRAP_IGNORE(aMidi->SetTempoL(1));
sl@0	4242	err = CompareInterface(_L8("SetTempoL"));
sl@0	4243	INFO_PRINTF3(_L("Check interface SetTempoL gave error %d (expected %d)"), err, expErr);
sl@0	4244	if(err != expErr)
sl@0	4245	{
sl@0	4246	ret = EFail;
sl@0	4247	return ret;
sl@0	4248	}
sl@0	4249
sl@0	4250	//
sl@0	4251	//PitchTranspositionCentsL//
sl@0	4252	//
sl@0	4253	TRAP_IGNORE(aMidi->PitchTranspositionCentsL());
sl@0	4254	err = CompareInterface(_L8("PitchTranspositionCentsL"));
sl@0	4255	INFO_PRINTF3(_L("Check interface PitchTranspositionCentsL gave error %d (expected %d)"), err, expErr);
sl@0	4256	if(err != expErr)
sl@0	4257	{
sl@0	4258	ret = EFail;
sl@0	4259	return ret;
sl@0	4260	}
sl@0	4261
sl@0	4262	//
sl@0	4263	//SetPitchTranspositionL//
sl@0	4264	//
sl@0	4265	TRAP_IGNORE(aMidi->SetPitchTranspositionL(0));
sl@0	4266	err = CompareInterface(_L8("SetPitchTranspositionL"));
sl@0	4267	INFO_PRINTF3(_L("Check interface SetPitchTranspositionL gave error %d (expected %d)"), err, expErr);
sl@0	4268	if(err != expErr)
sl@0	4269	{
sl@0	4270	ret = EFail;
sl@0	4271	return ret;
sl@0	4272	}
sl@0	4273
sl@0	4274	//
sl@0	4275	//DurationMicroBeatsL//
sl@0	4276	//
sl@0	4277	TRAP_IGNORE(aMidi->DurationMicroBeatsL());
sl@0	4278	err = CompareInterface(_L8("DurationMicroBeatsL"));
sl@0	4279	INFO_PRINTF3(_L("Check interface DurationMicroBeatsL gave error %d (expected %d)"), err, expErr);
sl@0	4280	if(err != expErr)
sl@0	4281	{
sl@0	4282	ret = EFail;
sl@0	4283	return ret;
sl@0	4284	}
sl@0	4285
sl@0	4286	//
sl@0	4287	//NumTracksL//
sl@0	4288	//
sl@0	4289	TRAP_IGNORE(aMidi->NumTracksL());
sl@0	4290	err = CompareInterface(_L8("NumTracksL"));
sl@0	4291	INFO_PRINTF3(_L("Check interface NumTracksL gave error %d (expected %d)"), err, expErr);
sl@0	4292	if(err != expErr)
sl@0	4293	{
sl@0	4294	ret = EFail;
sl@0	4295	return ret;
sl@0	4296	}
sl@0	4297
sl@0	4298	//
sl@0	4299	//SetTrackMuteL//
sl@0	4300	//
sl@0	4301	TRAP_IGNORE(aMidi->SetTrackMuteL(0,ETrue));
sl@0	4302	err = CompareInterface(_L8("SetTrackMuteL"));
sl@0	4303	INFO_PRINTF3(_L("Check interface SetTrackMuteL gave error %d (expected %d)"), err, expErr);
sl@0	4304	if(err != expErr)
sl@0	4305	{
sl@0	4306	ret = EFail;
sl@0	4307	return ret;
sl@0	4308	}
sl@0	4309
sl@0	4310	//
sl@0	4311	//MimeTypeL//
sl@0	4312	//
sl@0	4313	TRAP_IGNORE(aMidi->MimeTypeL());
sl@0	4314	err = CompareInterface(_L8("MimeTypeL"));
sl@0	4315	INFO_PRINTF3(_L("Check interface MimeTypeL gave error %d (expected %d)"), err, expErr);
sl@0	4316	if(err != expErr)
sl@0	4317	{
sl@0	4318	ret = EFail;
sl@0	4319	return ret;
sl@0	4320	}
sl@0	4321
sl@0	4322	//
sl@0	4323	//PositionMicroBeatsL//
sl@0	4324	//
sl@0	4325	TRAP_IGNORE(aMidi->PositionMicroBeatsL());
sl@0	4326	err = CompareInterface(_L8("PositionMicroBeatsL"));
sl@0	4327	INFO_PRINTF3(_L("Check interface PositionMicroBeatsL gave error %d (expected %d)"), err, expErr);
sl@0	4328	if(err != expErr)
sl@0	4329	{
sl@0	4330	ret = EFail;
sl@0	4331	return ret;
sl@0	4332	}
sl@0	4333
sl@0	4334	//
sl@0	4335	//SetPositionMicroBeatsL//
sl@0	4336	//
sl@0	4337	TRAP_IGNORE(aMidi->SetPositionMicroBeatsL(0));
sl@0	4338	err = CompareInterface(_L8("SetPositionMicroBeatsL"));
sl@0	4339	INFO_PRINTF3(_L("Check interface SetPositionMicroBeatsL gave error %d (expected %d)"), err, expErr);
sl@0	4340	if(err != expErr)
sl@0	4341	{
sl@0	4342	ret = EFail;
sl@0	4343	return ret;
sl@0	4344	}
sl@0	4345
sl@0	4346	//
sl@0	4347	//SetSyncUpdateCallbackIntervalL//
sl@0	4348	//
sl@0	4349	TRAP_IGNORE(aMidi->SetSyncUpdateCallbackIntervalL(TTimeIntervalMicroSeconds(1)));
sl@0	4350	err = CompareInterface(_L8("SetSyncUpdateCallbackIntervalL"));
sl@0	4351	INFO_PRINTF3(_L("Check interface SetSyncUpdateCallbackIntervalL gave error %d (expected %d)"), err, expErr);
sl@0	4352	if(err != expErr)
sl@0	4353	{
sl@0	4354	ret = EFail;
sl@0	4355	return ret;
sl@0	4356	}
sl@0	4357
sl@0	4358	//
sl@0	4359	//SendMessageL//
sl@0	4360	//
sl@0	4361	TRAP_IGNORE(aMidi->SendMessageL(_L8("")));
sl@0	4362	err = CompareInterface(_L8("SendMessageL"));
sl@0	4363	INFO_PRINTF3(_L("Check interface SendMessageL gave error %d (expected %d)"), err, expErr);
sl@0	4364	if(err != expErr)
sl@0	4365	{
sl@0	4366	ret = EFail;
sl@0	4367	return ret;
sl@0	4368	}
sl@0	4369
sl@0	4370	//
sl@0	4371	//SendMessageL (WithTimeStamp)//
sl@0	4372	//
sl@0	4373	TRAP_IGNORE(aMidi->SendMessageL(_L8(""), TTimeIntervalMicroSeconds(0)));
sl@0	4374	err = CompareInterface(_L8("SendMessageWithTimeStamp"));
sl@0	4375	INFO_PRINTF3(_L("Check interface SendMessageL (WithTimeStamp) gave error %d (expected %d)"), err, expErr);
sl@0	4376	if(err != expErr)
sl@0	4377	{
sl@0	4378	ret = EFail;
sl@0	4379	return ret;
sl@0	4380	}
sl@0	4381
sl@0	4382	//
sl@0	4383	//SendMipMessageL//
sl@0	4384	//
sl@0	4385	{
sl@0	4386	TMipMessageEntry mipEntry;
sl@0	4387	mipEntry.iChannel = 10;
sl@0	4388	mipEntry.iMIPValue = 20;
sl@0	4389	RArray<TMipMessageEntry> mipArray;
sl@0	4390	mipArray.Append(mipEntry);
sl@0	4391
sl@0	4392	TRAP_IGNORE(aMidi->SendMipMessageL(mipArray));
sl@0	4393	mipArray.Close();
sl@0	4394	}
sl@0	4395	err = CompareInterface(_L8("SendMipMessageL"));
sl@0	4396	INFO_PRINTF3(_L("Check interface SendMipMessageL gave error %d (expected %d)"), err, expErr);
sl@0	4397	if(err != expErr)
sl@0	4398	{
sl@0	4399	ret = EFail;
sl@0	4400	return ret;
sl@0	4401	}
sl@0	4402
sl@0	4403	//
sl@0	4404	//NumberOfBanksL//
sl@0	4405	//
sl@0	4406	TRAP_IGNORE(aMidi->NumberOfBanksL(ETrue));
sl@0	4407	err = CompareInterface(_L8("NumberOfBanksL"));
sl@0	4408	INFO_PRINTF3(_L("Check interface NumberOfBanksL gave error %d (expected %d)"), err, expErr);
sl@0	4409	if(err != expErr)
sl@0	4410	{
sl@0	4411	ret = EFail;
sl@0	4412	return ret;
sl@0	4413	}
sl@0	4414
sl@0	4415	//
sl@0	4416	//GetBankIdL//
sl@0	4417	//
sl@0	4418	TRAP_IGNORE(aMidi->GetBankIdL(ETrue,0));
sl@0	4419	err = CompareInterface(_L8("GetBankIdL"));
sl@0	4420	INFO_PRINTF3(_L("Check interface GetBankIdL gave error %d (expected %d)"), err, expErr);
sl@0	4421	if(err != expErr)
sl@0	4422	{
sl@0	4423	ret = EFail;
sl@0	4424	return ret;
sl@0	4425	}
sl@0	4426
sl@0	4427	//
sl@0	4428	//LoadCustomBankL//
sl@0	4429	//
sl@0	4430	{
sl@0	4431	TInt bankId = 0;
sl@0	4432	TRAP_IGNORE(aMidi->LoadCustomBankL(_L(""),bankId));
sl@0	4433	}
sl@0	4434	err = CompareInterface(_L8("LoadCustomBankL"));
sl@0	4435	INFO_PRINTF3(_L("Check interface LoadCustomBankL gave error %d (expected %d)"), err, expErr);
sl@0	4436	if(err != expErr)
sl@0	4437	{
sl@0	4438	ret = EFail;
sl@0	4439	return ret;
sl@0	4440	}
sl@0	4441
sl@0	4442	//
sl@0	4443	//LoadCustomBankDataL//
sl@0	4444	//
sl@0	4445	{
sl@0	4446	TInt bankId = 0;
sl@0	4447	TRAP_IGNORE(aMidi->LoadCustomBankDataL(_L8(""),bankId));
sl@0	4448	}
sl@0	4449	err = CompareInterface(_L8("LoadCustomBankDataL"));
sl@0	4450	INFO_PRINTF3(_L("Check interface LoadCustomBankDataL gave error %d (expected %d)"), err, expErr);
sl@0	4451	if(err != expErr)
sl@0	4452	{
sl@0	4453	ret = EFail;
sl@0	4454	return ret;
sl@0	4455	}
sl@0	4456
sl@0	4457	//
sl@0	4458	//UnloadCustomBankL//
sl@0	4459	//
sl@0	4460	TRAP_IGNORE(aMidi->UnloadCustomBankL(0));
sl@0	4461	err = CompareInterface(_L8("UnloadCustomBankL"));
sl@0	4462	INFO_PRINTF3(_L("Check interface UnloadCustomBankL gave error %d (expected %d)"), err, expErr);
sl@0	4463	if(err != expErr)
sl@0	4464	{
sl@0	4465	ret = EFail;
sl@0	4466	return ret;
sl@0	4467	}
sl@0	4468
sl@0	4469	//
sl@0	4470	//CustomBankLoadedL//
sl@0	4471	//
sl@0	4472	TRAP_IGNORE(aMidi->CustomBankLoadedL(0));
sl@0	4473	err = CompareInterface(_L8("CustomBankLoadedL"));
sl@0	4474	INFO_PRINTF3(_L("Check interface CustomBankLoadedL gave error %d (expected %d)"), err, expErr);
sl@0	4475	if(err != expErr)
sl@0	4476	{
sl@0	4477	ret = EFail;
sl@0	4478	return ret;
sl@0	4479	}
sl@0	4480
sl@0	4481	//
sl@0	4482	//UnloadAllCustomBanksL//
sl@0	4483	//
sl@0	4484	TRAP_IGNORE(aMidi->UnloadAllCustomBanksL());
sl@0	4485	err = CompareInterface(_L8("UnloadAllCustomBanksL"));
sl@0	4486	INFO_PRINTF3(_L("Check interface UnloadAllCustomBanksL gave error %d (expected %d)"), err, expErr);
sl@0	4487	if(err != expErr)
sl@0	4488	{
sl@0	4489	ret = EFail;
sl@0	4490	return ret;
sl@0	4491	}
sl@0	4492
sl@0	4493	//
sl@0	4494	//NumberOfInstrumentsL//
sl@0	4495	//
sl@0	4496	TRAP_IGNORE(aMidi->NumberOfInstrumentsL(0,ETrue));
sl@0	4497	err = CompareInterface(_L8("NumberOfInstrumentsL"));
sl@0	4498	INFO_PRINTF3(_L("Check interface NumberOfInstrumentsL gave error %d (expected %d)"), err, expErr);
sl@0	4499	if(err != expErr)
sl@0	4500	{
sl@0	4501	ret = EFail;
sl@0	4502	return ret;
sl@0	4503	}
sl@0	4504
sl@0	4505	//
sl@0	4506	//GetInstrumentIdL//
sl@0	4507	//
sl@0	4508	TRAP_IGNORE(aMidi->GetInstrumentIdL(0, ETrue, 0));
sl@0	4509	err = CompareInterface(_L8("GetInstrumentIdL"));
sl@0	4510	INFO_PRINTF3(_L("Check interface GetInstrumentIdL gave error %d (expected %d)"), err, expErr);
sl@0	4511	if(err != expErr)
sl@0	4512	{
sl@0	4513	ret = EFail;
sl@0	4514	return ret;
sl@0	4515	}
sl@0	4516
sl@0	4517	//
sl@0	4518	//InstrumentNameL//
sl@0	4519	//
sl@0	4520	{
sl@0	4521	HBufC* instrumentName = NULL;
sl@0	4522	TRAP_IGNORE(instrumentName = aMidi->InstrumentNameL(0, ETrue, 0));
sl@0	4523	delete instrumentName;
sl@0	4524	}
sl@0	4525	err = CompareInterface(_L8("InstrumentNameL"));
sl@0	4526	INFO_PRINTF3(_L("Check interface InstrumentNameL gave error %d (expected %d)"), err, expErr);
sl@0	4527	if(err != expErr)
sl@0	4528	{
sl@0	4529	ret = EFail;
sl@0	4530	return ret;
sl@0	4531	}
sl@0	4532
sl@0	4533	//
sl@0	4534	//GetInstrumentL//
sl@0	4535	//
sl@0	4536	{
sl@0	4537	TInt instrumentId = 0;
sl@0	4538	TInt bankId = 0;
sl@0	4539	TRAP_IGNORE(aMidi->GetInstrumentL(0, instrumentId, bankId));
sl@0	4540	}
sl@0	4541	err = CompareInterface(_L8("GetInstrumentL"));
sl@0	4542	INFO_PRINTF3(_L("Check interface GetInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	4543	if(err != expErr)
sl@0	4544	{
sl@0	4545	ret = EFail;
sl@0	4546	return ret;
sl@0	4547	}
sl@0	4548
sl@0	4549	//
sl@0	4550	//SetInstrumentL//
sl@0	4551	//
sl@0	4552	TRAP_IGNORE(aMidi->SetInstrumentL(0, 0, 0));
sl@0	4553	err = CompareInterface(_L8("SetInstrumentL"));
sl@0	4554	INFO_PRINTF3(_L("Check interface SetInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	4555	if(err != expErr)
sl@0	4556	{
sl@0	4557	ret = EFail;
sl@0	4558	return ret;
sl@0	4559	}
sl@0	4560
sl@0	4561	//
sl@0	4562	//LoadCustomInstrumentL//
sl@0	4563	//
sl@0	4564	TRAP_IGNORE(aMidi->LoadCustomInstrumentL(_L(""),0,0,0,0));
sl@0	4565	err = CompareInterface(_L8("LoadCustomInstrumentL"));
sl@0	4566	INFO_PRINTF3(_L("Check interface LoadCustomInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	4567	if(err != expErr)
sl@0	4568	{
sl@0	4569	ret = EFail;
sl@0	4570	return ret;
sl@0	4571	}
sl@0	4572
sl@0	4573	//
sl@0	4574	//LoadCustomInstrumentDataL//
sl@0	4575	//
sl@0	4576	TRAP_IGNORE(aMidi->LoadCustomInstrumentDataL(_L8(""),0,0,0,0));
sl@0	4577	err = CompareInterface(_L8("LoadCustomInstrumentDataL"));
sl@0	4578	INFO_PRINTF3(_L("Check interface LoadCustomInstrumentDataL gave error %d (expected %d)"), err, expErr);
sl@0	4579	if(err != expErr)
sl@0	4580	{
sl@0	4581	ret = EFail;
sl@0	4582	return ret;
sl@0	4583	}
sl@0	4584
sl@0	4585	//
sl@0	4586	//UnloadCustomInstrumentL//
sl@0	4587	//
sl@0	4588	TRAP_IGNORE(aMidi->UnloadCustomInstrumentL(0,0));
sl@0	4589	err = CompareInterface(_L8("UnloadCustomInstrumentL"));
sl@0	4590	INFO_PRINTF3(_L("Check interface UnloadCustomInstrumentL gave error %d (expected %d)"), err, expErr);
sl@0	4591	if(err != expErr)
sl@0	4592	{
sl@0	4593	ret = EFail;
sl@0	4594	return ret;
sl@0	4595	}
sl@0	4596
sl@0	4597	//
sl@0	4598	//PercussionKeyNameL//
sl@0	4599	//
sl@0	4600	{
sl@0	4601	HBufC* percussionKeyName = NULL;
sl@0	4602	TRAP_IGNORE(percussionKeyName = aMidi->PercussionKeyNameL(0,0,0,0));
sl@0	4603	delete percussionKeyName;
sl@0	4604	}
sl@0	4605	err = CompareInterface(_L8("PercussionKeyNameL"));
sl@0	4606	INFO_PRINTF3(_L("Check interface PercussionKeyNameL gave error %d (expected %d)"), err, expErr);
sl@0	4607	if(err != expErr)
sl@0	4608	{
sl@0	4609	ret = EFail;
sl@0	4610	return ret;
sl@0	4611	}
sl@0	4612
sl@0	4613	//
sl@0	4614	//StopTimeL//
sl@0	4615	//
sl@0	4616	{
sl@0	4617	TTimeIntervalMicroSeconds stopTime(0);
sl@0	4618	TRAP_IGNORE(aMidi->StopTimeL(stopTime));
sl@0	4619	}
sl@0	4620	err = CompareInterface(_L8("StopTimeL"));
sl@0	4621	INFO_PRINTF3(_L("Check interface StopTimeL gave error %d (expected %d)"), err, expErr);
sl@0	4622	if(err != expErr)
sl@0	4623	{
sl@0	4624	ret = EFail;
sl@0	4625	return ret;
sl@0	4626	}
sl@0	4627
sl@0	4628	//
sl@0	4629	//SetStopTimeL//
sl@0	4630	//
sl@0	4631	{
sl@0	4632	TTimeIntervalMicroSeconds stopTime(0);
sl@0	4633	TRAP_IGNORE(aMidi->SetStopTimeL(stopTime));
sl@0	4634	}
sl@0	4635	err = CompareInterface(_L8("SetStopTimeL"));
sl@0	4636	INFO_PRINTF3(_L("Check interface SetStopTimeL gave error %d (expected %d)"), err, expErr);
sl@0	4637	if(err != expErr)
sl@0	4638	{
sl@0	4639	ret = EFail;
sl@0	4640	return ret;
sl@0	4641	}
sl@0	4642
sl@0	4643	//
sl@0	4644	//SetRepeatsL//
sl@0	4645	//
sl@0	4646	{
sl@0	4647	TInt repeatNumberOfTimes = 0;
sl@0	4648	TTimeIntervalMicroSeconds trailingSilence(0);
sl@0	4649	TRAP_IGNORE(aMidi->SetRepeatsL(repeatNumberOfTimes, trailingSilence));
sl@0	4650	}
sl@0	4651	err = CompareInterface(_L8("SetRepeatsL"));
sl@0	4652	INFO_PRINTF3(_L("Check interface SetRepeatsL gave error %d (expected %d)"), err, expErr);
sl@0	4653	if(err != expErr)
sl@0	4654	{
sl@0	4655	ret = EFail;
sl@0	4656	return ret;
sl@0	4657	}
sl@0	4658	//
sl@0	4659	//GetRepeats//
sl@0	4660	//
sl@0	4661	TRAP_IGNORE(aMidi->GetRepeats());
sl@0	4662	err = CompareInterface(_L8("GetRepeats"));
sl@0	4663	INFO_PRINTF3(_L("Check interface GetRepeats gave error %d (expected %d)"), err, expErr);
sl@0	4664	if(err != expErr)
sl@0	4665	{
sl@0	4666	ret = EFail;
sl@0	4667	return ret;
sl@0	4668	}
sl@0	4669
sl@0	4670
sl@0	4671	//
sl@0	4672	//PolyphonyL//
sl@0	4673	//
sl@0	4674	TRAP_IGNORE(aMidi->PolyphonyL());
sl@0	4675	err = CompareInterface(_L8("PolyphonyL"));
sl@0	4676	INFO_PRINTF3(_L("Check interface PolyphonyL gave error %d (expected %d)"), err, expErr);
sl@0	4677	if(err != expErr)
sl@0	4678	{
sl@0	4679	ret = EFail;
sl@0	4680	return ret;
sl@0	4681	}
sl@0	4682
sl@0	4683	//
sl@0	4684	//SetMaxPolyphonyL//
sl@0	4685	//
sl@0	4686	TRAP_IGNORE(aMidi->SetMaxPolyphonyL(1));
sl@0	4687	err = CompareInterface(_L8("SetMaxPolyphonyL"));
sl@0	4688	INFO_PRINTF3(_L("Check interface SetMaxPolyphonyL gave error %d (expected %d)"), err, expErr);
sl@0	4689	if(err != expErr)
sl@0	4690	{
sl@0	4691	ret = EFail;
sl@0	4692	return ret;
sl@0	4693	}
sl@0	4694
sl@0	4695	//
sl@0	4696	//ChannelsSupportedL//
sl@0	4697	//
sl@0	4698	TRAP_IGNORE(aMidi->ChannelsSupportedL());
sl@0	4699	err = CompareInterface(_L8("ChannelsSupportedL"));
sl@0	4700	INFO_PRINTF3(_L("Check interface ChannelsSupportedL gave error %d (expected %d)"), err, expErr);
sl@0	4701	if(err != expErr)
sl@0	4702	{
sl@0	4703	ret = EFail;
sl@0	4704	return ret;
sl@0	4705	}
sl@0	4706
sl@0	4707	//
sl@0	4708	//ChannelVolumeL//
sl@0	4709	//
sl@0	4710	TRAP_IGNORE(aMidi->ChannelVolumeL(0));
sl@0	4711	err = CompareInterface(_L8("ChannelVolumeL"));
sl@0	4712	INFO_PRINTF3(_L("Check interface ChannelVolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4713	if(err != expErr)
sl@0	4714	{
sl@0	4715	ret = EFail;
sl@0	4716	return ret;
sl@0	4717	}
sl@0	4718
sl@0	4719	//
sl@0	4720	//MaxChannelVolumeL//
sl@0	4721	//
sl@0	4722	TRAP_IGNORE(aMidi->MaxChannelVolumeL());
sl@0	4723	err = CompareInterface(_L8("MaxChannelVolumeL"));
sl@0	4724	INFO_PRINTF3(_L("Check interface MaxChannelVolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4725	if(err != expErr)
sl@0	4726	{
sl@0	4727	ret = EFail;
sl@0	4728	return ret;
sl@0	4729	}
sl@0	4730
sl@0	4731	//
sl@0	4732	//SetChannelVolumeL//
sl@0	4733	//
sl@0	4734	TRAP_IGNORE(aMidi->SetChannelVolumeL(0,0));
sl@0	4735	err = CompareInterface(_L8("SetChannelVolumeL"));
sl@0	4736	INFO_PRINTF3(_L("Check interface SetChannelVolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4737	if(err != expErr)
sl@0	4738	{
sl@0	4739	ret = EFail;
sl@0	4740	return ret;
sl@0	4741	}
sl@0	4742
sl@0	4743	//
sl@0	4744	//SetChannelMuteL//
sl@0	4745	//
sl@0	4746	TRAP_IGNORE(aMidi->SetChannelMuteL(0,0));
sl@0	4747	err = CompareInterface(_L8("SetChannelMuteL"));
sl@0	4748	INFO_PRINTF3(_L("Check interface SetChannelMuteL gave error %d (expected %d)"), err, expErr);
sl@0	4749	if(err != expErr)
sl@0	4750	{
sl@0	4751	ret = EFail;
sl@0	4752	return ret;
sl@0	4753	}
sl@0	4754
sl@0	4755	//
sl@0	4756	//VolumeL//
sl@0	4757	//
sl@0	4758	TRAP_IGNORE(aMidi->VolumeL());
sl@0	4759	err = CompareInterface(_L8("VolumeL"));
sl@0	4760	INFO_PRINTF3(_L("Check interface VolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4761	if(err != expErr)
sl@0	4762	{
sl@0	4763	ret = EFail;
sl@0	4764	return ret;
sl@0	4765	}
sl@0	4766
sl@0	4767	//
sl@0	4768	//MaxVolumeL//
sl@0	4769	//
sl@0	4770	TRAP_IGNORE(aMidi->MaxVolumeL());
sl@0	4771	err = CompareInterface(_L8("MaxVolumeL"));
sl@0	4772	INFO_PRINTF3(_L("Check interface MaxVolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4773	if(err != expErr)
sl@0	4774	{
sl@0	4775	ret = EFail;
sl@0	4776	return ret;
sl@0	4777	}
sl@0	4778
sl@0	4779	//
sl@0	4780	//SetVolumeL//
sl@0	4781	//
sl@0	4782	TRAP_IGNORE(aMidi->SetVolumeL(0));
sl@0	4783	err = CompareInterface(_L8("SetVolumeL"));
sl@0	4784	INFO_PRINTF3(_L("Check interface SetVolumeL gave error %d (expected %d)"), err, expErr);
sl@0	4785	if(err != expErr)
sl@0	4786	{
sl@0	4787	ret = EFail;
sl@0	4788	return ret;
sl@0	4789	}
sl@0	4790
sl@0	4791	//
sl@0	4792	//SetVolumeRampL//
sl@0	4793	//
sl@0	4794	TRAP_IGNORE(aMidi->SetVolumeRampL(TTimeIntervalMicroSeconds(0)));
sl@0	4795	err = CompareInterface(_L8("SetVolumeRampL"));
sl@0	4796	INFO_PRINTF3(_L("Check interface SetVolumeRampL gave error %d (expected %d)"), err, expErr);
sl@0	4797	if(err != expErr)
sl@0	4798	{
sl@0	4799	ret = EFail;
sl@0	4800	return ret;
sl@0	4801	}
sl@0	4802
sl@0	4803	//
sl@0	4804	//GetBalanceL//
sl@0	4805	//
sl@0	4806	TRAP_IGNORE(aMidi->GetBalanceL());
sl@0	4807	err = CompareInterface(_L8("GetBalanceL"));
sl@0	4808	INFO_PRINTF3(_L("Check interface GetBalanceL gave error %d (expected %d)"), err, expErr);
sl@0	4809	if(err != expErr)
sl@0	4810	{
sl@0	4811	ret = EFail;
sl@0	4812	return ret;
sl@0	4813	}
sl@0	4814
sl@0	4815	//
sl@0	4816	//SetBalanceL//
sl@0	4817	//
sl@0	4818	TRAP_IGNORE(aMidi->SetBalanceL());
sl@0	4819	err = CompareInterface(_L8("SetBalanceL"));
sl@0	4820	INFO_PRINTF3(_L("Check interface SetBalanceL gave error %d (expected %d)"), err, expErr);
sl@0	4821	if(err != expErr)
sl@0	4822	{
sl@0	4823	ret = EFail;
sl@0	4824	return ret;
sl@0	4825	}
sl@0	4826
sl@0	4827	//
sl@0	4828	//SetBankL//
sl@0	4829	//
sl@0	4830	TRAP_IGNORE(aMidi->SetBankL(ETrue));
sl@0	4831	err = CompareInterface(_L8("SetBankL"));
sl@0	4832	INFO_PRINTF3(_L("Check interface SetBankL gave error %d (expected %d)"), err, expErr);
sl@0	4833	if(err != expErr)
sl@0	4834	{
sl@0	4835	ret = EFail;
sl@0	4836	return ret;
sl@0	4837	}
sl@0	4838
sl@0	4839	//
sl@0	4840	//IsTrackMuteL//
sl@0	4841	//
sl@0	4842	TRAP_IGNORE(aMidi->IsTrackMuteL(0));
sl@0	4843	err = CompareInterface(_L8("IsTrackMuteL"));
sl@0	4844	INFO_PRINTF3(_L("Check interface IsTrackMuteL gave error %d (expected %d)"), err, expErr);
sl@0	4845	if(err != expErr)
sl@0	4846	{
sl@0	4847	ret = EFail;
sl@0	4848	return ret;
sl@0	4849	}
sl@0	4850
sl@0	4851	//
sl@0	4852	//IsChannelMuteL//
sl@0	4853	//
sl@0	4854	TRAP_IGNORE(aMidi->IsChannelMuteL(0));
sl@0	4855	err = CompareInterface(_L8("IsChannelMuteL"));
sl@0	4856	INFO_PRINTF3(_L("Check interface IsChannelMuteL gave error %d (expected %d)"), err, expErr);
sl@0	4857	if(err != expErr)
sl@0	4858	{
sl@0	4859	ret = EFail;
sl@0	4860	return ret;
sl@0	4861	}
sl@0	4862
sl@0	4863	return ret;
sl@0	4864	}
sl@0	4865
sl@0	4866	TInt CTestCheckInterface::CompareInterface(const TDesC8& aInterfaceName)
sl@0	4867	{
sl@0	4868	TBuf8<40> clientBuf;
sl@0	4869	TBuf8<40> controllerBuf;
sl@0	4870	clientBuf.FillZ(40);
sl@0	4871	controllerBuf.FillZ(40);
sl@0	4872
sl@0	4873	clientBuf.Copy(aInterfaceName);
sl@0	4874	iSemaphore.Wait();
sl@0	4875	controllerBuf = iChunk.Base();
sl@0	4876	controllerBuf.SetLength(aInterfaceName.Length());
sl@0	4877
sl@0	4878	TInt err = clientBuf.Compare(controllerBuf);
sl@0	4879
sl@0	4880	return err;
sl@0	4881	}
sl@0	4882
sl@0	4883	//--------------------------------------------------------------------------------
sl@0	4884	//MS 3.4 File Handles API
sl@0	4885	//--------------------------------------------------------------------------------
sl@0	4886	CTestMidiClntOpenFileByHandle::CTestMidiClntOpenFileByHandle(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TTestStepType aTestType)
sl@0	4887	:CTestMmfMidiClntStep(aTestName, aTestType),
sl@0	4888	iPlay(aPlay)
sl@0	4889	{
sl@0	4890	iSectName = aSectName;
sl@0	4891	iKeyName = aKeyName;
sl@0	4892	}
sl@0	4893
sl@0	4894	CTestMidiClntOpenFileByHandle* CTestMidiClntOpenFileByHandle::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TTestStepType aTestType)
sl@0	4895	{
sl@0	4896	CTestMidiClntOpenFileByHandle* self = new(ELeave) CTestMidiClntOpenFileByHandle(aTestName, aSectName, aKeyName, aPlay, aTestType);
sl@0	4897	return self;
sl@0	4898	}
sl@0	4899
sl@0	4900	TVerdict CTestMidiClntOpenFileByHandle::DoTestStepL()
sl@0	4901	{
sl@0	4902	//[ Local variables ]
sl@0	4903	TPtrC filename;
sl@0	4904	TInt expErr = KErrNone;
sl@0	4905	TVerdict ret = EFail;
sl@0	4906
sl@0	4907	//[ Get the File name from ini file ]
sl@0	4908	if(!GetStringFromConfig(iSectName,iKeyName,filename))
sl@0	4909	{
sl@0	4910	return EInconclusive;
sl@0	4911	}
sl@0	4912
sl@0	4913	//[ Expected results ]
sl@0	4914	switch(iTestType)
sl@0	4915	{
sl@0	4916	case ETestValid:
sl@0	4917	expErr = KErrNone;
sl@0	4918	break;
sl@0	4919	case ETestNegative:
sl@0	4920	expErr = KErrNotSupported;
sl@0	4921	break;
sl@0	4922	default:
sl@0	4923	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	4924	return EInconclusive;
sl@0	4925	}
sl@0	4926
sl@0	4927	//[ Create CMidiClientUtility - player ]
sl@0	4928	CMidiClientUtility* player=NULL;
sl@0	4929	TRAPD(err1, player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality));
sl@0	4930	if (err1 != KErrNone)
sl@0	4931	{
sl@0	4932	ERR_PRINTF2(_L("Error while creating a CMidiClientUtility : %d"),err1);
sl@0	4933	return EInconclusive;
sl@0	4934	}
sl@0	4935
sl@0	4936	if (!player)
sl@0	4937	{
sl@0	4938	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	4939	return EInconclusive;
sl@0	4940	}
sl@0	4941	CleanupStack::PushL(player);
sl@0	4942
sl@0	4943	TMMFMessageDestinationPckg dummyPckg;
sl@0	4944	TInt dummyFunc = EDevMidiOff;
sl@0	4945	TBuf8<8> dummyBuff;
sl@0	4946	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);
sl@0	4947
sl@0	4948	//[ RFs and RFile ]
sl@0	4949	RFs rFs;
sl@0	4950	RFile rFile;
sl@0	4951
sl@0	4952	//[ Connect to File System using RFs ]
sl@0	4953	User::LeaveIfError(rFs.Connect());
sl@0	4954	CleanupClosePushL(rFs);
sl@0	4955	User::LeaveIfError(rFs.ShareProtected());
sl@0	4956
sl@0	4957	//[ Open the file using RFile ]
sl@0	4958	TFileName theDestinationFileName;
sl@0	4959	theDestinationFileName.Append(filename);
sl@0	4960
sl@0	4961	INFO_PRINTF2(_L("Start : Opening the file : %S by RFile"), &filename);
sl@0	4962	TInt theRes = rFile.Open(rFs, theDestinationFileName, EFileRead);
sl@0	4963	User::LeaveIfError(theRes);
sl@0	4964	CleanupClosePushL(rFile);
sl@0	4965	INFO_PRINTF2(_L("End : Opening the file : %S by RFile"), &filename);
sl@0	4966
sl@0	4967	//[ API Call ]
sl@0	4968	player->OpenFile(rFile);
sl@0	4969
sl@0	4970	//[ Wait for Initialisation Callback ]
sl@0	4971	INFO_PRINTF1(_L("Start : CMidiClientUtility->OpenFile()"));
sl@0	4972	CActiveScheduler::Start();
sl@0	4973	INFO_PRINTF1(_L("End : CMidiClientUtility->OpenFile()"));
sl@0	4974
sl@0	4975	//[ Check for errors ]
sl@0	4976	if (iError == expErr)
sl@0	4977	{
sl@0	4978	INFO_PRINTF3(_L("Expected Error : %d, Actual Error : %d"), expErr, iError);
sl@0	4979	ret = EPass;
sl@0	4980	}
sl@0	4981	else
sl@0	4982	{
sl@0	4983	ERR_PRINTF3(_L("Expected Error : %d, Actual Error : %d"), expErr, iError);
sl@0	4984	ret = EFail;
sl@0	4985	}
sl@0	4986
sl@0	4987	//[ Clean-up RFs, RFile and CMidiClientUtility ]
sl@0	4988	CleanupStack::PopAndDestroy(3);
sl@0	4989
sl@0	4990	return ret;
sl@0	4991	}
sl@0	4992
sl@0	4993
sl@0	4994	//------------------------------------------------------------------------
sl@0	4995
sl@0	4996	CTestMidiClntPlayFileByHandle::CTestMidiClntPlayFileByHandle(const TDesC& aTestName)
sl@0	4997	:CTestMmfMidiClntStep(aTestName, ETestValid)
sl@0	4998	{
sl@0	4999	}
sl@0	5000
sl@0	5001	CTestMidiClntPlayFileByHandle* CTestMidiClntPlayFileByHandle::NewL(const TDesC& aTestName)
sl@0	5002	{
sl@0	5003	CTestMidiClntPlayFileByHandle* self = new(ELeave) CTestMidiClntPlayFileByHandle(aTestName);
sl@0	5004	return self;
sl@0	5005	}
sl@0	5006
sl@0	5007	TVerdict CTestMidiClntPlayFileByHandle::DoTestL(CMidiClientUtility* aMidi)
sl@0	5008	{
sl@0	5009	//[ Local variables ]
sl@0	5010	TPtrC filename;
sl@0	5011
sl@0	5012	//[ Get the filename ]
sl@0	5013	if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),filename))
sl@0	5014	{
sl@0	5015	return EInconclusive;
sl@0	5016	}
sl@0	5017
sl@0	5018	INFO_PRINTF1(_L("CMidiClientUtility : Play MIDI File"));
sl@0	5019
sl@0	5020	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5021
sl@0	5022	//[ RFs and RFile ]
sl@0	5023	RFs rFs;
sl@0	5024	RFile rFile;
sl@0	5025
sl@0	5026	//[ Connect to File System using RFs ]
sl@0	5027	User::LeaveIfError(rFs.Connect());
sl@0	5028	CleanupClosePushL(rFs);
sl@0	5029	User::LeaveIfError(rFs.ShareProtected());
sl@0	5030
sl@0	5031	INFO_PRINTF1(_L("Opening the file : c:\\DoesntExist.mid"));
sl@0	5032
sl@0	5033	//[ Open the file using RFile ]
sl@0	5034	TInt theRes = rFile.Open(rFs, filename, EFileRead);
sl@0	5035	if(theRes != KErrNone)
sl@0	5036	{
sl@0	5037	INFO_PRINTF2(_L("Cannot open file : %S"), &filename);
sl@0	5038	}
sl@0	5039	CleanupClosePushL(rFile);
sl@0	5040
sl@0	5041	//[ Call the OpenFile Method using the File Handle ]
sl@0	5042	aMidi->OpenFile(rFile);
sl@0	5043
sl@0	5044	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5045	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged
sl@0	5046
sl@0	5047	//[ Clean up RFs and RFile ]
sl@0	5048	CleanupStack::PopAndDestroy(2);
sl@0	5049
sl@0	5050	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	5051	{
sl@0	5052	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5053	return EFail;
sl@0	5054	}
sl@0	5055	aMidi->Play();
sl@0	5056	if (iError != KErrNone)
sl@0	5057	{
sl@0	5058	ERR_PRINTF2(_L("Play gave error %d"),iError);
sl@0	5059	return EFail;
sl@0	5060	}
sl@0	5061
sl@0	5062	INFO_PRINTF1(_L("Waiting for EMidiStateOpenPlaying state..."));
sl@0	5063	CActiveScheduler::Start(); // EMidiStateOpenDisengaged ->EMidiStateOpenPlaying
sl@0	5064	if (iCurrentState != EMidiStateOpenPlaying)
sl@0	5065	{
sl@0	5066	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState);
sl@0	5067	return EFail;
sl@0	5068	}
sl@0	5069
sl@0	5070	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5071	CActiveScheduler::Start(); // EMidiStateOpenPlaying ->EMidiStateOpenEngaged
sl@0	5072	if (iCurrentState != EMidiStateOpenEngaged)
sl@0	5073	{
sl@0	5074	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5075	return EFail;
sl@0	5076	}
sl@0	5077
sl@0	5078	return EPass;
sl@0	5079	}
sl@0	5080
sl@0	5081
sl@0	5082	//------------------------------------------------------------------------
sl@0	5083	// The purpose of this test is that we can hold more than 10 events in the
sl@0	5084	// MIDI event queue and none of them gets lost
sl@0	5085
sl@0	5086	CTestMidiClntThirteenMidiEvents::CTestMidiClntThirteenMidiEvents(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5087	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	5088	{
sl@0	5089	// set the current transion to 0, the start point
sl@0	5090	iCurrentTransion = 0;
sl@0	5091	}
sl@0	5092
sl@0	5093
sl@0	5094	CTestMidiClntThirteenMidiEvents* CTestMidiClntThirteenMidiEvents::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5095	{
sl@0	5096	CTestMidiClntThirteenMidiEvents* self = new(ELeave)CTestMidiClntThirteenMidiEvents(aTestName, aTestType);
sl@0	5097	return self;
sl@0	5098	}
sl@0	5099
sl@0	5100	void CTestMidiClntThirteenMidiEvents::InitialiseExpectedTransArrayL()
sl@0	5101	{
sl@0	5102	User::LeaveIfError(expectedTransitions.Append(EMmcuoTempoChanged));
sl@0	5103	User::LeaveIfError(expectedTransitions.Append(EMmcuoVolumeChanged));
sl@0	5104	User::LeaveIfError(expectedTransitions.Append(EMmcuoMuteChanged));
sl@0	5105	User::LeaveIfError(expectedTransitions.Append(EMmcuoPolyphonyChanged));
sl@0	5106	User::LeaveIfError(expectedTransitions.Append(EMmcuoInstrumentChanged));
sl@0	5107	User::LeaveIfError(expectedTransitions.Append(EMmcuoMetaDataEntryFound));
sl@0	5108	User::LeaveIfError(expectedTransitions.Append(EMmcuoVolumeChanged));
sl@0	5109	User::LeaveIfError(expectedTransitions.Append(EMmcuoMuteChanged));
sl@0	5110	User::LeaveIfError(expectedTransitions.Append(EMmcuoPolyphonyChanged));
sl@0	5111	User::LeaveIfError(expectedTransitions.Append(EMmcuoInstrumentChanged));
sl@0	5112	User::LeaveIfError(expectedTransitions.Append(EMmcuoMetaDataEntryFound));
sl@0	5113	User::LeaveIfError(expectedTransitions.Append(EMmcuoMipMessageReceived));
sl@0	5114	User::LeaveIfError(expectedTransitions.Append(EMmcuoMipMessageReceived));
sl@0	5115
sl@0	5116	}
sl@0	5117
sl@0	5118	void CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged(TInt /aMicroBeatsPerMinute/)
sl@0	5119	{
sl@0	5120	if (expectedTransitions[iCurrentTransion] == EMmcuoTempoChanged)
sl@0	5121	{
sl@0	5122	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged callback"));
sl@0	5123	iCurrentTransion++;
sl@0	5124	}
sl@0	5125	else
sl@0	5126	{
sl@0	5127	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged callback not expected"));
sl@0	5128	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5129	}
sl@0	5130	}
sl@0	5131
sl@0	5132	void CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged(TInt /aChannel/,TReal32 /aVolumeInDecibels/)
sl@0	5133	{
sl@0	5134	if (expectedTransitions[iCurrentTransion] == EMmcuoVolumeChanged)
sl@0	5135	{
sl@0	5136	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged callback"));
sl@0	5137	iCurrentTransion++;
sl@0	5138	}
sl@0	5139	else
sl@0	5140	{
sl@0	5141	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged callback not expected"));
sl@0	5142	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5143	}
sl@0	5144	}
sl@0	5145
sl@0	5146	void CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged(TInt /aChannel/,TBool /aMuted/)
sl@0	5147	{
sl@0	5148	if (expectedTransitions[iCurrentTransion] == EMmcuoMuteChanged)
sl@0	5149	{
sl@0	5150	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged callback"));
sl@0	5151	iCurrentTransion++;
sl@0	5152	}
sl@0	5153	else
sl@0	5154	{
sl@0	5155	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged callback not expected"));
sl@0	5156	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5157	}
sl@0	5158	}
sl@0	5159
sl@0	5160
sl@0	5161	void CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound(const TInt /aMetaDataEntryId/,const TTimeIntervalMicroSeconds& /aPosition/)
sl@0	5162	{
sl@0	5163	if (expectedTransitions[iCurrentTransion] == EMmcuoMetaDataEntryFound)
sl@0	5164	{
sl@0	5165	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound callback"));
sl@0	5166	iCurrentTransion++;
sl@0	5167	}
sl@0	5168	else
sl@0	5169	{
sl@0	5170	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound callback not expected"));
sl@0	5171	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5172	}
sl@0	5173	}
sl@0	5174
sl@0	5175	void CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived(const RArray<TMipMessageEntry>& /aEntry/)
sl@0	5176	{
sl@0	5177	if (expectedTransitions[iCurrentTransion] == EMmcuoMipMessageReceived)
sl@0	5178	{
sl@0	5179	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived callback"));
sl@0	5180	iCurrentTransion++;
sl@0	5181	}
sl@0	5182	else
sl@0	5183	{
sl@0	5184	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived callback not expected"));
sl@0	5185	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5186	}
sl@0	5187	}
sl@0	5188
sl@0	5189	void CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged(TInt /aNewPolyphony/)
sl@0	5190	{
sl@0	5191	if (expectedTransitions[iCurrentTransion] == EMmcuoPolyphonyChanged)
sl@0	5192	{
sl@0	5193	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged callback"));
sl@0	5194	iCurrentTransion++;
sl@0	5195	}
sl@0	5196	else
sl@0	5197	{
sl@0	5198	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged callback not expected"));
sl@0	5199	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5200	}
sl@0	5201	}
sl@0	5202
sl@0	5203	void CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged(TInt /aChannel/,TInt /aBankId/,TInt /aInstrumentId/)
sl@0	5204	{
sl@0	5205	if (expectedTransitions[iCurrentTransion] == EMmcuoInstrumentChanged)
sl@0	5206	{
sl@0	5207	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged callback"));
sl@0	5208	iCurrentTransion++;
sl@0	5209	}
sl@0	5210	else
sl@0	5211	{
sl@0	5212	INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged callback not expected"));
sl@0	5213	expectedTransitions[iCurrentTransion] = EMmcuoInvalid;
sl@0	5214	}
sl@0	5215	}
sl@0	5216
sl@0	5217
sl@0	5218	TVerdict CTestMidiClntThirteenMidiEvents::DoTestL(CMidiClientUtility* aMidi)
sl@0	5219	{
sl@0	5220	TVerdict ret = EPass;
sl@0	5221	TInt expErr = KErrNone;
sl@0	5222
sl@0	5223	InitialiseExpectedTransArrayL();
sl@0	5224
sl@0	5225	TPtrC fileName;
sl@0	5226	if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName))
sl@0	5227	{
sl@0	5228	return EInconclusive;
sl@0	5229	}
sl@0	5230
sl@0	5231	INFO_PRINTF1(_L("CMidiClientUtility: Play midi file"));
sl@0	5232	// expected results
sl@0	5233	switch(iTestType)
sl@0	5234	{
sl@0	5235	case ETestValid:
sl@0	5236	expErr = KErrNone;
sl@0	5237	break;
sl@0	5238	case ETestNoPlugin:
sl@0	5239	expErr = KErrNotSupported;
sl@0	5240	break;
sl@0	5241	case ETestInvalidState:
sl@0	5242	expErr = KErrUnknown;
sl@0	5243	break;
sl@0	5244	default:
sl@0	5245	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	5246	return EInconclusive;
sl@0	5247	}
sl@0	5248
sl@0	5249	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5250	aMidi->OpenFile(fileName);
sl@0	5251	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5252	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged
sl@0	5253	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	5254	{
sl@0	5255	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5256	expectedTransitions.Close();
sl@0	5257	return EFail;
sl@0	5258	}
sl@0	5259
sl@0	5260	aMidi->Play();
sl@0	5261	if (expErr != iError)
sl@0	5262	{
sl@0	5263	ERR_PRINTF3(_L("Play gave error %d (expected %d)"),iError, expErr);
sl@0	5264	expectedTransitions.Close();
sl@0	5265	return EFail;
sl@0	5266	}
sl@0	5267	else
sl@0	5268	{
sl@0	5269	INFO_PRINTF3(_L("Play, %d = %d"), iError, expErr);
sl@0	5270	}
sl@0	5271
sl@0	5272
sl@0	5273	INFO_PRINTF1(_L("Waiting for EMidiStateOpenPlaying state..."));
sl@0	5274	CActiveScheduler::Start(); // EMidiStateOpenDisengaged ->EMidiStateOpenPlaying
sl@0	5275	if (iCurrentState != EMidiStateOpenPlaying)
sl@0	5276	{
sl@0	5277	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState);
sl@0	5278	expectedTransitions.Close();
sl@0	5279	return EFail;
sl@0	5280	}
sl@0	5281	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5282	CActiveScheduler::Start(); // EMidiStateOpenPlaying ->EMidiStateOpenEngaged
sl@0	5283	if (iCurrentState != EMidiStateOpenEngaged)
sl@0	5284	{
sl@0	5285	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState);
sl@0	5286	expectedTransitions.Close();
sl@0	5287	return EFail;
sl@0	5288	}
sl@0	5289
sl@0	5290	if (expectedTransitions.Find(EMmcuoInvalid) != KErrNotFound)
sl@0	5291	{
sl@0	5292	ERR_PRINTF1(_L("One of the transactions was lost"));
sl@0	5293	expectedTransitions.Close();
sl@0	5294	return EFail;
sl@0	5295	}
sl@0	5296
sl@0	5297	expectedTransitions.Close();
sl@0	5298
sl@0	5299	return ret;
sl@0	5300	}
sl@0	5301
sl@0	5302	//------------------------------------------------------------------
sl@0	5303	// TEST 1: Test the transtion from EMidiStateClosedDisengaged to EMidiStateClosedEngaged.
sl@0	5304
sl@0	5305	CTestTrasitionFromEClosedToEClosedEngaged::CTestTrasitionFromEClosedToEClosedEngaged(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5306	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	5307	{
sl@0	5308	}
sl@0	5309
sl@0	5310	CTestTrasitionFromEClosedToEClosedEngaged* CTestTrasitionFromEClosedToEClosedEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5311	{
sl@0	5312	CTestTrasitionFromEClosedToEClosedEngaged* self = new(ELeave) CTestTrasitionFromEClosedToEClosedEngaged(aTestName, aTestType);
sl@0	5313	return self;
sl@0	5314	}
sl@0	5315
sl@0	5316	TVerdict CTestTrasitionFromEClosedToEClosedEngaged::DoTestL(CMidiClientUtility* aMidi)
sl@0	5317	{
sl@0	5318	//[ Local variables ]
sl@0	5319	TVerdict ret = EPass;
sl@0	5320	TInt expErr = KErrNone;
sl@0	5321
sl@0	5322	INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedDisengaged to EMidiStateClosedEngaged"));
sl@0	5323	//[ Expected results ]
sl@0	5324	switch(iTestType)
sl@0	5325	{
sl@0	5326	case ETestValid:
sl@0	5327	expErr = KErrNone;
sl@0	5328	break;
sl@0	5329	case ETestNoPlugin:
sl@0	5330	expErr = KErrNotSupported;
sl@0	5331	break;
sl@0	5332	case ETestInvalidState:
sl@0	5333	expErr = KErrUnknown;
sl@0	5334	break;
sl@0	5335	default:
sl@0	5336	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	5337	return EInconclusive;
sl@0	5338	}
sl@0	5339
sl@0	5340	//[ Set the current state to EMidiStateClosedDisengaged ]
sl@0	5341	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5342
sl@0	5343	//[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ]
sl@0	5344	TMidiState MIDIClientState = aMidi->State();
sl@0	5345
sl@0	5346	if (MIDIClientState == EMidiStateClosedDisengaged)
sl@0	5347	{
sl@0	5348	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged"));
sl@0	5349	}
sl@0	5350	else
sl@0	5351	{
sl@0	5352	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState);
sl@0	5353	return EFail;
sl@0	5354	}
sl@0	5355
sl@0	5356	// [ Call Play() ]
sl@0	5357	aMidi->Play();
sl@0	5358	if (expErr != iError)
sl@0	5359	{
sl@0	5360	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5361	return EFail;
sl@0	5362	}
sl@0	5363
sl@0	5364	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateClosedEngaged
sl@0	5365
sl@0	5366	if (iCurrentState != EMidiStateClosedEngaged)
sl@0	5367	{
sl@0	5368	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState);
sl@0	5369	return EFail;
sl@0	5370	}
sl@0	5371
sl@0	5372	MIDIClientState = aMidi->State();
sl@0	5373
sl@0	5374	if (MIDIClientState == EMidiStateClosedEngaged)
sl@0	5375	{
sl@0	5376	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged"));
sl@0	5377	}
sl@0	5378	else
sl@0	5379	{
sl@0	5380	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState);
sl@0	5381	return EFail;
sl@0	5382	}
sl@0	5383
sl@0	5384	return ret;
sl@0	5385	}
sl@0	5386
sl@0	5387
sl@0	5388	//------------------------------------------------------------------
sl@0	5389	// TEST 2: Test the transtion from EMidiStateClosedDisengaged to EMidiStateOpenEngaged.
sl@0	5390
sl@0	5391	CTestTrasitionFromEClosedToEOpenEngaged::CTestTrasitionFromEClosedToEOpenEngaged(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5392	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	5393	{
sl@0	5394	}
sl@0	5395
sl@0	5396	CTestTrasitionFromEClosedToEOpenEngaged* CTestTrasitionFromEClosedToEOpenEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5397	{
sl@0	5398	CTestTrasitionFromEClosedToEOpenEngaged* self = new(ELeave) CTestTrasitionFromEClosedToEOpenEngaged(aTestName, aTestType);
sl@0	5399	return self;
sl@0	5400	}
sl@0	5401
sl@0	5402	TVerdict CTestTrasitionFromEClosedToEOpenEngaged::DoTestL(CMidiClientUtility* aMidi)
sl@0	5403	{
sl@0	5404	//[ Local variables ]
sl@0	5405	TVerdict ret = EPass;
sl@0	5406	TInt expErr = KErrNone;
sl@0	5407
sl@0	5408	INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedDisengaged to EMidiStateOpenEngaged"));
sl@0	5409	//[ Expected results ]
sl@0	5410	switch(iTestType)
sl@0	5411	{
sl@0	5412	case ETestValid:
sl@0	5413	expErr = KErrNone;
sl@0	5414	break;
sl@0	5415	case ETestNoPlugin:
sl@0	5416	expErr = KErrNotSupported;
sl@0	5417	break;
sl@0	5418	case ETestInvalidState:
sl@0	5419	expErr = KErrUnknown;
sl@0	5420	break;
sl@0	5421	default:
sl@0	5422	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	5423	return EInconclusive;
sl@0	5424	}
sl@0	5425
sl@0	5426	//[ Set the current state to EMidiStateClosedDisengaged ]
sl@0	5427	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5428
sl@0	5429	//[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ]
sl@0	5430	TMidiState MIDIClientState = aMidi->State();
sl@0	5431
sl@0	5432	if (MIDIClientState == EMidiStateClosedDisengaged)
sl@0	5433	{
sl@0	5434	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged"));
sl@0	5435	}
sl@0	5436	else
sl@0	5437	{
sl@0	5438	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState);
sl@0	5439	return EFail;
sl@0	5440	}
sl@0	5441
sl@0	5442	// [ Call OpenFile() ]
sl@0	5443	TPtrC fileName;
sl@0	5444	if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName))
sl@0	5445	{
sl@0	5446	return EInconclusive;
sl@0	5447	}
sl@0	5448	aMidi->OpenFile(fileName);
sl@0	5449
sl@0	5450	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged(EMidiStateOpenDisengaged)
sl@0	5451	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	5452	{
sl@0	5453	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5454	return EFail;
sl@0	5455	}
sl@0	5456
sl@0	5457	MIDIClientState = aMidi->State();
sl@0	5458	if (MIDIClientState == EMidiStateOpenDisengaged)
sl@0	5459	{
sl@0	5460	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged"));
sl@0	5461	}
sl@0	5462	else
sl@0	5463	{
sl@0	5464	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState);
sl@0	5465	return EFail;
sl@0	5466	}
sl@0	5467
sl@0	5468	// [ Call Play() ]
sl@0	5469	aMidi->Play();
sl@0	5470	if (expErr != iError)
sl@0	5471	{
sl@0	5472	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5473	return EFail;
sl@0	5474	}
sl@0	5475
sl@0	5476	CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying
sl@0	5477
sl@0	5478	if (iCurrentState != EMidiStateOpenPlaying)
sl@0	5479	{
sl@0	5480	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState);
sl@0	5481	return EFail;
sl@0	5482	}
sl@0	5483
sl@0	5484	MIDIClientState = aMidi->State();
sl@0	5485	if (MIDIClientState == EMidiStateOpenPlaying)
sl@0	5486	{
sl@0	5487	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying"));
sl@0	5488	}
sl@0	5489	else
sl@0	5490	{
sl@0	5491	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState);
sl@0	5492	return EFail;
sl@0	5493	}
sl@0	5494
sl@0	5495	CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged
sl@0	5496
sl@0	5497	if (iCurrentState != EMidiStateOpenEngaged)
sl@0	5498	{
sl@0	5499	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState);
sl@0	5500	return EFail;
sl@0	5501	}
sl@0	5502
sl@0	5503	MIDIClientState = aMidi->State();
sl@0	5504
sl@0	5505	if (MIDIClientState == EMidiStateOpenEngaged)
sl@0	5506	{
sl@0	5507	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged"));
sl@0	5508	}
sl@0	5509	else
sl@0	5510	{
sl@0	5511	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState);
sl@0	5512	return EFail;
sl@0	5513	}
sl@0	5514
sl@0	5515	return ret;
sl@0	5516	}
sl@0	5517
sl@0	5518
sl@0	5519	//------------------------------------------------------------------
sl@0	5520	// TEST 3: Test the transtion from EMidiStateOpenEngaged to EMidiStateClosedEngaged.
sl@0	5521
sl@0	5522	CTestTrasitionFromEOpenEngagedToEClosedEngaged::CTestTrasitionFromEOpenEngagedToEClosedEngaged(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5523	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	5524	{
sl@0	5525	}
sl@0	5526
sl@0	5527	CTestTrasitionFromEOpenEngagedToEClosedEngaged* CTestTrasitionFromEOpenEngagedToEClosedEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5528	{
sl@0	5529	CTestTrasitionFromEOpenEngagedToEClosedEngaged* self = new(ELeave) CTestTrasitionFromEOpenEngagedToEClosedEngaged(aTestName, aTestType);
sl@0	5530	return self;
sl@0	5531	}
sl@0	5532
sl@0	5533	TVerdict CTestTrasitionFromEOpenEngagedToEClosedEngaged::DoTestL(CMidiClientUtility* aMidi)
sl@0	5534	{
sl@0	5535	//[ Local variables ]
sl@0	5536	TVerdict ret = EPass;
sl@0	5537	TInt expErr = KErrNone;
sl@0	5538
sl@0	5539	INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateOpenEngaged to EMidiStateClosedEngaged"));
sl@0	5540	//[ Expected results ]
sl@0	5541	switch(iTestType)
sl@0	5542	{
sl@0	5543	case ETestValid:
sl@0	5544	expErr = KErrNone;
sl@0	5545	break;
sl@0	5546	case ETestNoPlugin:
sl@0	5547	expErr = KErrNotSupported;
sl@0	5548	break;
sl@0	5549	case ETestInvalidState:
sl@0	5550	expErr = KErrUnknown;
sl@0	5551	break;
sl@0	5552	default:
sl@0	5553	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	5554	return EInconclusive;
sl@0	5555	}
sl@0	5556
sl@0	5557	//[ Set the current state to EMidiStateClosedDisengaged ]
sl@0	5558	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5559
sl@0	5560	//[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ]
sl@0	5561	TMidiState MIDIClientState = aMidi->State();
sl@0	5562
sl@0	5563	if (MIDIClientState == EMidiStateClosedDisengaged)
sl@0	5564	{
sl@0	5565	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged"));
sl@0	5566	}
sl@0	5567	else
sl@0	5568	{
sl@0	5569	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState);
sl@0	5570	return EFail;
sl@0	5571	}
sl@0	5572
sl@0	5573	// [ Call OpenFile() ]
sl@0	5574	TPtrC fileName;
sl@0	5575	if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName))
sl@0	5576	{
sl@0	5577	return EInconclusive;
sl@0	5578	}
sl@0	5579
sl@0	5580	aMidi->OpenFile(fileName);
sl@0	5581	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5582	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged
sl@0	5583	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	5584	{
sl@0	5585	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5586	return EFail;
sl@0	5587	}
sl@0	5588	MIDIClientState = aMidi->State();
sl@0	5589
sl@0	5590	if (MIDIClientState == EMidiStateOpenDisengaged)
sl@0	5591	{
sl@0	5592	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged"));
sl@0	5593	}
sl@0	5594	else
sl@0	5595	{
sl@0	5596	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState);
sl@0	5597	return EFail;
sl@0	5598	}
sl@0	5599
sl@0	5600	// [ Call Play() ]
sl@0	5601	aMidi->Play();
sl@0	5602	if (expErr != iError)
sl@0	5603	{
sl@0	5604	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5605	return EFail;
sl@0	5606	}
sl@0	5607
sl@0	5608	CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying
sl@0	5609
sl@0	5610	if (iCurrentState != EMidiStateOpenPlaying)
sl@0	5611	{
sl@0	5612	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState);
sl@0	5613	return EFail;
sl@0	5614	}
sl@0	5615
sl@0	5616	MIDIClientState = aMidi->State();
sl@0	5617	if (MIDIClientState == EMidiStateOpenPlaying)
sl@0	5618	{
sl@0	5619	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying"));
sl@0	5620	}
sl@0	5621	else
sl@0	5622	{
sl@0	5623	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState);
sl@0	5624	return EFail;
sl@0	5625	}
sl@0	5626
sl@0	5627	CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged
sl@0	5628
sl@0	5629	if (iCurrentState != EMidiStateOpenEngaged)
sl@0	5630	{
sl@0	5631	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState);
sl@0	5632	return EFail;
sl@0	5633	}
sl@0	5634
sl@0	5635	MIDIClientState = aMidi->State();
sl@0	5636	if (MIDIClientState == EMidiStateOpenEngaged)
sl@0	5637	{
sl@0	5638	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged"));
sl@0	5639	}
sl@0	5640	else
sl@0	5641	{
sl@0	5642	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState);
sl@0	5643	return EFail;
sl@0	5644	}
sl@0	5645
sl@0	5646
sl@0	5647	// [ Call Close() ]
sl@0	5648	aMidi->Close();
sl@0	5649	if (expErr != iError)
sl@0	5650	{
sl@0	5651	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5652	return EFail;
sl@0	5653	}
sl@0	5654
sl@0	5655	CActiveScheduler::Start(); // EMidiStateOpenEngaged -> EMidiStateClosedEngaged
sl@0	5656
sl@0	5657	if (iCurrentState != EMidiStateClosedEngaged)
sl@0	5658	{
sl@0	5659	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState);
sl@0	5660	return EFail;
sl@0	5661	}
sl@0	5662
sl@0	5663	MIDIClientState = aMidi->State();
sl@0	5664	if (MIDIClientState == EMidiStateClosedEngaged)
sl@0	5665	{
sl@0	5666	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged"));
sl@0	5667	}
sl@0	5668	else
sl@0	5669	{
sl@0	5670	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState);
sl@0	5671	return EFail;
sl@0	5672	}
sl@0	5673
sl@0	5674	return ret;
sl@0	5675	}
sl@0	5676
sl@0	5677
sl@0	5678
sl@0	5679	//---------------------------------------------------------------------
sl@0	5680	// TEST 4: Test the transtion from EMidiStateClosedEngaged to EMidiStateClosedDisengaged.
sl@0	5681
sl@0	5682	CTestTrasitionFromEClosedEngagedToEClosed::CTestTrasitionFromEClosedEngagedToEClosed(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5683	:CTestMmfMidiClntStep(aTestName, aTestType)
sl@0	5684	{
sl@0	5685	}
sl@0	5686
sl@0	5687	CTestTrasitionFromEClosedEngagedToEClosed* CTestTrasitionFromEClosedEngagedToEClosed::NewL(const TDesC& aTestName, const TTestStepType aTestType)
sl@0	5688	{
sl@0	5689	CTestTrasitionFromEClosedEngagedToEClosed* self = new(ELeave) CTestTrasitionFromEClosedEngagedToEClosed(aTestName, aTestType);
sl@0	5690	return self;
sl@0	5691	}
sl@0	5692
sl@0	5693	TVerdict CTestTrasitionFromEClosedEngagedToEClosed::DoTestL(CMidiClientUtility* aMidi)
sl@0	5694	{
sl@0	5695	//[ Local variables ]
sl@0	5696	TVerdict ret = EPass;
sl@0	5697	TInt expErr = KErrNone;
sl@0	5698
sl@0	5699	INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedEngaged to EMidiStateClosedDisengaged"));
sl@0	5700	//[ Expected results ]
sl@0	5701	switch(iTestType)
sl@0	5702	{
sl@0	5703	case ETestValid:
sl@0	5704	expErr = KErrNone;
sl@0	5705	break;
sl@0	5706	case ETestNoPlugin:
sl@0	5707	expErr = KErrNotSupported;
sl@0	5708	break;
sl@0	5709	case ETestInvalidState:
sl@0	5710	expErr = KErrUnknown;
sl@0	5711	break;
sl@0	5712	default:
sl@0	5713	ERR_PRINTF1(_L("Error - invalid test step type"));
sl@0	5714	return EInconclusive;
sl@0	5715	}
sl@0	5716
sl@0	5717	//[ Set the current state to EMidiStateClosedDisengaged ]
sl@0	5718	iCurrentState = EMidiStateClosedDisengaged;
sl@0	5719
sl@0	5720	//[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ]
sl@0	5721	TMidiState MIDIClientState = aMidi->State();
sl@0	5722
sl@0	5723	if (MIDIClientState == EMidiStateClosedDisengaged)
sl@0	5724	{
sl@0	5725	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged"));
sl@0	5726	}
sl@0	5727	else
sl@0	5728	{
sl@0	5729	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState);
sl@0	5730	return EFail;
sl@0	5731	}
sl@0	5732
sl@0	5733	// [ Call OpenFile() ]
sl@0	5734	TPtrC fileName;
sl@0	5735	if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName))
sl@0	5736	{
sl@0	5737	return EInconclusive;
sl@0	5738	}
sl@0	5739
sl@0	5740	aMidi->OpenFile(fileName);
sl@0	5741	INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state..."));
sl@0	5742	CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged
sl@0	5743	if (iCurrentState != EMidiStateOpenDisengaged)
sl@0	5744	{
sl@0	5745	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState);
sl@0	5746	return EFail;
sl@0	5747	}
sl@0	5748
sl@0	5749	MIDIClientState = aMidi->State();
sl@0	5750	if (MIDIClientState == EMidiStateOpenDisengaged)
sl@0	5751	{
sl@0	5752	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged"));
sl@0	5753	}
sl@0	5754	else
sl@0	5755	{
sl@0	5756	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState);
sl@0	5757	return EFail;
sl@0	5758	}
sl@0	5759
sl@0	5760	// [ Call Play() ]
sl@0	5761	aMidi->Play();
sl@0	5762	if (expErr != iError)
sl@0	5763	{
sl@0	5764	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5765	return EFail;
sl@0	5766	}
sl@0	5767
sl@0	5768	CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying
sl@0	5769
sl@0	5770	if (iCurrentState != EMidiStateOpenPlaying)
sl@0	5771	{
sl@0	5772	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState);
sl@0	5773	return EFail;
sl@0	5774	}
sl@0	5775
sl@0	5776	MIDIClientState = aMidi->State();
sl@0	5777	if (MIDIClientState == EMidiStateOpenPlaying)
sl@0	5778	{
sl@0	5779	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying"));
sl@0	5780	}
sl@0	5781	else
sl@0	5782	{
sl@0	5783	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState);
sl@0	5784	return EFail;
sl@0	5785	}
sl@0	5786
sl@0	5787	CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged
sl@0	5788
sl@0	5789	if (iCurrentState != EMidiStateOpenEngaged)
sl@0	5790	{
sl@0	5791	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState);
sl@0	5792	return EFail;
sl@0	5793	}
sl@0	5794
sl@0	5795	MIDIClientState = aMidi->State();
sl@0	5796
sl@0	5797	if (MIDIClientState == EMidiStateOpenEngaged)
sl@0	5798	{
sl@0	5799	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged"));
sl@0	5800	}
sl@0	5801	else
sl@0	5802	{
sl@0	5803	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState);
sl@0	5804	return EFail;
sl@0	5805	}
sl@0	5806
sl@0	5807
sl@0	5808	// [ Call Close() ]
sl@0	5809	aMidi->Close();
sl@0	5810	if (expErr != iError)
sl@0	5811	{
sl@0	5812	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5813	return EFail;
sl@0	5814	}
sl@0	5815
sl@0	5816	CActiveScheduler::Start(); // EMidiStateOpenEngaged -> EMidiStateClosedEngaged
sl@0	5817
sl@0	5818	if (iCurrentState != EMidiStateClosedEngaged)
sl@0	5819	{
sl@0	5820	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState);
sl@0	5821	return EFail;
sl@0	5822	}
sl@0	5823
sl@0	5824	MIDIClientState = aMidi->State();
sl@0	5825	if (MIDIClientState == EMidiStateClosedEngaged)
sl@0	5826	{
sl@0	5827	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged"));
sl@0	5828	}
sl@0	5829	else
sl@0	5830	{
sl@0	5831	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState);
sl@0	5832	return EFail;
sl@0	5833	}
sl@0	5834
sl@0	5835	// [ Call Stop() ]
sl@0	5836	TTimeIntervalMicroSeconds fadeOutDuration(0);
sl@0	5837	aMidi->Stop(fadeOutDuration);
sl@0	5838	if (expErr != iError)
sl@0	5839	{
sl@0	5840	ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr);
sl@0	5841	return EFail;
sl@0	5842	}
sl@0	5843
sl@0	5844	CActiveScheduler::Start(); // EMidiStateClosedEngaged -> EMidiStateClosedDisengaged
sl@0	5845
sl@0	5846	if (iCurrentState != EMidiStateClosedDisengaged)
sl@0	5847	{
sl@0	5848	ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedDisengaged, received = %d)"), iCurrentState);
sl@0	5849	return EFail;
sl@0	5850	}
sl@0	5851
sl@0	5852	MIDIClientState = aMidi->State();
sl@0	5853
sl@0	5854	if (MIDIClientState == EMidiStateClosedDisengaged)
sl@0	5855	{
sl@0	5856	ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged"));
sl@0	5857	}
sl@0	5858	else
sl@0	5859	{
sl@0	5860	ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState);
sl@0	5861	return EFail;
sl@0	5862	}
sl@0	5863	return ret;
sl@0	5864	}
sl@0	5865
sl@0	5866	//------------------------------------------------------------------------
sl@0	5867	// This test checks for opening the file using a FileHandle more than
sl@0	5868	// once.
sl@0	5869
sl@0	5870
sl@0	5871	CTestMidiOpenFileHandleRepeat::CTestMidiOpenFileHandleRepeat(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	5872	:CTestMmfMidiClntStep(aTestName, ETestValid),
sl@0	5873	iPlay(aPlay)
sl@0	5874	{
sl@0	5875	iSectName = aSectName;
sl@0	5876	iKeyName = aKeyName;
sl@0	5877	}
sl@0	5878
sl@0	5879	CTestMidiOpenFileHandleRepeat* CTestMidiOpenFileHandleRepeat::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
sl@0	5880	{
sl@0	5881	CTestMidiOpenFileHandleRepeat* self = new(ELeave) CTestMidiOpenFileHandleRepeat(aTestName, aSectName, aKeyName, aPlay);
sl@0	5882	return self;
sl@0	5883	}
sl@0	5884
sl@0	5885	TVerdict CTestMidiOpenFileHandleRepeat::DoTestStepL()
sl@0	5886	{
sl@0	5887	TPtrC filename;
sl@0	5888	if(!GetStringFromConfig(iSectName,iKeyName,filename))
sl@0	5889	return EInconclusive;
sl@0	5890	TVerdict ret = EFail;
sl@0	5891	INFO_PRINTF1(_L("Test to check whether OpenFile(const RFile& aFile) works fine when opened more than once using the same filehandle "));
sl@0	5892
sl@0	5893	CMidiClientUtility midiClient = CMidiClientUtility::NewL(this);
sl@0	5894	if (!midiClient)
sl@0	5895	{
sl@0	5896	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	5897	return EInconclusive;
sl@0	5898	}
sl@0	5899	CleanupStack::PushL(midiClient);
sl@0	5900	RFs fs;
sl@0	5901	RFile file;
sl@0	5902	fs.Connect();
sl@0	5903	CleanupClosePushL(fs);
sl@0	5904
sl@0	5905	TMMFMessageDestinationPckg dummyPckg;
sl@0	5906	TInt dummyFunc = 0; //EDevMidiOff;
sl@0	5907	TBuf8<8> dummyBuff;
sl@0	5908	midiClient->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);
sl@0	5909	TInt err = fs.ShareProtected();
sl@0	5910	if ((err = file.Open(fs, filename, EFileRead )) == KErrNone)
sl@0	5911	{
sl@0	5912	INFO_PRINTF1(_L("Inside the first call"));
sl@0	5913	midiClient->OpenFile(file);//opening the file for the first time using the handle
sl@0	5914	CActiveScheduler::Start();
sl@0	5915	midiClient->Close();
sl@0	5916	CActiveScheduler::Start();
sl@0	5917	file.Close();
sl@0	5918	}
sl@0	5919	err = file.Open(fs, filename, EFileRead);//Opening the file for the second time
sl@0	5920	if(err==KErrNone) //shouldn't give inuse error at this point
sl@0	5921	{
sl@0	5922	INFO_PRINTF1(_L("Inside the second call"));
sl@0	5923	midiClient->OpenFile(file);
sl@0	5924	CActiveScheduler::Start();
sl@0	5925	midiClient->Close();
sl@0	5926	CActiveScheduler::Start();
sl@0	5927	file.Close();
sl@0	5928	ret=EPass;
sl@0	5929	}
sl@0	5930	else
sl@0	5931	INFO_PRINTF2(_L("Failed to open the file the second time returned with err = %d"),err);
sl@0	5932
sl@0	5933	//To check whether OpenFile(TDesC& aFileName) works fine when opened more than once.
sl@0	5934	_LIT (KFilename,"c:\\MidiClntITestData\\midi.mid");
sl@0	5935	midiClient->OpenFile(KFilename);//First Open(TDesC& aFileName)
sl@0	5936	// Wait for initialisation callback
sl@0	5937	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));
sl@0	5938	CActiveScheduler::Start();
sl@0	5939	if(iError != KErrNone)
sl@0	5940	{
sl@0	5941	INFO_PRINTF2(_L("Failed to open the file.Failed with error %d"),err);
sl@0	5942	}
sl@0	5943	midiClient->Close();
sl@0	5944	CActiveScheduler::Start();
sl@0	5945	midiClient->OpenFile(KFilename);//Second Open(TDesC& aFileName)
sl@0	5946	// Wait for initialisation callback
sl@0	5947	INFO_PRINTF1(_L("CMidiClientUtility: Opening file for the second time"));
sl@0	5948	CActiveScheduler::Start();
sl@0	5949	if(iError != KErrNone)
sl@0	5950	{
sl@0	5951	INFO_PRINTF2(_L("Failed to open the file second time.Failed with error %d"),err);
sl@0	5952	}
sl@0	5953	//Opening the file again without calling the close for the previous open
sl@0	5954	midiClient->OpenFile(KFilename);
sl@0	5955	INFO_PRINTF1(_L("CMidiClientUtility: Opening file for the second time without close"));
sl@0	5956	CActiveScheduler::Start();
sl@0	5957	if(iError != KErrNone)
sl@0	5958	{
sl@0	5959	INFO_PRINTF2(_L("Failed with error %d"),err);
sl@0	5960	}
sl@0	5961	midiClient->Close();
sl@0	5962	CActiveScheduler::Start();
sl@0	5963
sl@0	5964	// To check that calling Open twice without closing the file inbetween does return an inuse error
sl@0	5965	file.Open(fs, filename, EFileRead);//Opening for the first time
sl@0	5966	User::After(1000000);
sl@0	5967	err = file.Open(fs, filename, EFileRead);//Opening for the secondtime without closing the previous open, should return KErrInUse
sl@0	5968	if(err != KErrInUse)
sl@0	5969	{
sl@0	5970	ret=EFail;
sl@0	5971	INFO_PRINTF2(_L("Expected to return error -14, but returned error %d"),err);
sl@0	5972	}
sl@0	5973	file.Close();
sl@0	5974	CleanupStack::PopAndDestroy(2); // fileServer, midiClient
sl@0	5975	return ret;
sl@0	5976	}
sl@0	5977
sl@0	5978	TVerdict CTestMidiOpenFileHandleRepeat::DoTestL(CMidiClientUtility* /aMidi/)
sl@0	5979	{
sl@0	5980	return EPass;
sl@0	5981	}
sl@0	5982
sl@0	5983	/*
sl@0	5984	Playing a midi file without opening a file and checking for its status during call back.
sl@0	5985	*/
sl@0	5986
sl@0	5987	CTestMidiClntPlayWithoutFile::CTestMidiClntPlayWithoutFile(const TDesC& aTestName)
sl@0	5988	:CTestMmfMidiClntStep(aTestName, ETestValid)
sl@0	5989	{}
sl@0	5990
sl@0	5991	CTestMidiClntPlayWithoutFile* CTestMidiClntPlayWithoutFile::NewL(const TDesC& aTestName)
sl@0	5992	{
sl@0	5993	CTestMidiClntPlayWithoutFile* self = new(ELeave) CTestMidiClntPlayWithoutFile(aTestName);
sl@0	5994	return self;
sl@0	5995	}
sl@0	5996
sl@0	5997
sl@0	5998	TVerdict CTestMidiClntPlayWithoutFile::DoTestStepL()
sl@0	5999	{
sl@0	6000	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
sl@0	6001	TVerdict ret = EPass;
sl@0	6002	iError = KErrNone;
sl@0	6003
sl@0	6004	if (!player)
sl@0	6005	{
sl@0	6006	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	6007	return EInconclusive;
sl@0	6008	}
sl@0	6009	CleanupStack::PushL(player);
sl@0	6010
sl@0	6011	player->Play();
sl@0	6012	CActiveScheduler::Start();
sl@0	6013
sl@0	6014	if (iError != KErrNone)
sl@0	6015	{
sl@0	6016	ERR_PRINTF1(_L("Error while playing"));
sl@0	6017	return EInconclusive;
sl@0	6018	}
sl@0	6019
sl@0	6020	TTimeIntervalMicroSeconds fadeOutDuration(0);
sl@0	6021	player->Stop(fadeOutDuration);
sl@0	6022	CActiveScheduler::Start();
sl@0	6023
sl@0	6024	// Check for errors.
sl@0	6025	if (iError != KErrNone)
sl@0	6026	{
sl@0	6027	ret = EFail;
sl@0	6028	ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
sl@0	6029	}
sl@0	6030
sl@0	6031	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
sl@0	6032	CleanupStack::PopAndDestroy(player);
sl@0	6033
sl@0	6034	return ret;
sl@0	6035	}
sl@0	6036
sl@0	6037	void CTestMidiClntPlayWithoutFile::MmcuoStateChanged(TMidiState aOldState,TMidiState aNewState,const TTimeIntervalMicroSeconds& /aTime/,TInt aError)
sl@0	6038	{
sl@0	6039	iError=aError;
sl@0	6040	ERR_PRINTF2(_L("Old State: %d "),aOldState);
sl@0	6041	ERR_PRINTF2(_L("New State : %d "),aNewState);
sl@0	6042	ERR_PRINTF2(_L("Error Code : %d "),aError);
sl@0	6043
sl@0	6044	if(aError == KErrNone)
sl@0	6045	{
sl@0	6046	if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateClosedEngaged))
sl@0	6047	{
sl@0	6048	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateClosedEngaged, with no error"));
sl@0	6049	}
sl@0	6050	else if((aOldState == EMidiStateClosedEngaged) && (aNewState == EMidiStateClosedDisengaged))
sl@0	6051	{
sl@0	6052	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedEngaged to EMidiStateClosedDisengaged, with no error"));
sl@0	6053	}
sl@0	6054	else if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateOpenDisengaged))
sl@0	6055	{
sl@0	6056	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateOpenDisengaged, with no error"));
sl@0	6057	}
sl@0	6058	else if((aOldState == EMidiStateOpenDisengaged) && (aNewState == EMidiStateOpenPlaying))
sl@0	6059	{
sl@0	6060	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenDisengaged to EMidiStateOpenPlaying, with no error"));
sl@0	6061	}
sl@0	6062	else if((aOldState == EMidiStateOpenPlaying) && (aNewState == EMidiStateOpenDisengaged))
sl@0	6063	{
sl@0	6064	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenPlaying to EMidiStateOpenDisengaged, with no error"));
sl@0	6065	}
sl@0	6066	else
sl@0	6067	{
sl@0	6068	INFO_PRINTF1(_L("State changed call back occurs,the states remain the same with no error"));
sl@0	6069	}
sl@0	6070	}
sl@0	6071	else
sl@0	6072	{
sl@0	6073	INFO_PRINTF1(_L("Error during calback"));
sl@0	6074	}
sl@0	6075
sl@0	6076	CActiveScheduler::Stop();
sl@0	6077	}
sl@0	6078
sl@0	6079	//------------------------------------------------------------------
sl@0	6080
sl@0	6081	/*
sl@0	6082	Opening a midi file and playing it and checking for its status during call back.
sl@0	6083	*/
sl@0	6084
sl@0	6085	CTestMidiClntOpenAndPlayFile::CTestMidiClntOpenAndPlayFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName)
sl@0	6086	:CTestMmfMidiClntStep(aTestName, ETestValid)
sl@0	6087	{
sl@0	6088	iSectName = aSectName;
sl@0	6089	iKeyName = aKeyName;
sl@0	6090	}
sl@0	6091
sl@0	6092	CTestMidiClntOpenAndPlayFile* CTestMidiClntOpenAndPlayFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName)
sl@0	6093	{
sl@0	6094	CTestMidiClntOpenAndPlayFile* self = new(ELeave) CTestMidiClntOpenAndPlayFile(aTestName, aSectName, aKeyName);
sl@0	6095	return self;
sl@0	6096	}
sl@0	6097
sl@0	6098	TVerdict CTestMidiClntOpenAndPlayFile::DoTestStepL()
sl@0	6099	{
sl@0	6100	TVerdict ret = EPass;
sl@0	6101	iError = KErrNone;
sl@0	6102	TPtrC filename;
sl@0	6103	if(!GetStringFromConfig(iSectName,iKeyName,filename))
sl@0	6104	return EInconclusive;
sl@0	6105
sl@0	6106	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
sl@0	6107	if (!player)
sl@0	6108	{
sl@0	6109	ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
sl@0	6110	return EInconclusive;
sl@0	6111	}
sl@0	6112	CleanupStack::PushL(player);
sl@0	6113
sl@0	6114	player->OpenFile(filename);
sl@0	6115
sl@0	6116	// Wait for initialisation callback
sl@0	6117	INFO_PRINTF1(_L("CMidiClientUtility: Opening file"));
sl@0	6118	CActiveScheduler::Start();
sl@0	6119
sl@0	6120	player->Play();
sl@0	6121	CActiveScheduler::Start();
sl@0	6122
sl@0	6123	if (iError != KErrNone)
sl@0	6124	{
sl@0	6125	ERR_PRINTF1(_L("Error while playing"));
sl@0	6126	return EInconclusive;
sl@0	6127	}
sl@0	6128
sl@0	6129	TTimeIntervalMicroSeconds fadeOutDuration(0);
sl@0	6130	player->Stop(fadeOutDuration);
sl@0	6131	CActiveScheduler::Start();
sl@0	6132
sl@0	6133	// Check for errors.
sl@0	6134	if (iError != KErrNone)
sl@0	6135	{
sl@0	6136	ret = EFail;
sl@0	6137	ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
sl@0	6138	}
sl@0	6139
sl@0	6140	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
sl@0	6141	CleanupStack::PopAndDestroy(player);
sl@0	6142
sl@0	6143	return ret;
sl@0	6144	}
sl@0	6145
sl@0	6146	void CTestMidiClntOpenAndPlayFile::MmcuoStateChanged(TMidiState aOldState,TMidiState aNewState,const TTimeIntervalMicroSeconds& /aTime/,TInt aError)
sl@0	6147	{
sl@0	6148	iError=aError;
sl@0	6149	ERR_PRINTF2(_L("Old State: %d "),aOldState);
sl@0	6150	ERR_PRINTF2(_L("New State : %d "),aNewState);
sl@0	6151	ERR_PRINTF2(_L("Error Code : %d "),aError);
sl@0	6152
sl@0	6153	if(aError == KErrNone)
sl@0	6154	{
sl@0	6155	if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateClosedEngaged))
sl@0	6156	{
sl@0	6157	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateClosedEngaged, with no error"));
sl@0	6158	}
sl@0	6159	else if((aOldState == EMidiStateClosedEngaged) && (aNewState == EMidiStateClosedDisengaged))
sl@0	6160	{
sl@0	6161	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedEngaged to EMidiStateClosedDisengaged, with no error"));
sl@0	6162	}
sl@0	6163	else if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateOpenDisengaged))
sl@0	6164	{
sl@0	6165	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateOpenDisengaged, with no error"));
sl@0	6166	}
sl@0	6167	else if((aOldState == EMidiStateOpenDisengaged) && (aNewState == EMidiStateOpenPlaying))
sl@0	6168	{
sl@0	6169	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenDisengaged to EMidiStateOpenPlaying, with no error"));
sl@0	6170	}
sl@0	6171	else if((aOldState == EMidiStateOpenPlaying) && (aNewState == EMidiStateOpenDisengaged))
sl@0	6172	{
sl@0	6173	INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenPlaying to EMidiStateOpenDisengaged, with no error"));
sl@0	6174	}
sl@0	6175	else
sl@0	6176	{
sl@0	6177	INFO_PRINTF1(_L("State changed call back occurs,the states remain the same with no error"));
sl@0	6178	}
sl@0	6179	}
sl@0	6180	else
sl@0	6181	{
sl@0	6182	INFO_PRINTF1(_L("Error during calback"));
sl@0	6183	}
sl@0	6184
sl@0	6185	CActiveScheduler::Stop();
sl@0	6186	}
sl@0	6187

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--