diff -r 4ce423f34688 -r e267340986c9 mmmw_plat/telephony_multimedia_service_api/tsrc/TmsAudioServicesTestClass/src/TmsAudioServicesTestClassBlocks.cpp --- a/mmmw_plat/telephony_multimedia_service_api/tsrc/TmsAudioServicesTestClass/src/TmsAudioServicesTestClassBlocks.cpp Fri Sep 17 08:33:15 2010 +0300 +++ b/mmmw_plat/telephony_multimedia_service_api/tsrc/TmsAudioServicesTestClass/src/TmsAudioServicesTestClassBlocks.cpp Mon Oct 04 00:51:56 2010 +0300 @@ -22,6 +22,162 @@ #include "TmsAudioServicesTestClass.h" #include "debug.h" +class TMSStreamTest : public TMSStream + { +public: + ~TMSStreamTest() {}; + TMSStreamTest() : TMSStream() {}; + }; + +class TMSCallTest : public TMSCall + { +public: + ~TMSCallTest() {}; + TMSCallTest() : TMSCall() {}; + }; + +class TMSDTMFTest : public TMSDTMF + { +public: + ~TMSDTMFTest() {}; + TMSDTMFTest() : TMSDTMF() {}; + }; + +class TMSInbandToneTest : public TMSInbandTone + { +public: + ~TMSInbandToneTest() {}; + TMSInbandToneTest() : TMSInbandTone() {}; + }; + +class TMSRingToneTest : public TMSRingTone + { +public: + ~TMSRingToneTest() {}; + TMSRingToneTest() : TMSRingTone() {}; + }; + +class TMSClientSinkTest : public TMSClientSink + { +public: + ~TMSClientSinkTest() {}; + TMSClientSinkTest() : TMSClientSink() {}; + }; + +class TMSClientSourceTest : public TMSClientSource + { +public: + ~TMSClientSourceTest() {}; + TMSClientSourceTest() : TMSClientSource() {}; + }; + +class TMSMicSourceTest : public TMSMicSource + { +public: + ~TMSMicSourceTest() {}; + TMSMicSourceTest() : TMSMicSource() {}; + }; + +class TMSModemSourceTest : public TMSModemSource + { +public: + ~TMSModemSourceTest() {}; + TMSModemSourceTest() : TMSModemSource() {}; + }; + +class TMSSpeakerSinkTest : public TMSSpeakerSink + { +public: + ~TMSSpeakerSinkTest() {}; + TMSSpeakerSinkTest() : TMSSpeakerSink() {}; + }; + +class TMSModemSinkTest : public TMSModemSink + { +public: + ~TMSModemSinkTest() {}; + TMSModemSinkTest() : TMSModemSink() {}; + }; + +class TMSGlobalVolTest : public TMSGlobalVolEffect + { +public: + ~TMSGlobalVolTest() {}; + TMSGlobalVolTest() : TMSGlobalVolEffect() {}; + }; + +class TMSGlobalGainTest : public TMSGlobalGainEffect + { +public: + ~TMSGlobalGainTest() {}; + TMSGlobalGainTest() : TMSGlobalGainEffect() {}; + }; + +class TMSVolumeEffectTest : public TMSVolumeEffect + { +public: + ~TMSVolumeEffectTest() {}; + TMSVolumeEffectTest() : TMSVolumeEffect() {}; + }; + +class TMSGainEffectTest : public TMSGainEffect + { +public: + ~TMSGainEffectTest() {}; + TMSGainEffectTest() : TMSGainEffect() {}; + }; + +class TMSGlobalRoutingTest : public TMSGlobalRouting + { +public: + ~TMSGlobalRoutingTest() {}; + TMSGlobalRoutingTest() : TMSGlobalRouting() {}; + }; + +class TMSG711Test : public TMSG711Format + { +public: + ~TMSG711Test() {}; + TMSG711Test() : TMSG711Format() {}; + }; + +class TMSG729Test : public TMSG729Format + { +public: + ~TMSG729Test() {}; + TMSG729Test() : TMSG729Format() {}; + }; + +class TMSILBCTest : public TMSILBCFormat + { +public: + ~TMSILBCTest() {}; + TMSILBCTest() : TMSILBCFormat() {}; + }; + +/* + * Mini TMSProxy + */ +class TMSProxy : public RSessionBase + { +public: + TMSProxy() {} + virtual ~TMSProxy() {} + + void Connect(const TDesC& srvname) + { + TVersion ver(1,0,0); + TRequestStatus stat; + CreateSession(srvname, ver, 2, EIpcSession_Unsharable, 0, &stat); + User::WaitForRequest(stat); + } + + void SendRequest(TInt command) + { + SendReceive(command); + } + }; + // ----------------------------------------------------------------------------- // CTmsAudioServicesTestClass::Delete // Delete here all resources allocated and opened from test methods. @@ -32,6 +188,11 @@ { FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Delete"))); + if (iProxy) + { + iProxy->Close(); + delete iProxy; + } if (iFactory && iTmsBuffer) { iFactory->DeleteBuffer(iTmsBuffer); @@ -50,6 +211,7 @@ } if (iFactory && iTmsClientSink) { + static_cast (iTmsClientSink)->RemoveObserver(*this); iFactory->DeleteSink(iTmsClientSink); } if (iFactory && iTmsModemSink) @@ -90,22 +252,28 @@ } if (iFactory && iTmsDnlinkEffect) { + static_cast (iTmsDnlinkEffect)->RemoveObserver( + *this); iFactory->DeleteEffect(iTmsDnlinkEffect); } if (iFactory && iTmsUplinkEffect) { + static_cast (iTmsUplinkEffect)->RemoveObserver(*this); iFactory->DeleteEffect(iTmsUplinkEffect); } if (iFactory && iGlobalVol) { + static_cast (iGlobalVol)->RemoveObserver(*this); iFactory->DeleteEffect(iGlobalVol); } if (iFactory && iGlobalGain) { + static_cast (iGlobalGain)->RemoveObserver(*this); iFactory->DeleteEffect(iGlobalGain); } if (iFactory && iTmsGlobalRouting) { + iTmsGlobalRouting->RemoveObserver(*this); iFactory->DeleteGlobalRouting(iTmsGlobalRouting); } @@ -129,6 +297,7 @@ { iTmsDnlink->Deinit(); } + delete iTmsDnlink; iTmsDnlink = NULL; } @@ -155,102 +324,119 @@ { static TStifFunctionInfo const KFunctions[] = { - // Copy this line for every implemented function. - // First string is the function name used in TestScripter script file. - // Second is the actual implementation member function. - - ENTRY( "SetTimeout", CTmsAudioServicesTestClass::SetTimeout ), - ENTRY( "CreateFactory", CTmsAudioServicesTestClass::CreateTmsFactory ), - ENTRY( "CreateCall", CTmsAudioServicesTestClass::CreateCall ), - ENTRY( "CreateFormat", CTmsAudioServicesTestClass::CreateFormat ), - ENTRY( "CreateBuffer", CTmsAudioServicesTestClass::CreateBuffer ), - ENTRY( "CreateEffect", CTmsAudioServicesTestClass::CreateEffect ), - ENTRY( "CreateGlobalRouting", CTmsAudioServicesTestClass::CreateGlobalRouting ), - ENTRY( "CreateSource", CTmsAudioServicesTestClass::CreateSource ), - ENTRY( "DeleteSource", CTmsAudioServicesTestClass::DeleteSource ), - ENTRY( "CreateSink", CTmsAudioServicesTestClass::CreateSink ), - ENTRY( "DeleteSink", CTmsAudioServicesTestClass::DeleteSink ), - ENTRY( "GetSourceType", CTmsAudioServicesTestClass::GetSourceType ), - ENTRY( "GetSinkType", CTmsAudioServicesTestClass::GetSinkType ), - ENTRY( "GetEffectType", CTmsAudioServicesTestClass::GetEffectType ), - ENTRY( "CreateDownlinkStream", CTmsAudioServicesTestClass::CreateDownlinkStream ), - ENTRY( "CreateUplinkStream", CTmsAudioServicesTestClass::CreateUplinkStream ), - ENTRY( "GetSupportedFormats", CTmsAudioServicesTestClass::GetSupportedFormats ), - ENTRY( "IsCallTypeSupported", CTmsAudioServicesTestClass::IsCallTypeSupported ), - ENTRY( "SetDownlinkFormat", CTmsAudioServicesTestClass::SetDownlinkFormat ), - ENTRY( "SetUplinkFormat", CTmsAudioServicesTestClass::SetUplinkFormat ), - ENTRY( "ReSetDownlinkFormat", CTmsAudioServicesTestClass::ReSetDownlinkFormat ), - ENTRY( "ReSetUplinkFormat", CTmsAudioServicesTestClass::ReSetUplinkFormat ), - ENTRY( "OpenDownlink", CTmsAudioServicesTestClass::OpenDownlink ), - ENTRY( "OpenUplink", CTmsAudioServicesTestClass::OpenUplink ), - ENTRY( "Gain", CTmsAudioServicesTestClass::Gain ), - ENTRY( "AddGlobalGainEffectToStream", CTmsAudioServicesTestClass::AddGlobalGainEffectToStream), - ENTRY( "RemoveGlobalGainEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalGainEffectToStream), - ENTRY( "Volume", CTmsAudioServicesTestClass::Volume ), - ENTRY( "AddGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::AddGlobalVolumeEffectToStream), - ENTRY( "RemoveGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalVolumeEffectToStream), - ENTRY( "CreateGlobalGainEffect", CTmsAudioServicesTestClass::CreateGlobalGainEffect), - ENTRY( "Close", CTmsAudioServicesTestClass::Close ), - ENTRY( "Start", CTmsAudioServicesTestClass::Start ), - ENTRY( "Pause", CTmsAudioServicesTestClass::Pause ), - ENTRY( "Stop", CTmsAudioServicesTestClass::Stop ), - ENTRY( "GetBitRateList", CTmsAudioServicesTestClass::GetBitRateList ), - ENTRY( "SetBitrates", CTmsAudioServicesTestClass::SetBitrates ), - ENTRY( "GetBitrates", CTmsAudioServicesTestClass::GetBitrates ), - ENTRY( "CreateDTMFTonePlayer", CTmsAudioServicesTestClass::CreateDTMFTonePlayer ), - ENTRY( "DTMFTonePlay", CTmsAudioServicesTestClass::DTMFTonePlay ), - ENTRY( "StopDTMFTonePlayer", CTmsAudioServicesTestClass::StopDTMFTonePlayer ), - ENTRY( "ContinueDTMFStringSending", CTmsAudioServicesTestClass::ContinueDTMFStringSending ), - ENTRY( "CloseDTMFPlayer", CTmsAudioServicesTestClass::CloseDTMFPlayer ), - ENTRY( "CreateRingTonePlayer", CTmsAudioServicesTestClass::CreateRingTonePlayer ), - ENTRY( "InitRingTonePlayer", CTmsAudioServicesTestClass::InitRingTonePlayer ), - ENTRY( "PlayRingTone", CTmsAudioServicesTestClass::PlayRingTone ), - ENTRY( "PlayRingToneNoEvent", CTmsAudioServicesTestClass::PlayRingToneNoEvent ), - ENTRY( "PauseRingTone", CTmsAudioServicesTestClass::PauseRingTone ), - ENTRY( "MuteRingTone", CTmsAudioServicesTestClass::MuteRingTone ), - ENTRY( "StopRingTone", CTmsAudioServicesTestClass::StopRingTone ), - ENTRY( "CloseRingTonePlayer", CTmsAudioServicesTestClass::CloseRingTonePlayer ), - ENTRY( "CreateInbandTonePlayer", CTmsAudioServicesTestClass::CreateInbandTonePlayer ), - ENTRY( "StartInbandTone", CTmsAudioServicesTestClass::StartInbandTone ), - ENTRY( "StopInbandTone", CTmsAudioServicesTestClass::StopInbandTone ), - ENTRY( "CloseInbandTonePlayer", CTmsAudioServicesTestClass::CloseInbandTonePlayer ), - ENTRY( "GetDownlinkVersion", CTmsAudioServicesTestClass::GetDownlinkVersion ), - ENTRY( "GetUplinkVersion", CTmsAudioServicesTestClass::GetUplinkVersion ), - ENTRY( "GetType", CTmsAudioServicesTestClass::GetType ), - ENTRY( "GetVAD", CTmsAudioServicesTestClass::GetVAD ), - ENTRY( "ToggleVAD", CTmsAudioServicesTestClass::ToggleVAD ), - ENTRY( "GetMode", CTmsAudioServicesTestClass::GetMode ), - ENTRY( "SetMode", CTmsAudioServicesTestClass::SetMode ), - ENTRY( "GetCNG", CTmsAudioServicesTestClass::GetCNG ), - ENTRY( "ToggleCNG", CTmsAudioServicesTestClass::ToggleCNG ), - ENTRY( "GetPLC", CTmsAudioServicesTestClass::GetPLC ), - ENTRY( "TogglePLC", CTmsAudioServicesTestClass::TogglePLC ), - ENTRY( "GetBufferType", CTmsAudioServicesTestClass::GetBufferType ), - ENTRY( "AddClientSrcToDnlStream", CTmsAudioServicesTestClass::AddClientSrcToDnlStream ), - ENTRY( "AddMicSrcToUplStream", CTmsAudioServicesTestClass::AddMicSrcToUplStream ), - ENTRY( "AddModemSrcToDnlStream", CTmsAudioServicesTestClass::AddModemSrcToDnlStream ), - ENTRY( "RemoveClientSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream ), - ENTRY( "RemoveMicSrcFromUplStream", CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream ), - ENTRY( "RemoveModemSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream ), - ENTRY( "AddSourceObserver", CTmsAudioServicesTestClass::AddSourceObserver ), - ENTRY( "RemoveSourceObserver", CTmsAudioServicesTestClass::RemoveSourceObserver ), - ENTRY( "AddClientSinkToUplStream", CTmsAudioServicesTestClass::AddClientSinkToUplStream ), - ENTRY( "AddModemSinkToUplStream", CTmsAudioServicesTestClass::AddModemSinkToUplStream ), - ENTRY( "AddSpkrSinkToDnlStream", CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream ), - ENTRY( "RemoveClientSinkFromUplStream", CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream ), - ENTRY( "RemoveModemSinkFromUplStream", CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream ), - ENTRY( "RemoveSpkrSinkFromDnlStream", CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream ), - ENTRY( "AddSinkObserver", CTmsAudioServicesTestClass::AddSinkObserver ), - ENTRY( "RemoveSinkObserver", CTmsAudioServicesTestClass::RemoveSinkObserver ), - ENTRY( "GetStreamType", CTmsAudioServicesTestClass::GetStreamType ), - ENTRY( "GetStreamState", CTmsAudioServicesTestClass::GetStreamState ), - ENTRY( "SetOutput", CTmsAudioServicesTestClass::SetOutput ), - ENTRY( "GetOutput", CTmsAudioServicesTestClass::GetOutput ), - ENTRY( "GetPreviousOutput", CTmsAudioServicesTestClass::GetPreviousOutput ), - ENTRY( "GetAvailableOutputs", CTmsAudioServicesTestClass::GetAvailableOutputs ), - ENTRY( "AddGlobalRoutingObserver", CTmsAudioServicesTestClass::AddGlobalRoutingObserver ), - ENTRY( "DeleteGlobalRoutingObserver", CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver ), - ENTRY( "Example", CTmsAudioServicesTestClass::ExampleL ) + ENTRY("SetTimeout", CTmsAudioServicesTestClass::SetTimeout), + ENTRY("CreateFactory", CTmsAudioServicesTestClass::CreateTmsFactory), + ENTRY("CreateCall", CTmsAudioServicesTestClass::CreateCall), + ENTRY("CreateFormat", CTmsAudioServicesTestClass::CreateFormat), + ENTRY("CreateBuffer", CTmsAudioServicesTestClass::CreateBuffer), + ENTRY("CreateEffect", CTmsAudioServicesTestClass::CreateEffect), + ENTRY("CreateGlobalRouting", CTmsAudioServicesTestClass::CreateGlobalRouting), + ENTRY("CreateSource", CTmsAudioServicesTestClass::CreateSource), + ENTRY("DeleteSource", CTmsAudioServicesTestClass::DeleteSource), + ENTRY("CreateSink", CTmsAudioServicesTestClass::CreateSink), + ENTRY("DeleteSink", CTmsAudioServicesTestClass::DeleteSink), + ENTRY("GetSourceType", CTmsAudioServicesTestClass::GetSourceType), + ENTRY("GetSinkType", CTmsAudioServicesTestClass::GetSinkType), + ENTRY("GetEffectType", CTmsAudioServicesTestClass::GetEffectType), + ENTRY("CreateDownlinkStream", CTmsAudioServicesTestClass::CreateDownlinkStream), + ENTRY("CreateUplinkStream", CTmsAudioServicesTestClass::CreateUplinkStream), + ENTRY("GetSupportedFormats", CTmsAudioServicesTestClass::GetSupportedFormats), + ENTRY("IsCallTypeSupported", CTmsAudioServicesTestClass::IsCallTypeSupported), + ENTRY("SetDownlinkFormat", CTmsAudioServicesTestClass::SetDownlinkFormat), + ENTRY("SetUplinkFormat", CTmsAudioServicesTestClass::SetUplinkFormat), + ENTRY("ReSetDownlinkFormat", CTmsAudioServicesTestClass::ReSetDownlinkFormat), + ENTRY("ReSetUplinkFormat", CTmsAudioServicesTestClass::ReSetUplinkFormat), + ENTRY("OpenDownlink", CTmsAudioServicesTestClass::OpenDownlink), + ENTRY("OpenUplink", CTmsAudioServicesTestClass::OpenUplink), + ENTRY("Gain", CTmsAudioServicesTestClass::Gain), + ENTRY("AddVolumeEffectToStream", CTmsAudioServicesTestClass::AddVolumeEffectToStream), + ENTRY("AddGainEffectToStream", CTmsAudioServicesTestClass::AddGainEffectToStream), + ENTRY("AddGlobalGainEffectToStream", CTmsAudioServicesTestClass::AddGlobalGainEffectToStream), + ENTRY("RemoveGlobalGainEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalGainEffectToStream), + ENTRY("Volume", CTmsAudioServicesTestClass::Volume), + ENTRY("AddGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::AddGlobalVolumeEffectToStream), + ENTRY("RemoveGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalVolumeEffectToStream), + ENTRY("CreateGlobalGainEffect", CTmsAudioServicesTestClass::CreateGlobalGainEffect), + ENTRY("Close", CTmsAudioServicesTestClass::Close), + ENTRY("Start", CTmsAudioServicesTestClass::Start), + ENTRY("Pause", CTmsAudioServicesTestClass::Pause), + ENTRY("Stop", CTmsAudioServicesTestClass::Stop), + ENTRY("GetBitRateList", CTmsAudioServicesTestClass::GetBitRateList), + ENTRY("SetBitrates", CTmsAudioServicesTestClass::SetBitrates), + ENTRY("GetBitrates", CTmsAudioServicesTestClass::GetBitrates), + ENTRY("CreateDTMFTonePlayer", CTmsAudioServicesTestClass::CreateDTMFTonePlayer), + ENTRY("DTMFTonePlay", CTmsAudioServicesTestClass::DTMFTonePlay), + ENTRY("StopDTMFTonePlayer", CTmsAudioServicesTestClass::StopDTMFTonePlayer), + ENTRY("ContinueDTMFStringSending", CTmsAudioServicesTestClass::ContinueDTMFStringSending), + ENTRY("CloseDTMFPlayer", CTmsAudioServicesTestClass::CloseDTMFPlayer), + ENTRY("CreateRingTonePlayer", CTmsAudioServicesTestClass::CreateRingTonePlayer), + ENTRY("CreateVideoRingTonePlayer", CTmsAudioServicesTestClass::CreateVideoRingTonePlayer), + ENTRY("InitRingTonePlayer", CTmsAudioServicesTestClass::InitRingTonePlayer), + ENTRY("PlayRingTone", CTmsAudioServicesTestClass::PlayRingTone), + ENTRY("PlayRingToneNoEvent", CTmsAudioServicesTestClass::PlayRingToneNoEvent), + ENTRY("PauseRingTone", CTmsAudioServicesTestClass::PauseRingTone), + ENTRY("MuteRingTone", CTmsAudioServicesTestClass::MuteRingTone), + ENTRY("StopRingTone", CTmsAudioServicesTestClass::StopRingTone), + ENTRY("CloseRingTonePlayer", CTmsAudioServicesTestClass::CloseRingTonePlayer), + ENTRY("CreateInbandTonePlayer", CTmsAudioServicesTestClass::CreateInbandTonePlayer), + ENTRY("StartInbandTone", CTmsAudioServicesTestClass::StartInbandTone), + ENTRY("StopInbandTone", CTmsAudioServicesTestClass::StopInbandTone), + ENTRY("CloseInbandTonePlayer", CTmsAudioServicesTestClass::CloseInbandTonePlayer), + ENTRY("GetDownlinkVersion", CTmsAudioServicesTestClass::GetDownlinkVersion), + ENTRY("GetUplinkVersion", CTmsAudioServicesTestClass::GetUplinkVersion), + ENTRY("GetType", CTmsAudioServicesTestClass::GetType), + ENTRY("GetVAD", CTmsAudioServicesTestClass::GetVAD), + ENTRY("ToggleVAD", CTmsAudioServicesTestClass::ToggleVAD), + ENTRY("GetMode", CTmsAudioServicesTestClass::GetMode), + ENTRY("SetMode", CTmsAudioServicesTestClass::SetMode), + ENTRY("GetCNG", CTmsAudioServicesTestClass::GetCNG), + ENTRY("ToggleCNG", CTmsAudioServicesTestClass::ToggleCNG), + ENTRY("GetPLC", CTmsAudioServicesTestClass::GetPLC), + ENTRY("TogglePLC", CTmsAudioServicesTestClass::TogglePLC), + ENTRY("GetBufferType", CTmsAudioServicesTestClass::GetBufferType), + ENTRY("AddClientSrcToDnlStream", CTmsAudioServicesTestClass::AddClientSrcToDnlStream), + ENTRY("AddMicSrcToUplStream", CTmsAudioServicesTestClass::AddMicSrcToUplStream), + ENTRY("AddModemSrcToDnlStream", CTmsAudioServicesTestClass::AddModemSrcToDnlStream), + ENTRY("RemoveClientSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream), + ENTRY("RemoveMicSrcFromUplStream", CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream), + ENTRY("RemoveModemSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream), + ENTRY("AddSourceObserver", CTmsAudioServicesTestClass::AddSourceObserver), + ENTRY("RemoveSourceObserver", CTmsAudioServicesTestClass::RemoveSourceObserver), + ENTRY("AddClientSinkToUplStream", CTmsAudioServicesTestClass::AddClientSinkToUplStream), + ENTRY("AddModemSinkToUplStream", CTmsAudioServicesTestClass::AddModemSinkToUplStream), + ENTRY("AddSpkrSinkToDnlStream", CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream), + ENTRY("RemoveClientSinkFromUplStream", CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream), + ENTRY("RemoveModemSinkFromUplStream", CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream), + ENTRY("RemoveSpkrSinkFromDnlStream", CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream), + ENTRY("AddSinkObserver", CTmsAudioServicesTestClass::AddSinkObserver), + ENTRY("RemoveSinkObserver", CTmsAudioServicesTestClass::RemoveSinkObserver), + ENTRY("GetStreamType", CTmsAudioServicesTestClass::GetStreamType), + ENTRY("GetStreamState", CTmsAudioServicesTestClass::GetStreamState), + ENTRY("SetOutput", CTmsAudioServicesTestClass::SetOutput), + ENTRY("GetOutput", CTmsAudioServicesTestClass::GetOutput), + ENTRY("GetPreviousOutput", CTmsAudioServicesTestClass::GetPreviousOutput), + ENTRY("GetAvailableOutputs", CTmsAudioServicesTestClass::GetAvailableOutputs), + ENTRY("AddGlobalRoutingObserver", CTmsAudioServicesTestClass::AddGlobalRoutingObserver), + ENTRY("DeleteGlobalRoutingObserver", CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver), + ENTRY("TestRTPSession", CTmsAudioServicesTestClass::TestRTPSession), + ENTRY("CreateStreamTest", CTmsAudioServicesTestClass::CreateStreamTest), + ENTRY("CreateCallTest", CTmsAudioServicesTestClass::CreateCallTest), + ENTRY("CreateDTMFTest", CTmsAudioServicesTestClass::CreateDTMFTest), + ENTRY("CreateInbandToneTest", CTmsAudioServicesTestClass::CreateInbandToneTest), + ENTRY("CreateRingToneTest", CTmsAudioServicesTestClass::CreateRingToneTest), + ENTRY("CreateClientSinkTest", CTmsAudioServicesTestClass::CreateClientSinkTest), + ENTRY("CreateClientSourceTest", CTmsAudioServicesTestClass::CreateClientSourceTest), + ENTRY("CreateSourcesTest", CTmsAudioServicesTestClass::CreateSourcesTest), + ENTRY("CreateSinksTest", CTmsAudioServicesTestClass::CreateSinksTest), + ENTRY("CreateGlobalVolEffectTest", CTmsAudioServicesTestClass::CreateGlobalVolEffectTest), + ENTRY("CreateGlobalGainEffectTest", CTmsAudioServicesTestClass::CreateGlobalGainEffectTest), + ENTRY("CreateVolumeEffectTest", CTmsAudioServicesTestClass::CreateVolumeEffectTest), + ENTRY("CreateGainEffectTest", CTmsAudioServicesTestClass::CreateGainEffectTest), + ENTRY("CreateGlobalRoutingTest", CTmsAudioServicesTestClass::CreateGlobalRoutingTest), + ENTRY("CreateFormatsTest", CTmsAudioServicesTestClass::CreateFormatsTest), + ENTRY("SetLoopPlay", CTmsAudioServicesTestClass::SetLoopPlay), + ENTRY("CreateStreamFailTest", CTmsAudioServicesTestClass::CreateStreamFailTest), + ENTRY("TerminateServer", CTmsAudioServicesTestClass::TerminateServer) }; const TInt count = sizeof(KFunctions) / sizeof(TStifFunctionInfo); @@ -286,18 +472,18 @@ (TText*)L"EInbToneStarted", (TText*)L"EInbToneStopped", (TText*)L"EDTMFToneStarted", - (TText*)L"EDTMFToneStopped", + (TText*)L"EDTMFToneStopped" }; - if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) ) + if((TUint)aKey >= (sizeof(keywords)/sizeof(TText*))) { iLog->Log(_L("Keyword out of bounds")); - TPtrC keyword( badKeyword ); + TPtrC keyword(badKeyword); return keyword; } else { - TPtrC keyword( keywords[aKey] ); + TPtrC keyword(keywords[aKey]); return keyword; } } @@ -391,7 +577,6 @@ Signal(); iTimeoutController->Cancel(); } - } else { @@ -482,7 +667,7 @@ (KErrNone == aItem.GetNextInt(panicCode))) { iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode); - // iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode ); + //iTestModuleIf.SetExitReason(CTestModuleIf::EPanic, panicCode); iNormalExitReason = EFalse; } else @@ -508,33 +693,6 @@ return error; } -// ----------------------------------------------------------------------------- -// CTmsAudioServicesTestClass::ExampleL -// Example test method function. -// (other items were commented in a header). -// ----------------------------------------------------------------------------- -// -TInt CTmsAudioServicesTestClass::ExampleL(CStifItemParser& aItem) - { - // Print to UI - _LIT( KTmsAudioServicesTestClass, "TmsAudioServicesTestClass" ); - _LIT( KExample, "In Example" ); - TestModuleIf().Printf(0, KTmsAudioServicesTestClass, KExample); - // Print to log file - iLog->Log(KExample); - - TInt i = 0; - TPtrC string; - _LIT( KParam, "Param[%i]: %S" ); - while (aItem.GetNextString(string) == KErrNone) - { - TestModuleIf().Printf(i, KTmsAudioServicesTestClass, KParam, i, - &string); - i++; - } - return KErrNone; - } - TInt CTmsAudioServicesTestClass::CreateTmsFactory(CStifItemParser& /*aItem */) { RDebug::Printf("CTmsAudioServicesTestClass::CreateTmsFactory >> ENTER"); @@ -565,6 +723,14 @@ case TMS_CALL_IP: { error = iFactory->CreateCall(calltype, iTmsCall, 0); + //#ifdef __TEST_CODE_COVERAGE__ + guint ctxid; + if (iTmsCall) + { + iTmsCall->GetCallType(); + iTmsCall->GetCallContextId(ctxid); + } + //#endif __TEST_CODE_COVERAGE__ iLog->Log(_L("CTmsAudioServicesTestClass::CreateCall, error [%d]"), error); } break; @@ -672,10 +838,25 @@ case TMS_BUFFER_MEMORY: { error = iFactory->CreateBuffer(buffertype, size, iTmsBuffer); + //#ifdef __TEST_CODE_COVERAGE__ + if (iTmsBuffer) + { + guint bufsize; + iTmsBuffer->GetType(buffertype); + iTmsBuffer->GetDataSize(bufsize); + iTmsBuffer->SetDataSize(bufsize); + guint8* pbuf(NULL); + iTmsBuffer->GetDataPtr(pbuf); + guint64 ts(0); + iTmsBuffer->GetTimeStamp(ts); + iTmsBuffer->SetTimeStamp(ts); + //iFactory->DeleteBuffer(tmsbuffer); + } + //#endif //__TEST_CODE_COVERAGE__ } break; - default: - error = KErrNotSupported; + default: //covering failure case for coverage + error = iFactory->CreateBuffer(buffertype, size, iTmsBuffer); break; } } @@ -1411,6 +1592,7 @@ FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Close"))); iLog->Log(_L("CTmsAudioServicesTestClass::Close")); TInt error = KErrNone; + iLoopPlay = EFalse; TPtrC closeType; error = aItem.GetNextString(closeType); @@ -1456,17 +1638,16 @@ error = aItem.GetNextString(startType); if (error == KErrNone) { + iLoopCounter = 0; + if (startType == KTagUplink) { if ((iUpLinkStatus == INITIALIZED) || (iUpLinkStatus == PAUSED)) { iTmsUplink->Start(2); - - if (iUpLinkStatus == INITIALIZED) - { - AddExpectedEvent(EEmptyBuffer, KMediumTimeout); - } - else + iTmsUplink->GetStreamId(); + + if (iUpLinkStatus == PAUSED) { AddExpectedEvent(EStreamStarted, KMediumTimeout); } @@ -1484,11 +1665,9 @@ if ((iDnLinkStatus == INITIALIZED) || (iDnLinkStatus == PAUSED)) { iTmsDnlink->Start(2); - if (iDnLinkStatus == INITIALIZED) - { - AddExpectedEvent(EFillBuffer, KMediumTimeout); - } - else + iTmsDnlink->GetStreamId(); + + if (iDnLinkStatus == PAUSED) { AddExpectedEvent(EStreamStarted, KMediumTimeout); } @@ -1622,8 +1801,12 @@ iMaxGain); RDebug::Printf("[TMS STIF] GAIN, GetMaxLevel Level [%d] Ret Err [%d]", iMaxGain, ret); RDebug::Printf("[TMS STIF] GAIN, SetLevel to [%d]", iMaxGain); - ret = static_cast(iTmsUplinkEffect)->SetLevel(iMaxGain); + ret = static_cast (iTmsUplinkEffect)->SetLevel( + iMaxGain); RDebug::Printf("[TMS STIF] GAIN, SetLevel ret [%d]", ret); + + AddExpectedEvent(EStreamGainChange, KMediumTimeout); + iLog->Log(_L("SetMaxGain: %d"), iMaxGain); RDebug::Printf("[TMS STIF] GAIN, GetLevel"); ret = static_cast (iTmsUplinkEffect)->GetLevel(iGain); @@ -1636,6 +1819,9 @@ static_cast (iTmsUplinkEffect)->SetLevel(0); iLog->Log(_L("MuteMic")); + + AddExpectedEvent(EStreamGainChange, KMediumTimeout); + static_cast (iTmsUplinkEffect)->GetLevel(iGain); if (iGain != 0) @@ -1655,6 +1841,9 @@ iMaxGain); RDebug::Printf("[TMS STIF] GLOBAL GAIN, SetLevel ret [%d]", ret); iLog->Log(_L("SetGlobalMaxGain: %d"), iMaxGain); + + AddExpectedEvent(EGlobalGainChange, KMediumTimeout); + RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetLevel"); ret = static_cast(iGlobalGain)->GetLevel(iGain); RDebug::Printf("[TMS STIF] GLOBAL GAIN, Exp Level [%d] Ret Level [%d] Ret Err [%d]", iMaxGain, iGain, ret); @@ -1666,6 +1855,9 @@ static_cast (iGlobalGain)->SetLevel(0); iLog->Log(_L("MuteMic")); + + AddExpectedEvent(EGlobalGainChange, KMediumTimeout); + static_cast (iGlobalGain)->GetLevel(iGain); if (iGain != 0) @@ -1698,6 +1890,9 @@ RDebug::Printf("[TMS STIF] Volume, SetLevel to MaxLevel [%d]", iMaxVolume); ret = static_cast (iTmsDnlinkEffect)->SetLevel( iMaxVolume); + + AddExpectedEvent(EStreamVolChange, KMediumTimeout); + RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); iLog->Log(_L("SetMaxVolume: %d"), iMaxVolume); RDebug::Printf("[TMS STIF] GetLevel"); @@ -1713,6 +1908,9 @@ RDebug::Printf("[TMS STIF] Volume, SetLevel to 0 "); ret = static_cast (iTmsDnlinkEffect)->SetLevel(0); RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); + + AddExpectedEvent(EStreamVolChange, KMediumTimeout); + iLog->Log(_L("Mute Volume")); ret = static_cast (iTmsDnlinkEffect)->GetLevel( iVolume); @@ -1735,6 +1933,9 @@ RDebug::Printf("[TMS STIF] GLOBAL_VOL, SetLevel to [%d]", iMaxVolume); ret = static_cast (iGlobalVol)->SetLevel( iMaxVolume); + + AddExpectedEvent(EGlobalVolChange, KMediumTimeout); + RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret); iLog->Log(_L("SetMaxGlobalVolume: %d"), iMaxVolume); RDebug::Printf("[TMS STIF] GLOBAL_VOL,GetLevel"); @@ -1749,6 +1950,9 @@ static_cast (iGlobalVol)->SetLevel(0); iLog->Log(_L("Mute Global Volume")); + + AddExpectedEvent(EGlobalVolChange, KMediumTimeout); + static_cast (iGlobalVol)->GetLevel(iVolume); if (iVolume != 0) @@ -2128,7 +2332,7 @@ if (iTmsGlobalRouting) { - error = iTmsGlobalRouting ->GetAvailableOutputs(iAvailableoutputs); + error = iTmsGlobalRouting->GetAvailableOutputs(iAvailableoutputs); if (error == KErrNone) { @@ -2188,7 +2392,8 @@ { if (iBitratesVector.size() > 0) { - std::vector::iterator iBitrate = iBitratesVector.begin(); + std::vector::iterator iBitrate = + iBitratesVector.begin(); error = iTmsFormatUp -> SetBitRate(*iBitrate); iLog->Log(_L("BR set %d"), *iBitrate); } @@ -2593,6 +2798,16 @@ { error = iTmsDnlink->AddSource(iTmsClientSource); } +//#ifdef __TEST_CODE_COVERAGE__ //Features not supported + TMSSourceType st; + static_cast (iTmsClientSource)->GetType(st); + gboolean enqueue(false); + static_cast (iTmsClientSource)->GetEnqueueMode(enqueue); + static_cast (iTmsClientSource)->ProcessBuffer(NULL); + static_cast (iTmsClientSource)->SetEnqueueMode(FALSE); + static_cast (iTmsClientSource)->Flush(); +//#endif //__TEST_CODE_COVERAGE__ + iLog->Log(_L("CTmsAudioServicesTestClass::AddClientSrcToDnlStream Error [%d]"), error); return error; } @@ -2696,7 +2911,7 @@ TInt error = KErrNone; if (iTmsUplink && iTmsClientSink) { - //static_cast(iTmsSink)->AddObserver(*this, NULL); + //static_cast(iTmsClientSink)->AddObserver(*this, NULL); error = iTmsUplink->AddSink(iTmsClientSink); } return error; @@ -3152,6 +3367,24 @@ return error; } +TInt CTmsAudioServicesTestClass::CreateVideoRingTonePlayer( + CStifItemParser& /*aItem */) + { + //Just for coverage feature not supported yet. + FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateVideoRingTonePlayer"))); + iLog->Log(_L("CTmsAudioServicesTestClass::CreateVideoRingTonePlayer")); + TInt error = TMS_RESULT_SUCCESS; + if (iFactory) + { + RWindow* window(NULL); + gint scrid; + error = iFactory->CreateRingTonePlayer(iRingTonePlayer, *window, + scrid); + } + iLog->Log(_L("CTmsAudioServicesTestClass::CreateVideoRingTonePlayer Error [%d]"), error); + return error; + } + TInt CTmsAudioServicesTestClass::InitRingTonePlayer(CStifItemParser& aItem) { FTRACE(FPrint(_L("CTmsAudioServicesTestClass::InitRingTonePlayer"))); @@ -3169,7 +3402,7 @@ } else if (StreamType == KTagRTFile) { - TBuf buf(KTestFile3); + TBuf buf(KTestFile1); iRTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2); error = iRingTonePlayer->Init(TMS_RINGTONE_FILE, iRTStr); g_string_free(iRTStr, TRUE); @@ -3413,6 +3646,7 @@ { error = iInbandTonePlayer->Stop(); RemoveExpectedEvent(EInbToneStarted); + AddExpectedEvent(EInbToneStopped, KShortTimeout); } iLog->Log(_L("CTmsAudioServicesTestClass::StopInbandTone Error [%d]"), error); return error; @@ -3433,39 +3667,75 @@ } // ---------------------------------------------------------------------------- +// CVoIPTestEngine::SetLoopPlay +// +// ---------------------------------------------------------------------------- +// +TInt CTmsAudioServicesTestClass::SetLoopPlay(CStifItemParser& /*aItem*/) + { + iLog->Log(_L("CTmsAudioServicesTestClass::SetLoopPlay")); + iLoopPlay = ETrue; + return 0; + } + +// ---------------------------------------------------------------------------- // CTmsTestEngine::DoLoopback // // ---------------------------------------------------------------------------- // void CTmsAudioServicesTestClass::DoLoopback() { - iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback")); - - if (iPlayBufReady && iRecBufReady) + //iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback")); + + if (!iLoopPlay) { - iLog->Log(_L("Both uplink and downlink are ready")); - guint8* srcptr(0); - guint8* desptr(0); - guint srcsize(0); - guint dessize(0); - - iPlayBuf->GetDataPtr(desptr); - iPlayBuf->GetDataSize(dessize); - - iRecBuf->GetDataPtr(srcptr); - iRecBuf->GetDataSize(srcsize); - - Mem::Copy(desptr, srcptr, srcsize); - - static_cast (iTmsClientSource)->BufferFilled( - *iPlayBuf); - static_cast (iTmsClientSink)->BufferProcessed(iRecBuf); - - iPlayBufReady = EFalse; // buf filled, ready for FillBuffer - iRecBufReady = EFalse; // buf consumed, ready for EmptyBuffer + if (iPlayBufReady) + { + // Just keep D/S NULL playback going + iPlayBufReady = EFalse; + guint8* desptr(0); + iPlayBuf->GetDataPtr(desptr); + TPtr8 p(desptr, 4); + p.Copy(_L("0000")); + iPlayBuf->SetDataSize(4); + static_cast (iTmsClientSource)->BufferFilled( + *iPlayBuf); + iLoopCounter++; //speed up count for single stream + } + else if (iRecBufReady) + { + // Just keep recording going + iRecBufReady = EFalse; + static_cast (iTmsClientSink)->BufferProcessed( + iRecBuf); + iLoopCounter++; //speed up count for single stream + } } - - iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback END")); + else + { + if (iPlayBufReady && iRecBufReady) + { + iPlayBufReady = EFalse; + iRecBufReady = EFalse; + guint8* srcptr(0); + guint8* desptr(0); + guint srcsize(0); + guint dessize(0); + iPlayBuf->GetDataPtr(desptr); + iPlayBuf->GetDataSize(dessize); + iRecBuf->GetDataPtr(srcptr); + iRecBuf->GetDataSize(srcsize); + Mem::Copy(desptr, srcptr, srcsize); + static_cast (iTmsClientSink)->BufferProcessed( + iRecBuf); + iPlayBuf->SetDataSize(srcsize); + static_cast (iTmsClientSource)->BufferFilled( + *iPlayBuf); + } + } + + iLoopCounter++; + //iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback END")); } TInt CTmsAudioServicesTestClass::ConfigEncAudDevice(CStifItemParser& /*aItem*/) @@ -3476,6 +3746,20 @@ return error; } +TInt CTmsAudioServicesTestClass::TestRTPSession(CStifItemParser& /*aItem*/) + { + FTRACE(FPrint(_L("CTmsAudioServicesTestClass::TestRTPSession"))); + TInt error = KErrNone; + //Just for CTC coverage not supported yet. + if (iFactory) + { + TMSRTPSession* rtpsession(NULL); + error = iFactory->CreateRTPSession(rtpsession, 0, 0); + iFactory->DeleteRTPSession(rtpsession); + } + return error; + } + // ---------------------------------------------------------------------------- // CTmsAudioServicesTestClass::DisplayDevice // @@ -3513,3 +3797,308 @@ break; } } + +// Coverage tests to ensure there are no null pointer panics + +TInt CTmsAudioServicesTestClass::CreateStreamTest(CStifItemParser& /*aItem*/) + { + TMSStreamTest stream = TMSStreamTest(); + stream.AddObserver(*this, NULL); + stream.RemoveObserver(*this); + stream.Init(); + stream.AddEffect(NULL); + stream.RemoveEffect(NULL); + stream.AddSink(NULL); + stream.RemoveSink(NULL); + stream.AddSource(NULL); + stream.RemoveSource(NULL); + stream.GetState(); + stream.GetStreamId(); + stream.GetStreamType(); + stream.Pause(); + stream.Deinit(); + stream.Start(); + stream.Stop(); + stream.SetFormat(NULL); + stream.ResetFormat(NULL); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateCallTest(CStifItemParser& /*aItem*/) + { + TMSCallTest call = TMSCallTest(); + TMSStream* strm(NULL); + + call.CreateStream(1, strm); + guint contextId; + call.GetCallContextId(contextId); + call.GetCallType(); + call.DeleteStream(strm); + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateDTMFTest(CStifItemParser& /*aItem*/) + { + TMSDTMFTest dtmf = TMSDTMFTest(); + + dtmf.AddObserver(*this, NULL); + dtmf.RemoveObserver(*this); + dtmf.SetTone(NULL); + dtmf.Start(); + dtmf.Stop(); + dtmf.ContinueDTMFStringSending(FALSE); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateInbandToneTest(CStifItemParser& /*aItem*/) + { + TMSInbandToneTest inband = TMSInbandToneTest(); + + inband.AddObserver(*this, NULL); + inband.RemoveObserver(*this); + inband.Start(TMS_INBAND_NO_SEQUENCE); + inband.Stop(); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateRingToneTest(CStifItemParser& /*aItem*/) + { + TMSRingToneTest ringtone = TMSRingToneTest(); + + ringtone.AddObserver(*this, NULL); + ringtone.RemoveObserver(*this); + ringtone.Init(1, NULL, NULL); + ringtone.Mute(); + ringtone.Pause(); + ringtone.Play(); + ringtone.Stop(); + ringtone.Deinit(); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateClientSinkTest(CStifItemParser& /*aItem*/) + { + TMSClientSinkTest clientsink = TMSClientSinkTest(); + + clientsink.AddObserver(*this, NULL); + clientsink.RemoveObserver(*this); + TMSSinkType snktype; + clientsink.GetType(snktype); + TMSBuffer* tmsbuffer(NULL); + clientsink.BufferProcessed(tmsbuffer); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateClientSourceTest(CStifItemParser& /*aItem*/) + { + TMSClientSourceTest clientsource = TMSClientSourceTest(); + + clientsource.AddObserver(*this, NULL); + clientsource.RemoveObserver(*this); + clientsource.Flush(); + gboolean enq; + clientsource.GetEnqueueMode(enq); + TMSSourceType srctype; + clientsource.GetType(srctype); + TMSBuffer* tmsbuffer(NULL); + clientsource.ProcessBuffer(tmsbuffer); + clientsource.SetEnqueueMode(FALSE); + clientsource.BufferFilled(*tmsbuffer); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateSinksTest(CStifItemParser& /*aItem*/) + { + TMSModemSinkTest modemsink = TMSModemSinkTest(); + + TMSSinkType sinktype; + modemsink.GetType(sinktype); + + TMSSpeakerSinkTest speaker = TMSSpeakerSinkTest(); + speaker.GetType(sinktype); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateSourcesTest(CStifItemParser& /*aItem*/) + { + TMSModemSourceTest modemsource = TMSModemSourceTest(); + + TMSSourceType sourcetype; + modemsource.GetType(sourcetype); + + TMSMicSourceTest micsource = TMSMicSourceTest(); + micsource.GetType(sourcetype); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateGlobalVolEffectTest(CStifItemParser& /*aItem*/) + { + TMSGlobalVolTest globalvol = TMSGlobalVolTest(); + + globalvol.AddObserver(*this, NULL); + globalvol.RemoveObserver(*this); + TMSEffectType effecttype; + globalvol.GetType(effecttype); + guint level(0); + globalvol.GetLevel(level); + globalvol.GetMaxLevel(level); + globalvol.SetLevel(level); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateGlobalGainEffectTest(CStifItemParser& /*aItem*/) + { + TMSGlobalGainTest globalgain = TMSGlobalGainTest(); + + globalgain.AddObserver(*this, NULL); + globalgain.RemoveObserver(*this); + TMSEffectType effecttype; + globalgain.GetType(effecttype); + guint level(0); + globalgain.GetLevel(level); + globalgain.GetMaxLevel(level); + globalgain.SetLevel(level); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateVolumeEffectTest(CStifItemParser& /*aItem*/) + { + TMSVolumeEffectTest vol = TMSVolumeEffectTest(); + + vol.AddObserver(*this, NULL); + vol.RemoveObserver(*this); + TMSEffectType effecttype; + vol.GetType(effecttype); + guint level(0); + vol.GetLevel(level); + vol.GetMaxLevel(level); + vol.SetLevel(level); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateGainEffectTest(CStifItemParser& /*aItem*/) + { + TMSGainEffectTest gain = TMSGainEffectTest(); + + gain.AddObserver(*this, NULL); + gain.RemoveObserver(*this); + TMSEffectType effecttype; + gain.GetType(effecttype); + guint level(0); + gain.GetLevel(level); + gain.GetMaxLevel(level); + gain.SetLevel(level); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateGlobalRoutingTest(CStifItemParser& /*aItem*/) + { + TMSGlobalRoutingTest routing = TMSGlobalRoutingTest(); + + routing.AddObserver(*this, NULL); + routing.RemoveObserver(*this); + OutputVector outputvector; + routing.GetAvailableOutputs(outputvector); + TMSAudioOutput output; + routing.GetOutput(output); + routing.GetPreviousOutput(output); + routing.SetOutput(output); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateFormatsTest(CStifItemParser& /*aItem*/) + { + TMSG711Test g711 = TMSG711Test(); + guint bitrate; + g711.GetBitRate(bitrate); + gboolean cng; + g711.GetCNG(cng); + TMSG711CodecMode mode; + g711.GetMode(mode); + gboolean plc; + g711.GetPlc(plc); + BitRateVector brvector; + g711.GetSupportedBitRates(brvector); + TMSFormatType formattype; + g711.GetType(formattype); + gboolean vad; + g711.GetVADMode(vad); + g711.SetBitRate(0); + g711.SetCNG(cng); + g711.SetMode(mode); + g711.SetPlc(plc); + g711.SetVADMode(vad); + + TMSG729Test g729 = TMSG729Test(); + g729.GetBitRate(bitrate); + g729.GetSupportedBitRates(brvector); + g729.GetType(formattype); + g729.GetVADMode(vad); + g729.SetBitRate(0); + g729.SetVADMode(vad); + + TMSILBCTest ilbc = TMSILBCTest(); + ilbc.GetBitRate(bitrate); + ilbc.GetCNG(cng); + TMSILBCCodecMode mod; + ilbc.GetMode(mod); + ilbc.GetSupportedBitRates(brvector); + ilbc.GetType(formattype); + ilbc.GetVADMode(vad); + ilbc.SetBitRate(0); + ilbc.SetCNG(cng); + ilbc.SetMode(mod); + ilbc.SetVADMode(vad); + + return KErrNone; + } + +TInt CTmsAudioServicesTestClass::CreateStreamFailTest(CStifItemParser& /*aItem*/) + { + FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateStreamFailTest"))); + iLog->Log(_L("CTmsAudioServicesTestClass::CreateStreamFailTest")); + TInt error = KErrNone; + + TMSStreamTest stream = TMSStreamTest(); + TMSStream *stm = &stream; + if (iTmsCall) + { + error = iTmsCall->CreateStream(TMS_STREAM_DOWNLINK, stm); + } + + iLog->Log(_L("CTmsAudioServicesTestClass::CreateStreamFailTest Error [%d]"), error); + return error; + } + +TInt CTmsAudioServicesTestClass::TerminateServer(CStifItemParser& /*aItem*/) + { + FTRACE(FPrint(_L("CTmsAudioServicesTestClass::TerminateServer"))); + iLog->Log(_L("CTmsAudioServicesTestClass::TerminateServer")); + TInt error = KErrNone; + + iProxy = new TMSProxy(); + if (iProxy) + { + _LIT(KTMSServerName, "!TmsServer"); + iProxy->Connect(KTMSServerName); + const TInt KTMSTermSrv = 37; + iProxy->SendRequest(KTMSTermSrv); + } + + iLog->Log(_L("CTmsAudioServicesTestClass::TerminateServer Error [%d]"), error); + return error; + } +