diff -r ccd8e69b5392 -r 496ad160a278 mmsharing/mmshengine/tsrc/ut_engine/src/ut_musengreceivesession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmsharing/mmshengine/tsrc/ut_engine/src/ut_musengreceivesession.cpp Fri Jun 11 13:36:18 2010 +0300 @@ -0,0 +1,1873 @@ +/* +* Copyright (c) 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: +* +*/ + + +// INTERNAL INCLUDES +#include "ut_musengreceivesession.h" +#include "musengstubs.h" +#include "musengtestdefs.h" +#include "musengreceivesession.h" +#include "mussessionproperties.h" +#include "contactenginestub.h" +#include "musengremotevideoplayer.h" + +// SYSTEM INCLUDES +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +// Using following value increases treshold buffer to 1 second from +// default 100 ms +const TInt KMusEngJitterBufferTreshold = 50; +const TInt KMusEngTresholdToSecondsFactor = 20; +const TInt KMusEngTwoSecondInMilliSeconds = 2000; +// Use inactivity timer value that is a little bigger than treshold in seconds +const TUint KMusEngInactivityTimer = KMusEngTresholdToSecondsFactor * + KMusEngJitterBufferTreshold + + KMusEngTwoSecondInMilliSeconds; + +_LIT( KTestContactName, "nokia" ); + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +UT_CMusEngReceiveSession* UT_CMusEngReceiveSession::NewL() + { + UT_CMusEngReceiveSession* self = UT_CMusEngReceiveSession::NewLC(); + CleanupStack::Pop( self ); + return self; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +UT_CMusEngReceiveSession* UT_CMusEngReceiveSession::NewLC() + { + UT_CMusEngReceiveSession* self = new( ELeave ) UT_CMusEngReceiveSession(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +UT_CMusEngReceiveSession::~UT_CMusEngReceiveSession() + { + // NOP + } + + +// ----------------------------------------------------------------------------- +// Default constructor +// ----------------------------------------------------------------------------- +// +UT_CMusEngReceiveSession::UT_CMusEngReceiveSession() + { + // NOP + } + + +// ----------------------------------------------------------------------------- +// Second phase construct +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::ConstructL() + { + // The ConstructL from the base class CEUnitTestSuiteClass must be called. + // It generates the test case table. + CEUnitTestSuiteClass::ConstructL(); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::SetupL( ) + { + // set fast mode ON + User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid, + NMusSessionApi::KFastMode, + 0 ) ); + iLcSessionObserver = new( ELeave )CLcSessionObserverStub; + iLcUiProvider = new( ELeave )CLcUiProviderStub; + iReceiveSession = CMusEngReceiveSession::NewL(); + iReceiveSession->SetLcSessionObserver( iLcSessionObserver ); + iReceiveSession->SetLcUiProvider( iLcUiProvider ); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::Teardown( ) + { + PropertyHelper::Close(); + delete iReceiveSession; + delete iLcUiProvider; + delete iLcSessionObserver; + PropertyHelper::Close(); + // Delete static data from CenRep stub + CRepository::ResetStubGlobal(); + CRepository::iForceFailWithCode = KErrNone; + } + + +// TEST HELPERS + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +CMceVideoStream* UT_CMusEngReceiveSession::ConstructVideoInStreamLC() + { + CMceVideoStream* videoStream = CMceVideoStream::NewLC(); + + videoStream->SetSourceL( CMceRtpSource::NewLC() ); + CleanupStack::Pop(); + + videoStream->AddSinkL( + CMceDisplaySink::NewLC( *iReceiveSession->iManager ) ); + CleanupStack::Pop(); + + return videoStream; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +CMceVideoStream* UT_CMusEngReceiveSession::ConstructVideoOutStreamLC() + { + CMceVideoStream* videoStream = CMceVideoStream::NewLC(); + + videoStream->SetSourceL( + CMceCameraSource::NewLC( *iReceiveSession->iManager ) ); + CleanupStack::Pop(); + + videoStream->AddSinkL( CMceRtpSink::NewLC() ); + CleanupStack::Pop(); + + return videoStream; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +CMceAudioStream* UT_CMusEngReceiveSession::ConstructAudioInStreamLC() + { + CMceAudioStream* audioStream = CMceAudioStream::NewLC(); + + audioStream->SetSourceL( CMceRtpSource::NewLC() ); + CleanupStack::Pop(); + + audioStream->AddSinkL( CMceSpeakerSink::NewLC() ); + CleanupStack::Pop(); + + return audioStream; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +CMceAudioStream* UT_CMusEngReceiveSession::ConstructAudioOutStreamLC() + { + CMceAudioStream* audioStream = CMceAudioStream::NewLC(); + + audioStream->SetSourceL( + CMceFileSource::NewLC( *iReceiveSession->iManager, KNullDesC() ) ); + CleanupStack::Pop(); + + audioStream->AddSinkL( CMceRtpSink::NewLC() ); + CleanupStack::Pop(); + + return audioStream; + + } + + +// ----------------------------------------------------------------------------- +// Helper to construct incoming sessions. +// ----------------------------------------------------------------------------- +// +CMceInSession* UT_CMusEngReceiveSession::ConstructInSessionLC( + TInt aVideoStreamCount, + TInt aAudioStreamCount, + TBool aConstructSinks ) + { + CMceInSession* inSession = CMceInSession::NewL( + *(iReceiveSession->iManager), + KTestOriginator() ); + CleanupStack::PushL( inSession ); + + for ( TInt i = 0; i < aVideoStreamCount; ++i ) + { + CMceVideoStream* videoStream = CMceVideoStream::NewLC(); + + CMceRtpSource* rtpSource = CMceRtpSource::NewLC(); + videoStream->SetSourceL( rtpSource ); + CleanupStack::Pop( rtpSource ); + + if ( aConstructSinks ) + { + CMceDisplaySink* display = CMceDisplaySink::NewLC( + *(iReceiveSession->iManager) ); + videoStream->AddSinkL( display ); + CleanupStack::Pop( display ); + } + + inSession->AddStreamL( videoStream ); + CleanupStack::Pop( videoStream ); + } + + for ( TInt i = 0; i < aAudioStreamCount; ++i ) + { + CMceAudioStream* audioStream = CMceAudioStream::NewLC(); + + CMceRtpSource* rtpSource = CMceRtpSource::NewLC(); + audioStream->SetSourceL( rtpSource ); + CleanupStack::Pop( rtpSource ); + + if ( aConstructSinks ) + { + CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC(); + audioStream->AddSinkL( speaker ); + CleanupStack::Pop( speaker ); + } + + inSession->AddStreamL( audioStream ); + CleanupStack::Pop( audioStream ); + } + + return inSession; + } + + + + +// TEST CASES + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_NewLL( ) + { + EUNIT_ASSERT( iReceiveSession ); + EUNIT_ASSERT( !iReceiveSession->iSession ); + EUNIT_ASSERT( iReceiveSession->iMceManagerUid == TUid::Uid( KMusUiUid ) ); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_LcSessionStateL() + { + // No MCE session -> Convert to MLcSession::EReceived + EUNIT_ASSERT_EQUALS( TInt( MLcSession::EReceived ), + TInt( iReceiveSession->LcSessionState() ) ) + + // Some other state -> State returned from the base class + TMceTransactionDataContainer container; + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EProceeding; + iReceiveSession->EstablishLcSessionL(); + EUNIT_ASSERT_EQUALS( TInt( MLcSession::EOpening ), + TInt( iReceiveSession->LcSessionState() ) ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_EstablishLcSessionL() + { + // No MCE session + EUNIT_ASSERT_SPECIFIC_LEAVE( + iReceiveSession->EstablishLcSessionL(), KErrNotReady ) + + // Construct a new session and accept it + TMceTransactionDataContainer container; + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EProceeding; + iReceiveSession->EstablishLcSessionL(); + EUNIT_ASSERT( iReceiveSession->iSession ) + EUNIT_ASSERT_EQUALS( inSession, iReceiveSession->iSession ); + EUNIT_ASSERT_EQUALS( TInt( CMceSession::EAnswering ), + TInt( iReceiveSession->iSession->iState ) ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_TerminateLcSessionL() + { + // No MCE session + EUNIT_ASSERT_SPECIFIC_LEAVE( + iReceiveSession->TerminateLcSessionL(), KErrNotReady ) + + // Reject session, session state incoming, no operator variant + TMceTransactionDataContainer container; + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EIncoming; + iReceiveSession->iOperatorVariant = EFalse; + iReceiveSession->TerminateLcSessionL(); + EUNIT_ASSERT_EQUALS( TInt( CMceSession::ETerminated ), + TInt( iReceiveSession->iSession->iState ) ) + + // Reject session, session state proceeding, no operator variant + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EProceeding; + iReceiveSession->iOperatorVariant = EFalse; + iReceiveSession->TerminateLcSessionL(); + EUNIT_ASSERT_EQUALS( TInt( CMceSession::ETerminated ), + TInt( iReceiveSession->iSession->iState ) ) + + // Reject session, operator variant + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EProceeding; + iReceiveSession->iOperatorVariant = ETrue; + iReceiveSession->TerminateLcSessionL(); + EUNIT_ASSERT_EQUALS( TInt( CMceSession::ETerminated ), + TInt( iReceiveSession->iSession->iState ) ) + + // Terminate an established session + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iReceiveSession->iSession->iState = CMceSession::EEstablished; + iReceiveSession->iOperatorVariant = EFalse; + iReceiveSession->TerminateLcSessionL(); + EUNIT_ASSERT_EQUALS( TInt( CMceSession::ETerminating ), + TInt( iReceiveSession->iSession->iState ) ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_RemoteVideoPlayerL() + { + EUNIT_ASSERT( iReceiveSession->RemoteVideoPlayer() == + iReceiveSession->iRemoteVideoPlayer ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_RemoteDisplayName() + { + + // Creating Valid Session + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + iReceiveSession->CompleteSessionStructureL(); + EUNIT_ASSERT( inSession->Streams().Count() == 1 ); + + + // Name is published using publish/subscribe key by Availblity + User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid, + NMusSessionApi::KContactName, + KTestContactName ) ); + + EUNIT_ASSERT_EQUALS ( KTestContactName(), iReceiveSession->RemoteDisplayName() ) + + + User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid, + NMusSessionApi::KContactName, + KNullDesC) ); + + // Ensure its not null and its not equal + EUNIT_ASSERT( KTestContactName() != iReceiveSession->RemoteDisplayName() ); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_HandleSessionStateChangedL() + { + // Unknown session, let the base class handle + CMceInSession* inSession = ConstructInSessionLC( 1, 1 ); + + iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() ); + + // Simulate incoming session + TMceTransactionDataContainer container; + + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + + // Session is in state EReserving, let the base class handle + iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() ); + + // The normal cases: + + // 1 ) First transition to state EProceeding, user and remote end should + // be notified + inSession->iState = CMceSession::EProceeding; + iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() ); + EUNIT_ASSERT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ), + TInt( CLcSessionObserverStub::ESessionStateChanged ) ) + EUNIT_ASSERT( iReceiveSession->iRingLCalled ) + + // Ensure Originator is taken from the incoming session + EUNIT_ASSERT_EQUALS ( KTestOriginator(), *iReceiveSession->iOriginator ) + + iLcSessionObserver->Reset(); + + // 2 ) Now simulate second transition to EProceeding state which can happen + // if we force 100rel to be used. User and remote end should not be + // notified anymore but change should be ignored. + inSession->iState = CMceSession::EProceeding; + iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() ); + EUNIT_ASSERT_EQUALS( TInt( CLcSessionObserverStub::EUnknown ), + TInt( iLcSessionObserver->iCalledFunction ) ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_AdjustVideoCodecLL() + { + CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() ); + CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() ); + CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + CMceVideoCodec* codecUnknown = CMceH263Codec::NewLC( KNullDesC8() ); + + iReceiveSession->AdjustVideoCodecL( *codecH263, KMceRTPSource ); + iReceiveSession->AdjustVideoCodecL( *codecH2632000, KMceRTPSource ); + iReceiveSession->AdjustVideoCodecL( *codecAvc, KMceRTPSource ); + iReceiveSession->AdjustVideoCodecL( *codecUnknown, KMceRTPSource ); + + EUNIT_ASSERT_EQUALS( codecH263->KeepAliveTimer(), 5 ) + EUNIT_ASSERT_EQUALS( codecH263->KeepAlivePayloadType(), 96 ) + EUNIT_ASSERT_EQUALS( codecH263->KeepAliveData(), KNullDesC8() ) + + EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveTimer(), 5 ) + EUNIT_ASSERT_EQUALS( codecH2632000->KeepAlivePayloadType(), 96 ) + EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveData(), KNullDesC8() ) + + EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveTimer(), 5 ) + EUNIT_ASSERT_EQUALS( codecAvc->KeepAlivePayloadType(), 98 ) + EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveData(), KNullDesC8() ) + + EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveTimer(), 5 ) + EUNIT_ASSERT_EQUALS( codecUnknown->KeepAlivePayloadType(), 0 ) + EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveData(), KNullDesC8() ) + + CleanupStack::PopAndDestroy( codecUnknown ); + CleanupStack::PopAndDestroy( codecAvc ); + CleanupStack::PopAndDestroy( codecH2632000 ); + CleanupStack::PopAndDestroy( codecH263 ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_AdjustAudioCodecLL() + { + CMceAudioCodec* codec = + iReceiveSession->iManager->SupportedAudioCodecs()[0]->CloneL(); + CleanupStack::PushL( codec ); + iReceiveSession->AdjustAudioCodecL( *codec ); + + // Test keepalive timer + + TUint8 keepAliveTimer = codec->KeepAliveTimer(); + EUNIT_ASSERT( codec->KeepAliveTimer() == 5 ) + EUNIT_ASSERT( codec->KeepAlivePayloadType() == 97 ) + EUNIT_ASSERT( codec->KeepAliveData() == KNullDesC8() ) + + // Test that base class has been called + + EUNIT_ASSERT( codec->iMMFPriority == KAudioPrioritySwisPlayback ) + EUNIT_ASSERT( codec->iMMFPriorityPreference == KAudioPrefSwisPlayback ) + + CleanupStack::PopAndDestroy( codec ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_DoCodecSelectionLL() + { + // Check that Non-Interleaved AVC is preferred over single NAL + CMceVideoStream* videoStream = CMceVideoStream::NewLC(); + + CMceVideoCodec* codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; + videoStream->AddCodecL( codecAvcSingleNal ); + CleanupStack::Pop( codecAvcSingleNal ); + + CMceVideoCodec* codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved; + videoStream->AddCodecL( codecAvcNonInterleaved ); + CleanupStack::Pop( codecAvcNonInterleaved ); + + iReceiveSession->DoCodecSelectionL( *videoStream ); + + EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 ) + EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() ) + EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(), + KMceAvcModeNonInterleaved ) + + CleanupStack::PopAndDestroy( videoStream ); + + // Check that Single NAL AVC is preferred over H263 + videoStream = CMceVideoStream::NewLC(); + + CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() ); + videoStream->AddCodecL( codecH263 ); + CleanupStack::Pop( codecH263 ); + + codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; + videoStream->AddCodecL( codecAvcSingleNal ); + CleanupStack::Pop( codecAvcSingleNal ); + + iReceiveSession->DoCodecSelectionL( *videoStream ); + + EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 ) + EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() ) + EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(), + KMceAvcModeSingleNal ) + + CleanupStack::PopAndDestroy( videoStream ); + + // Check that H263 codecs without AVC are handled correctly (in base class) + videoStream = CMceVideoStream::NewLC(); + + codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() ); + videoStream->AddCodecL( codecH263 ); + CleanupStack::Pop( codecH263 ); + + CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() ); + videoStream->AddCodecL( codecH2632000 ); + CleanupStack::Pop( codecH2632000 ); + + iReceiveSession->DoCodecSelectionL( *videoStream ); + + EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 ) + + CleanupStack::PopAndDestroy( videoStream ); + + // Check that AVC non-interleaved with best bitrate is preferred + videoStream = CMceVideoStream::NewLC(); + + codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved; + codecAvcNonInterleaved->SetMaxBitrateL( 80000 ); + videoStream->AddCodecL( codecAvcNonInterleaved ); + CleanupStack::Pop( codecAvcNonInterleaved ); + + CMceVideoCodec* codecAvcNonInterleaved128 = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcNonInterleaved128->iCodecMode = KMceAvcModeNonInterleaved; + codecAvcNonInterleaved128->SetMaxBitrateL( 128000 ); + videoStream->AddCodecL( codecAvcNonInterleaved128 ); + CleanupStack::Pop( codecAvcNonInterleaved128 ); + + iReceiveSession->DoCodecSelectionL( *videoStream ); + + EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 ) + EUNIT_ASSERT( videoStream->Codecs()[0] == codecAvcNonInterleaved128 ) + + CleanupStack::PopAndDestroy( videoStream ); + + // Check that in case of several AVC single NALs, the best bitrate is preferred + videoStream = CMceVideoStream::NewLC(); + + codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; + codecAvcSingleNal->SetMaxBitrateL( 80000 ); + videoStream->AddCodecL( codecAvcSingleNal ); + CleanupStack::Pop( codecAvcSingleNal ); + + CMceVideoCodec* codecAvcSingleNal128 = CMceAvcCodec::NewLC( KMceSDPNameH264() ); + codecAvcSingleNal128->iCodecMode = KMceAvcModeSingleNal; + codecAvcSingleNal128->SetMaxBitrateL( 128000 ); + videoStream->AddCodecL( codecAvcSingleNal128 ); + CleanupStack::Pop( codecAvcSingleNal128 ); + + iReceiveSession->DoCodecSelectionL( *videoStream ); + + EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 ) + EUNIT_ASSERT( videoStream->Codecs()[0] == codecAvcSingleNal128 ) + + CleanupStack::PopAndDestroy( videoStream ); + + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_IncomingSessionL() + { + _LIT8( KMusEngSwisTestIdentifier, "Require: precondition" ); + _LIT8( KMusEngTestHeader, "Some header" ); + + TMceTransactionDataContainer container; + + // Simulate SWIS 2.2 invite. There are no streams, so completion fails and + // session gets rejected. Still prenotification has been given. + CMceInSession* inSession = ConstructInSessionLC( 0, 0 ); + CDesC8Array* headers = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( headers ); + headers->AppendL( KMusEngTestHeader() ); + headers->AppendL( KMusEngSwisTestIdentifier() ); + container.SetHeaders( headers ); + CleanupStack::Pop( headers ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + container.Clear(); + + EUNIT_ASSERT( iReceiveSession->iSession ); + EUNIT_ASSERT( iReceiveSession->iSession->iState == + CMceSession::ETerminated ); + + EUNIT_ASSERT( iReceiveSession->iSession->i100RelUsage == + KMce100RelRequired ) + EUNIT_ASSERT( !iReceiveSession->iRingLCalled ) + + // Try again with valid session, normal case + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + + EUNIT_ASSERT( iReceiveSession->iSession ); + // Next state depends on success of completion of session structure. + // When using alloc failure state is ETerminated, in succesfull case it is + // EReserving. However it is set to "normal" state EReserving after + // assertion + EUNIT_ASSERT( iReceiveSession->iSession->iState == + CMceSession::EReserving || + iReceiveSession->iSession->iState == + CMceSession::ETerminated ); + iReceiveSession->iSession->iState = CMceSession::EReserving; + + // Try again without container, new session gets terminated and deleted + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, NULL ); + CleanupStack::Pop( inSession ); + + EUNIT_ASSERT( iReceiveSession->iSession ); + EUNIT_ASSERT( iReceiveSession->iSession != inSession ); + EUNIT_ASSERT( iReceiveSession->iSession->iState == + CMceSession::EReserving ); + + // Try again when there is session pending, new session gets terminated + // and deleted + inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + + EUNIT_ASSERT( iReceiveSession->iSession ); + EUNIT_ASSERT( iReceiveSession->iSession != inSession ); + EUNIT_ASSERT( iReceiveSession->iSession->iState == + CMceSession::EReserving ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_IncomingUpdateL() + { + TMceTransactionDataContainer container; + + // We do not have session and thus cannot have an update, new session gets + // rejected and deleted. + CMceInSession* oldSession = ConstructInSessionLC( 0, 0 ); + CMceInSession* newSession = ConstructInSessionLC( 0, 0 ); + iReceiveSession->IncomingUpdate( *oldSession, newSession, NULL ); + CleanupStack::Pop( newSession ); + CleanupStack::PopAndDestroy( oldSession ); + + // Start establishing a session + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + + iReceiveSession->iSession->iState = CMceSession::EProceeding; + iReceiveSession->EstablishLcSessionL(); + + // Now we have an insession, try to update session that is not ours, + // new one gets rejected and deleted. + oldSession = ConstructInSessionLC( 0, 0 ); + newSession = ConstructInSessionLC( 0, 0 ); + iReceiveSession->IncomingUpdate( *oldSession, newSession, NULL ); + CleanupStack::Pop( newSession ); + CleanupStack::PopAndDestroy( oldSession ); + + // Try to update our insession before it is established. New session gets + // rejected and deleted. + newSession = ConstructInSessionLC( 0, 0 ); + iReceiveSession->IncomingUpdate( *iReceiveSession->iSession, + newSession, + NULL ); + CleanupStack::Pop( newSession ); + + // Finish establishing insession + iReceiveSession->iSession->iState = CMceSession::EEstablished; + + // Try to update the established session with invalid session, it gets + // rejected and deleted + newSession = ConstructInSessionLC( 0, 0 ); + iReceiveSession->IncomingUpdate( *iReceiveSession->iSession, + newSession, + NULL ); + CleanupStack::Pop( newSession ); + + // Succeed in update + newSession = ConstructInSessionLC( 1, 0 ); + iReceiveSession->IncomingUpdate( *iReceiveSession->iSession, + newSession, + NULL ); + CleanupStack::Pop( newSession ); + EUNIT_ASSERT( iReceiveSession->iSession ); + EUNIT_ASSERT( iReceiveSession->iSession == newSession ); + + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_StreamStateChangedL() + { + TMceTransactionDataContainer container; + + CMceInSession* inSession = ConstructInSessionLC( 1, 1 ); + + CMceMediaStream* videoStream = inSession->Streams()[0]; + CMceMediaStream* audioStream = inSession->Streams()[1]; + + // Try without a session, nothing happens + iReceiveSession->StreamStateChanged( *audioStream ); + + // Establish session + iReceiveSession->IncomingSession( inSession, &container ); + CleanupStack::Pop( inSession ); + iLcSessionObserver->Reset(); + + // Try with audiostream, nothing happens + audioStream->iState = CMceMediaStream::EBuffering; + iReceiveSession->StreamStateChanged( *audioStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + + // Try with videostream, but without a source, nothing happens + CMceRtpSource* rtpSource = + static_cast( videoStream->Source() ); //hack + videoStream->iSource = NULL; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + + // Try with videostream and a camera source, nothing happens + videoStream->iSource = + CMceCameraSource::NewL( *iReceiveSession->iManager ); //hack + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + + // Remove hacks + delete videoStream->iSource; + videoStream->iSource = rtpSource; + + // Buffering, normal case + videoStream->iState = CMceMediaStream::EBuffering; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ), + TInt( CLcSessionObserverStub::EPlayerStateChanged ) ) + EUNIT_ASSERT( iReceiveSession->iBuffered ) + iLcSessionObserver->Reset(); + + // Streaming, normal case + videoStream->iState = CMceMediaStream::EStreaming; + iReceiveSession->iReceiving = EFalse; + iReceiveSession->iBuffered = ETrue; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ), + TInt( CLcSessionObserverStub::EPlayerStateChanged ) ) + EUNIT_ASSERT_EQUALS( KMusEngInactivityTimer, rtpSource->iInactivityTimer ) + iLcSessionObserver->Reset(); + EUNIT_ASSERT_EQUALS( TInt( iLcUiProvider->iCalledFunction ), + TInt( CLcUiProviderStub::EHandleForegroundStatus ) ) + iLcUiProvider->Reset(); + // Normally background info will be cleared once ui comes to foreground and + // notifies engine about it + iReceiveSession->iBackground = EFalse; + + // Streaming, event is received even when already receiving. Streaming + // event is anyway notified. + videoStream->iState = CMceMediaStream::EStreaming; + iReceiveSession->iReceiving = ETrue; + iReceiveSession->iBuffered = ETrue; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ), + TInt( CLcSessionObserverStub::EPlayerStateChanged ) ) + EUNIT_ASSERT_EQUALS( KMusEngInactivityTimer, rtpSource->iInactivityTimer ) + iLcSessionObserver->Reset(); + EUNIT_ASSERT_EQUALS( TInt( iLcUiProvider->iCalledFunction ), + TInt( CLcUiProviderStub::EUnknown ) ) + + // Streaming and receiving started already. Streaming is not notified because + // of buffering event hasn't been received + videoStream->iState = CMceMediaStream::EStreaming; + iReceiveSession->iReceiving = ETrue; + iReceiveSession->iBuffered = EFalse; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + iLcSessionObserver->Reset(); + + // Streaming, receiving not started and buffering not happened ( means no packet + // received yet. Ignore this event too. + videoStream->iState = CMceMediaStream::EStreaming; + iReceiveSession->iReceiving = EFalse; + iReceiveSession->iBuffered = EFalse; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + iLcSessionObserver->Reset(); + + // Streaming, receiving not started and buffering happened. + // Enabling RTP timer leaves. Should be a failure case. + videoStream->iState = CMceMediaStream::EStreaming; + iReceiveSession->iReceiving = EFalse; + iReceiveSession->iBuffered = ETrue; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT_NOT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ), + TInt( CLcSessionObserverStub::EPlayerFailed ) ) + iLcSessionObserver->Reset(); + + // Try default behaviors + videoStream->iState = CMceMediaStream::EIdle; + iReceiveSession->StreamStateChanged( *videoStream ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ) + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithoutSessionL() + { + TRAPD( error, iReceiveSession->CompleteSessionStructureL() ); + MUS_TEST_FORWARD_ALLOC_FAILURE( error ); + EUNIT_ASSERT( error == KErrNotReady ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithoutStreamsL() + { + CMceInSession* inSession = ConstructInSessionLC( 0, 0 ); + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + TRAPD( error, iReceiveSession->CompleteSessionStructureL() ); + MUS_TEST_FORWARD_ALLOC_FAILURE( error ); + EUNIT_ASSERT( error == KErrCorrupt ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithOutgoingStreamL() + { + // Stream will be removed. + CMceInSession* inSession = ConstructInSessionLC( 0, 0 ); + + inSession->AddStreamL( ConstructVideoOutStreamLC() ); + CleanupStack::Pop(); + + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + TRAPD( error, iReceiveSession->CompleteSessionStructureL() ) + MUS_TEST_FORWARD_ALLOC_FAILURE( error ); + EUNIT_ASSERT( error == KErrCorrupt ); + EUNIT_ASSERT( inSession->Streams().Count() == 0 ); + EUNIT_ASSERT( inSession->Bundles().Count() == 0 ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithVideoInL() + { + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + EUNIT_ASSERT( inSession->Streams().Count() == 1 ); + EUNIT_ASSERT( inSession->Streams()[0]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[0]->Type() == KMceVideo ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks()[0]->Type() == + KMceDisplaySink ) + + // No audio, bundle is not constructed + EUNIT_ASSERT( inSession->Bundles().Count() == 0 ) + } + + +// ----------------------------------------------------------------------------- +// Video out is bound stream, it gets disabled +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithVideoOutBoundToVideoInL() + { + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + + CMceVideoStream* videoOut = ConstructVideoOutStreamLC(); + inSession->Streams()[0]->BindL( videoOut ); + CleanupStack::Pop( videoOut ); + + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + EUNIT_ASSERT( inSession->Streams().Count() == 1 ); + + CMceMediaStream* videoIn = inSession->Streams()[0]; + + EUNIT_ASSERT( videoIn->IsEnabled() ) + EUNIT_ASSERT( videoIn->Type() == KMceVideo ) + EUNIT_ASSERT( videoIn->Sinks().Count() == 1 ) + EUNIT_ASSERT( videoIn->Sinks()[0]->Type() == KMceDisplaySink ) + + EUNIT_ASSERT( videoIn->BoundStream() ) + EUNIT_ASSERT( !videoIn->BoundStreamL().IsEnabled() ) + + // No audio, bundle is not constructed + EUNIT_ASSERT( inSession->Bundles().Count() == 0 ) + } + + +// ----------------------------------------------------------------------------- +// Video in is bound stream, another one gets disabled +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithVideoInBoundToVideoOutL() + { + CMceInSession* inSession = ConstructInSessionLC( 0, 0 ); + + CMceVideoStream* videoOut = ConstructVideoOutStreamLC(); + + CMceVideoStream* videoIn = ConstructVideoInStreamLC(); + videoOut->BindL( videoIn ); + CleanupStack::Pop( videoIn ); + + inSession->AddStreamL( videoOut ); + CleanupStack::Pop( videoOut ); + + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + EUNIT_ASSERT( inSession->Streams().Count() == 1 ); + EUNIT_ASSERT( !videoOut->IsEnabled() ) + EUNIT_ASSERT( videoOut->Type() == KMceVideo ) + EUNIT_ASSERT( videoOut->Sinks().Count() == 1 ) + EUNIT_ASSERT( videoOut->Sinks()[0]->Type() == KMceRTPSink ) + EUNIT_ASSERT( !videoOut->Sinks()[0]->IsEnabled() ) + + EUNIT_ASSERT( videoOut->BoundStream() ) + EUNIT_ASSERT( videoOut->BoundStreamL().IsEnabled() ) + EUNIT_ASSERT( videoOut->BoundStreamL().Type() == KMceVideo ) + EUNIT_ASSERT( videoOut->BoundStreamL().Sinks().Count() == 1 ) + EUNIT_ASSERT( videoOut->BoundStreamL().Sinks()[0]->Type() == + KMceDisplaySink ) + EUNIT_ASSERT( videoOut->BoundStreamL().Sinks()[0]->IsEnabled() ) + + // No audio, bundle is not constructed + EUNIT_ASSERT( inSession->Bundles().Count() == 0 ) + } + + +// ----------------------------------------------------------------------------- +// Construct 3 video instreams: +// 0. Without bound stream +// 1. Bounds video out stream +// 2. Bounded by video out stream +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_WithMultipleVideoInsL() + { + // construct session and stream 0 + CMceInSession* inSession = ConstructInSessionLC( 2, 0 ); + + // finish constructing stream 1 + CMceVideoStream* videoOut = ConstructVideoOutStreamLC(); + inSession->Streams()[1]->BindL( videoOut ); + CleanupStack::Pop( videoOut ); + + // finish constructing stream 2 + videoOut = ConstructVideoOutStreamLC(); + + CMceVideoStream* videoIn = ConstructVideoInStreamLC(); + videoOut->BindL( videoIn ); + CleanupStack::Pop( videoIn ); + + inSession->AddStreamL( videoOut ); + CleanupStack::Pop( videoOut ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + // complete + iReceiveSession->CompleteSessionStructureL(); + + // First should be used, 4 other streams should be deleted + + EUNIT_ASSERT( inSession->Streams().Count() == 1 ); + + // First stream + EUNIT_ASSERT( inSession->Streams()[0]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[0]->Type() == KMceVideo ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks()[0]->Type() == KMceDisplaySink ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks()[0]->IsEnabled() ) + + // No audio, bundle is not constructed + EUNIT_ASSERT( inSession->Bundles().Count() == 0 ) + } + + +// ----------------------------------------------------------------------------- +// Streams in this test case +// 0. Video in +// 1. Audio in +// 2. Audio out bound to audio in +// 3. Audio in bound to audio out +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession:: + UT_CompleteSessionStructureL_WithVideoAndMultipleAudioInsL() + { + // Construct session and streams 0 and 1 + CMceInSession* inSession = inSession = ConstructInSessionLC( 1, 2 ); + + // Construct stream 2 + CMceAudioStream* audioOut = ConstructAudioOutStreamLC(); + inSession->Streams()[2]->BindL( audioOut ); + CleanupStack::Pop( audioOut ); + + // Construct stream 3 + + audioOut = ConstructAudioOutStreamLC(); + + CMceAudioStream* audioIn = ConstructAudioInStreamLC(); + audioOut->BindL( audioIn ); + CleanupStack::Pop( audioIn ); + + inSession->AddStreamL( audioOut ); + CleanupStack::Pop( audioOut ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + // Complete + iReceiveSession->CompleteSessionStructureL(); + EUNIT_ASSERT( inSession->Streams().Count() == 4 ); + + // Stream 0 + EUNIT_ASSERT( inSession->Streams()[0]->Type() == KMceVideo ) + EUNIT_ASSERT( inSession->Streams()[0]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[0]->Sinks()[0]->Type() == + KMceDisplaySink ) + + // Stream 1 + EUNIT_ASSERT( inSession->Streams()[1]->Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Streams()[1]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[1]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[1]->Sinks()[0]->Type() == + KMceSpeakerSink ); + CMceSpeakerSink* speaker = + static_cast(inSession->Streams()[1]->Sinks()[0]); + EUNIT_ASSERT( speaker->VolumeL() == iReceiveSession->LcVolumeL() ) + + // Stream 2 and bound stream + EUNIT_ASSERT( inSession->Streams()[2]->Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Streams()[2]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[2]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[2]->Sinks()[0]->Type() == + KMceSpeakerSink ); + speaker = static_cast(inSession->Streams()[2]->Sinks()[0]); + EUNIT_ASSERT( speaker->VolumeL() == iReceiveSession->LcVolumeL() ) + + EUNIT_ASSERT( inSession->Streams()[2]->BoundStream() ) + EUNIT_ASSERT( !inSession->Streams()[2]->BoundStreamL().IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[2]->BoundStreamL().Type() == KMceAudio ) + + EUNIT_ASSERT( inSession->Streams()[2]->BoundStreamL().Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[2]->BoundStreamL().Sinks()[0]->Type() == + KMceRTPSink ); + + // Stream 3 and bound stream + EUNIT_ASSERT( inSession->Streams()[3]->Type() == KMceAudio ) + EUNIT_ASSERT( !inSession->Streams()[3]->IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[3]->Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[3]->Sinks()[0]->Type() == KMceRTPSink ) + EUNIT_ASSERT( !inSession->Streams()[3]->Sinks()[0]->IsEnabled() ) + + EUNIT_ASSERT( inSession->Streams()[3]->BoundStream() ) + EUNIT_ASSERT( inSession->Streams()[3]->BoundStreamL().IsEnabled() ) + EUNIT_ASSERT( inSession->Streams()[3]->BoundStreamL().Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Streams()[3]->BoundStreamL().Sinks().Count() == 1 ) + EUNIT_ASSERT( inSession->Streams()[3]->BoundStreamL().Sinks()[0]->Type() == + KMceSpeakerSink ) + speaker = static_cast + (inSession->Streams()[3]->BoundStreamL().Sinks()[0]); + EUNIT_ASSERT( speaker->VolumeL() == iReceiveSession->LcVolumeL() ) + + // Check for bundles + EUNIT_ASSERT( inSession->Bundles().Count() == 1 ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams().Count() == 4 ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[0]->Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[0]->Sinks()[0]->Type() == + KMceSpeakerSink ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[1]->Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[1]->Sinks()[0]->Type() == + KMceSpeakerSink ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[2]->Type() == KMceAudio ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[2]->Sinks()[0]->Type() == + KMceSpeakerSink ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[3]->Type() == KMceVideo ) + EUNIT_ASSERT( inSession->Bundles()[0]->Streams()[3]->Sinks()[0]->Type() == + KMceDisplaySink ) + } + + +// ----------------------------------------------------------------------------- +// Streams in this test case +// 0. Video in +// 1. Audio in +// 2. Audio out bound to audio in +// 3. Audio in bound to audio out +// All audio will be removed because of operator variant +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_OperatorVariant() + { + iReceiveSession->iOperatorVariant = ETrue; + + // Construct session and streams 0 and 1 + CMceInSession* inSession = inSession = ConstructInSessionLC( 1, 2 ); + + // Construct stream 2 + CMceAudioStream* audioOut = ConstructAudioOutStreamLC(); + inSession->Streams()[2]->BindL( audioOut ); + CleanupStack::Pop( audioOut ); + + // Construct stream 3 + + audioOut = ConstructAudioOutStreamLC(); + + CMceAudioStream* audioIn = ConstructAudioInStreamLC(); + audioOut->BindL( audioIn ); + CleanupStack::Pop( audioIn ); + + inSession->AddStreamL( audioOut ); + CleanupStack::Pop( audioOut ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + // Complete + iReceiveSession->CompleteSessionStructureL(); + + // Check that all audio has been removed and no bundles has been + // constructed + EUNIT_ASSERT_EQUALS( inSession->Streams().Count(), 1 ) + EUNIT_ASSERT_EQUALS( inSession->Streams()[0]->Type(), KMceVideo ) + EUNIT_ASSERT_EQUALS( inSession->Bundles().Count(), 0 ) + + + // Session with bandwidth attributes b=AS and b=TIAS at session and media + // levels -> b=AS is taken in use at session level (b=TIAS is ignored) + // + delete iReceiveSession->iSession; + iReceiveSession->iSession = NULL; + + inSession = ConstructInSessionLC( 1, 0 ); + //setting session level SDP attributes + CDesC8Array* sdpLines = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + sdpLines->AppendL( KMusEngSessionSdpLineTiasLine() ); + inSession->SetSessionSDPLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + //setting media level SDP attributes + sdpLines = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + sdpLines->AppendL( KMusEngSessionSdpLineTiasLine() ); + inSession->Streams()[ 0 ]->SetMediaAttributeLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure there is only b=AS and no b=TIAS present at session level + MDesC8Array* newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + TBool bandwidthFoundFromSessionLevel = EFalse; + TBool tiasFoundFromSessionLevel = EFalse; + for ( TInt i = 0; newSdpLines && i < newSdpLines->MdcaCount(); i++ ) + { + if ( newSdpLines->MdcaPoint( i ).Compare( + KMusEngSessionSdpLineBandwidthField() ) == 0 ) + { + bandwidthFoundFromSessionLevel = ETrue; + } + else if ( newSdpLines->MdcaPoint( i ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ) + { + tiasFoundFromSessionLevel = ETrue; + } + } + EUNIT_ASSERT( bandwidthFoundFromSessionLevel ); + EUNIT_ASSERT( !tiasFoundFromSessionLevel ); + + // Ensure there is no bandwidth attributes at media level + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( !newSdpLines->MdcaCount() ); + + + // Session with bandwidth AS and TIAS attributes at media level + // -> bandwidth AS is taken in use at media level + // + delete iReceiveSession->iSession; + iReceiveSession->iSession = NULL; + + inSession = ConstructInSessionLC( 1, 0 ); + + sdpLines = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + sdpLines->AppendL( KMusEngSessionSdpLineTiasLine() ); + inSession->Streams()[ 0 ]->SetMediaAttributeLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure there is no bandwidth attribute at session level + newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + bandwidthFoundFromSessionLevel = EFalse; + for ( TInt i = 0; newSdpLines && i < newSdpLines->MdcaCount(); i++ ) + { + if ( newSdpLines->MdcaPoint( i ).Compare( + KMusEngSessionSdpLineBandwidthField() ) == 0 + || newSdpLines->MdcaPoint( i ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ) + { + bandwidthFoundFromSessionLevel = ETrue; + } + } + EUNIT_ASSERT( !bandwidthFoundFromSessionLevel ); + + // Ensure media level has only b=AS attribute + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 1 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineBandwidthField() ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_CompleteSessionStructureL_SdpBandwidthAttributesL() + { + CRepository::SetStubGlobal( MusSettingsKeys::KVideoBandwidth, + 128 ); + + // 1. Session without bandwidth attributes. => b=AS and b=TIAS will be + // taken at media level + CMceInSession* inSession = ConstructInSessionLC( 1, 0 ); + + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure b=AS and b=TIAS present at media level only + MDesC8Array* newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + EUNIT_ASSERT( newSdpLines->MdcaCount() == 1 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() ); + + // Ensure b=AS and b=TIAS present at media level + EUNIT_ASSERT( iReceiveSession->iSession->Streams().Count() > 0 ); + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 2 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ).Find( + KMusEngSessionSdpLineBandwidthLine() ) == 0 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 1 ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ); + + + // 2. Session with b=AS bandwidth attribute at session level + // => b=AS and b=TIAS will be taken at session level + delete iReceiveSession->iSession; + iReceiveSession->iSession = NULL; + + inSession = ConstructInSessionLC( 1, 0 ); + //setting session level SDP attributes + CDesC8Array* sdpLines = new ( ELeave ) CDesC8ArrayFlat( 1 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + inSession->SetSessionSDPLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure b=AS and b=TIAS present at session level only + newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 3 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 1 ).Find ( + KMusEngSessionSdpLineBandwidthLine() ) == 0 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 2 ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ); + + EUNIT_ASSERT( iReceiveSession->iSession->Streams().Count() > 0 ); + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 0 ); + + // 3. Session with b=AS bandwidth attribute at media level + // => b=AS and b=TIAS will be taken at media level + delete iReceiveSession->iSession; + iReceiveSession->iSession = NULL; + + inSession = ConstructInSessionLC( 1, 0 ); + //setting media level SDP attributes + sdpLines = new ( ELeave ) CDesC8ArrayFlat( 1 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + inSession->Streams()[ 0 ]->SetMediaAttributeLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure b=AS and b=TIAS present only at media level + newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 1 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() ); + + EUNIT_ASSERT( iReceiveSession->iSession->Streams().Count() > 0 ); + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 2 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ).Find ( + KMusEngSessionSdpLineBandwidthLine() ) == 0 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 1 ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ); + + + // 4. Session with b=AS attribute at session level and + // b=AS and b=TIAS at media level + // => b=AS and b=TIAS will be taken at session and media level + delete iReceiveSession->iSession; + iReceiveSession->iSession = NULL; + + inSession = ConstructInSessionLC( 1, 0 ); + //setting session level SDP attributes + sdpLines = new ( ELeave ) CDesC8ArrayFlat( 1 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + inSession->SetSessionSDPLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + //setting media level SDP attributes + sdpLines = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( sdpLines ); + sdpLines->AppendL( KMusEngSessionSdpLineBandwidthField() ); + sdpLines->AppendL( KMusEngSessionSdpLineTiasLine() ); + inSession->Streams()[ 0 ]->SetMediaAttributeLinesL( sdpLines ); + CleanupStack::Pop( sdpLines ); + + // Transfers ownership + iReceiveSession->iSession = inSession; + CleanupStack::Pop( inSession ); + + iReceiveSession->CompleteSessionStructureL(); + + // Ensure b=AS and b=TIAS present at session and media level + newSdpLines = iReceiveSession->iSession->iSessionSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 3 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 1 ).Find ( + KMusEngSessionSdpLineBandwidthLine() ) == 0 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 2 ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ); + + EUNIT_ASSERT( iReceiveSession->iSession->Streams().Count() > 0 ); + newSdpLines = iReceiveSession->iSession->Streams()[ 0 ]->iMediaSDPLines; + EUNIT_ASSERT( newSdpLines ); + EUNIT_ASSERT( newSdpLines->MdcaCount() == 2 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 0 ).Find ( + KMusEngSessionSdpLineBandwidthLine() ) == 0 ); + EUNIT_ASSERT( newSdpLines->MdcaPoint( 1 ).Find( + KMusEngSessionSdpLineTiasLine() ) == 0 ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_ParseAssertedIdentityL() + { + _LIT8( KMusEngAssertedIdentitySip, "P-Asserted-Identity: sip:fluffy@cisco.com" ); + _LIT8( KMusEngIdentitySip, "fluffy" ); + _LIT8( KMusEngAssertedIdentityTel, "P-Asserted-Identity: tel:+14085264000" ); + _LIT8( KMusEngAssertedIdentityTelBrace, "P-Asserted-Identity: " ); + _LIT8( KMusEngIdentityTel, "+14085264000" ); + _LIT8( KMusEngTestHeader, "Some header" ); + + _LIT8( KMusEngAssertedIdentityInvalid, "P-Asserted-Identity: sip:fluffy cisco.com" ); + + TMceTransactionDataContainer container; + CDesC8Array* headers; + + // only sip uri in asserted identity header + headers = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( headers ); + headers->AppendL( KMusEngTestHeader ); + headers->AppendL( KMusEngAssertedIdentitySip ); + container.SetHeaders( headers ); + CleanupStack::Pop( headers ); + iReceiveSession->ParseAssertedIdentity( &container ); + container.Clear(); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KMusEngIdentitySip ) + + // sip && tel uris in asserted identity headers + headers = new ( ELeave ) CDesC8ArrayFlat( 3 ); + CleanupStack::PushL( headers ); + headers->AppendL( KMusEngTestHeader ); + headers->AppendL( KMusEngAssertedIdentitySip ); + headers->AppendL( KMusEngAssertedIdentityTel ); + container.SetHeaders( headers ); + CleanupStack::Pop( headers ); + iReceiveSession->ParseAssertedIdentity( &container ); + container.Clear(); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KMusEngIdentityTel ) + + // tel uri with braces in asserted identity header + headers = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( headers ); + headers->AppendL( KMusEngTestHeader ); + headers->AppendL( KMusEngAssertedIdentityTelBrace ); + container.SetHeaders( headers ); + CleanupStack::Pop( headers ); + iReceiveSession->ParseAssertedIdentity( &container ); + container.Clear(); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KMusEngIdentityTel ) + + // invalid uri in asserted identity header + headers = new ( ELeave ) CDesC8ArrayFlat( 2 ); + CleanupStack::PushL( headers ); + headers->AppendL( KMusEngTestHeader ); + headers->AppendL( KMusEngAssertedIdentityInvalid ); + container.SetHeaders( headers ); + CleanupStack::Pop( headers ); + iReceiveSession->ParseAssertedIdentity( &container ); + container.Clear(); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KNullDesC8 ) + + // null container + iReceiveSession->ParseAssertedIdentity( NULL ); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KNullDesC8 ) + + // null header + iReceiveSession->ParseAssertedIdentity( &container ); + EUNIT_ASSERT_EQUALS( iReceiveSession->iIdentity, KNullDesC8 ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_ContactSavingLL() + { + ContactEngineStubHelper::Reset(); + + // Saving of contact is done at destruction phase only if originator value + // exists + // + CMusEngReceiveSession* receiveSession = CMusEngReceiveSession::NewL(); + receiveSession->SetLcSessionObserver( iLcSessionObserver ); + delete receiveSession; + receiveSession = NULL; + EUNIT_ASSERT( ContactEngineStubHelper::GetCalledFunction() == EContactEngineStubNone ); + + + User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid, + NMusSessionApi::KContactId, + 2 ) ); + User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid, + NMusSessionApi::KTelNumber, + _L("12341234") ) ); + + receiveSession = CMusEngReceiveSession::NewL(); + CleanupStack::PushL( receiveSession ); + receiveSession->SetLcSessionObserver( iLcSessionObserver ); + delete receiveSession->iOriginator; + receiveSession->iOriginator = NULL; + receiveSession->iOriginator = _L8("sip:yep@10.10.10.10").AllocL(); + CleanupStack::PopAndDestroy( receiveSession ); + if ( ContactEngineStubHelper::GetCalledFunction() != EContactEngineStubSetText ) + { + // out-of-memory was trap ignored and saving failed because of that + User::Leave( KErrNoMemory ); + } + EUNIT_ASSERT( ContactEngineStubHelper::GetCalledFunction() == EContactEngineStubSetText ); + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_IsDisplayActive() + { + // Display is active only if receiving and display is explicitly enabled + CMceInSession* inSession = ConstructInSessionLC( 1, 1 ); + iReceiveSession->iSession = inSession; // Transfers ownership + CleanupStack::Pop( inSession ); + iReceiveSession->EnableDisplayL( ETrue ); + EUNIT_ASSERT( !iReceiveSession->IsDisplayActive() ) + iReceiveSession->iReceiving = ETrue; + EUNIT_ASSERT( iReceiveSession->IsDisplayActive() ) + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void UT_CMusEngReceiveSession::UT_InactivityTimeoutL() + { + // Not receiving, no effect + iReceiveSession->iReceiving = EFalse; + CMceVideoStream* videoStream = CMceVideoStream::NewLC(); + CMceRtpSource* rtpSource = CMceRtpSource::NewLC(); + iReceiveSession->InactivityTimeout( *videoStream, *rtpSource ); + EUNIT_ASSERT( iLcSessionObserver->IsReseted() ); + + // Receiving, state change is notified and + // receiving and buffering status are cleared + iReceiveSession->iBuffered = ETrue; + iReceiveSession->iReceiving = ETrue; + iReceiveSession->InactivityTimeout( *videoStream, *rtpSource ); + EUNIT_ASSERT_EQUALS( iLcSessionObserver->iCalledFunction, + CLcSessionObserverStub::EPlayerStateChanged ); + EUNIT_ASSERT( !iReceiveSession->iReceiving ); + EUNIT_ASSERT( !iReceiveSession->iBuffered ); + CleanupStack::PopAndDestroy( rtpSource ); + CleanupStack::PopAndDestroy( videoStream ); + } + + +// TEST TABLE + +EUNIT_BEGIN_TEST_TABLE( + UT_CMusEngReceiveSession, + "UT_CMusEngReceiveSesssion", + "UNIT" ) + +EUNIT_TEST( + "NewL - test ", + "CMusEngReceiveSession", + "NewL", + "FUNCTIONALITY", + SetupL, UT_NewLL, Teardown) + +EUNIT_TEST( + "LcSessionState - test ", + "CMusEngReceiveSession", + "LcSessionState", + "FUNCTIONALITY", + SetupL, UT_LcSessionStateL, Teardown) + +EUNIT_TEST( + "EstablishLcSessionL - test ", + "CMusEngReceiveSession", + "EstablishLcSessionL", + "FUNCTIONALITY", + SetupL, UT_EstablishLcSessionL, Teardown) + +EUNIT_TEST( + "TerminateLcSessionL - test ", + "CMusEngReceiveSession", + "TerminateLcSessionL", + "FUNCTIONALITY", + SetupL, UT_TerminateLcSessionL, Teardown) + +EUNIT_TEST( + "RemoteVideoPlayer - test ", + "CMusEngReceiveSession", + "RemoteVideoPlayer", + "FUNCTIONALITY", + SetupL, UT_RemoteVideoPlayerL, Teardown) + +EUNIT_TEST( + "RemoteDisplayName - test ", + "CMusEngReceiveSession", + "RemoteDisplayName", + "FUNCTIONALITY", + SetupL, UT_RemoteDisplayName, Teardown) + +EUNIT_TEST( + "HandleSessionStateChanged - test ", + "CMusEngReceiveSession", + "HandleSessionStateChanged", + "FUNCTIONALITY", + SetupL, UT_HandleSessionStateChangedL, Teardown) + +EUNIT_TEST( + "AdjustVideoCodecL - test ", + "CMusEngReceiveSession", + "AdjustVideoCodecL", + "FUNCTIONALITY", + SetupL, UT_AdjustVideoCodecLL, Teardown) + +EUNIT_TEST( + "AdjustAudioCodecL - test ", + "CMusEngReceiveSession", + "AdjustAudioCodecL", + "FUNCTIONALITY", + SetupL, UT_AdjustAudioCodecLL, Teardown) + +EUNIT_TEST( + "DoCodecSelectionL - test ", + "CMusEngReceiveSession", + "DoCodecSelectionL", + "FUNCTIONALITY", + SetupL, UT_DoCodecSelectionLL, Teardown) + +EUNIT_TEST( + "IncomingSession - test ", + "CMusEngReceiveSession", + "IncomingSession", + "FUNCTIONALITY", + SetupL, UT_IncomingSessionL, Teardown) + +EUNIT_TEST( + "IncomingUpdate - test ", + "CMusEngReceiveSession", + "IncomingUpdate", + "FUNCTIONALITY", + SetupL, UT_IncomingUpdateL, Teardown) + +EUNIT_TEST( + "StreamStateChanged - test ", + "CMusEngReceiveSession", + "StreamStateChanged", + "FUNCTIONALITY", + SetupL, UT_StreamStateChangedL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithoutSessionL - test without a session", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithoutSessionL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithoutStreamsL - without streams", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithoutStreamsL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithOutgoingStreamL - with outgoing stream", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithOutgoingStreamL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithVideoInL - with video in stream", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithVideoInL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithVideoOutBoundToVideoInL - with sendrecv video, video out bound to video in", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithVideoOutBoundToVideoInL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithVideoInBoundToVideoOutL - with sendrecv video, video in bound to video out", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithVideoInBoundToVideoOutL, Teardown) + +EUNIT_TEST( + "UT_CompleteSessionStructureL_WithMultipleVideoInsL - with multiple video in streams", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithMultipleVideoInsL, Teardown) + +EUNIT_TEST( + "CompleteSessionStructureL - test one video and multiple audio streams", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_WithVideoAndMultipleAudioInsL, Teardown) + +EUNIT_TEST( + "CompleteSessionStructureL - test operator variant", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_OperatorVariant, Teardown) + +EUNIT_TEST( + "CompleteSessionStructureL - test SDP bandwidth attributes handling", + "CMusEngReceiveSession", + "CompleteSessionStructureL", + "FUNCTIONALITY", + SetupL, UT_CompleteSessionStructureL_SdpBandwidthAttributesL, Teardown) + +EUNIT_TEST( + "ParseAssertedIdentity", + "CMusEngReceiveSession", + "ParseAssertedIdentity", + "FUNCTIONALITY", + SetupL, UT_ParseAssertedIdentityL, Teardown) + +EUNIT_TEST( + "ContactSavingL - test", + "CMusEngReceiveSession", + "ContactSavingL", + "FUNCTIONALITY", + SetupL, UT_ContactSavingLL, Teardown) + +EUNIT_TEST( + "IsDisplayActive - test", + "CMusEngReceiveSession", + "IsDisplayActive", + "FUNCTIONALITY", + SetupL, UT_IsDisplayActive, Teardown) + +EUNIT_TEST( + "InactivityTimeout - test ", + "CMusEngReceiveSession", + "InactivityTimeout", + "FUNCTIONALITY", + SetupL, UT_InactivityTimeoutL, Teardown) + +EUNIT_END_TEST_TABLE + +// END OF FILE + +