--- /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 <digia/eunit/eunitmacros.h>
+
+#include <mceinsession.h>
+#include <mcestreambundle.h>
+#include <mcevideostream.h>
+#include <mceaudiostream.h>
+#include <mcertpsource.h>
+#include <mcedisplaysink.h>
+#include <mcespeakersink.h>
+#include <mcecamerasource.h>
+#include <mcefilesource.h>
+#include <mcertpsink.h>
+#include <mceaudiocodec.h>
+#include <mceh263codec.h>
+#include <mceavccodec.h>
+
+#include <audiopreference.h>
+#include <centralrepository.h>
+
+
+// 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<CMceRtpSource*>( 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<CMceSpeakerSink*>(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<CMceSpeakerSink*>(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<CMceSpeakerSink*>
+ (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: <tel:+14085264000>" );
+ _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
+
+