/*
* 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_musengmcesession.h"
#include "musengstubs.h"
#include "musengtestdefs.h"
#include "mussettings.h"
#include "musenglivesession.h"
#include "musengclipsession.h"
#include "musengreceivesession.h"
#include "musengsessiondurationtimer.h"
#include "musengtelephoneutils.h"
#include "musengmceutils.h"
// SYSTEM INCLUDES
#include <digia/eunit/eunitmacros.h>
#include <mceinsession.h>
#include <mcevideostream.h>
#include <mcedisplaysink.h>
#include <mcertpsource.h>
#include <mcespeakersink.h>
#include <mceaudiostream.h>
#include <mcertpsink.h>
#include <mcevideocodec.h>
#include <mceaudiocodec.h>
#include <audiopreference.h>
#include <mceh263codec.h>
#include <mceavccodec.h>
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
UT_CMusEngMceSession* UT_CMusEngMceSession::NewL()
{
UT_CMusEngMceSession* self = UT_CMusEngMceSession::NewLC();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
UT_CMusEngMceSession* UT_CMusEngMceSession::NewLC()
{
UT_CMusEngMceSession* self = new( ELeave ) UT_CMusEngMceSession();
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
UT_CMusEngMceSession::~UT_CMusEngMceSession()
{
// NOP
}
// -----------------------------------------------------------------------------
// Default constructor
// -----------------------------------------------------------------------------
//
UT_CMusEngMceSession::UT_CMusEngMceSession()
{
// NOP
}
// -----------------------------------------------------------------------------
// Second phase construct
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::ConstructL()
{
// The ConstructL from the base class CEUnitTestSuiteClass must be called.
// It generates the test case table.
CEUnitTestSuiteClass::ConstructL();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::SetupL( )
{
iObserver = new( ELeave ) CMusEngObserverStub;
iLiveSession = CMusEngLiveSession::NewL( KNullDesC,
TRect(0,0, 100,100),
*iObserver,
*iObserver,
*iObserver );
iSomeOtherSession = CMusEngLiveSession::NewL( KNullDesC,
TRect(0,0, 100,100),
*iObserver,
*iObserver,
*iObserver );
ESTABLISH_OUT_SESSION( iSomeOtherSession );
iClipSession = CMusEngClipSession::NewL( TRect(0,0, 100,100),
*iObserver,
*iObserver,
*iObserver );
iClipSession->SetClipL( KTestVideoFileName() );
TBuf<50> videoCodec;
videoCodec.Copy( KMceSDPNameH264() );
iClipSession->SetSupportedVideoCodecListL(videoCodec);
// Construct and establish an incoming session
iReceiveSession = CMusEngReceiveSession::NewL( TRect(0,0, 100,100),
*iObserver,
*iObserver );
CMceInSession* inSession = CMceInSession::NewL( *iReceiveSession->iManager,
KTestOriginator() );
CMceVideoStream* videoStream = CMceVideoStream::NewLC();
videoStream->SetSourceL( CMceRtpSource::NewLC() );
CleanupStack::Pop();
inSession->AddStreamL( videoStream );
CleanupStack::Pop( videoStream );
iReceiveSession->iManager->iInSessionObserver->IncomingSession(
inSession,
&iContainer );
iReceiveSession->iSession->iState = CMceSession::EProceeding;
iReceiveSession->AcceptInvitationL( ETrue );
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::Teardown( )
{
delete iLiveSession;
delete iClipSession;
delete iReceiveSession;
delete iObserver;
delete iSomeOtherSession;
}
// TEST CASES
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_TerminateLL()
{
TRAPD( error, iLiveSession->TerminateL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
ESTABLISH_OUT_SESSION( iLiveSession );
EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::EEstablished );
iLiveSession->TerminateL();
EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::ETerminating );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_GetSessionTimeL()
{
EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );
// Invite
iLiveSession->InviteL( KTestRecipientSipUri );
EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );
// Simulate establishment
iLiveSession->iSession->iState = CMceSession::EEstablished;
iLiveSession->iStartTime.HomeTime();
TTimeIntervalSeconds sessionTime = iLiveSession->GetSessionTime();
EUNIT_ASSERT( sessionTime >= TTimeIntervalSeconds( 0 ) );
}
void UT_CMusEngMceSession::UT_CMusEngMceSession_IsDisplayEnabledLL()
{
TRAPD( error, iLiveSession->IsDisplayEnabledL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
ESTABLISH_OUT_SESSION( iLiveSession );
//Enable
CMceDisplaySink* display =
MusEngMceUtils::GetDisplayL( *(iLiveSession->iSession) );
display->iIsEnabled = ETrue;
EUNIT_ASSERT( iLiveSession->IsDisplayEnabledL() );
//Disable
display->iIsEnabled = EFalse;
EUNIT_ASSERT( !iLiveSession->IsDisplayEnabledL() );
// Display is reported as disabled when session state is terminated or idle
iLiveSession->iSession->iState = CMceSession::ETerminated;
display->iIsEnabled = ETrue;
EUNIT_ASSERT( !iLiveSession->IsDisplayEnabledL() );
iLiveSession->iSession->iState = CMceSession::EIdle;
EUNIT_ASSERT( !iLiveSession->IsDisplayEnabledL() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_ConnectionActiveL()
{
EUNIT_ASSERT( !iLiveSession->ConnectionActive() );
ESTABLISH_OUT_SESSION( iLiveSession );
EUNIT_ASSERT( iLiveSession->ConnectionActive() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_ContainsAudioLL()
{
// Try without session, fails
EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->ContainsAudioL(), KErrNotReady )
// Establish session without audio
ESTABLISH_OUT_SESSION( iLiveSession )
EUNIT_ASSERT( !iLiveSession->ContainsAudioL() )
// Establish session with audio
ESTABLISH_OUT_SESSION( iClipSession )
EUNIT_ASSERT( iClipSession->ContainsAudioL() )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_IsMutedLL()
{
// Try without session, fails
EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->IsMutedL(), KErrNotReady )
// Establish session without audio
ESTABLISH_OUT_SESSION( iLiveSession )
EUNIT_ASSERT( iLiveSession->IsMutedL() )
// Establish session with audio
ESTABLISH_OUT_SESSION( iClipSession )
EUNIT_ASSERT( !iClipSession->IsMutedL() ) // Not muted although disabled
iClipSession->EnableDisplayL( ETrue ); // Enabled also speaker
EUNIT_ASSERT( !iClipSession->IsMutedL() ) // Enabled and not muted
iClipSession->MuteL();
EUNIT_ASSERT( iClipSession->IsMutedL() ) // Explicitly muted
iClipSession->UnmuteL();
EUNIT_ASSERT( !iClipSession->IsMutedL() ) // Explicitly unmuted
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_OrientationLL()
{
// Try without session, fails
EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->OrientationL(), KErrNotReady )
// Establish a session and try all the MCE rotation values
ESTABLISH_OUT_SESSION( iLiveSession )
CMceDisplaySink* display =
MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );
display->iRotation = CMceDisplaySink::ENone;
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::EPortrait )
display->iRotation = CMceDisplaySink::EClockwise90Degree;
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::ELandscape )
display->iRotation = CMceDisplaySink::EClockwise180Degree;
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::ELandscape )
display->iRotation = CMceDisplaySink::EClockwise270Degree;
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::ELandscape )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SetOrientationLL()
{
// Try without session, fails
EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->SetOrientationL(
CMusEngMceSession::EPortrait ),
KErrNotReady )
// Establish a session
ESTABLISH_OUT_SESSION( iLiveSession )
CMceDisplaySink* display =
MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );
// Check the initial state
display->iRotation = CMceDisplaySink::ENone;
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::EPortrait )
// Successfully change orientation
iLiveSession->SetOrientationL( CMusEngMceSession::ELandscape );
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::ELandscape )
iLiveSession->SetOrientationL( CMusEngMceSession::EPortrait );
EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(),
CMusEngMceSession::EPortrait )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeUpLL()
{
// Try without session, fails
TRAPD( error, iLiveSession->VolumeUpL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
// Test only usage of CMceSpeaker, phone part is tested in base class
// Check that nothing crashes without any speakers
iReceiveSession->VolumeUpL();
// Establish session
ESTABLISH_OUT_SESSION( iClipSession )
TInt initialVolume = iClipSession->VolumeL();
iClipSession->VolumeUpL();
// Check that all speaker volumes are adjusted and store one speaker pointer
CMceSpeakerSink* speaker = NULL;
CMceSession* session = iClipSession->iSession;
for ( TInt i = 0; i < session->Streams().Count(); ++i )
{
for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )
{
if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
speaker = static_cast<CMceSpeakerSink*>(
session->Streams()[i]->Sinks()[j] );
EUNIT_ASSERT( speaker->VolumeL() == initialVolume + 1 );
}
}
}
while ( iClipSession->VolumeL() < speaker->MaxVolumeL() )
{
iClipSession->VolumeUpL();
}
iClipSession->VolumeUpL(); // Does not do anything to volume
EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeDownLL()
{
// Try without session, fails
TRAPD( error, iLiveSession->VolumeDownL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
// Test only usage of CMceSpeaker, phone part is tested in base class
// Check that nothing crashes without any speakers
iReceiveSession->VolumeUpL();
// Establish session
ESTABLISH_OUT_SESSION( iClipSession )
TInt initialVolume = iClipSession->VolumeL();
iClipSession->VolumeDownL();
// Check that all speaker volumes are adjusted and store one speaker pointer
CMceSpeakerSink* speaker = NULL;
CMceSession* session = iClipSession->iSession;
for ( TInt i = 0; i < session->Streams().Count(); ++i )
{
for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )
{
if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
speaker = static_cast<CMceSpeakerSink*>(
session->Streams()[i]->Sinks()[j] );
EUNIT_ASSERT( speaker->VolumeL() == initialVolume - 1 );
}
}
}
while ( iClipSession->VolumeL() > 0 )
{
iClipSession->VolumeDownL();
}
iClipSession->VolumeDownL(); // Does not do anything to volume
EUNIT_ASSERT_EQUALS( iClipSession->VolumeL(), 0 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SetVolumeLL()
{
// Try without session, fails
TInt newVolume = KTelephonyVolumeDefaultValue + 1;
TRAPD( error, iLiveSession->SetVolumeL( newVolume ) );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
// Test only usage of CMceSpeaker, phone part is tested in base class
// Check that nothing crashes without any speakers
iReceiveSession->SetVolumeL( newVolume );
// Establish session
ESTABLISH_OUT_SESSION( iClipSession )
TInt initialVolume = iClipSession->VolumeL();
iClipSession->SetVolumeL( newVolume );
// Check that all speaker volumes are adjusted and store one speaker pointer
CMceSpeakerSink* speaker = NULL;
CMceSession* session = iClipSession->iSession;
for ( TInt i = 0; i < session->Streams().Count(); ++i )
{
for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )
{
if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
speaker = static_cast<CMceSpeakerSink*>(
session->Streams()[i]->Sinks()[j] );
EUNIT_ASSERT( speaker->VolumeL() == newVolume );
}
}
}
newVolume = speaker->MaxVolumeL() + 1;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );
newVolume = -1;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == 0 );
// Test situation where MCE max volume is bigger than MUS max vol
SetMaxVolForSpeakersL(*session, KMusEngMaxVolume * 10);
newVolume = 5;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );
newVolume = 1;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );
newVolume = KMusEngMaxVolume;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );
SetMaxVolForSpeakersL(*session, KMusEngMaxVolume * 1000);
newVolume = 7;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );
newVolume = 1;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );
newVolume = KMusEngMaxVolume;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );
// Test situation where MCE max volume is smaller than MUS max vol
SetMaxVolForSpeakersL(*session, KMusEngMaxVolume / 2);
newVolume = 3;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume / 2 );
newVolume = 1;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == 1 );
newVolume = KMusEngMaxVolume;
iClipSession->SetVolumeL( newVolume );
EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );
EUNIT_ASSERT( speaker->VolumeL() == newVolume / 2 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_EnableDisplayL()
{
TRAPD( error, iLiveSession->EnableDisplayL( ETrue ) );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
ESTABLISH_OUT_SESSION( iLiveSession );
CMceDisplaySink* display =
MusEngMceUtils::GetDisplayL( *(iLiveSession->iSession) );
// Disable
iLiveSession->EnableDisplayL( EFalse );
EUNIT_ASSERT( !display->iIsEnabled );
// Try to disable again, request should be ignored
iLiveSession->EnableDisplayL( EFalse );
EUNIT_ASSERT( !display->iIsEnabled );
// Enable
iLiveSession->EnableDisplayL( ETrue );
EUNIT_ASSERT( display->iIsEnabled );
// Try to enable again, request should be ignored
iLiveSession->EnableDisplayL( ETrue );
EUNIT_ASSERT( display->iIsEnabled );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_MuteLL()
{
TRAPD( error, iClipSession->MuteL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
ESTABLISH_OUT_SESSION_AND_START_STREAMING( iClipSession );
const RPointerArray<CMceMediaStream> streams =
iClipSession->iSession->Streams();
iClipSession->MuteL();
// Check that all audio speaker sinks are disabled and only those
for ( TInt i = 0; i < streams.Count(); ++i )
{
for ( TInt j = 0; j < streams[i]->Sinks().Count(); ++j )
{
CMceMediaSink* sink = streams[i]->Sinks()[j];
if ( sink->Type() == KMceSpeakerSink &&
streams[i]->Type() == KMceAudio )
{
EUNIT_ASSERT( sink->IsEnabled() == EFalse )
}
else
{
EUNIT_ASSERT( sink->IsEnabled() == ETrue )
}
}
}
EUNIT_ASSERT( iClipSession->iExplicitlyMuted )
// Try to mute again, request should be ignored without actions or leaving
iClipSession->MuteL();
}
// -----------------------------------------------------------------------------
// Relies on previous test
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_UnmuteLL()
{
TRAPD( error, iClipSession->UnmuteL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
ESTABLISH_OUT_SESSION( iClipSession );
const RPointerArray<CMceMediaStream> streams =
iClipSession->iSession->Streams();
iClipSession->MuteL();
iClipSession->UnmuteL();
// Check that all audio speaker sinks are enabled
for ( TInt i = 0; i < streams.Count(); ++i )
{
for ( TInt j = 0; j < streams[i]->Sinks().Count(); ++j )
{
if ( streams[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
EUNIT_ASSERT( streams[i]->Sinks()[j]->IsEnabled() == ETrue )
}
}
}
EUNIT_ASSERT( !iClipSession->iExplicitlyMuted )
// Try to unmute again, request should be ignored without actions or leaving
iClipSession->UnmuteL();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_HandleTerminationL()
{
// Try different values
iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCodeNoCodeSet,
KNullDesC8() );
EUNIT_ASSERT( iObserver->iSessionTerminatedCalled );
iObserver->Reset();
iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCode200OK,
KNullDesC8() );
EUNIT_ASSERT( iObserver->iSessionTerminatedCalled );
iObserver->Reset();
iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCodeUnknown,
KNullDesC8() );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustVideoCodecLL()
{
// CMusEngMceSession::AdjustVideoCodecL does nothing, so NULL test is enough
CMceVideoCodec* codec =
iLiveSession->iManager->SupportedVideoCodecs()[0]->CloneL();
CleanupStack::PushL( codec );
iLiveSession->CMusEngMceSession::AdjustVideoCodecL( *codec );
CleanupStack::PopAndDestroy( codec );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustAudioCodecLL()
{
CMceAudioCodec* codec =
iLiveSession->iManager->SupportedAudioCodecs()[0]->CloneL();
CleanupStack::PushL( codec );
iLiveSession->CMusEngMceSession::AdjustAudioCodecL( *codec );
EUNIT_ASSERT( codec->iMMFPriority == KAudioPrioritySwisPlayback )
EUNIT_ASSERT( codec->iMMFPriorityPreference == KAudioPrefSwisPlayback )
CleanupStack::PopAndDestroy( codec );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_RectChangedLL()
{
// Does nothing before session establishment
iLiveSession->RectChangedL();
ESTABLISH_OUT_SESSION( iLiveSession );
// Next leads to a call to RectChangedL()
iLiveSession->SetRectL( TRect( 100, 200, 300, 400 ) );
// Display size has been updated
CMceDisplaySink* display =
MusEngMceUtils::GetDisplayL( *( iLiveSession->iSession ) );
EUNIT_ASSERT( display->DisplayRectL() == iLiveSession->Rect() );
// Terminate session and try again, rect must not be changed
iLiveSession->iSession->iState = CMceSession::ETerminated;
TRect newRect( 200, 300, 400, 500 );
iLiveSession->SetRectL( newRect );
EUNIT_ASSERT( display->DisplayRectL() != newRect )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SetSessionSdpLinesLL()
{
// set operator variant off
MultimediaSharingSettings::SetOperatorVariantSettingL(
MusSettingsKeys::EStandard );
// There is no sdp lines in session, right one is added
CMceInSession* inSession = CMceInSession::NewL( *iReceiveSession->iManager,
KTestOriginator );
CleanupStack::PushL( inSession );
iReceiveSession->SetSessionSdpLinesL( *inSession );
MDesC8Array* sdpLines = inSession->SessionSDPLinesL();
CleanupDeletePushL( sdpLines );
EUNIT_ASSERT( sdpLines );
EUNIT_ASSERT( sdpLines->MdcaCount() == 1 );
EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() );
CleanupStack::PopAndDestroy(); // sdplines
// There is one line ready, replace it with right one
CDesC8Array* newSdpLines = new ( ELeave ) CDesC8ArrayFlat( 3 );
CleanupStack::PushL( newSdpLines );
newSdpLines->AppendL( KTestRecipientRandomText8() );
inSession->SetSessionSDPLinesL( newSdpLines );
CleanupStack::Pop( newSdpLines );
iReceiveSession->SetSessionSdpLinesL( *inSession );
sdpLines = inSession->SessionSDPLinesL();
CleanupDeletePushL( sdpLines );
EUNIT_ASSERT( sdpLines );
EUNIT_ASSERT( sdpLines->MdcaCount() == 1 );
EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() );
CleanupStack::PopAndDestroy(); // sdplines
CleanupStack::PopAndDestroy( inSession );
// for operator variant testing
// set operator variant
iReceiveSession->iOperatorVariant = ETrue;
// There is no sdp lines in session, right ones are added to session and media level
inSession = CMceInSession::NewL( *iReceiveSession->iManager,
KTestOriginator );
CleanupStack::PushL( inSession );
iReceiveSession->SetSessionSdpLinesL( *inSession );
sdpLines = inSession->SessionSDPLinesL();
CleanupDeletePushL( sdpLines );
EUNIT_ASSERT( sdpLines );
EUNIT_ASSERT( sdpLines->MdcaCount() == 2 );
EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineApplication() );
EUNIT_ASSERT( sdpLines->MdcaPoint( 1 ) == KMusEngSessionSdpLineType() );
CleanupStack::PopAndDestroy(); // sdplines
MDesC8Array* mediaSdpLines =
iReceiveSession->iSession->Streams()[ 0 ]->MediaAttributeLinesL();
CleanupDeletePushL( mediaSdpLines );
TBool bandwidthFoundFromMediaLevel = EFalse;
for ( TInt i = 0; mediaSdpLines && i < mediaSdpLines->MdcaCount(); i++ )
{
if ( mediaSdpLines->MdcaPoint( i ).Compare(
KMusEngSessionSdpLineBandwidthField() ) == 0 )
{
bandwidthFoundFromMediaLevel = ETrue;
}
}
EUNIT_ASSERT( bandwidthFoundFromMediaLevel );
CleanupStack::PopAndDestroy( mediaSdpLines );
// There is one line ready, replace it with right ones
newSdpLines = new ( ELeave ) CDesC8ArrayFlat( 3 );
CleanupStack::PushL( newSdpLines );
newSdpLines->AppendL( KTestRecipientRandomText8() );
inSession->SetSessionSDPLinesL( newSdpLines );
CleanupStack::Pop( newSdpLines );
iReceiveSession->SetSessionSdpLinesL( *inSession );
sdpLines = inSession->SessionSDPLinesL();
CleanupDeletePushL( sdpLines );
EUNIT_ASSERT( sdpLines );
EUNIT_ASSERT( sdpLines->MdcaCount() == 2 );
EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineApplication() );
EUNIT_ASSERT( sdpLines->MdcaPoint( 1 ) == KMusEngSessionSdpLineType() );
CleanupStack::PopAndDestroy(); // sdplines
CleanupStack::PopAndDestroy( inSession );
// set operator variant off
MultimediaSharingSettings::SetOperatorVariantSettingL(
MusSettingsKeys::EStandard );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustStreamsAndCodecsLL()
{
// Check that function cannot be called before creating the session
TRAPD( error, iClipSession->AdjustStreamsAndCodecsL() );
MUS_TEST_FORWARD_ALLOC_FAILURE( error );
EUNIT_ASSERT( error == KErrNotReady );
// Establishing a clip session leads to call to AdjustStreamsAndCodecsL
ESTABLISH_OUT_SESSION( iClipSession )
const RPointerArray<CMceMediaStream>& streams =
iClipSession->iSession->Streams();
TBool videoCodecFound = EFalse;
TBool audioCodecFound = EFalse;
// Test that AdjustVideoCodecL and AdjustAudioCodecL have been called
CMceVideoStream* videoStream = NULL;
for ( TInt i = 0; i < streams.Count(); ++i )
{
if ( streams[i]->Type() == KMceAudio )
{
CMceAudioStream* audioStream =
static_cast<CMceAudioStream*>( streams[i] );
const RPointerArray<CMceAudioCodec>& codecs = audioStream->Codecs();
for ( TInt i = 0; i < codecs.Count(); ++i )
{
audioCodecFound = ETrue;
EUNIT_ASSERT( codecs[i]->MMFPriority() ==
KAudioPrioritySwisPlayback )
EUNIT_ASSERT( codecs[i]->MMFPriorityPreference() ==
KAudioPrefSwisPlayback )
}
}
else
{
videoStream = static_cast<CMceVideoStream*>( streams[i] );
const RPointerArray<CMceVideoCodec>& codecs = videoStream->Codecs();
for ( TInt i = 0; i < codecs.Count(); ++i )
{
videoCodecFound = ETrue;
EUNIT_ASSERT( codecs[i]->iPayloadType == 96 ||
codecs[i]->iPayloadType == 98 )
}
}
}
EUNIT_ASSERT( audioCodecFound ) // At least one audiocodec found
EUNIT_ASSERT( videoCodecFound ) // At least one videocodec found
// Test removing of H.263 multiples (mode 2000 preferred)
EUNIT_ASSERT( videoStream != NULL )
for ( TInt i = videoStream->Codecs().Count() - 1; i >= 0; i-- )
{
videoStream->RemoveCodecL(
*const_cast<CMceVideoCodec*>( videoStream->Codecs()[ i ] ) );
}
CMceH263Codec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );
videoStream->AddCodecL( codecH2632000 );
CleanupStack::Pop( codecH2632000 );
CMceH263Codec* codecH2631998 = CMceH263Codec::NewLC( KMceSDPNameH2631998() );
videoStream->AddCodecL( codecH2631998 );
CleanupStack::Pop( codecH2631998 );
iClipSession->AdjustStreamsAndCodecsL();
// 1998 version should have been removed
for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )
{
EUNIT_ASSERT(
!videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH2632000() ) );
}
// Test removing of multiples with different bitrates
for ( TInt i = videoStream->Codecs().Count() - 1; i >= 0; i-- )
{
videoStream->RemoveCodecL(
*const_cast<CMceVideoCodec*>( videoStream->Codecs()[ i ] ) );
}
codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );
codecH2632000->SetMaxBitrateL( 64000 );
videoStream->AddCodecL( codecH2632000 );
CleanupStack::Pop( codecH2632000 );
codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );
codecH2632000->SetMaxBitrateL( 128000 );
videoStream->AddCodecL( codecH2632000 );
CleanupStack::Pop( codecH2632000 );
iClipSession->AdjustStreamsAndCodecsL();
// Lower bitrate version should have been removed
for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )
{
EUNIT_ASSERT(
videoStream->Codecs()[ i ]->MaxBitRate() == 128000 );
}
// Test for Configuration based codec removal. Magic uid not set.
CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );
videoStream->AddCodecL( codecAvc );
CleanupStack::Pop( codecAvc );
iClipSession->AdjustStreamsAndCodecsL();
TBool avcCodecFound(EFalse);
for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )
{
if( !videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH264 ) )
{
avcCodecFound = ETrue;
}
}
// AVC should present
EUNIT_ASSERT(avcCodecFound);
// Test for Configuration based codec removal. Magic uid set.
// Store the real value and revert back later , so that other tests will not be affected.
TUid uid = MultimediaSharingSettings::EncodingDeviceL();
TInt32 KMusDisableAVC = 0x0fffffff;
MultimediaSharingSettings::SetPropertyValueL( MusSettingsKeys::KEncodingDevice,KMusDisableAVC);
codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );
videoStream->AddCodecL( codecAvc );
CleanupStack::Pop( codecAvc );
codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );
videoStream->AddCodecL( codecH2632000 );
CleanupStack::Pop( codecH2632000 );
iClipSession->AdjustStreamsAndCodecsL();
for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )
{
// H264 ( AVC ) codec should be removed
EUNIT_ASSERT(
videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH264 ) );
}
MultimediaSharingSettings::SetPropertyValueL( MusSettingsKeys::KEncodingDevice,uid.iUid);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_IncomingSessionL()
{
// New session should get rejected and deleted in any case, first failure
CMceInSession* inSession = CMceInSession::NewL(
*iLiveSession->iManager, KNullDesC8 );
CleanupStack::PushL( inSession );
iLiveSession->IncomingSession( inSession, NULL );
CleanupStack::Pop( inSession );
// And then succesfull case, this would leak memory if session was not
// deleted
inSession = CMceInSession::NewL( *iLiveSession->iManager, KNullDesC8 );
CleanupStack::PushL( inSession );
iLiveSession->IncomingSession( inSession, NULL );
CleanupStack::Pop( inSession );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_IncomingUpdateL()
{
CMceInSession* inSession = CMceInSession::NewL(
*iLiveSession->iManager, KNullDesC8 );
// Try to update before having a session, session gets rejected and deleted
CleanupStack::PushL( inSession );
iLiveSession->IncomingUpdate( *inSession, inSession, NULL );
CleanupStack::Pop( inSession );
// Try to update with unknown session, session gets rejected and deleted
ESTABLISH_OUT_SESSION( iLiveSession )
inSession = CMceInSession::NewL(
*iLiveSession->iManager, KNullDesC8 );
CleanupStack::PushL( inSession );
iLiveSession->IncomingUpdate( *inSession, inSession, NULL );
CleanupStack::Pop( inSession );
// Normal case, old session gets deleted. New session gets rejected.
inSession = CMceInSession::NewL(
*iLiveSession->iManager, KNullDesC8 );
CleanupStack::PushL( inSession );
iLiveSession->IncomingUpdate( *iLiveSession->iSession, inSession, NULL );
CleanupStack::Pop( inSession );
EUNIT_ASSERT( iLiveSession->iSession == inSession )
EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::ETerminated )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_StreamStateChangedL()
{
// Try without a session, nothing happens
CMceAudioStream* audioStream = CMceAudioStream::NewLC();
iLiveSession->CMusEngMceSession::StreamStateChanged( *audioStream );
CleanupStack::PopAndDestroy( audioStream );
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// No observer set, so expect nothing to be done, cannot be asserted
CMceMediaStream* changedStream = iLiveSession->iSession->Streams()[0];
// Try all the stream states
// EUninitialized, stream is created, unexpected change, nothing happens
changedStream->iState = CMceMediaStream::EUninitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EInitialized, stream is initialized
changedStream->iState = CMceMediaStream::EInitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EBuffering, stream is buffering
changedStream->iState = CMceMediaStream::EBuffering;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EIdle, stream is not receiving RTP
changedStream->iState = CMceMediaStream::EIdle;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamIdleCalled );
// EStreaming, stream is streaming
changedStream->iState = CMceMediaStream::EStreaming;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamStreamingCalled );
iObserver->Reset();
// EStreaming, stream is streaming, other than video out- or instream
changedStream->iState = CMceMediaStream::EStreaming;
iLiveSession->CMusEngMceSession::StreamStateChanged(
*iLiveSession->iSession->Streams()[1] );
EUNIT_ASSERT( iObserver->IsReseted() );
iObserver->Reset();
// EDisabled, stream is explicitly disabled
changedStream->iState = CMceMediaStream::EDisabled;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ENoResources, stream has no needed resources to stream
changedStream->iState = CMceMediaStream::ENoResources;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscodingRequired, stream requires non-realtime transcoding
changedStream->iState = CMceMediaStream::ETranscodingRequired;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscoding, stream is transcoding in non-realtime
changedStream->iState = CMceMediaStream::ETranscoding;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
}
// -----------------------------------------------------------------------------
// All the possibilities are tested in order to make sure unit tests are changed
// when function is changed
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_StreamStateChangedWithSourceL()
{
// Try without a session, nothing happens
iLiveSession->CMusEngMceSession::StreamStateChanged(
*CMceAudioStream::NewLC(),
*CMceRtpSource::NewLC() );
CleanupStack::PopAndDestroy(); // rtp
CleanupStack::PopAndDestroy(); // audiostream
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// Try all the stream states
CMceMediaStream* changedStream = iLiveSession->iSession->Streams()[0];
// EUninitialized, stream is created, unexpected change, nothing happens
changedStream->iState = CMceMediaStream::EUninitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EInitialized, stream is initialized
changedStream->iState = CMceMediaStream::EInitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EBuffering, stream is buffering
changedStream->iState = CMceMediaStream::EBuffering;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EIdle, stream is not receiving RTP
changedStream->iState = CMceMediaStream::EIdle;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamIdleCalled );
// EStreaming, stream is streaming
changedStream->iState = CMceMediaStream::EStreaming;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamStreamingCalled );
iObserver->Reset();
// EDisabled, stream is explicitly disabled
changedStream->iState = CMceMediaStream::EDisabled;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ENoResources, stream has no needed resources to stream
changedStream->iState = CMceMediaStream::ENoResources;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscodingRequired, stream requires non-realtime transcoding
changedStream->iState = CMceMediaStream::ETranscodingRequired;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscoding, stream is transcoding in non-realtime
changedStream->iState = CMceMediaStream::ETranscoding;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
}
// -----------------------------------------------------------------------------
// All the possibilities are tested in order to make sure unit tests are changed
// when function is changed
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_StreamStateChangedWithSinkL()
{
// Try without a session, nothing happens
CMceAudioStream* audioStream = CMceAudioStream::NewLC();
iLiveSession->CMusEngMceSession::StreamStateChanged( *audioStream );
CleanupStack::PopAndDestroy( audioStream );
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// Try all the stream states
CMceMediaStream* changedStream = iLiveSession->iSession->Streams()[0];
// EUninitialized, stream is created, unexpected change, nothing happens
changedStream->iState = CMceMediaStream::EUninitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EInitialized, stream is initialized
changedStream->iState = CMceMediaStream::EInitialized;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EBuffering, stream is buffering
changedStream->iState = CMceMediaStream::EBuffering;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// EIdle, stream is not receiving RTP
changedStream->iState = CMceMediaStream::EIdle;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamIdleCalled );
// EStreaming, stream is streaming
changedStream->iState = CMceMediaStream::EStreaming;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->iStreamStreamingCalled );
iObserver->Reset();
// EDisabled, stream is explicitly disabled
changedStream->iState = CMceMediaStream::EDisabled;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ENoResources, stream has no needed resources to stream
changedStream->iState = CMceMediaStream::ENoResources;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscodingRequired, stream requires non-realtime transcoding
changedStream->iState = CMceMediaStream::ETranscodingRequired;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
// ETranscoding, stream is transcoding in non-realtime
changedStream->iState = CMceMediaStream::ETranscoding;
iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );
EUNIT_ASSERT( iObserver->IsReseted() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SessionStateChangedL()
{
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// No container, so expect to be handled as internal error
iLiveSession->SessionStateChanged( *iLiveSession->iSession, NULL );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
// Try to tell session about some other session's state transition
TMceTransactionDataContainer container;
iLiveSession->SessionStateChanged( *iSomeOtherSession->iSession, &container );
EUNIT_ASSERT( iObserver->IsReseted() );
// Try all the normal cases:
// EIdle
iLiveSession->iSession->iState = CMceSession::EIdle;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
// Set up any text to simulate reasonphrase
HBufC8* anyReasonPhrase = KTestOriginator().AllocL();
container.SetReasonPhrase( anyReasonPhrase );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
container.Clear();
// EOffering
iLiveSession->iSession->iState = CMceSession::EOffering;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
// EIncoming
iLiveSession->iSession->iState = CMceSession::EIncoming;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
// EReserving
iLiveSession->iSession->iState = CMceSession::EReserving;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
// EAnswering
iLiveSession->iSession->iState = CMceSession::EAnswering;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
// EProceeding
iLiveSession->iSession->iState = CMceSession::EProceeding;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
// EEstablished
iLiveSession->iSession->iState = CMceSession::EEstablished;
container.SetStatusCode( KSipStatusCode200OK );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->iSessionEstablishedCalled );
iObserver->Reset();
// EEstablished again (meaning expiration of session timer
// and refresment of session )
iLiveSession->iSession->iState = CMceSession::EEstablished;
container.SetStatusCode( KSipStatusCode200OK );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
// ECancelling
iLiveSession->iSession->iState = CMceSession::ECancelling;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
iObserver->Reset();
// ETerminating
iLiveSession->iSession->iState = CMceSession::ETerminating;
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->IsReseted() );
iObserver->Reset();
// ETerminated
iLiveSession->iSession->iState = CMceSession::ETerminated;
container.SetStatusCode( KSipStatusCode200OK );
iLiveSession->SessionStateChanged( *iLiveSession->iSession,
&container );
EUNIT_ASSERT( iObserver->iSessionTerminatedCalled );
iObserver->Reset();
// Default case
iLiveSession->iSession->iState = static_cast<CMceSession::TState>( 10 );
container.SetStatusCode( KSipStatusCodeNoCodeSet );
iLiveSession->SessionStateChanged( *iLiveSession->iSession, &container );
EUNIT_ASSERT( iObserver->IsReseted() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SessionConnectionStateChangedL()
{
// Try to tell session about another session's connection state change
iLiveSession->SessionConnectionStateChanged( *iSomeOtherSession->iSession,
ETrue );
EUNIT_ASSERT( iObserver->IsReseted() ); // No session yet, nothing happened
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// Now try again to notify session about session connection state change
// of an another session
iLiveSession->SessionConnectionStateChanged( *iSomeOtherSession->iSession,
ETrue );
EUNIT_ASSERT( iObserver->IsReseted() ); // Wrong session, nothing happened
// Try tell session connection state is active
iLiveSession->SessionConnectionStateChanged( *iLiveSession->iSession,
ETrue );
EUNIT_ASSERT( iObserver->IsReseted() ); // Session active, nothing happened
// Try tell session connection state is inactive
iLiveSession->SessionConnectionStateChanged( *iLiveSession->iSession,
EFalse );
EUNIT_ASSERT( iObserver->iSessionConnectionLostCalled );
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_FailedL()
{
// Try to tell session about failure of another session
iLiveSession->Failed( *iSomeOtherSession->iSession, 0 );
EUNIT_ASSERT( iObserver->IsReseted() ); // No session yet, nothing happened
// Simulate sending invite
iLiveSession->InviteL( KTestRecipientSipUri() );
// Now try again to notify session about failure of an another session
iLiveSession->Failed( *iSomeOtherSession->iSession, 0 );
EUNIT_ASSERT( iObserver->IsReseted() ); // Wrong session, nothing happened
// Tell session that it has failed
iLiveSession->Failed( *iLiveSession->iSession, 0 );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_UpdateFailedL()
{
// Try to tell session about update failure of another session
iLiveSession->UpdateFailed( *iSomeOtherSession->iSession, NULL );
EUNIT_ASSERT( iObserver->iSessionFailedCalled ); // No container, internal error
iObserver->Reset();
// Try again with container
TMceTransactionDataContainer container;
iLiveSession->UpdateFailed( *iSomeOtherSession->iSession, &container );
EUNIT_ASSERT( iObserver->IsReseted() ); // No session yet, nothing happened
// Invite and try again.
iLiveSession->InviteL( KTestRecipientSipUri() );
iLiveSession->UpdateFailed( *iSomeOtherSession->iSession, &container );
EUNIT_ASSERT( iObserver->IsReseted() ); // Wrong session, nothing happened¨
// Try with right session
iLiveSession->UpdateFailed( *iLiveSession->iSession, &container );
EUNIT_ASSERT( iObserver->iSessionFailedCalled );
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SRReceivedL()
{
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
// No session yet, nothing happens
iLiveSession->SRReceived( *iSomeOtherSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
ESTABLISH_OUT_SESSION( iLiveSession );
// Simulate bigger value
iLiveSession->iSecondsFromLastRtcpReport = 10;
// We have session, but informing concearn wrong session, timer is
// not nullified
iLiveSession->SRReceived( *iSomeOtherSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 10 );
// Right session but wrong stream, timer should not be nullified
iLiveSession->SRReceived( *iLiveSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 10 );
// Right stream and established session, timer should be nullified
iLiveSession->SRReceived( *iLiveSession->iSession,
*(iLiveSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_RRReceivedL()
{
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
// No session yet, nothing happens
iLiveSession->RRReceived( *iSomeOtherSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
ESTABLISH_OUT_SESSION( iLiveSession );
// Simulate bigger value
iLiveSession->iSecondsFromLastRtcpReport = 10;
// We have session, but informing concearn wrong session, timer is
// not nullified
iLiveSession->RRReceived( *iSomeOtherSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 10 );
// Right session but wrong stream, timer should not be nullified
iLiveSession->RRReceived( *iLiveSession->iSession,
*(iSomeOtherSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 10 );
// Right stream and established session, timer should be nullified
iLiveSession->RRReceived( *iLiveSession->iSession,
*(iLiveSession->iSession->Streams()[0]) );
EUNIT_ASSERT( iLiveSession->iSecondsFromLastRtcpReport == 0 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_InactivityTimeoutL()
{
// Construct an audio stream for this test
CMceAudioStream* audioStream = CMceAudioStream::NewLC();
CMceRtpSource* rtpSource = CMceRtpSource::NewLC();
audioStream->SetSourceL( rtpSource );
CleanupStack::Pop( rtpSource );
iReceiveSession->InactivityTimeout( *audioStream, *rtpSource );
EUNIT_ASSERT( iObserver->IsReseted() )
CleanupStack::PopAndDestroy( audioStream );
// And now real inactivity timeout
iReceiveSession->InactivityTimeout(
*iReceiveSession->iSession->Streams()[0],
*static_cast<CMceRtpSource*>
(iReceiveSession->iSession->Streams()[0]->Source()) );
EUNIT_ASSERT( iObserver->iStreamIdleCalled )
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SsrcAddedL()
{
// As CMusEngMceSession::SsrcAdded is expected to do nothing, just call
// it to make sure it does not weaken the test coverage
CMceRtpSource* rtpSource = static_cast<CMceRtpSource*>(
iReceiveSession->iSession->Streams()[0]->Source() );
iReceiveSession->SsrcAdded(
*iReceiveSession->iSession->Streams()[0],
*rtpSource,
0 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_SsrcRemovedL()
{
// As CMusEngMceSession::SsrcRemoved is expected to do nothing, just call
// it to make sure it does not weaken the test coverage
CMceRtpSource* rtpSource = static_cast<CMceRtpSource*>(
iReceiveSession->iSession->Streams()[0]->Source() );
iReceiveSession->SsrcRemoved(
*iReceiveSession->iSession->Streams()[0],
*rtpSource,
0 );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_UpdateTimerEventL()
{
iLiveSession->UpdateTimerEvent();
EUNIT_ASSERT( iObserver->iSessionTimeChangedCalled )
EUNIT_ASSERT( iLiveSession->iUpdateTimer->IsActive() )
iLiveSession->iUpdateTimer->Cancel();
iObserver->Reset();
iLiveSession->iSecondsFromLastRtcpReport = 25; // >KMusEngRtcpInactivityThreshold
iLiveSession->UpdateTimerEvent();
EUNIT_ASSERT( iObserver->iSessionTimeChangedCalled )
EUNIT_ASSERT( iObserver->iInactivityTimeoutCalled );
EUNIT_ASSERT( iLiveSession->iUpdateTimer->IsActive() )
iLiveSession->iUpdateTimer->Cancel();
iObserver->Reset();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_IsRoamingBetweenAPsAllowedL()
{
// No session
EUNIT_ASSERT( iLiveSession->IsRoamingBetweenAPsAllowed() )
// Session idle
_LIT( KRecipientSipUri, "sip:user@some.where" );
iLiveSession->InviteL( KRecipientSipUri );
iLiveSession->iSession->iState = CMceSession::EIdle;
EUNIT_ASSERT( iLiveSession->IsRoamingBetweenAPsAllowed() )
// Session established
iLiveSession->iSession->iState = CMceSession::EEstablished;
EUNIT_ASSERT( !iLiveSession->IsRoamingBetweenAPsAllowed() )
// Session terminated
iLiveSession->iSession->iState = CMceSession::ETerminated;
EUNIT_ASSERT( iLiveSession->IsRoamingBetweenAPsAllowed() )
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeChangedL()
{
// Try without session, nothing happens
EUNIT_ASSERT( iObserver->iVolume == 0 );
iLiveSession->VolumeChanged( 1, EFalse );
EUNIT_ASSERT( !VerifySpeakersVolume(*iLiveSession, 1) )
EUNIT_ASSERT( iObserver->iVolume == 0 );
// Establish session
ESTABLISH_OUT_SESSION( iClipSession )
// Try without observer
iClipSession->VolumeChanged( 2, EFalse );
EUNIT_ASSERT( VerifySpeakersVolume(*iClipSession, 2) )
EUNIT_ASSERT( iObserver->iVolume == 0 );
// Try with observer set
iClipSession->SetVolumeChangeObserver( iObserver );
iClipSession->VolumeChanged( 3, EFalse );
EUNIT_ASSERT( VerifySpeakersVolume(*iClipSession, 3) )
EUNIT_ASSERT( iObserver->iVolume == 3 );
}
// HELPERS
TBool UT_CMusEngMceSession::VerifySpeakersVolume(CMusEngMceSession& aSession, TInt aVolume)
{
TBool result = EFalse;
CMceSpeakerSink* speaker = NULL;
CMceSession* session = aSession.iSession;
if ( session )
{
for ( TInt i = 0; i < session->Streams().Count(); ++i )
{
for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )
{
if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
speaker = static_cast<CMceSpeakerSink*>(
session->Streams()[i]->Sinks()[j] );
result = ( speaker->VolumeL() == aVolume );
}
}
}
}
return result;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void UT_CMusEngMceSession::SetMaxVolForSpeakersL(CMceSession& aSession, TInt aMaxVol)
{
for ( TInt i = 0; i < aSession.Streams().Count(); ++i )
{
for ( TInt j = 0; j < aSession.Streams()[i]->Sinks().Count(); ++j )
{
if ( aSession.Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )
{
CMceSpeakerSink* speaker = static_cast<CMceSpeakerSink*>(
aSession.Streams()[i]->Sinks()[j] );
speaker->iMaxVolume = aMaxVol;
}
}
}
}
// TEST TABLE
EUNIT_BEGIN_TEST_TABLE(
UT_CMusEngMceSession,
"UT_CMusEngMceSesssion",
"UNIT" )
EUNIT_TEST(
"TerminateL - test ",
"CMusEngMceSession",
"TerminateL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_TerminateLL, Teardown)
EUNIT_TEST(
"GetSessionTime - test ",
"CMusEngMceSession",
"GetSessionTime",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_GetSessionTimeL, Teardown)
EUNIT_TEST(
"ConnectionActive - test ",
"CMusEngMceSession",
"ConnectionActive",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_ConnectionActiveL, Teardown)
EUNIT_TEST(
"ContainsAudioL - test ",
"CMusEngMceSession",
"ContainsAudioL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_ContainsAudioLL, Teardown)
EUNIT_TEST(
"IsMutedL - test ",
"CMusEngMceSession",
"IsMutedL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_IsMutedLL, Teardown)
EUNIT_TEST(
"OrientationL - test ",
"CMusEngMceSession",
"OrientationL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_OrientationLL, Teardown)
EUNIT_TEST(
"SetOrientationL - test ",
"CMusEngMceSession",
"SetOrientationL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SetOrientationLL, Teardown)
EUNIT_TEST(
"VolumeUpL - test ",
"CMusEngMceSession",
"VolumeUpL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_VolumeUpLL, Teardown)
EUNIT_TEST(
"VolumeDownL - test ",
"CMusEngMceSession",
"VolumeDownL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_VolumeDownLL, Teardown)
EUNIT_TEST(
"SetVolumeL - test ",
"CMusEngMceSession",
"SetVolumeL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SetVolumeLL, Teardown)
EUNIT_TEST(
"EnableDisplay - test ",
"CMusEngMceSession",
"EnableDisplay",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_EnableDisplayL, Teardown)
EUNIT_TEST(
"MuteL - test ",
"CMusEngMceSession",
"MuteL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_MuteLL, Teardown)
EUNIT_TEST(
"UnmuteL - test ",
"CMusEngMceSession",
"UnmuteL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_UnmuteLL, Teardown)
EUNIT_TEST(
"HandleTermination - test ",
"CMusEngMceSession",
"HandleTermination",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_HandleTerminationL, Teardown)
EUNIT_TEST(
"AdjustVideoCodecL - test ",
"CMusEngMceSession",
"AdjustVideoCodecL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_AdjustVideoCodecLL, Teardown)
EUNIT_TEST(
"AdjustAudioCodecL - test ",
"CMusEngMceSession",
"AdjustAudioCodecL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_AdjustAudioCodecLL, Teardown)
EUNIT_TEST(
"RectChangedL - test ",
"CMusEngMceSession",
"RectChangedL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_RectChangedLL, Teardown)
EUNIT_TEST(
"SetSessionSdpLinesL - test ",
"CMusEngMceSession",
"SetSessionSdpLinesL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SetSessionSdpLinesLL, Teardown)
EUNIT_TEST(
"AdjustStreamsAndCodecsL - test ",
"CMusEngMceSession",
"AdjustStreamsAndCodecsL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_AdjustStreamsAndCodecsLL, Teardown)
EUNIT_TEST(
"IncomingSession - test ",
"CMusEngMceSession",
"IncomingSession",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_IncomingSessionL, Teardown)
EUNIT_TEST(
"IncomingUpdate - test ",
"CMusEngMceSession",
"IncomingUpdate",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_IncomingUpdateL, Teardown)
EUNIT_TEST(
"StreamStateChangedL( source ) - test ",
"CMusEngMceSession",
"StreamStateChangedL( source )",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_StreamStateChangedWithSourceL, Teardown)
EUNIT_TEST(
"SessionStateChanged - test ",
"CMusEngMceSession",
"SessionStateChanged",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SessionStateChangedL, Teardown)
EUNIT_TEST(
"SessionConnectionStateChanged - test ",
"CMusEngMceSession",
"SessionConnectionStateChanged",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SessionConnectionStateChangedL, Teardown)
EUNIT_TEST(
"Failed - test ",
"CMusEngMceSession",
"Failed",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_FailedL, Teardown)
EUNIT_TEST(
"UpdateFailed - test ",
"CMusEngMceSession",
"UpdateFailed",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_UpdateFailedL, Teardown)
EUNIT_TEST(
"StreamStateChanged - test ",
"CMusEngMceSession",
"StreamStateChanged",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_StreamStateChangedL, Teardown)
EUNIT_TEST(
"StreamStateChangedL (sink ) - test ",
"CMusEngMceSession",
"StreamStateChangedL( sink )",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_StreamStateChangedWithSinkL, Teardown)
EUNIT_TEST(
"SRReceived - test ",
"CMusEngMceSession",
"SRReceived",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SRReceivedL, Teardown)
EUNIT_TEST(
"RRReceived - test ",
"CMusEngMceSession",
"RRReceived",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_RRReceivedL, Teardown)
EUNIT_TEST(
"InactivityTimeout - test ",
"CMusEngMceSession",
"InactivityTimeout",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_InactivityTimeoutL, Teardown)
EUNIT_TEST(
"SsrcAdded - test ",
"CMusEngMceSession",
"SsrcAdded",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SsrcAddedL, Teardown)
EUNIT_TEST(
"SsrcRemoved - test ",
"CMusEngMceSession",
"SsrcRemoved",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_SsrcRemovedL, Teardown)
EUNIT_TEST(
"IsDisplayEnabledL - test ",
"CMusEngMceSession",
"IsDisplayEnabledL",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_IsDisplayEnabledLL, Teardown)
EUNIT_TEST(
"UpdateTimerEvent - test ",
"CMusEngMceSession",
"UpdateTimerEvent",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_UpdateTimerEventL, Teardown)
EUNIT_TEST(
"IsRoamingBetweenAPsAllowed - test ",
"CMusEngMceSession",
"IsRoamingBetweenAPsAllowed",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_IsRoamingBetweenAPsAllowedL, Teardown)
EUNIT_TEST(
"VolumeChanged - test ",
"CMusEngMceSession",
"VolumeChanged",
"FUNCTIONALITY",
SetupL, UT_CMusEngMceSession_VolumeChangedL, Teardown)
EUNIT_END_TEST_TABLE
// END OF FILE