diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfunittest/MidiClnt/TestMidiClientUtility.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfunittest/MidiClnt/TestMidiClientUtility.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,6187 @@ + +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "TestMidiClientUtility.h" +#include + + +CTestMidiClntOpenFile::CTestMidiClntOpenFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + :CTestMmfMidiClntStep(aTestName, ETestValid), + iPlay(aPlay) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiClntOpenFile* CTestMidiClntOpenFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMidiClntOpenFile* self = new(ELeave) CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay); + return self; + } + +TVerdict CTestMidiClntOpenFile::DoTestStepL() + { + TPtrC filename; + if(!GetStringFromConfig(iSectName,iKeyName,filename)) + return EInconclusive; + + CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + CleanupStack::PushL(player); + + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = 0; //EDevMidiOff; + TBuf8<8> dummyBuff; + player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + + player->OpenFile(filename); + + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening file")); + CActiveScheduler::Start(); + + TVerdict ret = EFail; + + // Check for errors. + if (iError == KErrNone) + ret = DoTestL(player); + + INFO_PRINTF1(_L("CMidiClientUtility: Destroying")); + CleanupStack::PopAndDestroy(player); + + if(iError != KErrNone) + ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError ); + + return ret; + } + +TVerdict CTestMidiClntOpenFile::DoTestL(CMidiClientUtility* /*aMidi*/) + { + return EPass; + } + +//------------------------------------------------------------------ + +CTestMidiClntOpenDes::CTestMidiClntOpenDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + :CTestMmfMidiClntStep(aTestName, ETestValid), + iPlay(aPlay) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiClntOpenDes* CTestMidiClntOpenDes::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMidiClntOpenDes* self = new(ELeave) CTestMidiClntOpenDes(aTestName, aSectName, aKeyName, aPlay); + return self; + } + +TVerdict CTestMidiClntOpenDes::DoTestStepPreambleL() + { + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + return EInconclusive; + + RFs fs; + RFile file; + TInt size = 0; + + // connect to file system and open file + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + // Set HBuf size + User::LeaveIfError(file.Size(size)); + INFO_PRINTF2(_L("size of file = %d\n"),size); + + iAudio = HBufC8::NewMaxL(size); + + // read data into Hbuf + TPtr8 bufferDes(iAudio->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + CleanupStack::PopAndDestroy(); //file + return CTestMmfMidiClntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMidiClntOpenDes::DoTestStepPostambleL() + { + delete iAudio; + iAudio = NULL; + return CTestMmfMidiClntStep::DoTestStepPostambleL(); + } + +TVerdict CTestMidiClntOpenDes::DoTestStepL() + { + CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + + CleanupStack::PushL(player); + + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = EDevMidiOff; + TBuf8<8> dummyBuff; + player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + + player->OpenDes(iAudio->Des()); + + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening file")); + CActiveScheduler::Start(); + + TVerdict ret = EFail; + + // Check for errors. + if (iError == KErrNone) + ret = DoTestL(player); + + INFO_PRINTF1(_L("CMidiClientUtility: Destroying")); + CleanupStack::PopAndDestroy(player); + + if(iError != KErrNone) + ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError ); + + return ret; + } + +TVerdict CTestMidiClntOpenDes::DoTestL(CMidiClientUtility* /*aMidi*/) + { + return EPass; + } + +//------------------------------------------------------------------ + +CTestMidiClntOpenUrl::CTestMidiClntOpenUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + :CTestMmfMidiClntStep(aTestName, ETestValid), + iPlay(aPlay) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiClntOpenUrl* CTestMidiClntOpenUrl::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMidiClntOpenUrl* self = new(ELeave) CTestMidiClntOpenUrl(aTestName, aSectName, aKeyName, aPlay); + return self; + } + +TVerdict CTestMidiClntOpenUrl::DoTestStepL() + { + TPtrC urlname; + if(!GetStringFromConfig(iSectName,iKeyName,urlname)) + return EInconclusive; + + CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + + CleanupStack::PushL(player); + + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = EDevMidiOff; + TBuf8<8> dummyBuff; + player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + + player->OpenUrl(urlname); + + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening url")); + CActiveScheduler::Start(); + + TVerdict ret = EFail; + + // Check for errors. + if (iError == KErrNone) + ret = DoTestL(player); + + INFO_PRINTF1(_L("CMidiClientUtility: Destroying")); + CleanupStack::PopAndDestroy(player); + + if(iError != KErrNone) + ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError ); + + return ret; + } + +TVerdict CTestMidiClntOpenUrl::DoTestL(CMidiClientUtility* /*aMidi*/) + { + return EPass; + } + +//------------------------------------------------------------------ + +CTestMidiClntClose::CTestMidiClntClose(const TDesC& aTestName) + :CTestMmfMidiClntStep(aTestName, ETestValid) + { + } + +CTestMidiClntClose* CTestMidiClntClose::NewL(const TDesC& aTestName) + { + CTestMidiClntClose* self = new(ELeave) CTestMidiClntClose(aTestName); + return self; + } + +TVerdict CTestMidiClntClose::DoTestL(CMidiClientUtility* aMidi) + { + INFO_PRINTF1(_L("CMidiClientUtility: Closing file")); + aMidi->Close(); + return EPass; + } + +//------------------------------------------------------------------ + +CTestMidiClntPlay::CTestMidiClntPlay(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntPlay* CTestMidiClntPlay::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntPlay* self = new(ELeave) CTestMidiClntPlay(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntPlay::DoTestL(CMidiClientUtility* aMidi) + { + TInt expErr = KErrNone; + //TTimeIntervalMicroSeconds fadeOutDuration(0); + + INFO_PRINTF1(_L("CMidiClientUtility: Play midi file")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + iCurrentState = EMidiStateClosedDisengaged; + aMidi->OpenFile(_L("c:\\DoesntExist.mid")); + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play gave error %d (expected %d)"),iError, expErr); + return EFail; + } + else + INFO_PRINTF3(_L("Play, %d = %d"), iError, expErr); + + return EPass; + } + +//------------------------------------------------------------------ + + +CTestMidiClntStop::CTestMidiClntStop(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntStop* CTestMidiClntStop::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntStop* self = new(ELeave) CTestMidiClntStop(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntStop::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TTimeIntervalMicroSeconds fadeOutDuration(0); + + INFO_PRINTF1(_L("CMidiClientUtility: Stop midi file")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + fadeOutDuration = 20; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + aMidi->Stop(fadeOutDuration); + if (expErr != KErrNone) + INFO_PRINTF2(_L("Stop gave error %d"),expErr); + else + INFO_PRINTF1(_L("Stopping midi file")); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntGetState::CTestMidiClntGetState(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay) + :CTestMidiClntOpenFile(aTestName, aSectName, aKeyName, aPlay) + { + // NB this inherits from CTestMidiClntOpenFile, NOT from CTestMmfMidiClntStep + // so we have to set this manually. + iTestType = aTestType; + } + +CTestMidiClntGetState* CTestMidiClntGetState::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TTestStepType aTestType, const TBool aPlay) + { + CTestMidiClntGetState* self = new(ELeave) CTestMidiClntGetState(aTestName, aSectName, aKeyName, aTestType, aPlay); + return self; + } + +TVerdict CTestMidiClntGetState::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TMidiState expErr; + //TTimeIntervalMicroSeconds fadeOutDuration(10); + + INFO_PRINTF1(_L("CMidiClientUtility: Get current state of midi file")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = EMidiStateOpenDisengaged; + break; + case ETestNegative: + expErr = EMidiStateClosedDisengaged; + // Close player so we can perform negative test, get state before any initialisation has been done + aMidi->Close(); + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TMidiState state = aMidi->State(); + if (expErr != state) + { + ERR_PRINTF3(_L("State gave error %d (expected %d)"),state, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("State %d = %d"),state, expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestMidiClntPlayNote::CTestMidiClntPlayNote(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntPlayNote* CTestMidiClntPlayNote::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntPlayNote* self = new(ELeave) CTestMidiClntPlayNote(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntPlayNote::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt channel = 0; + TInt note = 0; + TTimeIntervalMicroSeconds duration(10); + TInt noteOnVelocity = 0; + TInt noteOffVelocity = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Play midi note")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestZeroDurationOutOfRange: + expErr = KErrNotSupported; + duration = 0; + break; + case ETestInvalidChannelOutOfRange: + expErr = KErrArgument; + channel = 16; + break; + case ETestNoteHighOutOfRange: + expErr = KErrArgument; + note = 128; + break; + case ETestNoteLowOutOfRange: + expErr = KErrArgument; + note = -1; + break; + case ETestAttackHighOutOfRange: + expErr = KErrArgument; + noteOnVelocity = 128; + break; + case ETestAttackLowOutOfRange: + expErr = KErrArgument; + noteOnVelocity = -1; + break; + case ETestReleaseHighOutOfRange: + expErr = KErrArgument; + noteOffVelocity = 128; + break; + case ETestReleaseLowOutOfRange: + expErr = KErrArgument; + noteOffVelocity = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + TRAPD(err, aMidi->PlayNoteL(channel, note, duration, noteOnVelocity, noteOffVelocity)); + + if (expErr != err) + { + ERR_PRINTF3(_L("State gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("PlayNoteL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestMidiClntStopNotes::CTestMidiClntStopNotes(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntStopNotes* CTestMidiClntStopNotes::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntStopNotes* self = new(ELeave) CTestMidiClntStopNotes(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntStopNotes::DoTestL(CMidiClientUtility* aMidi) + { + // The framework will catch the invalid channel and no note available + TVerdict ret = EPass; + TInt channel = 0; + //TInt expErr = KErrNone; + + switch(iTestType) + { + case ETestValid: + break; + case ETestInvalidChannelOutOfRange: + channel = 16; + break; + case ETestNoNoteAvailable: + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + INFO_PRINTF1(_L("CMidiClientUtility: Stop midi note")); + aMidi->StopNotes(channel); + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntNoteOn::CTestMidiClntNoteOn(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntNoteOn* CTestMidiClntNoteOn::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntNoteOn* self = new(ELeave) CTestMidiClntNoteOn(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntNoteOn::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt channel = 0; + TInt note = 0; + TInt velocity = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Midi note on")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + channel = 1; + note = 2; + velocity = 10; + break; + case ETestNoNoteAvailable: + expErr = KErrArgument; + break; + case ETestInvalidChannelOutOfRange: + expErr = KErrArgument; + channel = 16; + break; + case ETestNoteHighOutOfRange: + expErr = KErrArgument; + note = 128; + break; + case ETestNoteLowOutOfRange: + expErr = KErrArgument; + note = -1; + break; + case ETestVelocityHighOutOfRange: + expErr = KErrArgument; + velocity = 128; + break; + case ETestVelocityLowOutOfRange: + expErr = KErrArgument; + velocity = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->NoteOnL(channel,note,velocity)); + if (expErr != err) + { + ERR_PRINTF3(_L("NoteOnL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("NoteOnL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntNoteOff::CTestMidiClntNoteOff(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntNoteOff* CTestMidiClntNoteOff::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntNoteOff* self = new(ELeave) CTestMidiClntNoteOff(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntNoteOff::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt channel = 0; + TInt note = 0; + TInt velocity = 0; + + // Play Midi Note on channel=0, note=1, velocity=50 + TRAPD(err, aMidi->NoteOnL(0,1,50)); + if (expErr != err) + { + ERR_PRINTF3(_L("NoteOnL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("NoteOnL %d = %d"),err ,expErr); + + INFO_PRINTF1(_L("CMidiClientUtility: Midi note off")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + channel = 1; + note = 2; + velocity = 10; + break; + case ETestNoNoteAvailable: + expErr = KErrNone; // No error is raised, as per specification + break; + case ETestInvalidChannelOutOfRange: + expErr = KErrArgument; + channel = 16; + break; + case ETestDifferentNoteVelocity: + expErr = KErrArgument; + note = 1; + velocity = 127; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err2, aMidi->NoteOffL(channel,note,velocity)); + if (expErr != err2) + { + ERR_PRINTF3(_L("NoteOffL gave error %d (expected %d)"),err2, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("NoteOffL %d = %d"),err2 ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntReturnPlaybackRate::CTestMidiClntReturnPlaybackRate(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntReturnPlaybackRate* CTestMidiClntReturnPlaybackRate::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntReturnPlaybackRate* self = new(ELeave) CTestMidiClntReturnPlaybackRate(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntReturnPlaybackRate::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Check playback rate")); + + // expected results + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt rate = 0; // fixes warning + +// TRAPD(err, rate = aMidi->PlaybackRateL()); + TRAPD(err, aMidi->PlaybackRateL()); // EABI warning removal + if(expErr != err) + { + ERR_PRINTF3( _L("PlaybackRateL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("PlaybackRateL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetPlaybackRate::CTestMidiClntSetPlaybackRate(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetPlaybackRate* CTestMidiClntSetPlaybackRate::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetPlaybackRate* self = new(ELeave) CTestMidiClntSetPlaybackRate(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetPlaybackRate::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt playbackRate = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set playback rate")); + + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + case ETestOutOfRangeHigh: + // high limit on playback rate is dependant on controller + // when have a proper controller the value below should be changed + // to a value higher than the upper limit + playbackRate = -1; + expErr = KErrNotSupported; + break; + case ETestOutOfRangeLow: + playbackRate = -1; // negative values not supported + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetPlaybackRateL(playbackRate)); + if(expErr != err) + { + ERR_PRINTF3( _L("SetPlaybackRateL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetPlaybackRateL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntReturnMaxPlayRate::CTestMidiClntReturnMaxPlayRate(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntReturnMaxPlayRate* CTestMidiClntReturnMaxPlayRate::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntReturnMaxPlayRate* self = new(ELeave) CTestMidiClntReturnMaxPlayRate(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntReturnMaxPlayRate::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Check the max play rate")); + + // expected results + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt rate = 0; // fixes warning +// TRAPD(err, rate = aMidi->MaxPlaybackRateL()); + TRAPD(err, aMidi->MaxPlaybackRateL()); // EABI warning removal + if(expErr != err) + { + ERR_PRINTF3( _L("MaxPlayRateL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("MaxPlayRateL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntReturnMinPlayRate::CTestMidiClntReturnMinPlayRate(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntReturnMinPlayRate* CTestMidiClntReturnMinPlayRate::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntReturnMinPlayRate* self = new(ELeave) CTestMidiClntReturnMinPlayRate(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntReturnMinPlayRate::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Check the min play rate")); + + // expected results + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + +// TInt rate = 0; // fixes warning +// TRAPD(err, rate = aMidi->MinPlaybackRateL()); + TRAPD(err, aMidi->MinPlaybackRateL()); // EABI warning removal + if(expErr != err) + { + ERR_PRINTF3( _L("MinPlayRateL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("MinPlayRateL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntTempoMicroBeatsPerMinute::CTestMidiClntTempoMicroBeatsPerMinute(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntTempoMicroBeatsPerMinute* CTestMidiClntTempoMicroBeatsPerMinute::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntTempoMicroBeatsPerMinute* self = new(ELeave) CTestMidiClntTempoMicroBeatsPerMinute(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntTempoMicroBeatsPerMinute::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; +// TInt microBeatsPerMinute = 0; // EABI warning removal + + INFO_PRINTF1(_L("CMidiClientUtility: Return the tempo micro beats per minute")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + +// TRAPD(err, microBeatsPerMinute = aMidi->TempoMicroBeatsPerMinuteL()); + TRAPD(err, aMidi->TempoMicroBeatsPerMinuteL()); // EABI warning removal + if (expErr != err) + { + ERR_PRINTF3(_L("TempoMicroBeatsPerMinuteL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("TempoMicroBeatsPerMinuteL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetTempo::CTestMidiClntSetTempo(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetTempo* CTestMidiClntSetTempo::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetTempo* self = new(ELeave) CTestMidiClntSetTempo(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetTempo::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt microBeatsPerMinute = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set the tempo micro beats per minute")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + microBeatsPerMinute = 60*1000000; + break; + case ETestNoResource: + expErr = KErrNotReady; + microBeatsPerMinute = 80*1000000; + break; + case ETestBeatsLowOutOfRange: + expErr = KErrArgument; + microBeatsPerMinute = -1*1000000; + break; + case ETestBeatsHighOutOfRange: + expErr = KErrArgument; + //microBeatsPerMinute = 1000001*1000000; XXX overflow warning + microBeatsPerMinute = 1000001; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetTempoL(microBeatsPerMinute)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetTempoL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetTempoL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntGetPitchTranspositionCents::CTestMidiClntGetPitchTranspositionCents(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntGetPitchTranspositionCents* CTestMidiClntGetPitchTranspositionCents::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntGetPitchTranspositionCents* self = new(ELeave) CTestMidiClntGetPitchTranspositionCents(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntGetPitchTranspositionCents::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Set the pitch transposition")); + // expected results + + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + +// TInt pitch = 0; // fixes warning +// TRAPD(err, pitch = aMidi->PitchTranspositionCentsL()); + TRAPD(err, aMidi->PitchTranspositionCentsL()); // EABI warning removal - "I see trouble ahead..." + if(expErr != err) + { + ERR_PRINTF3( _L("PitchTranspositionCentsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("PitchTranspositionCentsL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetPitchTransposition::CTestMidiClntSetPitchTransposition(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetPitchTransposition* CTestMidiClntSetPitchTransposition::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetPitchTransposition* self = new(ELeave) CTestMidiClntSetPitchTransposition(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetPitchTransposition::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt pitchTrans = 1200; // one octave + + INFO_PRINTF1(_L("CMidiClientUtility: Set the pitch transposition")); + // expected results + + switch (iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; +//According to GM2 spec, the minimum value can be -6499 cents, or at least -1299 cents. + case ETestOutOfRangeHigh: + // high limit on pitch transposition is dependant on controller + // when have a proper controller the value below should be changed + // to a value higher than the upper limit + pitchTrans = -6499; //KErrArgument expect by a real controller implementation if out-of-range + expErr = KErrNone; + break; +/*This test has been removed by AD as it was not valid - negative values ARE allowed by MIDI spec +According to GM2 spec, the minimum value can be -6499 cents, or at least -1299 cents. + case ETestOutOfRangeLow: + pitchTrans = -1; // negative values not supported + expErr = KErrNotSupported; + break; +*/ + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetPitchTranspositionL(pitchTrans)); + if(expErr != err) + { + ERR_PRINTF3( _L("SetPitchTranspositionL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetPitchTranspositionL %d = %d"), err, expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntDurationMicroSeconds::CTestMidiClntDurationMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntDurationMicroSeconds* CTestMidiClntDurationMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntDurationMicroSeconds* self = new(ELeave) CTestMidiClntDurationMicroSeconds(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntDurationMicroSeconds::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TTimeIntervalMicroSeconds durationMicroSeconds(0); + + INFO_PRINTF1(_L("CMidiClientUtility: Get duration in micro seconds")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, durationMicroSeconds = aMidi->DurationMicroSecondsL()); + if (expErr != err) + { + ERR_PRINTF3(_L("DurationMicroSecondsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("DurationMicroSecondsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntDurationMicroBeats::CTestMidiClntDurationMicroBeats(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntDurationMicroBeats* CTestMidiClntDurationMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntDurationMicroBeats* self = new(ELeave) CTestMidiClntDurationMicroBeats(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntDurationMicroBeats::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + //TTimeIntervalMicroSeconds durationMicroSeconds(0); + + INFO_PRINTF1(_L("CMidiClientUtility: Get duration in micro beats")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + TRAPD(err, aMidi->DurationMicroBeatsL()); + if (expErr != err) + { + ERR_PRINTF3(_L("DurationMicroBeatsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("DurationMicroBeatsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntNumTracks::CTestMidiClntNumTracks(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntNumTracks* CTestMidiClntNumTracks::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntNumTracks* self = new(ELeave) CTestMidiClntNumTracks(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntNumTracks::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Get current number of tracks")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt numOfTracks = 0; +// TRAPD(err, numOfTracks = aMidi->NumTracksL()); + TRAPD(err, aMidi->NumTracksL()); // EABI warning removal + if (expErr != err) + { + ERR_PRINTF3(_L("NumTracksL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("NumTracksL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetTrackMute::CTestMidiClntSetTrackMute(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetTrackMute* CTestMidiClntSetTrackMute::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetTrackMute* self = new(ELeave) CTestMidiClntSetTrackMute(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetTrackMute::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt track = 0; + TBool muted = ETrue; + + INFO_PRINTF1(_L("CMidiClientUtility: Set track mute")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + TRAP_IGNORE(track = aMidi->NumTracksL()+1); + break; + case ETestInvalidTrack: + expErr = KErrArgument; + TRAP_IGNORE(track = aMidi->NumTracksL()+1); + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetTrackMuteL(track, muted)); + + // check correct result + if (iTestType == ETestValid) + { + TBool currMuted = EFalse; + + // until real MIDI controller IsTrackMuteL is always TRUE + TRAPD(err2, currMuted = aMidi->IsTrackMuteL(track)); + + if(err2 != KErrNone) + { + ERR_PRINTF2(_L("IsTrackMuteL() returned %d"), err2); + ret = EInconclusive; + return ret; + } + + if(currMuted != muted) + { + ERR_PRINTF2(_L("Error : expected %d"), muted); + ret = EFail; + return ret; + } + } + + if (expErr != err) + { + ERR_PRINTF3(_L("SetTrackMuteL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetTrackMuteL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntMimeType::CTestMidiClntMimeType(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntMimeType* CTestMidiClntMimeType::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntMimeType* self = new(ELeave) CTestMidiClntMimeType(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntMimeType::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Get mime type")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //TRAPD(err, TDesC8 mimeType = aMidi->MimeTypeL());//XXX: TDesC8 mimeType has to be define above + TRAPD(err, aMidi->MimeTypeL());//XXX: TDesC8 mimeType has to be define above + if (expErr != err) + { + ERR_PRINTF3(_L("MimeTypeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("MimeTypeL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntReturnPositionMicroSeconds::CTestMidiClntReturnPositionMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntReturnPositionMicroSeconds* CTestMidiClntReturnPositionMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntReturnPositionMicroSeconds* self = new(ELeave) CTestMidiClntReturnPositionMicroSeconds(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntReturnPositionMicroSeconds::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Get position in micro seconds")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + case ETestNoResourcePlaying: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + TTimeIntervalMicroSeconds positionMicroSeconds(0); + TRAPD(err, positionMicroSeconds = aMidi->PositionMicroSecondsL()); + if (expErr != err) + { + if (KErrNotReady != err) + { + ERR_PRINTF3(_L("Get PositionMicroSecondsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + { + ret = EPass; + } + } + else + INFO_PRINTF3(_L("Get PositionMicroSecondsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetPositionMicroSeconds::CTestMidiClntSetPositionMicroSeconds(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetPositionMicroSeconds* CTestMidiClntSetPositionMicroSeconds::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetPositionMicroSeconds* self = new(ELeave) CTestMidiClntSetPositionMicroSeconds(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetPositionMicroSeconds::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TTimeIntervalMicroSeconds position(0);; + + INFO_PRINTF1(_L("CMidiClientUtility: Set position in micro seconds")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + case ETestMicrosecondsHighOutOfRange: + expErr = KErrNotSupported; + position = 1008; + break; + case ETestMicrosecondsLowOutOfRange: + expErr = KErrNotSupported; + position = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetPositionMicroSecondsL(position)); + if (expErr != err) + { + ERR_PRINTF3(_L("Set PositionMicroSecondsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("Set PositionMicroSecondsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntReturnsPositionMicroBeats::CTestMidiClntReturnsPositionMicroBeats(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntReturnsPositionMicroBeats* CTestMidiClntReturnsPositionMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntReturnsPositionMicroBeats* self = new(ELeave) CTestMidiClntReturnsPositionMicroBeats(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntReturnsPositionMicroBeats::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Return position in micro beats")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + case ETestNoResourcePlaying: + expErr = KErrNotReady; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + TRAPD(err, aMidi->PositionMicroBeatsL()); + if (expErr != err) + { + ERR_PRINTF3(_L("PositionMicroBeatsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("PositionMicroBeatsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestMidiClntSetPositionMicroBeats::CTestMidiClntSetPositionMicroBeats(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMidiClntSetPositionMicroBeats* CTestMidiClntSetPositionMicroBeats::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntSetPositionMicroBeats* self = new(ELeave) CTestMidiClntSetPositionMicroBeats(aTestName, aTestType); + return self; + } + +TVerdict CTestMidiClntSetPositionMicroBeats::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt64 microBeats = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set position in micro beats")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoResource: + expErr = KErrNotReady; + break; + case ETestMicrobeatsHighOutOfRange: + expErr = KErrNotSupported; + microBeats = 1000000; + break; + case ETestMicrobeatsLowOutOfRange: + expErr = KErrNotSupported; + microBeats = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetPositionMicroBeatsL(microBeats)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetPositionMicroBeatsL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetPositionMicroBeatsL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestSetSyncUpdateCallbackInterval::CTestSetSyncUpdateCallbackInterval(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetSyncUpdateCallbackInterval* CTestSetSyncUpdateCallbackInterval::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetSyncUpdateCallbackInterval* self = new(ELeave) CTestSetSyncUpdateCallbackInterval(aTestName, aTestType); + return self; + } + +TVerdict CTestSetSyncUpdateCallbackInterval::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TTimeIntervalMicroSeconds microSeconds(0); + TInt64 microBeats = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set update call back interval")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestMicrosecondsMicrobeatsZero: + microSeconds = 0; + microBeats = 0; + expErr = KErrNotReady; + break; + case ETestMicrosecondsLowOutOfRange: + expErr = KErrArgument; + microSeconds = -1; + break; + case ETestMicrobeatsHighOutOfRange: + expErr = KErrArgument; + microBeats = 1000000; + break; + case ETestMicrobeatsLowOutOfRange: + expErr = KErrArgument; + microBeats = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetSyncUpdateCallbackIntervalL(microSeconds, microBeats)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetSyncUpdateCallbackIntervalL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetSyncUpdateCallbackIntervalL %d = %d"),err ,expErr); + + return ret; + } + +CTestSendMessage::CTestSendMessage(const TDesC& aTestName, + const TTestStepType aTestType, const TDesC8& aMessage) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + iMessage = aMessage; + } + +CTestSendMessage* CTestSendMessage::NewL(const TDesC& aTestName, + const TTestStepType aTestType, const TDesC8& aMessage) + { + CTestSendMessage* self = new (ELeave) CTestSendMessage(aTestName, + aTestType, aMessage); + return self; + } + +TVerdict CTestSendMessage::DoTestL(CMidiClientUtility* aMidi) + { + INFO_PRINTF1(_L("CMidiClientUtility: Send Message")); + + TVerdict ret = EPass; + TInt expErr = KErrNone; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNullMessage: + expErr = KErrArgument; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + case ETestCorrupt: + expErr = KErrCorrupt; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + +// TInt byteProcessed; +// TRAPD(err1, byteProcessed = aMidi->SendMessageL(iMessage)); + TRAPD(err1, aMidi->SendMessageL(iMessage)); // EABI warning removal + if(err1 != expErr) + { + ERR_PRINTF3(_L("SendMessageL(iMessage) gave error %d (expected %d)"), err1, expErr); + ret = EFail; + } + + TTimeIntervalMicroSeconds startTime(105); +// TRAPD(err2, byteProcessed = aMidi->SendMessageL(iMessage, startTime)); + TRAPD(err2, aMidi->SendMessageL(iMessage, startTime)); // EABI warning removal + if(err2 != expErr) + { + ERR_PRINTF3(_L("SendMessageL(iMessage, startTime) gave error %d (expected %d)"), err1, expErr); + ret = EFail; + } + + return ret; + } + +//------------------------------------------------------------------ + + +// CTestSendMessageTime incorporated into CTestSendMessage + +//------------------------------------------------------------------ + +// aTestType as follows : +// 0115 : valid +// 0116 : invalid device ID - REMOVED, API has changed +// 0117 : null +// 0118 : unsupported +// 0119 : unsupported - REMOVED, duplicate +// 0120 : corrupt + +CTestSendMipMessage::CTestSendMipMessage(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSendMipMessage* CTestSendMipMessage::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestSendMipMessage* self = new (ELeave) CTestSendMipMessage(aTestName, + aTestType); + return self; + } + +TVerdict CTestSendMipMessage::DoTestL(CMidiClientUtility* aMidi) + { + INFO_PRINTF1(_L("CMidiClientUtility: Send Mip Message")); + + TVerdict ret = EPass; + TInt expErr = KErrNone; + + RArray mipArray; + TMipMessageEntry mipEntry1; + TMipMessageEntry mipEntry2; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNullMessage: + expErr = KErrArgument; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + case ETestCorrupt: + expErr = KErrCorrupt; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + switch(iTestType) + { + case ETestValid: + mipEntry1.iChannel = 10; + mipEntry1.iMIPValue = 20; + mipEntry2.iChannel = 11; + mipEntry2.iMIPValue = 21; + + mipArray.Append(mipEntry1); + mipArray.Append(mipEntry2); + break; + + case ETestNullMessage: + // leave array empty + // *** NB this will cause a problem in debug mode - causes a server panic! + break; + + case ETestUnsupported: + // XXX : values defined as unsupported? + mipEntry1.iChannel = 0; + mipEntry1.iMIPValue = 0; + mipEntry2.iChannel = 0; + mipEntry2.iMIPValue = 0; + + mipArray.Append(mipEntry1); + mipArray.Append(mipEntry2); + break; + + case ETestCorrupt: + // XXX : values defined as corrupt? + mipEntry1.iChannel = -1; + mipEntry1.iMIPValue = -1; + mipEntry2.iChannel = -1; + mipEntry2.iMIPValue = -1; + + mipArray.Append(mipEntry1); + mipArray.Append(mipEntry2); + break; + } + + TRAPD(err1, aMidi->SendMipMessageL(mipArray)); + if(err1 != expErr) + { + ERR_PRINTF3(_L("SendMipMessageL(iMessage) gave error %d (expected %d)"), err1, expErr); + ret = EFail; + } + + mipArray.Close(); + return ret; + } + +//------------------------------------------------------------------ + + +CTestNumberOfBanks::CTestNumberOfBanks(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestNumberOfBanks* CTestNumberOfBanks::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestNumberOfBanks* self = new (ELeave) CTestNumberOfBanks(aTestName, + aTestType); + return self; + } + +TVerdict CTestNumberOfBanks::DoTestL(CMidiClientUtility* aMidi) + { + // to do : test for standard & custom banks + + // currently using ETestOverflow to simulate no banks + + TVerdict ret = EPass; + TInt expErr = KErrNone; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNegative: + expErr = KErrArgument; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt numBanks = 0; + TRAPD(err1, numBanks = aMidi->NumberOfBanksL(EFalse)); + if(err1 != expErr) + { + ERR_PRINTF3(_L("NumberOfBanksL(EFalse) gave error %d (expected %d)"), err1, expErr); + ret = EFail; + } + else + INFO_PRINTF2(_L("Number of Banks (standard) = %d"), numBanks); + + + TRAPD(err2, numBanks = aMidi->NumberOfBanksL(ETrue)); + if(err1 != expErr) + { + ERR_PRINTF3(_L("NumberOfBanksL(ETrue) gave error %d (expected %d)"), err2, expErr); + ret = EFail; + } + else + INFO_PRINTF2(_L("Number of Banks (custom) = %d"), numBanks); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestGetBankId::CTestGetBankId(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestGetBankId* CTestGetBankId::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestGetBankId* self = new (ELeave) CTestGetBankId(aTestName, + aTestType); + return self; + } + +TVerdict CTestGetBankId::DoTestL(CMidiClientUtility* aMidi) + { + // currently using ETestOverflow to simulate no banks + TVerdict ret = EPass; + TInt expErr; + TInt bankNum; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankNum = 54; + break; + case ETestNegative: + expErr = KErrArgument; + bankNum = -1; + break; + case ETestOverflow: + expErr = KErrArgument; + bankNum = 12000; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt bankId = 0; + TRAPD(err1, bankId = aMidi->GetBankIdL(EFalse, bankNum)); + if(err1 != expErr) + { + ERR_PRINTF4(_L("GetBankIdL(EFalse, %d) gave error %d (expected %d)"), bankNum, err1, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("GetBankIdL(EFalse, %d) = %d"), bankNum, bankId); + + TRAPD(err2, bankId = aMidi->GetBankIdL(ETrue, bankNum)); + if(err2 != expErr) + { + ERR_PRINTF4(_L("GetBankIdL(ETrue, %d) gave error %d (expected %d)"), bankNum, err2, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("GetBankIdL(ETrue, %d) = %d"), bankNum, bankId); + + return ret; + } + +//------------------------------------------------------------------ + + +CTestLoadCustomBank::CTestLoadCustomBank(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestLoadCustomBank* CTestLoadCustomBank::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestLoadCustomBank* self = new (ELeave) CTestLoadCustomBank(aTestName, + aTestType); + return self; + } + +TVerdict CTestLoadCustomBank::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TFileName bankFileName; + + _LIT8(KBankFileName, "Bank file name"); + _LIT8(KBankFileNameInvalid, "Invalid file name"); + _LIT8(KBankFileNameUnsupported, "Unsupported file name"); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankFileName.Copy(KBankFileName); + break; + case ETestNullMessage: + expErr = KErrArgument; + bankFileName.Copy(KNullDesC16); + break; + case ETestInvalidMessage: + expErr = KErrArgument; + bankFileName.Copy(KBankFileNameInvalid); + break; + case ETestUnsupported: + expErr = KErrNotSupported; + bankFileName.Copy(KBankFileNameUnsupported); + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt bankId = 0; + + TRAPD(err1, aMidi->LoadCustomBankL(bankFileName, bankId)); + INFO_PRINTF3(_L("LoadCustomBankL gave error %d (expected %d)"), err1, expErr); + if(err1 != expErr) + { + ret = EFail; + return ret; + } + // see if it's loaded + TBool loaded = EFalse; + TRAP(err1, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err1 != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err1); + ret = EFail; + return ret; + } + if(iTestType == ETestValid) + { + if(!loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned false")); + ret = EFail; + } + } + else + { + if(loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned true")); + ret = EFail; + } + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestUnloadCustomBank::CTestUnloadCustomBank(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestUnloadCustomBank* CTestUnloadCustomBank::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestUnloadCustomBank* self = new (ELeave) CTestUnloadCustomBank(aTestName, + aTestType); + return self; + } + +TVerdict CTestUnloadCustomBank::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TFileName bankFileName; + + _LIT8(KBankFileName, "Bank file name"); + bankFileName.Copy(KBankFileName); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNegative: + expErr = KErrNotFound; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt bankId = 0; + + // load a known bank + TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("LoadCustomBankL gave error %d"), err); + ret = EInconclusive; + return ret; + } + + // ensure it's loaded + TBool loaded = EFalse; + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(!loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned false")); + ret = EInconclusive; + return ret; + } + + // unload the bank we know is loaded + TRAP(err, aMidi->UnloadCustomBankL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("UnloadCustomBankL gave error %d"), err); + ret = EFail; + return ret; + } + + // ensure it's not loaded + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned true -> bank not unloaded")); + ret = EFail; + return ret; + } + + // if negative test, try and unload the same bank again + if(iTestType == ETestValid) + return ret; + else + { + TRAP(err, aMidi->UnloadCustomBankL(bankId)); + INFO_PRINTF3(_L("UnloadCustomBankL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + ret = EFail; + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestUnloadAllCustomBanks::CTestUnloadAllCustomBanks(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestUnloadAllCustomBanks* CTestUnloadAllCustomBanks::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestUnloadAllCustomBanks* self = new (ELeave) CTestUnloadAllCustomBanks(aTestName, + aTestType); + return self; + } + +TVerdict CTestUnloadAllCustomBanks::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TFileName bankFileName; + + _LIT8(KBankFileName, "Bank file name"); + bankFileName.Copy(KBankFileName); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNegative: + expErr = KErrNotFound; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TInt bankId = 0; + + // load a known bank + TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("LoadCustomBankL gave error %d"), err); + ret = EInconclusive; + return ret; + } + + // ensure it's loaded + TBool loaded = EFalse; + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(!loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned false")); + ret = EInconclusive; + return ret; + } + + // unload all + TRAP(err, aMidi->UnloadAllCustomBanksL()); + if(err != KErrNone) + { + ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err); + ret = EFail; + return ret; + } + + loaded = EFalse; + // ensure our bank is not loaded + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned true -> bank not unloaded")); + ret = EFail; + return ret; + } + + // if negative test, try and unload again + if(iTestType == ETestValid) + return ret; + else + { + TRAP(err, aMidi->UnloadAllCustomBanksL()); + INFO_PRINTF3(_L("UnloadAllCustomBanksL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + ret = EFail; + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestNumberOfInstruments::CTestNumberOfInstruments(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestNumberOfInstruments* CTestNumberOfInstruments::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestNumberOfInstruments* self = new (ELeave) CTestNumberOfInstruments(aTestName, + aTestType); + return self; + } + +TVerdict CTestNumberOfInstruments::DoTestL(CMidiClientUtility* aMidi) + { + // TO DO : situation where no standard banks exist + + TVerdict ret = EPass; + TInt expErr; + TFileName bankFileName; + + _LIT8(KBankFileName, "Bank file name"); + bankFileName.Copy(KBankFileName); + TInt bankId = 0; + TInt numInstruments = 0; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankId = 0; + break; + case ETestNegative: + expErr = KErrNotFound; + bankId = 0; + break; + case ETestInvalidId: + expErr = KErrArgument; + bankId = -2; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // check a known bank - standard + // *** TO DO : this will cause a failure with ETestNegative. To be re-done + // for no standard banks present + TRAPD(err, numInstruments = aMidi->NumberOfInstrumentsL(bankId, EFalse)); + if(err != expErr) + { + ERR_PRINTF3(_L("NumberOfInstrumentsL(bankId, EFalse) gave error %d (expected %d)"), err, expErr); + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("NumberOfInstrumentsL(bankId, EFalse) = %d"), numInstruments); + + if(iTestType != ETestInvalidMessage) + { + // load a known bank - custom + TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("LoadCustomBankL left with error %d"), err); + ret = EInconclusive; + return ret; + } + // ensure it's loaded + TBool loaded = EFalse; + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(!loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned false -> bank not loaded")); + ret = EInconclusive; + return ret; + } + } + + // check the custom bank + // NB if test type is InvalidId then we haven't bothered to load anything + TRAP(err, aMidi->NumberOfInstrumentsL(bankId, ETrue)); + if(err != expErr) + { + ERR_PRINTF2(_L("NumberOfInstrumentsL(bankId, ETrue) gave error %d"), err); + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("NumberOfInstrumentsL(bankId, ETrue) = %d"), numInstruments); + + if(iTestType == ETestNegative) + { + // negative test :- unload all, then check it again + TRAP(err, aMidi->UnloadAllCustomBanksL()); + if(err != KErrNone) + { + ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err); + ret = EInconclusive; + return ret; + } + // check it. it should leave + TRAP(err, aMidi->NumberOfInstrumentsL(bankId, ETrue)); + if(err != expErr) + { + ERR_PRINTF3(_L("NumberOfInstrumentsL gave error %d (expected %d)"), err, expErr); + ret = EFail; + return ret; + } + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestGetInstrumentId::CTestGetInstrumentId(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestGetInstrumentId* CTestGetInstrumentId::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestGetInstrumentId* self = new (ELeave) CTestGetInstrumentId(aTestName, + aTestType); + return self; + } + +TVerdict CTestGetInstrumentId::DoTestL(CMidiClientUtility* aMidi) + { + // TO DO : situation where no standard banks exist + + TVerdict ret = EPass; + TInt expErr; + TFileName bankFileName; + + _LIT8(KBankFileName, "Bank file name"); + bankFileName.Copy(KBankFileName); + TInt bankId = 0; + TInt instrIndex = 0; + TInt instrId = 0; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankId = 0; + instrIndex = 0; + break; + case ETestNegative: + expErr = KErrNotFound; + bankId = 0; + instrIndex = 0; + break; + case ETestInvalidId: + expErr = KErrArgument; + bankId = -2; + instrIndex = 0; + break; + case ETestInvalidIndex: + expErr = KErrArgument; + bankId = 0; + instrIndex = -2; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // check a known bank - standard + // *** TO DO : this will cause a failure with ETestNegative. To be re-done + // for no standard banks present + TRAPD(err, instrId = aMidi->GetInstrumentIdL(bankId, EFalse, instrIndex)); + if(err != expErr) + { + ERR_PRINTF3(_L("GetInstrumentIdL(bankId, EFalse, instrIndex) gave error %d (expected %d)"), err, expErr); + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("GetInstrumentIdL(bankId, EFalse, instrIndex) = %d"), instrId); + + if(iTestType != ETestInvalidId && iTestType != ETestInvalidIndex) + { + // load a known bank - custom + TRAPD(err, aMidi->LoadCustomBankL(bankFileName, bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("LoadCustomBankL left with error %d"), err); + ret = EInconclusive; + return ret; + } + // ensure it's loaded + TBool loaded = EFalse; + TRAP(err, loaded = aMidi->CustomBankLoadedL(bankId)); + if(err != KErrNone) + { + ERR_PRINTF2(_L("CustomBankLoadedL left with error %d"), err); + ret = EInconclusive; + return ret; + } + if(!loaded) + { + ERR_PRINTF1(_L("CustomBankLoadedL returned false -> bank not loaded")); + ret = EInconclusive; + return ret; + } + } + + // check the custom bank + // NB if test type is InvalidId/Index then we haven't bothered to load anything + TRAP(err, instrId = aMidi->GetInstrumentIdL(bankId, ETrue, instrIndex)); + if(err != expErr) + { + ERR_PRINTF2(_L("GetInstrumentIdL(bankId, ETrue, instrIndex) gave error %d"), err); + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("GetInstrumentIdL(bankId, ETrue, instrIndex) = %d"), instrId); + + if(iTestType == ETestNegative) + { + // negative test :- unload all, then check it again + TRAP(err, aMidi->UnloadAllCustomBanksL()); + if(err != KErrNone) + { + ERR_PRINTF2(_L("UnloadAllCustomBanksL gave error %d"), err); + ret = EInconclusive; + return ret; + } + // check it. it should leave + TRAP(err, instrId = aMidi->GetInstrumentIdL(bankId, ETrue, instrIndex)); + if(err != expErr) + { + ERR_PRINTF3(_L("GetInstrumentIdL gave error %d (expected %d)"), err, expErr); + ret = EFail; + return ret; + } + } + + return ret; + } + +//Check this +//Change it to return EFail for failing negative test +//------------------------------------------------------------------ +CTestReturnsInstrumentName::CTestReturnsInstrumentName(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestReturnsInstrumentName* CTestReturnsInstrumentName::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestReturnsInstrumentName* self = new (ELeave) CTestReturnsInstrumentName(aTestName, + aTestType); + return self; + } + +TVerdict CTestReturnsInstrumentName::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + //TFileName bankFileName; + + TInt bankId = 0; + TInt instrId = 0; + HBufC* instrName = NULL; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankId = 0; + instrId = 89; + break; + case ETestNegative: + expErr = KErrArgument; + bankId = 0; + instrId = -241; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // check a known bank - standard + // *** TO DO : custom? + + TRAPD(err, instrName = aMidi->InstrumentNameL(bankId, EFalse, instrId)); + INFO_PRINTF3(_L("InstrumentNameL(bankId, EFalse, instrId) gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + //ret = EInconclusive; + ret = EFail; + return ret; + } + // don't try and do this for negative test! it'll panic + if(iTestType == ETestValid) + INFO_PRINTF2(_L("InstrumentNameL(bankId, EFalse, instrId) = \'%S\'"), instrName); + + delete instrName; + return ret; + } + + + +//------------------------------------------------------------------ +// Tests that the GetInstrumentL() doesn't return KErrArgument when the +// channel value is between 0 and 15, but it will return KErrArgument +// when the channel value is out of range + +CTestGetInstrument::CTestGetInstrument(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestGetInstrument* CTestGetInstrument::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestGetInstrument* self = new (ELeave) CTestGetInstrument(aTestName, + aTestType); + return self; + } + +TVerdict CTestGetInstrument::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt instrumentId = 0; + TInt bankId = 0; + TInt validChannelId = 0; + TInt invalidChannelId = 16; + + TRAPD(err, aMidi->GetInstrumentL(validChannelId, instrumentId, bankId)); + + if(err == KErrArgument) + { + ERR_PRINTF2(_L("GetInstrumentL(validChannelId, ...) gave an error = %d"), err); + ret = EFail; + return ret; + } + + TRAPD(err1, aMidi->GetInstrumentL(invalidChannelId, instrumentId, bankId)); + + if(err1 != KErrArgument) + { + ERR_PRINTF2(_L("GetInstrumentL(invalidChannelId, ...) gave an error = %d"), err); + ret = EFail; + return ret; + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetInstrument::CTestSetInstrument(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetInstrument* CTestSetInstrument::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestSetInstrument* self = new (ELeave) CTestSetInstrument(aTestName, + aTestType); + return self; + } + +TVerdict CTestSetInstrument::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + //TFileName bankFileName; + + TInt bankId = 0; + TInt channelId = 0; + TInt instrId = 0; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + bankId = 0; + channelId = 0; + instrId = 89; + break; + case ETestInvalidChannel: + expErr = KErrNotFound; + bankId = 0; + channelId = -2; + instrId = 89; + break; + case ETestInvalidId: + expErr = KErrNotFound; + bankId = 0; + channelId = 0; + instrId = -241; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // *** TO DO : custom? + + TRAPD(err, aMidi->SetInstrumentL(channelId, bankId, instrId)); + INFO_PRINTF3(_L("SetInstrumentL(channelId, bankId, instrId) gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestLoadCustomInstrument::CTestLoadCustomInstrument(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestLoadCustomInstrument* CTestLoadCustomInstrument::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestLoadCustomInstrument* self = new (ELeave) CTestLoadCustomInstrument(aTestName, + aTestType); + return self; + } + +TVerdict CTestLoadCustomInstrument::DoTestL(CMidiClientUtility* aMidi) + { + // TO DO : need instrument file which we can load, with known bank and instrument IDs + // Negative tests to be done properly. + + TVerdict ret = EPass; + TInt expErr; + + _LIT(KInstrumentFile, "Instrument File Name"); // *** to change + _LIT(KBadInstrumentFile, "Bad Instrument File Name"); // *** to change + TFileName instFileName; + + TInt fileBankId = 90; + TInt fileInstrId = 91; + TInt bankId = 92; + TInt instrId = 93; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + instFileName.Copy(KInstrumentFile); + break; + case ETestInvalidId: + expErr = KErrArgument; + instFileName.Copy(KInstrumentFile); + fileBankId = -2; + break; + case ETestAlreadyLoaded: + // ** to do : load once and attempt to load again. + // when instrument data files are available, this will work + instFileName.Copy(KInstrumentFile); + expErr = KErrInUse; + break; + case ETestUnsupported: // ** to define test data for this + instFileName.Copy(KBadInstrumentFile); + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // if testing already loaded, preload the instrument here + if(iTestType == ETestAlreadyLoaded) + { + TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId)); + INFO_PRINTF2(_L("Preload : LoadCustomInstrumentL gave error %d"), err); + if(err != KErrNone) + { + ret = EInconclusive; + return ret; + } + } + + // load the instrument for real + TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId)); + INFO_PRINTF3(_L("LoadCustomInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + + +//------------------------------------------------------------------ + +CTestUnloadCustomInstrument::CTestUnloadCustomInstrument(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestUnloadCustomInstrument* CTestUnloadCustomInstrument::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestUnloadCustomInstrument* self = new (ELeave) CTestUnloadCustomInstrument(aTestName, + aTestType); + return self; + } + +TVerdict CTestUnloadCustomInstrument::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + + _LIT(KInstrumentFile, "Instrument File Name"); // *** to change + TFileName instFileName; + + TInt fileBankId = 90; + TInt fileInstrId = 91; + TInt bankId = 92; + TInt instrId = 93; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + instFileName.Copy(KInstrumentFile); + break; + case ETestInvalidId: + expErr = KErrNotFound; + instFileName.Copy(KInstrumentFile); + bankId = -2; + break; + case ETestNotLoaded: + expErr = KErrNotFound; + instFileName.Copy(KInstrumentFile); + break; + case ETestNotUnloadable: // ** TO DO : define test data for this + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // preload the instrument here + if(iTestType == ETestValid) + { + TRAPD(err, aMidi->LoadCustomInstrumentL(instFileName, fileBankId, fileInstrId, bankId, instrId)); + INFO_PRINTF2(_L("Preload : LoadCustomInstrumentL gave error %d"), err); + if(err != KErrNone) + { + ret = EInconclusive; + return ret; + } + } + + // now unload it + TRAPD(err, aMidi->UnloadCustomInstrumentL(bankId, instrId)); + INFO_PRINTF3(_L("UnloadCustomInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestPercussionKeyName::CTestPercussionKeyName(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestPercussionKeyName* CTestPercussionKeyName::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestPercussionKeyName* self = new (ELeave) CTestPercussionKeyName(aTestName, + aTestType); + return self; + } + +TVerdict CTestPercussionKeyName::DoTestL(CMidiClientUtility* aMidi) + { + // *** NB the actual arguments do not match those in the current API or test specs + TVerdict ret = EPass; + TInt expErr; + //TFileName bankFileName; + + TInt bankId = 0; + TInt instrId = 89; + TInt keyId = 0; + HBufC* keyName = NULL; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestInvalidId: + expErr = KErrNotFound; + keyId = -2; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // check a known bank - standard + // *** TO DO : custom? + + TRAPD(err, keyName = aMidi->PercussionKeyNameL(keyId, bankId, EFalse, instrId)); + INFO_PRINTF3(_L("PercussionKeyNameL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + // don't try and do this for negative test! it'll panic + if(iTestType == ETestValid) + INFO_PRINTF2(_L("PercussionKeyNameL(keyId, bankId, EFalse, instrId) = \'%S\'"), keyName); + + delete keyName; + return ret; + } + +//Check this// +//Not sure how to implement 'no opened resource' +//------------------------------------------------------------------ +CTestStopTime::CTestStopTime(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestStopTime* CTestStopTime::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestStopTime* self = new (ELeave) CTestStopTime(aTestName, + aTestType); + return self; + } + +TVerdict CTestStopTime::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TTimeIntervalMicroSeconds stopTime(0); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + + // NB no negative test specified + //Not sure how to implement 'no opened resource' + case ETestNoResource: + expErr = KErrNotReady; + break; + + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->StopTimeL(stopTime)); + INFO_PRINTF3(_L("StopTimeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("StopTime = %ld"), I64INT(stopTime.Int64())); + return ret; + } + + +//------------------------------------------------------------------ + + +CTestSetStopTime::CTestSetStopTime(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetStopTime* CTestSetStopTime::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestSetStopTime* self = new (ELeave) CTestSetStopTime(aTestName, + aTestType); + return self; + } + +TVerdict CTestSetStopTime::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TTimeIntervalMicroSeconds stopTime(999); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestOutOfRangeHigh: + stopTime = 999999999; + expErr = KErrArgument; + break; + case ETestOutOfRangeLow: + stopTime = -1; + expErr = KErrArgument; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetStopTimeL(stopTime)); + INFO_PRINTF3(_L("SetStopTimeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // check set correctly if a valid test + if (iTestType == ETestValid) + { + TTimeIntervalMicroSeconds newStopTime(999); + TRAP(err, aMidi->StopTimeL(newStopTime)); + INFO_PRINTF3(_L("StopTimeL gave error %d (expected %d)"), err, expErr); + + if(err != expErr) + { + ret = EInconclusive; + return ret; + } + INFO_PRINTF2(_L("StopTime = %ld"), I64INT(newStopTime.Int64())); + + if(newStopTime != stopTime) + { + ERR_PRINTF2(_L("Error : expected %ld"), I64INT(stopTime.Int64())); + ret = EFail; + return ret; + } + } + + return ret; + } + +//------------------------------------------------------------------ + + +CTestSetRepeats::CTestSetRepeats(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetRepeats* CTestSetRepeats::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestSetRepeats* self = new (ELeave) CTestSetRepeats(aTestName, + aTestType); + return self; + } + +TVerdict CTestSetRepeats::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TInt repeats = 0; + TTimeIntervalMicroSeconds silentTime(1000000); + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + // ** NB these are testing ONE out-of-range argument at a time. Suggest + // we modify the test spec to go with this? + case ETestOutOfRange: + expErr = KErrArgument; + //repeats = 9999; // ** XXX : max. range of repeats? + repeats = -1; + silentTime = 1000000; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetRepeatsL(repeats, silentTime)); + + // check set correctly if a valid test + if (iTestType == ETestValid) + { + // check the repeats value + TInt currRepeats = -1; + currRepeats = aMidi->GetRepeats(); + + INFO_PRINTF2(_L("Repeats = %d"), currRepeats); + + if(currRepeats != repeats) + { + ERR_PRINTF2(_L("Error : expected %d"), currRepeats); + ret = EFail; + return ret; + } + } + + INFO_PRINTF3(_L("SetRepeatsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + +//------------------------------------------------------------------ +// This test case has two steps: +// 1. High Polyphony Song vs. Low Polyphony Midi Utility +// - a test file has exactly 57 voices from beginning to end +// - during the instantiation of utility, the Maximum Polyphony is default to 48 implicitly. +// For this case: +// MaxPolyphonyL() return value is 48 +// PolyphonyL() return value is 48 (number of active voice the engine is playing now, +// this is being limited by the MaxPolyphonyL() number) +// +// +// 2. Low Polyphony Song vs. High Polyphony Midi Utility +// - a test file has exactly 57 voices from beginning to end +// - during the instantiation of utility, the Maximum Polyphony is default to 60 implicitly +// For this case: +// MaxPolyphonyL() return value is 60 +// PolyphonyL() return value is 57 + +// constants for the test case +const TUint8 KMaxPolyphonyValue1 = 48; +const TUint8 KMaxPolyphonyValue2 = 60; +const TUint8 KPolyphonyValue = 57; + +CTestPolyphony::CTestPolyphony(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestPolyphony* CTestPolyphony::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestPolyphony* self = new (ELeave) CTestPolyphony(aTestName, + aTestType); + return self; + } + +TVerdict CTestPolyphony::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt poly = 0; + TInt maxPoly = 0; + TInt expErr = 0; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + // NB no negative test specified + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // set the maxPolyphony to KMaxPolyphponyValue1 + TRAPD(err, aMidi->SetMaxPolyphonyL(KMaxPolyphonyValue1)); + if (err != expErr) + { + INFO_PRINTF2(_L("SetMaxPolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + + // verify that the maxPolyphony value was correctly set + TRAPD(err1, maxPoly = aMidi->MaxPolyphonyL()); + if (err1 != expErr) + { + INFO_PRINTF2(_L("MaxPolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + INFO_PRINTF3(_L("The maximum number of simultaneous voices the engine can handle : %d (expected %d)"), maxPoly, KMaxPolyphonyValue1); + + // get the number of the currently active voices. This value is set as + // KPolyphonyValue, but because the max number of voices that can be handled by the + // engine is smaller than the currently active voce, PolyphonyL() will + // return the MaxPolyphony() value + TRAPD(err2, poly = aMidi->PolyphonyL()); + + if (err2 != expErr) + { + INFO_PRINTF2(_L("PolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + + INFO_PRINTF3(_L("The number of currently active voices is: %d (expected %d)"), poly, KMaxPolyphonyValue1); + INFO_PRINTF1(_L("----------------------------------------------------------")); + + // set the maxPolyphony to KMaxPolyphonyValue2 + TRAPD(err3, aMidi->SetMaxPolyphonyL(KMaxPolyphonyValue2)); + if (err3 != expErr) + { + INFO_PRINTF2(_L("SetMaxPolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + + // verify that the maxPolyphony value was correctly set + TRAPD(err4, maxPoly = aMidi->MaxPolyphonyL()); + if (err4 != expErr) + { + INFO_PRINTF2(_L("MaxPolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + INFO_PRINTF3(_L("The maximum number of simultaneous voices the engine can handle : %d (expected %d)"), maxPoly, KMaxPolyphonyValue2); + + // get the number of the currently active voices. This value is set as + // KPolyphonyValue, but because the max number of voices that can be handled by the + // engine is smaller than the currently active voce, PolyphonyL() will + // return the MaxPolyphony() value + TRAPD(err5, poly = aMidi->PolyphonyL()); + if (err5 != expErr) + { + INFO_PRINTF2(_L("PolyphonyL failed (error = %d)"), err); + ret = EFail; + return ret; + } + INFO_PRINTF3(_L("The number of currently active voices is: %d (expected %d)"), poly, KPolyphonyValue); + + return ret; + } + +//Check this (0086) // +//Not sure how to implement 'no opened resource' +//------------------------------------------------------------------ + + +CTestChannelsSupported::CTestChannelsSupported(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestChannelsSupported* CTestChannelsSupported::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestChannelsSupported* self = new (ELeave) CTestChannelsSupported(aTestName, + aTestType); + return self; + } + +TVerdict CTestChannelsSupported::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr; + TInt numChannels = 0; + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + + // NB no negative test specified + + //Not sure how to implement 'no opened resource' + case ETestNoResource: + expErr = KErrNotReady; + break; + + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, numChannels = aMidi->ChannelsSupportedL()); + INFO_PRINTF3(_L("ChannelsSupportedL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + INFO_PRINTF2(_L("Channels supported = %d"), numChannels); + return ret; + } + +//------------------------------------------------------------------ +// Checks the ChannelVolumeL(...) method behaivior +// - if the argument passed in is a valid channel, the test should +// not return any error code, but should return the expected volume +// value +// - if the argument passed in is an invalid channel, the test should +// return KErrArgument + +CTestReturnChannelVolume::CTestReturnChannelVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestReturnChannelVolume* CTestReturnChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestReturnChannelVolume* self = new(ELeave) CTestReturnChannelVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestReturnChannelVolume::DoTestL(CMidiClientUtility* aMidi) + { + TInt channel = 2; + TInt volume = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Return channel volume")); + + // positive test + if (iTestType == ETestValid) + { + // if the test is valid check that the value returned for the + // volume is correct + TInt chanVolume = aMidi->MaxChannelVolumeL() - 10; + TRAPD(err1, aMidi->SetChannelVolumeL(channel, chanVolume)); + if (err1 != KErrNone) + { + ERR_PRINTF2(_L("SetChannelVolumeL gave error %d"),err1); + return EFail; + } + + TRAPD(err, volume = aMidi->ChannelVolumeL(channel)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("ChannelVolumeL gave error %d (expected KErrNone)"),err); + return EFail; + } + + if (volume != chanVolume) + { + ERR_PRINTF3(_L("ChannelVolumeL retrieve volume value %d (expected %d)"),volume, chanVolume); + return EFail; + } + return EPass; + } + + // negative test + if (iTestType == ETestInvalidChannel) + { + channel = -1; + TRAPD(err, aMidi->ChannelVolumeL(channel)); + if (err != KErrArgument) + { + ERR_PRINTF2(_L("ChannelVolumeL gave error %d (expected KErrArgument)"),err); + return EFail; + } + return EPass; + } + + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + +//Check This// +//------------------------------------------------------------------ +CTestMaxChannelVolume::CTestMaxChannelVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestMaxChannelVolume* CTestMaxChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMaxChannelVolume* self = new(ELeave) CTestMaxChannelVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestMaxChannelVolume::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Return Maximum channel volume")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TReal32 volume = 0; +// TRAPD(err, volume = aMidi->MaxChannelVolumeL() ); + TRAPD(err, aMidi->MaxChannelVolumeL() ); // EABI warning removal + + if (expErr != err) + { + ERR_PRINTF3(_L("MaxChannelVolumeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("MaxChannelVolumeL %d = %d "),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetChannelVolume::CTestSetChannelVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetChannelVolume* CTestSetChannelVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetChannelVolume* self = new(ELeave) CTestSetChannelVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestSetChannelVolume::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt channel = 0; + TReal32 volume = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestInvalidChannelOutOfRange: + expErr = KErrArgument; + channel = 16; + volume = 10; + break; + case ETestVolumeHighOutOfRange: + expErr = KErrArgument; + channel = 0; + volume = aMidi->MaxChannelVolumeL()+1; + break; + case ETestVolumeLowOutOfRange: + expErr = KErrNone; //real controller may return KErrArgument if out of range + channel = 0; + volume = -1; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetChannelVolumeL(channel, volume)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetChannelVolumeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetChannelVolumeL %d = %d"),err ,expErr); + + return ret; + } + +//Check this +//------------------------------------------------------------------ +CTestSetChannelMute::CTestSetChannelMute(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetChannelMute* CTestSetChannelMute::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetChannelMute* self = new(ELeave) CTestSetChannelMute(aTestName, aTestType); + return self; + } + +TVerdict CTestSetChannelMute::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt channel = 0; + TBool muted = ETrue; + + INFO_PRINTF1(_L("CMidiClientUtility: Set channel mute")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestInvalidChannelOutOfRange: + expErr = KErrArgument; + channel = 16; + break; + + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetChannelMuteL(channel, muted)); + + // check correct result + if (iTestType == ETestValid) + { + TBool currMuted = EFalse; + + // until real MIDI controller IsChannelMuteL is always TRUE + TRAPD(err2, currMuted = aMidi->IsChannelMuteL(channel)); + + if(err2 != KErrNone) + { + ERR_PRINTF2(_L("IsChannelMuteL() returned %d"), err2); + ret = EInconclusive; + return ret; + } + + if(currMuted != muted) + { + ERR_PRINTF2(_L("Error : expected %d"), muted); + ret = EFail; + return ret; + } + } + + + if (expErr != err) + { + ERR_PRINTF3(_L("SetChannelMuteL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetChannelMuteL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestReturnVolume::CTestReturnVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestReturnVolume* CTestReturnVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + + CTestReturnVolume* self = new(ELeave) CTestReturnVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestReturnVolume::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Return channel volume")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt volume = 0; +// TRAPD(err, volume = aMidi->VolumeL()); + TRAPD(err, aMidi->VolumeL()); // EABI warning removal + if (expErr != err) + { + ERR_PRINTF3(_L("VolumeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("VolumeL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestReturnMaxVolume::CTestReturnMaxVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestReturnMaxVolume* CTestReturnMaxVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestReturnMaxVolume* self = new(ELeave) CTestReturnMaxVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestReturnMaxVolume::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Return max channel volume")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt volume = 0; +// TRAPD(err, volume = aMidi->MaxVolumeL()); + TRAPD(err, aMidi->MaxVolumeL()); // EABI warning removal + if (expErr != err) + { + ERR_PRINTF3(_L("MaxVolumeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("MaxVolumeL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetVolume::CTestSetVolume(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetVolume* CTestSetVolume::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetVolume* self = new(ELeave) CTestSetVolume(aTestName, aTestType); + return self; + } + +TVerdict CTestSetVolume::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt volume = 0; + + INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + volume = 10; + break; + case ETestVolumeHighOutOfRange: + expErr = KErrNotSupported; + volume = 9999999; + break; + case ETestVolumeLowOutOfRange: + expErr = KErrNotSupported; + volume = -9999999; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetVolumeL(volume)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetVolumeL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetVolumeL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetVolumeRamp::CTestSetVolumeRamp(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetVolumeRamp* CTestSetVolumeRamp::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetVolumeRamp* self = new(ELeave) CTestSetVolumeRamp(aTestName, aTestType); + return self; + } + +TVerdict CTestSetVolumeRamp::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TTimeIntervalMicroSeconds rampDuration; + + INFO_PRINTF1(_L("CMidiClientUtility: Set channel volume ramp")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestRampDurationHighOutOfRange: + expErr = KErrNotSupported; + rampDuration = 9999999; + break; + case ETestRampDurationLowOutOfRange: + expErr = KErrNotSupported; + rampDuration = -9999999; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetVolumeRampL(rampDuration)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetVolumeRampL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetVolumeL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestGetBalance::CTestGetBalance(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestGetBalance* CTestGetBalance::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestGetBalance* self = new(ELeave) CTestGetBalance(aTestName, aTestType); + return self; + } + +TVerdict CTestGetBalance::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + //TTimeIntervalMicroSeconds rampDuration; + + INFO_PRINTF1(_L("CMidiClientUtility: Get balance")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt getBalance = 0; +// TRAPD(err, getBalance = aMidi->GetBalanceL()); + TRAPD(err, aMidi->GetBalanceL()); // EABI warning removal + + if (expErr != err) + { + ERR_PRINTF3(_L("GetBalanceL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("GetBalanceL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetBalance::CTestSetBalance(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetBalance* CTestSetBalance::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetBalance* self = new(ELeave) CTestSetBalance(aTestName, aTestType); + return self; + } + +TVerdict CTestSetBalance::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; +// TInt balance = 0; // EABI warning removal + + INFO_PRINTF1(_L("CMidiClientUtility: Set balance")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + case ETestBalanceHighOutOfRange: + expErr = KErrNotSupported; +// balance = 101; // EABI warning removal + break; + case ETestBalanceLowOutOfRange: + expErr = KErrNotSupported; +// balance = -101; // EABI warning removal + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + TRAPD(err, aMidi->SetBalanceL()); + if (expErr != err) + { + ERR_PRINTF3(_L("SetBalanceL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetBalanceL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestSetPriority::CTestSetPriority(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestSetPriority* CTestSetPriority::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestSetPriority* self = new(ELeave) CTestSetPriority(aTestName, aTestType); + return self; + } + +TVerdict CTestSetPriority::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt priority = 0; + TMdaPriorityPreference pref = EMdaPriorityPreferenceNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Set priority")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestPreferenceConflictsCannotBeResolved: + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TMdaPriorityPreference aPref Priority preference to use if there should be contention with another client. +// We need this to confict and cause PreferenceConflictsCannotBeResolved + TRAPD(err, aMidi->SetPriorityL(priority, pref)); + if (expErr != err) + { + ERR_PRINTF3(_L("SetPriorityL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("SetPriorityL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestNumberOfXmfMetaDataEntries::CTestNumberOfXmfMetaDataEntries(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestNumberOfXmfMetaDataEntries* CTestNumberOfXmfMetaDataEntries::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestNumberOfXmfMetaDataEntries* self = new(ELeave) CTestNumberOfXmfMetaDataEntries(aTestName, aTestType); + return self; + } + +TVerdict CTestNumberOfXmfMetaDataEntries::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Number Of Xmf Meta Data Entries")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } +// TInt numberOfXmfMetaDataEntriesL = 0; +// TRAPD(err, numberOfXmfMetaDataEntriesL = aMidi->NumberOfMetaDataEntriesL()); + TRAPD(err, aMidi->NumberOfMetaDataEntriesL()); // EABI warning removal + if (expErr != err) + { + ERR_PRINTF3(_L("NumberOfXmfMetaDataEntriesL gave error %d (expected %d)"),err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("NumberOfXmfMetaDataEntriesL %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + +CTestGetXmfMetaDataEntry::CTestGetXmfMetaDataEntry(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestGetXmfMetaDataEntry* CTestGetXmfMetaDataEntry::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestGetXmfMetaDataEntry* self = new(ELeave) CTestGetXmfMetaDataEntry(aTestName, aTestType); + return self; + } + +TVerdict CTestGetXmfMetaDataEntry::DoTestL(CMidiClientUtility* /*aMidi*/) + { + TVerdict ret = EPass; + TInt err = KErrNone; + + TInt expErr = KErrNone; +// TInt metaDataIndex = 1; // EABI warning removal + + INFO_PRINTF1(_L("CMidiClientUtility: Get Xmf Meta Data Entry")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestUnsupported: + expErr = KErrNotSupported; + break; + case ETestMetaDataIndexInvalid: +// metaDataIndex = -1; // EABI warning removal + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + // Default constructor. Returns a blank meta data object. To be used when internalizing data into the object. +// CMMFMetaDataEntry* getXmfMetaDataEntry = CMMFMetaDataEntry::NewL(); + +// Causes Access Violation +// TRAPD(err, CMMFMetaDataEntry* getXmfMetaDataEntry = aMidi->GetMetaDataEntryL(metaDataIndex)); + if (expErr != err) + { + ERR_PRINTF3(_L("GetXmfMetaDataEntry gave error %d (expected %d)"), err, expErr); + ret = EFail; + } + else + INFO_PRINTF3(_L("GetXmfMetaDataEntry %d = %d"),err ,expErr); + + return ret; + } + +//------------------------------------------------------------------ + + +//------------------------------------------------------------------ + +CTestLoadCustomInstrumentData::CTestLoadCustomInstrumentData(const TDesC& aTestName, + const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestLoadCustomInstrumentData* CTestLoadCustomInstrumentData::NewL(const TDesC& aTestName, + const TTestStepType aTestType) + { + CTestLoadCustomInstrumentData* self = new (ELeave) CTestLoadCustomInstrumentData(aTestName, + aTestType); + return self; + } + + +TVerdict CTestLoadCustomInstrumentData::DoTestL(CMidiClientUtility* aMidi) + { + // N.B. Until there is a MIDI controller there is no sense in having any + // invalid tests since at present LoadCustomInstrumentDataL always returns + // ETrue [it doesn't actually attempt a load]. When we actually have a + // proper MIDI instrument this test can be modified to load this instead of + // the NULL descriptor below. NJ + + TVerdict ret = EPass; + TInt expErr; + + TInt memBankId = 90; + TInt memInstrId = 91; + TInt bankId = 92; + TInt instrId = 93; + + // change these to real descriptors when we have a MIDI instruments + const TDesC8* ptrInstrument = &KNullDesC8; + const TDesC8* ptrBadInstrument = &KNullDesC8; + + // XXX::When we have a MIDI instrument / controller load the instrument + // into the descriptor here. + + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestInvalidId: + expErr = KErrArgument; + bankId = -2; + break; + case ETestAlreadyLoaded: + // ** to do : load once and attempt to load again. + // when instrument data files are available, this will work + expErr = KErrInUse; + break; + case ETestUnsupported: // ** to define test data for this + expErr = KErrNotSupported; + break; + + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + TInt err = KErrNone; + + // bad descriptor test + if (iTestType == ETestUnsupported) + { + // load the bad / unsupported instrument + TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrBadInstrument, bankId, instrId, memBankId, memInstrId)); + } + else + { + // if testing already loaded, preload the instrument here + if(iTestType == ETestAlreadyLoaded) + { + TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrInstrument, bankId, instrId, memBankId, memInstrId)); + INFO_PRINTF2(_L("Preload : LoadCustomInstrumentDataL gave error %d"), err); + if(err != KErrNone) + { + ret = EInconclusive; + return ret; + } + } + + // load the instrument + TRAP(err, aMidi->LoadCustomInstrumentDataL(*ptrInstrument, bankId, instrId, memBankId, memInstrId)); + } + + INFO_PRINTF3(_L("LoadCustomInstrumentDataL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + + +//------------------------------------------------------------------ + + +//------------------------------------------------------------------ + +_LIT(KMidiClntChunk, "MidiClntChunk"); +_LIT(KMidiClntSemaphore, "MidiClntSemaphore"); + +CTestCheckInterface::CTestCheckInterface(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName,aTestType) + { + } + +CTestCheckInterface* CTestCheckInterface::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestCheckInterface* self = new (ELeave) CTestCheckInterface(aTestName, aTestType); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CTestCheckInterface::ConstructL() + { + User::LeaveIfError(iChunk.CreateGlobal(KMidiClntChunk,20,20)); + User::LeaveIfError(iSemaphore.CreateGlobal(KMidiClntSemaphore, 0)); + + } + +CTestCheckInterface::~CTestCheckInterface() + { + } + +void CTestCheckInterface::Close() + { + iChunk.Close(); + iSemaphore.Close(); + } + + +TVerdict CTestCheckInterface::DoTestL(CMidiClientUtility* aMidi) + { + + TVerdict ret = EPass; + TInt expErr = KErrNone; + TInt err = KErrNone; + + // + //PlayNoteL// + // + TRAP_IGNORE(aMidi->PlayNoteL(0,0,TTimeIntervalMicroSeconds(0),0,0)); + err = CompareInterface( _L8("PlayNoteL")); + INFO_PRINTF3(_L("Check interface PlayNoteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //PlayNoteL(WithStartTime)// + // + TRAP_IGNORE(aMidi->PlayNoteL(0,0,TTimeIntervalMicroSeconds(0),TTimeIntervalMicroSeconds(0),0,0)); + err = CompareInterface(_L8("PlayNoteWithStartTime")); + INFO_PRINTF3(_L("Check interface PlayNoteL (WithStartTime) gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //StopNotes// + // + aMidi->StopNotes(0); + err = CompareInterface(_L8("StopNotes")); + INFO_PRINTF3(_L("Check interface StopNotes gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //NoteOnL// + // + TRAP_IGNORE(aMidi->NoteOnL(0,0,0)); + err = CompareInterface(_L8("NoteOnL")); + INFO_PRINTF3(_L("Check interface NoteOnL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //NoteOffL// + // + TRAP_IGNORE(aMidi->NoteOffL(0,0,0)); + err = CompareInterface(_L8("NoteOffL")); + INFO_PRINTF3(_L("Check interface NoteOffL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //PlaybackRateL// + // + TRAP_IGNORE(aMidi->PlaybackRateL()); + err = CompareInterface(_L8("PlaybackRateL")); + INFO_PRINTF3(_L("Check interface PlaybackRateL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetPlaybackRateL// + // + TRAP_IGNORE(aMidi->SetPlaybackRateL(0)); + err = CompareInterface(_L8("SetPlaybackRateL")); + INFO_PRINTF3(_L("Check interface SetPlaybackRateL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //MaxPlaybackRateL// + // + TRAP_IGNORE(aMidi->MaxPlaybackRateL()); + err = CompareInterface(_L8("MaxPlaybackRateL")); + INFO_PRINTF3(_L("Check interface MaxPlaybackRateL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //MinPlaybackRateL// + // + TRAP_IGNORE(aMidi->MinPlaybackRateL()); + err = CompareInterface(_L8("MinPlaybackRateL")); + INFO_PRINTF3(_L("Check interface MinPlaybackRateL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //TempoMicroBeatsPerMinuteL// + // + TRAP_IGNORE(aMidi->TempoMicroBeatsPerMinuteL()); + err = CompareInterface(_L8("TempoMicroBeatsPerMinuteL")); + INFO_PRINTF3(_L("Check interface TempoMicroBeatsPerMinuteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetTempoL// + // + TRAP_IGNORE(aMidi->SetTempoL(1)); + err = CompareInterface(_L8("SetTempoL")); + INFO_PRINTF3(_L("Check interface SetTempoL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //PitchTranspositionCentsL// + // + TRAP_IGNORE(aMidi->PitchTranspositionCentsL()); + err = CompareInterface(_L8("PitchTranspositionCentsL")); + INFO_PRINTF3(_L("Check interface PitchTranspositionCentsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetPitchTranspositionL// + // + TRAP_IGNORE(aMidi->SetPitchTranspositionL(0)); + err = CompareInterface(_L8("SetPitchTranspositionL")); + INFO_PRINTF3(_L("Check interface SetPitchTranspositionL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //DurationMicroBeatsL// + // + TRAP_IGNORE(aMidi->DurationMicroBeatsL()); + err = CompareInterface(_L8("DurationMicroBeatsL")); + INFO_PRINTF3(_L("Check interface DurationMicroBeatsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //NumTracksL// + // + TRAP_IGNORE(aMidi->NumTracksL()); + err = CompareInterface(_L8("NumTracksL")); + INFO_PRINTF3(_L("Check interface NumTracksL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetTrackMuteL// + // + TRAP_IGNORE(aMidi->SetTrackMuteL(0,ETrue)); + err = CompareInterface(_L8("SetTrackMuteL")); + INFO_PRINTF3(_L("Check interface SetTrackMuteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //MimeTypeL// + // + TRAP_IGNORE(aMidi->MimeTypeL()); + err = CompareInterface(_L8("MimeTypeL")); + INFO_PRINTF3(_L("Check interface MimeTypeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //PositionMicroBeatsL// + // + TRAP_IGNORE(aMidi->PositionMicroBeatsL()); + err = CompareInterface(_L8("PositionMicroBeatsL")); + INFO_PRINTF3(_L("Check interface PositionMicroBeatsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetPositionMicroBeatsL// + // + TRAP_IGNORE(aMidi->SetPositionMicroBeatsL(0)); + err = CompareInterface(_L8("SetPositionMicroBeatsL")); + INFO_PRINTF3(_L("Check interface SetPositionMicroBeatsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetSyncUpdateCallbackIntervalL// + // + TRAP_IGNORE(aMidi->SetSyncUpdateCallbackIntervalL(TTimeIntervalMicroSeconds(1))); + err = CompareInterface(_L8("SetSyncUpdateCallbackIntervalL")); + INFO_PRINTF3(_L("Check interface SetSyncUpdateCallbackIntervalL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SendMessageL// + // + TRAP_IGNORE(aMidi->SendMessageL(_L8(""))); + err = CompareInterface(_L8("SendMessageL")); + INFO_PRINTF3(_L("Check interface SendMessageL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SendMessageL (WithTimeStamp)// + // + TRAP_IGNORE(aMidi->SendMessageL(_L8(""), TTimeIntervalMicroSeconds(0))); + err = CompareInterface(_L8("SendMessageWithTimeStamp")); + INFO_PRINTF3(_L("Check interface SendMessageL (WithTimeStamp) gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SendMipMessageL// + // + { + TMipMessageEntry mipEntry; + mipEntry.iChannel = 10; + mipEntry.iMIPValue = 20; + RArray mipArray; + mipArray.Append(mipEntry); + + TRAP_IGNORE(aMidi->SendMipMessageL(mipArray)); + mipArray.Close(); + } + err = CompareInterface(_L8("SendMipMessageL")); + INFO_PRINTF3(_L("Check interface SendMipMessageL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //NumberOfBanksL// + // + TRAP_IGNORE(aMidi->NumberOfBanksL(ETrue)); + err = CompareInterface(_L8("NumberOfBanksL")); + INFO_PRINTF3(_L("Check interface NumberOfBanksL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //GetBankIdL// + // + TRAP_IGNORE(aMidi->GetBankIdL(ETrue,0)); + err = CompareInterface(_L8("GetBankIdL")); + INFO_PRINTF3(_L("Check interface GetBankIdL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //LoadCustomBankL// + // + { + TInt bankId = 0; + TRAP_IGNORE(aMidi->LoadCustomBankL(_L(""),bankId)); + } + err = CompareInterface(_L8("LoadCustomBankL")); + INFO_PRINTF3(_L("Check interface LoadCustomBankL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //LoadCustomBankDataL// + // + { + TInt bankId = 0; + TRAP_IGNORE(aMidi->LoadCustomBankDataL(_L8(""),bankId)); + } + err = CompareInterface(_L8("LoadCustomBankDataL")); + INFO_PRINTF3(_L("Check interface LoadCustomBankDataL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //UnloadCustomBankL// + // + TRAP_IGNORE(aMidi->UnloadCustomBankL(0)); + err = CompareInterface(_L8("UnloadCustomBankL")); + INFO_PRINTF3(_L("Check interface UnloadCustomBankL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //CustomBankLoadedL// + // + TRAP_IGNORE(aMidi->CustomBankLoadedL(0)); + err = CompareInterface(_L8("CustomBankLoadedL")); + INFO_PRINTF3(_L("Check interface CustomBankLoadedL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //UnloadAllCustomBanksL// + // + TRAP_IGNORE(aMidi->UnloadAllCustomBanksL()); + err = CompareInterface(_L8("UnloadAllCustomBanksL")); + INFO_PRINTF3(_L("Check interface UnloadAllCustomBanksL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //NumberOfInstrumentsL// + // + TRAP_IGNORE(aMidi->NumberOfInstrumentsL(0,ETrue)); + err = CompareInterface(_L8("NumberOfInstrumentsL")); + INFO_PRINTF3(_L("Check interface NumberOfInstrumentsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //GetInstrumentIdL// + // + TRAP_IGNORE(aMidi->GetInstrumentIdL(0, ETrue, 0)); + err = CompareInterface(_L8("GetInstrumentIdL")); + INFO_PRINTF3(_L("Check interface GetInstrumentIdL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //InstrumentNameL// + // + { + HBufC* instrumentName = NULL; + TRAP_IGNORE(instrumentName = aMidi->InstrumentNameL(0, ETrue, 0)); + delete instrumentName; + } + err = CompareInterface(_L8("InstrumentNameL")); + INFO_PRINTF3(_L("Check interface InstrumentNameL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //GetInstrumentL// + // + { + TInt instrumentId = 0; + TInt bankId = 0; + TRAP_IGNORE(aMidi->GetInstrumentL(0, instrumentId, bankId)); + } + err = CompareInterface(_L8("GetInstrumentL")); + INFO_PRINTF3(_L("Check interface GetInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetInstrumentL// + // + TRAP_IGNORE(aMidi->SetInstrumentL(0, 0, 0)); + err = CompareInterface(_L8("SetInstrumentL")); + INFO_PRINTF3(_L("Check interface SetInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //LoadCustomInstrumentL// + // + TRAP_IGNORE(aMidi->LoadCustomInstrumentL(_L(""),0,0,0,0)); + err = CompareInterface(_L8("LoadCustomInstrumentL")); + INFO_PRINTF3(_L("Check interface LoadCustomInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //LoadCustomInstrumentDataL// + // + TRAP_IGNORE(aMidi->LoadCustomInstrumentDataL(_L8(""),0,0,0,0)); + err = CompareInterface(_L8("LoadCustomInstrumentDataL")); + INFO_PRINTF3(_L("Check interface LoadCustomInstrumentDataL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //UnloadCustomInstrumentL// + // + TRAP_IGNORE(aMidi->UnloadCustomInstrumentL(0,0)); + err = CompareInterface(_L8("UnloadCustomInstrumentL")); + INFO_PRINTF3(_L("Check interface UnloadCustomInstrumentL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //PercussionKeyNameL// + // + { + HBufC* percussionKeyName = NULL; + TRAP_IGNORE(percussionKeyName = aMidi->PercussionKeyNameL(0,0,0,0)); + delete percussionKeyName; + } + err = CompareInterface(_L8("PercussionKeyNameL")); + INFO_PRINTF3(_L("Check interface PercussionKeyNameL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //StopTimeL// + // + { + TTimeIntervalMicroSeconds stopTime(0); + TRAP_IGNORE(aMidi->StopTimeL(stopTime)); + } + err = CompareInterface(_L8("StopTimeL")); + INFO_PRINTF3(_L("Check interface StopTimeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetStopTimeL// + // + { + TTimeIntervalMicroSeconds stopTime(0); + TRAP_IGNORE(aMidi->SetStopTimeL(stopTime)); + } + err = CompareInterface(_L8("SetStopTimeL")); + INFO_PRINTF3(_L("Check interface SetStopTimeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetRepeatsL// + // + { + TInt repeatNumberOfTimes = 0; + TTimeIntervalMicroSeconds trailingSilence(0); + TRAP_IGNORE(aMidi->SetRepeatsL(repeatNumberOfTimes, trailingSilence)); + } + err = CompareInterface(_L8("SetRepeatsL")); + INFO_PRINTF3(_L("Check interface SetRepeatsL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + // + //GetRepeats// + // + TRAP_IGNORE(aMidi->GetRepeats()); + err = CompareInterface(_L8("GetRepeats")); + INFO_PRINTF3(_L("Check interface GetRepeats gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + + // + //PolyphonyL// + // + TRAP_IGNORE(aMidi->PolyphonyL()); + err = CompareInterface(_L8("PolyphonyL")); + INFO_PRINTF3(_L("Check interface PolyphonyL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetMaxPolyphonyL// + // + TRAP_IGNORE(aMidi->SetMaxPolyphonyL(1)); + err = CompareInterface(_L8("SetMaxPolyphonyL")); + INFO_PRINTF3(_L("Check interface SetMaxPolyphonyL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //ChannelsSupportedL// + // + TRAP_IGNORE(aMidi->ChannelsSupportedL()); + err = CompareInterface(_L8("ChannelsSupportedL")); + INFO_PRINTF3(_L("Check interface ChannelsSupportedL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //ChannelVolumeL// + // + TRAP_IGNORE(aMidi->ChannelVolumeL(0)); + err = CompareInterface(_L8("ChannelVolumeL")); + INFO_PRINTF3(_L("Check interface ChannelVolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //MaxChannelVolumeL// + // + TRAP_IGNORE(aMidi->MaxChannelVolumeL()); + err = CompareInterface(_L8("MaxChannelVolumeL")); + INFO_PRINTF3(_L("Check interface MaxChannelVolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetChannelVolumeL// + // + TRAP_IGNORE(aMidi->SetChannelVolumeL(0,0)); + err = CompareInterface(_L8("SetChannelVolumeL")); + INFO_PRINTF3(_L("Check interface SetChannelVolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetChannelMuteL// + // + TRAP_IGNORE(aMidi->SetChannelMuteL(0,0)); + err = CompareInterface(_L8("SetChannelMuteL")); + INFO_PRINTF3(_L("Check interface SetChannelMuteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //VolumeL// + // + TRAP_IGNORE(aMidi->VolumeL()); + err = CompareInterface(_L8("VolumeL")); + INFO_PRINTF3(_L("Check interface VolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //MaxVolumeL// + // + TRAP_IGNORE(aMidi->MaxVolumeL()); + err = CompareInterface(_L8("MaxVolumeL")); + INFO_PRINTF3(_L("Check interface MaxVolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetVolumeL// + // + TRAP_IGNORE(aMidi->SetVolumeL(0)); + err = CompareInterface(_L8("SetVolumeL")); + INFO_PRINTF3(_L("Check interface SetVolumeL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetVolumeRampL// + // + TRAP_IGNORE(aMidi->SetVolumeRampL(TTimeIntervalMicroSeconds(0))); + err = CompareInterface(_L8("SetVolumeRampL")); + INFO_PRINTF3(_L("Check interface SetVolumeRampL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //GetBalanceL// + // + TRAP_IGNORE(aMidi->GetBalanceL()); + err = CompareInterface(_L8("GetBalanceL")); + INFO_PRINTF3(_L("Check interface GetBalanceL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetBalanceL// + // + TRAP_IGNORE(aMidi->SetBalanceL()); + err = CompareInterface(_L8("SetBalanceL")); + INFO_PRINTF3(_L("Check interface SetBalanceL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //SetBankL// + // + TRAP_IGNORE(aMidi->SetBankL(ETrue)); + err = CompareInterface(_L8("SetBankL")); + INFO_PRINTF3(_L("Check interface SetBankL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //IsTrackMuteL// + // + TRAP_IGNORE(aMidi->IsTrackMuteL(0)); + err = CompareInterface(_L8("IsTrackMuteL")); + INFO_PRINTF3(_L("Check interface IsTrackMuteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + // + //IsChannelMuteL// + // + TRAP_IGNORE(aMidi->IsChannelMuteL(0)); + err = CompareInterface(_L8("IsChannelMuteL")); + INFO_PRINTF3(_L("Check interface IsChannelMuteL gave error %d (expected %d)"), err, expErr); + if(err != expErr) + { + ret = EFail; + return ret; + } + + return ret; + } + +TInt CTestCheckInterface::CompareInterface(const TDesC8& aInterfaceName) + { + TBuf8<40> clientBuf; + TBuf8<40> controllerBuf; + clientBuf.FillZ(40); + controllerBuf.FillZ(40); + + clientBuf.Copy(aInterfaceName); + iSemaphore.Wait(); + controllerBuf = iChunk.Base(); + controllerBuf.SetLength(aInterfaceName.Length()); + + TInt err = clientBuf.Compare(controllerBuf); + + return err; + } + +//-------------------------------------------------------------------------------- +//MS 3.4 File Handles API +//-------------------------------------------------------------------------------- +CTestMidiClntOpenFileByHandle::CTestMidiClntOpenFileByHandle(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType), + iPlay(aPlay) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiClntOpenFileByHandle* CTestMidiClntOpenFileByHandle::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TTestStepType aTestType) + { + CTestMidiClntOpenFileByHandle* self = new(ELeave) CTestMidiClntOpenFileByHandle(aTestName, aSectName, aKeyName, aPlay, aTestType); + return self; + } + +TVerdict CTestMidiClntOpenFileByHandle::DoTestStepL() + { + //[ Local variables ] + TPtrC filename; + TInt expErr = KErrNone; + TVerdict ret = EFail; + + //[ Get the File name from ini file ] + if(!GetStringFromConfig(iSectName,iKeyName,filename)) + { + return EInconclusive; + } + + //[ Expected results ] + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNegative: + expErr = KErrNotSupported; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //[ Create CMidiClientUtility - player ] + CMidiClientUtility* player=NULL; + TRAPD(err1, player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality)); + if (err1 != KErrNone) + { + ERR_PRINTF2(_L("Error while creating a CMidiClientUtility : %d"),err1); + return EInconclusive; + } + + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + CleanupStack::PushL(player); + + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = EDevMidiOff; + TBuf8<8> dummyBuff; + player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + + //[ RFs and RFile ] + RFs rFs; + RFile rFile; + + //[ Connect to File System using RFs ] + User::LeaveIfError(rFs.Connect()); + CleanupClosePushL(rFs); + User::LeaveIfError(rFs.ShareProtected()); + + //[ Open the file using RFile ] + TFileName theDestinationFileName; + theDestinationFileName.Append(filename); + + INFO_PRINTF2(_L("Start : Opening the file : %S by RFile"), &filename); + TInt theRes = rFile.Open(rFs, theDestinationFileName, EFileRead); + User::LeaveIfError(theRes); + CleanupClosePushL(rFile); + INFO_PRINTF2(_L("End : Opening the file : %S by RFile"), &filename); + + //[ API Call ] + player->OpenFile(rFile); + + //[ Wait for Initialisation Callback ] + INFO_PRINTF1(_L("Start : CMidiClientUtility->OpenFile()")); + CActiveScheduler::Start(); + INFO_PRINTF1(_L("End : CMidiClientUtility->OpenFile()")); + + //[ Check for errors ] + if (iError == expErr) + { + INFO_PRINTF3(_L("Expected Error : %d, Actual Error : %d"), expErr, iError); + ret = EPass; + } + else + { + ERR_PRINTF3(_L("Expected Error : %d, Actual Error : %d"), expErr, iError); + ret = EFail; + } + + //[ Clean-up RFs, RFile and CMidiClientUtility ] + CleanupStack::PopAndDestroy(3); + + return ret; + } + + +//------------------------------------------------------------------------ + +CTestMidiClntPlayFileByHandle::CTestMidiClntPlayFileByHandle(const TDesC& aTestName) + :CTestMmfMidiClntStep(aTestName, ETestValid) + { + } + +CTestMidiClntPlayFileByHandle* CTestMidiClntPlayFileByHandle::NewL(const TDesC& aTestName) + { + CTestMidiClntPlayFileByHandle* self = new(ELeave) CTestMidiClntPlayFileByHandle(aTestName); + return self; + } + +TVerdict CTestMidiClntPlayFileByHandle::DoTestL(CMidiClientUtility* aMidi) + { + //[ Local variables ] + TPtrC filename; + + //[ Get the filename ] + if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),filename)) + { + return EInconclusive; + } + + INFO_PRINTF1(_L("CMidiClientUtility : Play MIDI File")); + + iCurrentState = EMidiStateClosedDisengaged; + + //[ RFs and RFile ] + RFs rFs; + RFile rFile; + + //[ Connect to File System using RFs ] + User::LeaveIfError(rFs.Connect()); + CleanupClosePushL(rFs); + User::LeaveIfError(rFs.ShareProtected()); + + INFO_PRINTF1(_L("Opening the file : c:\\DoesntExist.mid")); + + //[ Open the file using RFile ] + TInt theRes = rFile.Open(rFs, filename, EFileRead); + if(theRes != KErrNone) + { + INFO_PRINTF2(_L("Cannot open file : %S"), &filename); + } + CleanupClosePushL(rFile); + + //[ Call the OpenFile Method using the File Handle ] + aMidi->OpenFile(rFile); + + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged + + //[ Clean up RFs and RFile ] + CleanupStack::PopAndDestroy(2); + + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + aMidi->Play(); + if (iError != KErrNone) + { + ERR_PRINTF2(_L("Play gave error %d"),iError); + return EFail; + } + + INFO_PRINTF1(_L("Waiting for EMidiStateOpenPlaying state...")); + CActiveScheduler::Start(); // EMidiStateOpenDisengaged ->EMidiStateOpenPlaying + if (iCurrentState != EMidiStateOpenPlaying) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState); + return EFail; + } + + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateOpenPlaying ->EMidiStateOpenEngaged + if (iCurrentState != EMidiStateOpenEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + + return EPass; + } + + +//------------------------------------------------------------------------ +// The purpose of this test is that we can hold more than 10 events in the +// MIDI event queue and none of them gets lost + +CTestMidiClntThirteenMidiEvents::CTestMidiClntThirteenMidiEvents(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + // set the current transion to 0, the start point + iCurrentTransion = 0; + } + + +CTestMidiClntThirteenMidiEvents* CTestMidiClntThirteenMidiEvents::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestMidiClntThirteenMidiEvents* self = new(ELeave)CTestMidiClntThirteenMidiEvents(aTestName, aTestType); + return self; + } + +void CTestMidiClntThirteenMidiEvents::InitialiseExpectedTransArrayL() +{ + User::LeaveIfError(expectedTransitions.Append(EMmcuoTempoChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoVolumeChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMuteChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoPolyphonyChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoInstrumentChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMetaDataEntryFound)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoVolumeChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMuteChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoPolyphonyChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoInstrumentChanged)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMetaDataEntryFound)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMipMessageReceived)); + User::LeaveIfError(expectedTransitions.Append(EMmcuoMipMessageReceived)); + +} + +void CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged(TInt /*aMicroBeatsPerMinute*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoTempoChanged) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoTempoChanged callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + +void CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged(TInt /*aChannel*/,TReal32 /*aVolumeInDecibels*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoVolumeChanged) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoVolumeChanged callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + +void CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged(TInt /*aChannel*/,TBool /*aMuted*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoMuteChanged) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMuteChanged callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + + +void CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound(const TInt /*aMetaDataEntryId*/,const TTimeIntervalMicroSeconds& /*aPosition*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoMetaDataEntryFound) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMetaDataEntryFound callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + +void CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived(const RArray& /*aEntry*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoMipMessageReceived) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoMipMessageReceived callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + +void CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged(TInt /*aNewPolyphony*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoPolyphonyChanged) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoPolyphonyChanged callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + +void CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged(TInt /*aChannel*/,TInt /*aBankId*/,TInt /*aInstrumentId*/) +{ + if (expectedTransitions[iCurrentTransion] == EMmcuoInstrumentChanged) + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged callback")); + iCurrentTransion++; + } + else + { + INFO_PRINTF1(_L("CTestMidiClntThirteenMidiEvents::MmcuoInstrumentChanged callback not expected")); + expectedTransitions[iCurrentTransion] = EMmcuoInvalid; + } +} + + +TVerdict CTestMidiClntThirteenMidiEvents::DoTestL(CMidiClientUtility* aMidi) + { + TVerdict ret = EPass; + TInt expErr = KErrNone; + + InitialiseExpectedTransArrayL(); + + TPtrC fileName; + if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName)) + { + return EInconclusive; + } + + INFO_PRINTF1(_L("CMidiClientUtility: Play midi file")); + // expected results + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + iCurrentState = EMidiStateClosedDisengaged; + aMidi->OpenFile(fileName); + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + expectedTransitions.Close(); + return EFail; + } + + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play gave error %d (expected %d)"),iError, expErr); + expectedTransitions.Close(); + return EFail; + } + else + { + INFO_PRINTF3(_L("Play, %d = %d"), iError, expErr); + } + + + INFO_PRINTF1(_L("Waiting for EMidiStateOpenPlaying state...")); + CActiveScheduler::Start(); // EMidiStateOpenDisengaged ->EMidiStateOpenPlaying + if (iCurrentState != EMidiStateOpenPlaying) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState); + expectedTransitions.Close(); + return EFail; + } + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateOpenPlaying ->EMidiStateOpenEngaged + if (iCurrentState != EMidiStateOpenEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState); + expectedTransitions.Close(); + return EFail; + } + + if (expectedTransitions.Find(EMmcuoInvalid) != KErrNotFound) + { + ERR_PRINTF1(_L("One of the transactions was lost")); + expectedTransitions.Close(); + return EFail; + } + + expectedTransitions.Close(); + + return ret; + } + +//------------------------------------------------------------------ +// TEST 1: Test the transtion from EMidiStateClosedDisengaged to EMidiStateClosedEngaged. + +CTestTrasitionFromEClosedToEClosedEngaged::CTestTrasitionFromEClosedToEClosedEngaged(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestTrasitionFromEClosedToEClosedEngaged* CTestTrasitionFromEClosedToEClosedEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestTrasitionFromEClosedToEClosedEngaged* self = new(ELeave) CTestTrasitionFromEClosedToEClosedEngaged(aTestName, aTestType); + return self; + } + +TVerdict CTestTrasitionFromEClosedToEClosedEngaged::DoTestL(CMidiClientUtility* aMidi) + { + //[ Local variables ] + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedDisengaged to EMidiStateClosedEngaged")); + //[ Expected results ] + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //[ Set the current state to EMidiStateClosedDisengaged ] + iCurrentState = EMidiStateClosedDisengaged; + + //[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ] + TMidiState MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call Play() ] + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateClosedEngaged + + if (iCurrentState != EMidiStateClosedEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState); + return EFail; + } + + return ret; + } + + +//------------------------------------------------------------------ +// TEST 2: Test the transtion from EMidiStateClosedDisengaged to EMidiStateOpenEngaged. + +CTestTrasitionFromEClosedToEOpenEngaged::CTestTrasitionFromEClosedToEOpenEngaged(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestTrasitionFromEClosedToEOpenEngaged* CTestTrasitionFromEClosedToEOpenEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestTrasitionFromEClosedToEOpenEngaged* self = new(ELeave) CTestTrasitionFromEClosedToEOpenEngaged(aTestName, aTestType); + return self; + } + +TVerdict CTestTrasitionFromEClosedToEOpenEngaged::DoTestL(CMidiClientUtility* aMidi) + { + //[ Local variables ] + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedDisengaged to EMidiStateOpenEngaged")); + //[ Expected results ] + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //[ Set the current state to EMidiStateClosedDisengaged ] + iCurrentState = EMidiStateClosedDisengaged; + + //[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ] + TMidiState MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call OpenFile() ] + TPtrC fileName; + if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName)) + { + return EInconclusive; + } + aMidi->OpenFile(fileName); + + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged(EMidiStateOpenDisengaged) + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call Play() ] + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying + + if (iCurrentState != EMidiStateOpenPlaying) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenPlaying) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged + + if (iCurrentState != EMidiStateOpenEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateOpenEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState); + return EFail; + } + + return ret; + } + + +//------------------------------------------------------------------ +// TEST 3: Test the transtion from EMidiStateOpenEngaged to EMidiStateClosedEngaged. + +CTestTrasitionFromEOpenEngagedToEClosedEngaged::CTestTrasitionFromEOpenEngagedToEClosedEngaged(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestTrasitionFromEOpenEngagedToEClosedEngaged* CTestTrasitionFromEOpenEngagedToEClosedEngaged::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestTrasitionFromEOpenEngagedToEClosedEngaged* self = new(ELeave) CTestTrasitionFromEOpenEngagedToEClosedEngaged(aTestName, aTestType); + return self; + } + +TVerdict CTestTrasitionFromEOpenEngagedToEClosedEngaged::DoTestL(CMidiClientUtility* aMidi) + { + //[ Local variables ] + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateOpenEngaged to EMidiStateClosedEngaged")); + //[ Expected results ] + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //[ Set the current state to EMidiStateClosedDisengaged ] + iCurrentState = EMidiStateClosedDisengaged; + + //[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ] + TMidiState MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call OpenFile() ] + TPtrC fileName; + if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName)) + { + return EInconclusive; + } + + aMidi->OpenFile(fileName); + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateOpenDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call Play() ] + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying + + if (iCurrentState != EMidiStateOpenPlaying) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenPlaying) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged + + if (iCurrentState != EMidiStateOpenEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState); + return EFail; + } + + + // [ Call Close() ] + aMidi->Close(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenEngaged -> EMidiStateClosedEngaged + + if (iCurrentState != EMidiStateClosedEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateClosedEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState); + return EFail; + } + + return ret; + } + + + +//--------------------------------------------------------------------- +// TEST 4: Test the transtion from EMidiStateClosedEngaged to EMidiStateClosedDisengaged. + +CTestTrasitionFromEClosedEngagedToEClosed::CTestTrasitionFromEClosedEngagedToEClosed(const TDesC& aTestName, const TTestStepType aTestType) + :CTestMmfMidiClntStep(aTestName, aTestType) + { + } + +CTestTrasitionFromEClosedEngagedToEClosed* CTestTrasitionFromEClosedEngagedToEClosed::NewL(const TDesC& aTestName, const TTestStepType aTestType) + { + CTestTrasitionFromEClosedEngagedToEClosed* self = new(ELeave) CTestTrasitionFromEClosedEngagedToEClosed(aTestName, aTestType); + return self; + } + +TVerdict CTestTrasitionFromEClosedEngagedToEClosed::DoTestL(CMidiClientUtility* aMidi) + { + //[ Local variables ] + TVerdict ret = EPass; + TInt expErr = KErrNone; + + INFO_PRINTF1(_L("CMidiClientUtility: Transition from EMidiStateClosedEngaged to EMidiStateClosedDisengaged")); + //[ Expected results ] + switch(iTestType) + { + case ETestValid: + expErr = KErrNone; + break; + case ETestNoPlugin: + expErr = KErrNotSupported; + break; + case ETestInvalidState: + expErr = KErrUnknown; + break; + default: + ERR_PRINTF1(_L("Error - invalid test step type")); + return EInconclusive; + } + + //[ Set the current state to EMidiStateClosedDisengaged ] + iCurrentState = EMidiStateClosedDisengaged; + + //[ Retrieve the MIDI client utility state and check it is EMidiStateClosedDisengaged ] + TMidiState MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call OpenFile() ] + TPtrC fileName; + if(!GetStringFromConfig(_L("SectionOne"),_L("filename"),fileName)) + { + return EInconclusive; + } + + aMidi->OpenFile(fileName); + INFO_PRINTF1(_L("Waiting for EMidiStateOpenDisengaged state...")); + CActiveScheduler::Start(); // EMidiStateClosedDisengaged -> EMidiStateOpenDisengaged + if (iCurrentState != EMidiStateOpenDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenDisengaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenDisengaged)"), MIDIClientState); + return EFail; + } + + // [ Call Play() ] + aMidi->Play(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenDisengaged -> EMidiStateOpenPlaying + + if (iCurrentState != EMidiStateOpenPlaying) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenPlaying, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateOpenPlaying) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenPlaying")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenPlaying)"), MIDIClientState); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenPlaying -> EMidiStateOpenEngaged + + if (iCurrentState != EMidiStateOpenEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateOpenEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateOpenEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateOpenEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateOpenEngaged)"), MIDIClientState); + return EFail; + } + + + // [ Call Close() ] + aMidi->Close(); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateOpenEngaged -> EMidiStateClosedEngaged + + if (iCurrentState != EMidiStateClosedEngaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedEngaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + if (MIDIClientState == EMidiStateClosedEngaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedEngaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedEngaged)"), MIDIClientState); + return EFail; + } + + // [ Call Stop() ] + TTimeIntervalMicroSeconds fadeOutDuration(0); + aMidi->Stop(fadeOutDuration); + if (expErr != iError) + { + ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, expErr); + return EFail; + } + + CActiveScheduler::Start(); // EMidiStateClosedEngaged -> EMidiStateClosedDisengaged + + if (iCurrentState != EMidiStateClosedDisengaged) + { + ERR_PRINTF2(_L("Unexpected state (expected = EMidiStateClosedDisengaged, received = %d)"), iCurrentState); + return EFail; + } + + MIDIClientState = aMidi->State(); + + if (MIDIClientState == EMidiStateClosedDisengaged) + { + ERR_PRINTF1(_L("MIDI Client Utility ----> EMidiStateClosedDisengaged")); + } + else + { + ERR_PRINTF2(_L("MIDI Client Utility unexpected state %d (expected ----> EMidiStateClosedDisengaged)"), MIDIClientState); + return EFail; + } + return ret; + } + +//------------------------------------------------------------------------ +// This test checks for opening the file using a FileHandle more than +// once. + + +CTestMidiOpenFileHandleRepeat::CTestMidiOpenFileHandleRepeat(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + :CTestMmfMidiClntStep(aTestName, ETestValid), + iPlay(aPlay) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiOpenFileHandleRepeat* CTestMidiOpenFileHandleRepeat::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay) + { + CTestMidiOpenFileHandleRepeat* self = new(ELeave) CTestMidiOpenFileHandleRepeat(aTestName, aSectName, aKeyName, aPlay); + return self; + } + +TVerdict CTestMidiOpenFileHandleRepeat::DoTestStepL() + { + TPtrC filename; + if(!GetStringFromConfig(iSectName,iKeyName,filename)) + return EInconclusive; + TVerdict ret = EFail; + INFO_PRINTF1(_L("Test to check whether OpenFile(const RFile& aFile) works fine when opened more than once using the same filehandle ")); + + CMidiClientUtility *midiClient = CMidiClientUtility::NewL(*this); + if (!midiClient) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + CleanupStack::PushL(midiClient); + RFs fs; + RFile file; + fs.Connect(); + CleanupClosePushL(fs); + + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = 0; //EDevMidiOff; + TBuf8<8> dummyBuff; + midiClient->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + TInt err = fs.ShareProtected(); + if ((err = file.Open(fs, filename, EFileRead )) == KErrNone) + { + INFO_PRINTF1(_L("Inside the first call")); + midiClient->OpenFile(file);//opening the file for the first time using the handle + CActiveScheduler::Start(); + midiClient->Close(); + CActiveScheduler::Start(); + file.Close(); + } + err = file.Open(fs, filename, EFileRead);//Opening the file for the second time + if(err==KErrNone) //shouldn't give inuse error at this point + { + INFO_PRINTF1(_L("Inside the second call")); + midiClient->OpenFile(file); + CActiveScheduler::Start(); + midiClient->Close(); + CActiveScheduler::Start(); + file.Close(); + ret=EPass; + } + else + INFO_PRINTF2(_L("Failed to open the file the second time returned with err = %d"),err); + + //To check whether OpenFile(TDesC& aFileName) works fine when opened more than once. + _LIT (KFilename,"c:\\MidiClntITestData\\midi.mid"); + midiClient->OpenFile(KFilename);//First Open(TDesC& aFileName) + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening file")); + CActiveScheduler::Start(); + if(iError != KErrNone) + { + INFO_PRINTF2(_L("Failed to open the file.Failed with error %d"),err); + } + midiClient->Close(); + CActiveScheduler::Start(); + midiClient->OpenFile(KFilename);//Second Open(TDesC& aFileName) + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening file for the second time")); + CActiveScheduler::Start(); + if(iError != KErrNone) + { + INFO_PRINTF2(_L("Failed to open the file second time.Failed with error %d"),err); + } + //Opening the file again without calling the close for the previous open + midiClient->OpenFile(KFilename); + INFO_PRINTF1(_L("CMidiClientUtility: Opening file for the second time without close")); + CActiveScheduler::Start(); + if(iError != KErrNone) + { + INFO_PRINTF2(_L("Failed with error %d"),err); + } + midiClient->Close(); + CActiveScheduler::Start(); + + // To check that calling Open twice without closing the file inbetween does return an inuse error + file.Open(fs, filename, EFileRead);//Opening for the first time + User::After(1000000); + err = file.Open(fs, filename, EFileRead);//Opening for the secondtime without closing the previous open, should return KErrInUse + if(err != KErrInUse) + { + ret=EFail; + INFO_PRINTF2(_L("Expected to return error -14, but returned error %d"),err); + } + file.Close(); + CleanupStack::PopAndDestroy(2); // fileServer, midiClient + return ret; + } + +TVerdict CTestMidiOpenFileHandleRepeat::DoTestL(CMidiClientUtility* /*aMidi*/) + { + return EPass; + } + +/* +Playing a midi file without opening a file and checking for its status during call back. +*/ + +CTestMidiClntPlayWithoutFile::CTestMidiClntPlayWithoutFile(const TDesC& aTestName) + :CTestMmfMidiClntStep(aTestName, ETestValid) + {} + +CTestMidiClntPlayWithoutFile* CTestMidiClntPlayWithoutFile::NewL(const TDesC& aTestName) + { + CTestMidiClntPlayWithoutFile* self = new(ELeave) CTestMidiClntPlayWithoutFile(aTestName); + return self; + } + + +TVerdict CTestMidiClntPlayWithoutFile::DoTestStepL() + { + CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + TVerdict ret = EPass; + iError = KErrNone; + + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + CleanupStack::PushL(player); + + player->Play(); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error while playing")); + return EInconclusive; + } + + TTimeIntervalMicroSeconds fadeOutDuration(0); + player->Stop(fadeOutDuration); + CActiveScheduler::Start(); + + // Check for errors. + if (iError != KErrNone) + { + ret = EFail; + ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError ); + } + + INFO_PRINTF1(_L("CMidiClientUtility: Destroying")); + CleanupStack::PopAndDestroy(player); + + return ret; + } + +void CTestMidiClntPlayWithoutFile::MmcuoStateChanged(TMidiState aOldState,TMidiState aNewState,const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError) + { + iError=aError; + ERR_PRINTF2(_L("Old State: %d "),aOldState); + ERR_PRINTF2(_L("New State : %d "),aNewState); + ERR_PRINTF2(_L("Error Code : %d "),aError); + + if(aError == KErrNone) + { + if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateClosedEngaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateClosedEngaged, with no error")); + } + else if((aOldState == EMidiStateClosedEngaged) && (aNewState == EMidiStateClosedDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedEngaged to EMidiStateClosedDisengaged, with no error")); + } + else if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateOpenDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateOpenDisengaged, with no error")); + } + else if((aOldState == EMidiStateOpenDisengaged) && (aNewState == EMidiStateOpenPlaying)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenDisengaged to EMidiStateOpenPlaying, with no error")); + } + else if((aOldState == EMidiStateOpenPlaying) && (aNewState == EMidiStateOpenDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenPlaying to EMidiStateOpenDisengaged, with no error")); + } + else + { + INFO_PRINTF1(_L("State changed call back occurs,the states remain the same with no error")); + } + } + else + { + INFO_PRINTF1(_L("Error during calback")); + } + + CActiveScheduler::Stop(); + } + +//------------------------------------------------------------------ + +/* +Opening a midi file and playing it and checking for its status during call back. +*/ + +CTestMidiClntOpenAndPlayFile::CTestMidiClntOpenAndPlayFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName) + :CTestMmfMidiClntStep(aTestName, ETestValid) + { + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMidiClntOpenAndPlayFile* CTestMidiClntOpenAndPlayFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMidiClntOpenAndPlayFile* self = new(ELeave) CTestMidiClntOpenAndPlayFile(aTestName, aSectName, aKeyName); + return self; + } + +TVerdict CTestMidiClntOpenAndPlayFile::DoTestStepL() + { + TVerdict ret = EPass; + iError = KErrNone; + TPtrC filename; + if(!GetStringFromConfig(iSectName,iKeyName,filename)) + return EInconclusive; + + CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + if (!player) + { + ERR_PRINTF1(_L("Could not create a CMidiClientUtility")); + return EInconclusive; + } + CleanupStack::PushL(player); + + player->OpenFile(filename); + + // Wait for initialisation callback + INFO_PRINTF1(_L("CMidiClientUtility: Opening file")); + CActiveScheduler::Start(); + + player->Play(); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + ERR_PRINTF1(_L("Error while playing")); + return EInconclusive; + } + + TTimeIntervalMicroSeconds fadeOutDuration(0); + player->Stop(fadeOutDuration); + CActiveScheduler::Start(); + + // Check for errors. + if (iError != KErrNone) + { + ret = EFail; + ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError ); + } + + INFO_PRINTF1(_L("CMidiClientUtility: Destroying")); + CleanupStack::PopAndDestroy(player); + + return ret; + } + +void CTestMidiClntOpenAndPlayFile::MmcuoStateChanged(TMidiState aOldState,TMidiState aNewState,const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError) + { + iError=aError; + ERR_PRINTF2(_L("Old State: %d "),aOldState); + ERR_PRINTF2(_L("New State : %d "),aNewState); + ERR_PRINTF2(_L("Error Code : %d "),aError); + + if(aError == KErrNone) + { + if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateClosedEngaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateClosedEngaged, with no error")); + } + else if((aOldState == EMidiStateClosedEngaged) && (aNewState == EMidiStateClosedDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedEngaged to EMidiStateClosedDisengaged, with no error")); + } + else if((aOldState == EMidiStateClosedDisengaged) && (aNewState == EMidiStateOpenDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateClosedDisengaged to EMidiStateOpenDisengaged, with no error")); + } + else if((aOldState == EMidiStateOpenDisengaged) && (aNewState == EMidiStateOpenPlaying)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenDisengaged to EMidiStateOpenPlaying, with no error")); + } + else if((aOldState == EMidiStateOpenPlaying) && (aNewState == EMidiStateOpenDisengaged)) + { + INFO_PRINTF1(_L("State changed call back occurs,change from EMidiStateOpenPlaying to EMidiStateOpenDisengaged, with no error")); + } + else + { + INFO_PRINTF1(_L("State changed call back occurs,the states remain the same with no error")); + } + } + else + { + INFO_PRINTF1(_L("Error during calback")); + } + + CActiveScheduler::Stop(); + } +