1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 //  INTERNAL INCLUDES

    20 #include "ut_musengmcesession.h"

    21 #include "musengstubs.h"

    22 #include "musengtestdefs.h"

    23 

    24 #include "mussettings.h"

    25 #include "musenglivesession.h"

    26 #include "musengclipsession.h"

    27 #include "musengreceivesession.h"

    28 #include "musengsessiondurationtimer.h"

    29 #include "musengtelephoneutils.h"

    30 #include "musengmceutils.h"

    31 

    32 //  SYSTEM INCLUDES

    33 

    34 #include <digia/eunit/eunitmacros.h>

    35 #include <mceinsession.h>

    36 #include <mcevideostream.h>

    37 #include <mcedisplaysink.h>

    38 #include <mcertpsource.h>

    39 #include <mcespeakersink.h>

    40 #include <mceaudiostream.h>

    41 #include <mcertpsink.h>

    42 #include <mcevideocodec.h>

    43 #include <mceaudiocodec.h>

    44 #include <audiopreference.h>

    45 #include <mceh263codec.h>

    46 #include <mceavccodec.h>

    47 

    48 

    49 

    50 // -----------------------------------------------------------------------------

    51 //

    52 // -----------------------------------------------------------------------------

    53 //

    54 UT_CMusEngMceSession* UT_CMusEngMceSession::NewL()

    55     {

    56     UT_CMusEngMceSession* self = UT_CMusEngMceSession::NewLC();

    57     CleanupStack::Pop( self );

    58     return self;

    59     }

    60 

    61 

    62 // -----------------------------------------------------------------------------

    63 //

    64 // -----------------------------------------------------------------------------

    65 //

    66 UT_CMusEngMceSession* UT_CMusEngMceSession::NewLC()

    67     {

    68     UT_CMusEngMceSession* self = new( ELeave ) UT_CMusEngMceSession();

    69     CleanupStack::PushL( self );

    70     self->ConstructL();

    71     return self;

    72     }

    73 

    74 

    75 // -----------------------------------------------------------------------------

    76 //

    77 // -----------------------------------------------------------------------------

    78 //

    79 UT_CMusEngMceSession::~UT_CMusEngMceSession()

    80     {

    81     // NOP

    82     }

    83 

    84 

    85 // -----------------------------------------------------------------------------

    86 // Default constructor

    87 // -----------------------------------------------------------------------------

    88 //

    89 UT_CMusEngMceSession::UT_CMusEngMceSession()

    90     {

    91     // NOP

    92     }

    93 

    94 

    95 // -----------------------------------------------------------------------------

    96 // Second phase construct

    97 // -----------------------------------------------------------------------------

    98 //

    99 void UT_CMusEngMceSession::ConstructL()

   100     {

   101     // The ConstructL from the base class CEUnitTestSuiteClass must be called.

   102     // It generates the test case table.

   103     CEUnitTestSuiteClass::ConstructL();

   104     }

   105     

   106 

   107 // -----------------------------------------------------------------------------

   108 //

   109 // -----------------------------------------------------------------------------

   110 //

   111 void UT_CMusEngMceSession::SetupL(  )

   112     {

   113     iObserver = new( ELeave ) CMusEngObserverStub;

   114     iLiveSession = CMusEngLiveSession::NewL( KNullDesC,

   115                                              TRect(0,0, 100,100),

   116                                              *iObserver,

   117                                              *iObserver,

   118                                              *iObserver );

   119     

   120     iSomeOtherSession = CMusEngLiveSession::NewL( KNullDesC,

   121                                                   TRect(0,0, 100,100),

   122                                                   *iObserver,

   123                                                   *iObserver,

   124                                                   *iObserver );

   125     ESTABLISH_OUT_SESSION( iSomeOtherSession );

   126     

   127     iClipSession = CMusEngClipSession::NewL( TRect(0,0, 100,100),

   128                                              *iObserver,

   129                                              *iObserver,

   130                                              *iObserver );                                             

   131     iClipSession->SetClipL( KTestVideoFileName() );

   132 

   133     TBuf<50> videoCodec;

   134     videoCodec.Copy( KMceSDPNameH264() );

   135     iClipSession->SetSupportedVideoCodecListL(videoCodec);

   136     

   137     // Construct and establish an incoming session

   138     iReceiveSession = CMusEngReceiveSession::NewL( TRect(0,0, 100,100), 

   139                                                    *iObserver,

   140                                                    *iObserver );

   141     CMceInSession* inSession = CMceInSession::NewL( *iReceiveSession->iManager,

   142                                                     KTestOriginator() );

   143                                                     

   144     CMceVideoStream* videoStream = CMceVideoStream::NewLC();

   145     

   146     videoStream->SetSourceL( CMceRtpSource::NewLC() );

   147     CleanupStack::Pop();

   148     

   149     inSession->AddStreamL( videoStream );

   150     CleanupStack::Pop( videoStream );

   151                                                     

   152     iReceiveSession->iManager->iInSessionObserver->IncomingSession( 

   153                                                         inSession, 

   154                                                         &iContainer );

   155     iReceiveSession->iSession->iState = CMceSession::EProceeding;

   156     iReceiveSession->AcceptInvitationL( ETrue );

   157     

   158     iObserver->Reset();

   159     }

   160 

   161 

   162 // -----------------------------------------------------------------------------

   163 //

   164 // -----------------------------------------------------------------------------

   165 //

   166 void UT_CMusEngMceSession::Teardown(  )

   167     {

   168     delete iLiveSession;

   169     delete iClipSession;

   170     delete iReceiveSession;

   171     delete iObserver;

   172     delete iSomeOtherSession;

   173     

   174     }

   175 

   176 

   177 

   178 // TEST CASES

   179 

   180 

   181 // -----------------------------------------------------------------------------

   182 //

   183 // -----------------------------------------------------------------------------

   184 //

   185 void UT_CMusEngMceSession::UT_CMusEngMceSession_TerminateLL()

   186     {

   187     TRAPD( error, iLiveSession->TerminateL() );

   188     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   189     EUNIT_ASSERT( error == KErrNotReady );

   190     

   191     ESTABLISH_OUT_SESSION( iLiveSession );

   192     

   193     EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::EEstablished );

   194     

   195     iLiveSession->TerminateL();

   196     

   197     EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::ETerminating );

   198     

   199     }

   200 

   201 

   202 // -----------------------------------------------------------------------------

   203 //

   204 // -----------------------------------------------------------------------------

   205 //  

   206 void UT_CMusEngMceSession::UT_CMusEngMceSession_GetSessionTimeL()

   207     {

   208     EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );

   209     

   210     // Invite

   211     iLiveSession->InviteL( KTestRecipientSipUri );

   212     

   213     EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );

   214     

   215     // Simulate establishment

   216     iLiveSession->iSession->iState = CMceSession::EEstablished;

   217     iLiveSession->iStartTime.HomeTime();

   218     

   219     TTimeIntervalSeconds sessionTime = iLiveSession->GetSessionTime();

   220     EUNIT_ASSERT( sessionTime >= TTimeIntervalSeconds( 0 ) );

   221     }

   222     

   223 

   224 // -----------------------------------------------------------------------------

   225 //

   226 // -----------------------------------------------------------------------------

   227 //

   228 void UT_CMusEngMceSession::UT_CMusEngMceSession_ConnectionActiveL()

   229     {

   230     EUNIT_ASSERT( !iLiveSession->ConnectionActive() );

   231     

   232     ESTABLISH_OUT_SESSION( iLiveSession );

   233     

   234     EUNIT_ASSERT( iLiveSession->ConnectionActive() );

   235     }

   236 

   237 

   238 // -----------------------------------------------------------------------------

   239 //

   240 // -----------------------------------------------------------------------------

   241 //

   242 void UT_CMusEngMceSession::UT_CMusEngMceSession_ContainsAudioLL()

   243     {

   244     // Try without session, fails

   245     EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->ContainsAudioL(), KErrNotReady )

   246     

   247     // Establish session without audio

   248     ESTABLISH_OUT_SESSION( iLiveSession )

   249     

   250     EUNIT_ASSERT( !iLiveSession->ContainsAudioL() )

   251     

   252     // Establish session with audio

   253     ESTABLISH_OUT_SESSION( iClipSession )

   254     

   255     EUNIT_ASSERT( iClipSession->ContainsAudioL() )

   256     }

   257 

   258 

   259 // -----------------------------------------------------------------------------

   260 //

   261 // -----------------------------------------------------------------------------

   262 //

   263 void UT_CMusEngMceSession::UT_CMusEngMceSession_IsMutedLL()

   264     {

   265     // Try without session, fails

   266     EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->IsMutedL(), KErrNotReady )

   267     

   268     // Establish session without audio

   269     ESTABLISH_OUT_SESSION( iLiveSession )

   270     

   271     EUNIT_ASSERT( iLiveSession->IsMutedL() )

   272     

   273     // Establish session with audio

   274     ESTABLISH_OUT_SESSION( iClipSession )

   275     

   276     EUNIT_ASSERT( !iClipSession->IsMutedL() )  // Not muted although disabled

   277     

   278     iClipSession->EnableDisplayL( ETrue ); // Enabled also speaker

   279     

   280     EUNIT_ASSERT( !iClipSession->IsMutedL() )  // Enabled and not muted

   281 

   282     iClipSession->MuteL();

   283     

   284     EUNIT_ASSERT( iClipSession->IsMutedL() ) // Explicitly muted

   285     

   286     iClipSession->UnmuteL();

   287     

   288     EUNIT_ASSERT( !iClipSession->IsMutedL() ) // Explicitly unmuted

   289     }

   290 

   291 

   292 // -----------------------------------------------------------------------------

   293 //

   294 // -----------------------------------------------------------------------------

   295 //

   296 void UT_CMusEngMceSession::UT_CMusEngMceSession_OrientationLL()

   297     {

   298     // Try without session, fails

   299     EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->OrientationL(), KErrNotReady )

   300     

   301     // Establish a session and try all the MCE rotation values

   302     ESTABLISH_OUT_SESSION( iLiveSession )

   303     

   304     CMceDisplaySink* display = 

   305                     MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );

   306 

   307     display->iRotation = CMceDisplaySink::ENone;

   308     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   309                          CMusEngMceSession::EPortrait )

   310     

   311     display->iRotation = CMceDisplaySink::EClockwise90Degree;

   312     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   313                          CMusEngMceSession::ELandscape )

   314     

   315     display->iRotation = CMceDisplaySink::EClockwise180Degree;

   316     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   317                          CMusEngMceSession::ELandscape )

   318     

   319     display->iRotation = CMceDisplaySink::EClockwise270Degree;

   320     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   321                          CMusEngMceSession::ELandscape )

   322             

   323     }

   324     

   325 

   326 // -----------------------------------------------------------------------------

   327 //

   328 // -----------------------------------------------------------------------------

   329 //

   330 void UT_CMusEngMceSession::UT_CMusEngMceSession_SetOrientationLL()

   331     {

   332     // Try without session, fails

   333     EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->SetOrientationL( 

   334                                                 CMusEngMceSession::EPortrait ), 

   335                                  KErrNotReady )

   336 

   337     // Establish a session

   338     ESTABLISH_OUT_SESSION( iLiveSession )

   339     

   340     CMceDisplaySink* display = 

   341                     MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );

   342     

   343     // Check the initial state

   344     display->iRotation = CMceDisplaySink::ENone;

   345     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   346                          CMusEngMceSession::EPortrait )      

   347                          

   348     // Successfully change orientation

   349     

   350     iLiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

   351     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   352                          CMusEngMceSession::ELandscape )

   353     

   354     iLiveSession->SetOrientationL( CMusEngMceSession::EPortrait );

   355     EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

   356                          CMusEngMceSession::EPortrait )                     

   357                          

   358     }

   359         

   360 

   361 // -----------------------------------------------------------------------------

   362 //

   363 // -----------------------------------------------------------------------------

   364 //

   365 void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeUpLL()

   366     {    

   367     // Try without session, fails

   368     TRAPD( error, iLiveSession->VolumeUpL() );

   369     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   370     EUNIT_ASSERT( error == KErrNotReady );

   371     

   372     // Test only usage of CMceSpeaker, phone part is tested in base class

   373     

   374     // Check that nothing crashes without any speakers    

   375     iReceiveSession->VolumeUpL();

   376     

   377     // Establish session

   378     ESTABLISH_OUT_SESSION( iClipSession )

   379     

   380     TInt initialVolume = iClipSession->VolumeL();

   381     

   382     iClipSession->VolumeUpL();

   383 

   384     // Check that all speaker volumes are adjusted and store one speaker pointer

   385     

   386     CMceSpeakerSink* speaker = NULL;

   387     

   388     CMceSession* session = iClipSession->iSession;

   389     

   390     for ( TInt i = 0; i < session->Streams().Count(); ++i )

   391         {

   392         for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

   393             {

   394             if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

   395                 {

   396                 speaker = static_cast<CMceSpeakerSink*>(

   397                                             session->Streams()[i]->Sinks()[j] );

   398                 EUNIT_ASSERT( speaker->VolumeL() == initialVolume + 1 );

   399                 }

   400             }

   401         } 

   402 

   403     while ( iClipSession->VolumeL() < speaker->MaxVolumeL() )

   404         {

   405         iClipSession->VolumeUpL();

   406         }

   407 

   408     iClipSession->VolumeUpL(); // Does not do anything to volume

   409     

   410     EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );

   411     

   412     }

   413 

   414 

   415 // -----------------------------------------------------------------------------

   416 //

   417 // -----------------------------------------------------------------------------

   418 //

   419 void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeDownLL()

   420     {

   421         // Try without session, fails

   422     TRAPD( error, iLiveSession->VolumeDownL() );

   423     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   424     EUNIT_ASSERT( error == KErrNotReady );

   425     

   426     // Test only usage of CMceSpeaker, phone part is tested in base class

   427     

   428     // Check that nothing crashes without any speakers    

   429     iReceiveSession->VolumeUpL();

   430     

   431     // Establish session

   432     ESTABLISH_OUT_SESSION( iClipSession )

   433     

   434     TInt initialVolume = iClipSession->VolumeL();

   435     

   436     iClipSession->VolumeDownL();

   437 

   438     // Check that all speaker volumes are adjusted and store one speaker pointer

   439     

   440     CMceSpeakerSink* speaker = NULL;

   441     

   442     CMceSession* session = iClipSession->iSession;

   443     

   444     for ( TInt i = 0; i < session->Streams().Count(); ++i )

   445         {

   446         for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

   447             {

   448             if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

   449                 {

   450                 speaker = static_cast<CMceSpeakerSink*>(

   451                                             session->Streams()[i]->Sinks()[j] );

   452                 EUNIT_ASSERT( speaker->VolumeL() == initialVolume - 1 );

   453                 }

   454             }

   455         } 

   456 

   457     while ( iClipSession->VolumeL() > 0 )

   458         {

   459         iClipSession->VolumeDownL();

   460         }

   461 

   462     iClipSession->VolumeDownL(); // Does not do anything to volume

   463     

   464     EUNIT_ASSERT_EQUALS( iClipSession->VolumeL(), 0 );

   465         

   466     }

   467 

   468 

   469 // -----------------------------------------------------------------------------

   470 //

   471 // -----------------------------------------------------------------------------

   472 //

   473 void UT_CMusEngMceSession::UT_CMusEngMceSession_SetVolumeLL()

   474     {    

   475     // Try without session, fails

   476     TInt newVolume = KTelephonyVolumeDefaultValue + 1;

   477     

   478     TRAPD( error, iLiveSession->SetVolumeL( newVolume ) );

   479     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   480     EUNIT_ASSERT( error == KErrNotReady );

   481     

   482     // Test only usage of CMceSpeaker, phone part is tested in base class

   483     

   484     // Check that nothing crashes without any speakers    

   485     iReceiveSession->SetVolumeL( newVolume );

   486     

   487     // Establish session

   488     ESTABLISH_OUT_SESSION( iClipSession )

   489     

   490     TInt initialVolume = iClipSession->VolumeL();

   491     

   492     iClipSession->SetVolumeL( newVolume );

   493 

   494     // Check that all speaker volumes are adjusted and store one speaker pointer

   495     

   496     CMceSpeakerSink* speaker = NULL;

   497     

   498     CMceSession* session = iClipSession->iSession;

   499     

   500     for ( TInt i = 0; i < session->Streams().Count(); ++i )

   501         {

   502         for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

   503             {

   504             if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

   505                 {

   506                 speaker = static_cast<CMceSpeakerSink*>(

   507                                             session->Streams()[i]->Sinks()[j] );

   508                 EUNIT_ASSERT( speaker->VolumeL() == newVolume );

   509                 }

   510             }

   511         } 

   512 

   513     newVolume = speaker->MaxVolumeL() + 1;

   514     iClipSession->SetVolumeL( newVolume );

   515     EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );

   516     

   517     newVolume = -1;

   518     iClipSession->SetVolumeL( newVolume );

   519     EUNIT_ASSERT( iClipSession->VolumeL() == 0 );

   520     

   521     // Test situation where MCE max volume is bigger than MUS max vol

   522     SetMaxVolForSpeakersL(*session, KMusEngMaxVolume * 10);

   523     newVolume = 5;

   524     iClipSession->SetVolumeL( newVolume );

   525     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   526     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );

   527     newVolume = 1;

   528     iClipSession->SetVolumeL( newVolume );

   529     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   530     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );

   531     newVolume = KMusEngMaxVolume;

   532     iClipSession->SetVolumeL( newVolume );

   533     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   534     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );

   535     

   536     SetMaxVolForSpeakersL(*session, KMusEngMaxVolume * 1000);

   537     newVolume = 7;

   538     iClipSession->SetVolumeL( newVolume );

   539     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   540     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );

   541     newVolume = 1;

   542     iClipSession->SetVolumeL( newVolume );

   543     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   544     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );

   545     newVolume = KMusEngMaxVolume;

   546     iClipSession->SetVolumeL( newVolume );

   547     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   548     EUNIT_ASSERT( speaker->VolumeL() == newVolume * 1000 );

   549     

   550     

   551     // Test situation where MCE max volume is smaller than MUS max vol

   552     SetMaxVolForSpeakersL(*session, KMusEngMaxVolume / 2);

   553     newVolume = 3;

   554     iClipSession->SetVolumeL( newVolume );

   555     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   556     EUNIT_ASSERT( speaker->VolumeL() == newVolume / 2 );

   557     newVolume = 1;

   558     iClipSession->SetVolumeL( newVolume );

   559     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   560     EUNIT_ASSERT( speaker->VolumeL() == 1 );

   561     newVolume = KMusEngMaxVolume;

   562     iClipSession->SetVolumeL( newVolume );

   563     EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

   564     EUNIT_ASSERT( speaker->VolumeL() == newVolume / 2 );

   565     }

   566 

   567 // -----------------------------------------------------------------------------

   568 //

   569 // -----------------------------------------------------------------------------

   570 //

   571 void UT_CMusEngMceSession::UT_CMusEngMceSession_EnableDisplayL()

   572     {

   573     TRAPD( error, iLiveSession->EnableDisplayL( ETrue ) );

   574     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   575     EUNIT_ASSERT( error == KErrNotReady );

   576     

   577     ESTABLISH_OUT_SESSION( iLiveSession );

   578     

   579     CMceDisplaySink* display = 

   580                     MusEngMceUtils::GetDisplayL( *(iLiveSession->iSession) );

   581     

   582     // Disable

   583     iLiveSession->EnableDisplayL( EFalse );

   584     

   585     EUNIT_ASSERT( !display->iIsEnabled );

   586     

   587     // Try to disable again, request should be ignored

   588     

   589     iLiveSession->EnableDisplayL( EFalse );

   590     

   591     EUNIT_ASSERT( !display->iIsEnabled );

   592 

   593     // Enable

   594     

   595     iLiveSession->EnableDisplayL( ETrue );

   596     

   597     EUNIT_ASSERT( display->iIsEnabled );

   598     

   599     // Try to enable again, request should be ignored

   600     

   601     iLiveSession->EnableDisplayL( ETrue );

   602     

   603     EUNIT_ASSERT( display->iIsEnabled );

   604     }

   605 

   606 

   607 // -----------------------------------------------------------------------------

   608 //

   609 // -----------------------------------------------------------------------------

   610 //

   611 void UT_CMusEngMceSession::UT_CMusEngMceSession_MuteLL()

   612     {

   613     TRAPD( error, iClipSession->MuteL() );

   614     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   615     EUNIT_ASSERT( error == KErrNotReady );

   616     

   617     ESTABLISH_OUT_SESSION_AND_START_STREAMING( iClipSession );

   618     

   619     const RPointerArray<CMceMediaStream> streams = 

   620                                             iClipSession->iSession->Streams();

   621     

   622     iClipSession->MuteL();

   623     

   624     // Check that all audio speaker sinks are disabled and only those                                        

   625     for ( TInt i = 0; i < streams.Count(); ++i )

   626         {

   627         for ( TInt j = 0; j < streams[i]->Sinks().Count(); ++j )

   628             {

   629             CMceMediaSink* sink = streams[i]->Sinks()[j];

   630             if ( sink->Type() == KMceSpeakerSink  &&

   631                  streams[i]->Type() == KMceAudio )

   632                 {

   633                 EUNIT_ASSERT( sink->IsEnabled() == EFalse )

   634                 }    

   635             else

   636                 {

   637                 EUNIT_ASSERT( sink->IsEnabled() == ETrue )

   638                 } 

   639             }        

   640         }

   641     

   642     EUNIT_ASSERT( iClipSession->iExplicitlyMuted ) 

   643     

   644     // Try to mute again, request should be ignored without actions or leaving

   645 

   646     iClipSession->MuteL();

   647 

   648     }

   649     

   650 

   651 // -----------------------------------------------------------------------------

   652 // Relies on previous test

   653 // -----------------------------------------------------------------------------

   654 //

   655 void UT_CMusEngMceSession::UT_CMusEngMceSession_UnmuteLL()

   656     {

   657     TRAPD( error, iClipSession->UnmuteL() );

   658     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   659     EUNIT_ASSERT( error == KErrNotReady );

   660     

   661     ESTABLISH_OUT_SESSION( iClipSession );

   662     

   663     const RPointerArray<CMceMediaStream> streams = 

   664                                             iClipSession->iSession->Streams();

   665     

   666     iClipSession->MuteL();

   667     

   668     iClipSession->UnmuteL();

   669     

   670     // Check that all audio speaker sinks are enabled

   671                                             

   672     for ( TInt i = 0; i < streams.Count(); ++i )

   673         {

   674         for ( TInt j = 0; j < streams[i]->Sinks().Count(); ++j )

   675             {

   676             if ( streams[i]->Sinks()[j]->Type() == KMceSpeakerSink )

   677                 {

   678                 EUNIT_ASSERT( streams[i]->Sinks()[j]->IsEnabled() == ETrue )

   679                 }

   680             }        

   681         }

   682     

   683     EUNIT_ASSERT( !iClipSession->iExplicitlyMuted ) 

   684     

   685     // Try to unmute again, request should be ignored without actions or leaving

   686 

   687     iClipSession->UnmuteL();

   688     }

   689     

   690 

   691 // -----------------------------------------------------------------------------

   692 //

   693 // -----------------------------------------------------------------------------

   694 //

   695 void UT_CMusEngMceSession::UT_CMusEngMceSession_HandleTerminationL()

   696     { 

   697     // Try different values

   698     iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCodeNoCodeSet,

   699                                                         KNullDesC8() );

   700     EUNIT_ASSERT( iObserver->iSessionTerminatedCalled );

   701     iObserver->Reset();

   702 

   703     iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCode200OK,

   704                                                         KNullDesC8() );

   705     EUNIT_ASSERT( iObserver->iSessionTerminatedCalled );

   706     iObserver->Reset();

   707 

   708     iLiveSession->CMusEngMceSession::HandleTermination( KSipStatusCodeUnknown,

   709                                                         KNullDesC8() );

   710     EUNIT_ASSERT( iObserver->iSessionFailedCalled );

   711     iObserver->Reset();

   712     

   713     }

   714 

   715 

   716 // -----------------------------------------------------------------------------

   717 //

   718 // -----------------------------------------------------------------------------

   719 //

   720 void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustVideoCodecLL()

   721     {

   722     // CMusEngMceSession::AdjustVideoCodecL does nothing, so NULL test is enough

   723     CMceVideoCodec* codec = 

   724                 iLiveSession->iManager->SupportedVideoCodecs()[0]->CloneL();

   725     CleanupStack::PushL( codec );

   726     iLiveSession->CMusEngMceSession::AdjustVideoCodecL( *codec );

   727     CleanupStack::PopAndDestroy( codec );

   728     }

   729 

   730 

   731 // -----------------------------------------------------------------------------

   732 //

   733 // -----------------------------------------------------------------------------

   734 //

   735 void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustAudioCodecLL()

   736     {

   737     CMceAudioCodec* codec = 

   738                 iLiveSession->iManager->SupportedAudioCodecs()[0]->CloneL();

   739     CleanupStack::PushL( codec );

   740     iLiveSession->CMusEngMceSession::AdjustAudioCodecL( *codec );

   741     

   742     EUNIT_ASSERT( codec->iMMFPriority == KAudioPrioritySwisPlayback )

   743     EUNIT_ASSERT( codec->iMMFPriorityPreference == KAudioPrefSwisPlayback )

   744     

   745     CleanupStack::PopAndDestroy( codec );

   746     }

   747         

   748         

   749 // -----------------------------------------------------------------------------

   750 //

   751 // -----------------------------------------------------------------------------

   752 //

   753 void UT_CMusEngMceSession::UT_CMusEngMceSession_RectChangedLL()

   754     {

   755     

   756     // Does nothing before session establishment

   757     

   758     iLiveSession->RectChangedL();

   759     

   760     ESTABLISH_OUT_SESSION( iLiveSession );

   761 

   762     // Next leads to a call to RectChangedL()

   763     iLiveSession->SetRectL( TRect( 100, 200, 300, 400 ) ); 

   764     

   765     // Display size has been updated

   766     

   767     CMceDisplaySink* display = 

   768                 MusEngMceUtils::GetDisplayL( *( iLiveSession->iSession ) );

   769     

   770     EUNIT_ASSERT( display->DisplayRectL() == iLiveSession->Rect() );

   771     

   772     // Terminate session and try again, rect must not be changed

   773     

   774     iLiveSession->iSession->iState = CMceSession::ETerminated;

   775     

   776     TRect newRect( 200, 300, 400, 500 );

   777     

   778     iLiveSession->SetRectL( newRect ); 

   779     

   780     EUNIT_ASSERT( display->DisplayRectL() != newRect )

   781     

   782     

   783     }

   784 

   785 

   786 // -----------------------------------------------------------------------------

   787 //

   788 // -----------------------------------------------------------------------------

   789 //

   790 void UT_CMusEngMceSession::UT_CMusEngMceSession_SetSessionSdpLinesLL()

   791     {

   792     // set operator variant off

   793     MultimediaSharingSettings::SetOperatorVariantSettingL(

   794                      MusSettingsKeys::EStandard );

   795                      

   796     // There is no sdp lines in session, right one is added

   797 

   798     CMceInSession* inSession = CMceInSession::NewL( *iReceiveSession->iManager,

   799                                                     KTestOriginator );

   800     CleanupStack::PushL( inSession );

   801     

   802     iReceiveSession->SetSessionSdpLinesL( *inSession );

   803     

   804     MDesC8Array* sdpLines = inSession->SessionSDPLinesL();

   805     CleanupDeletePushL( sdpLines );

   806     

   807     EUNIT_ASSERT( sdpLines );

   808     EUNIT_ASSERT( sdpLines->MdcaCount() == 1 );

   809     EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() );

   810     

   811     CleanupStack::PopAndDestroy(); // sdplines

   812 

   813     // There is one line ready, replace it with right one

   814     CDesC8Array* newSdpLines = new ( ELeave ) CDesC8ArrayFlat( 3 );

   815     CleanupStack::PushL( newSdpLines );

   816     newSdpLines->AppendL( KTestRecipientRandomText8() );

   817     inSession->SetSessionSDPLinesL( newSdpLines );

   818     CleanupStack::Pop( newSdpLines );

   819     

   820     iReceiveSession->SetSessionSdpLinesL( *inSession );

   821     

   822     sdpLines = inSession->SessionSDPLinesL();

   823     CleanupDeletePushL( sdpLines );

   824       

   825     EUNIT_ASSERT( sdpLines );

   826     EUNIT_ASSERT( sdpLines->MdcaCount() == 1 );

   827     EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineXApplication() );

   828     

   829     CleanupStack::PopAndDestroy(); // sdplines

   830     

   831 

   832     CleanupStack::PopAndDestroy( inSession );

   833 

   834     // for operator variant testing

   835     // set operator variant

   836     iReceiveSession->iOperatorVariant = ETrue;

   837 

   838     // There is no sdp lines in session, right ones are added to session and media level

   839     inSession = CMceInSession::NewL( *iReceiveSession->iManager,

   840                                                     KTestOriginator );

   841     CleanupStack::PushL( inSession );

   842     

   843     iReceiveSession->SetSessionSdpLinesL( *inSession );

   844     

   845     sdpLines = inSession->SessionSDPLinesL();

   846     CleanupDeletePushL( sdpLines );

   847     

   848     EUNIT_ASSERT( sdpLines );

   849     EUNIT_ASSERT( sdpLines->MdcaCount() == 2 );

   850     EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineApplication() );

   851     EUNIT_ASSERT( sdpLines->MdcaPoint( 1 ) == KMusEngSessionSdpLineType() );

   852     

   853     CleanupStack::PopAndDestroy(); // sdplines

   854     

   855     MDesC8Array* mediaSdpLines = 

   856         iReceiveSession->iSession->Streams()[ 0 ]->MediaAttributeLinesL();

   857     CleanupDeletePushL( mediaSdpLines );

   858     TBool bandwidthFoundFromMediaLevel = EFalse;

   859     for ( TInt i = 0; mediaSdpLines && i < mediaSdpLines->MdcaCount(); i++ )

   860         {

   861         if ( mediaSdpLines->MdcaPoint( i ).Compare( 

   862                 KMusEngSessionSdpLineBandwidthField() ) == 0 )

   863             {

   864             bandwidthFoundFromMediaLevel = ETrue;

   865             }

   866         }

   867     EUNIT_ASSERT( bandwidthFoundFromMediaLevel );

   868     CleanupStack::PopAndDestroy( mediaSdpLines );

   869 

   870     // There is one line ready, replace it with right ones

   871     newSdpLines = new ( ELeave ) CDesC8ArrayFlat( 3 );

   872     CleanupStack::PushL( newSdpLines );

   873     newSdpLines->AppendL( KTestRecipientRandomText8() );

   874     inSession->SetSessionSDPLinesL( newSdpLines );

   875     CleanupStack::Pop( newSdpLines );

   876     

   877     iReceiveSession->SetSessionSdpLinesL( *inSession );

   878     

   879     sdpLines = inSession->SessionSDPLinesL();

   880     CleanupDeletePushL( sdpLines );

   881       

   882     EUNIT_ASSERT( sdpLines );

   883     EUNIT_ASSERT( sdpLines->MdcaCount() == 2 );

   884     EUNIT_ASSERT( sdpLines->MdcaPoint( 0 ) == KMusEngSessionSdpLineApplication() );

   885     EUNIT_ASSERT( sdpLines->MdcaPoint( 1 ) == KMusEngSessionSdpLineType() );

   886     

   887     CleanupStack::PopAndDestroy(); // sdplines

   888     

   889 

   890     CleanupStack::PopAndDestroy( inSession );

   891 

   892 

   893     // set operator variant off

   894     MultimediaSharingSettings::SetOperatorVariantSettingL(

   895                      MusSettingsKeys::EStandard );

   896     }

   897 

   898 

   899 // -----------------------------------------------------------------------------

   900 //

   901 // -----------------------------------------------------------------------------

   902 //

   903 void UT_CMusEngMceSession::UT_CMusEngMceSession_AdjustStreamsAndCodecsLL()

   904     {

   905     // Check that function cannot be called before creating the session

   906     TRAPD( error, iClipSession->AdjustStreamsAndCodecsL() );

   907     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   908     EUNIT_ASSERT( error == KErrNotReady );

   909     

   910     // Establishing a clip session leads to call to AdjustStreamsAndCodecsL

   911     ESTABLISH_OUT_SESSION( iClipSession )

   912    

   913     const RPointerArray<CMceMediaStream>& streams = 

   914                                             iClipSession->iSession->Streams();

   915     

   916     TBool videoCodecFound = EFalse;

   917     TBool audioCodecFound = EFalse;

   918     

   919     // Test that AdjustVideoCodecL and AdjustAudioCodecL have been called

   920     CMceVideoStream* videoStream = NULL;

   921     for ( TInt i = 0; i < streams.Count(); ++i )

   922         {

   923         if ( streams[i]->Type() == KMceAudio )

   924             {

   925             CMceAudioStream* audioStream = 

   926                             static_cast<CMceAudioStream*>( streams[i] );

   927             

   928             const RPointerArray<CMceAudioCodec>& codecs = audioStream->Codecs();

   929             

   930             for ( TInt i = 0; i < codecs.Count(); ++i )

   931                 {

   932                 audioCodecFound = ETrue;

   933 

   934                 EUNIT_ASSERT( codecs[i]->MMFPriority() == 

   935                               KAudioPrioritySwisPlayback )

   936                 EUNIT_ASSERT( codecs[i]->MMFPriorityPreference() == 

   937                               KAudioPrefSwisPlayback )

   938                 }

   939             }

   940         else

   941             {

   942             videoStream = static_cast<CMceVideoStream*>( streams[i] );

   943             

   944             const RPointerArray<CMceVideoCodec>& codecs = videoStream->Codecs();

   945             

   946             for ( TInt i = 0; i < codecs.Count(); ++i )

   947                 {

   948                 videoCodecFound = ETrue;

   949 

   950                 EUNIT_ASSERT( codecs[i]->iPayloadType == 96 ||

   951                               codecs[i]->iPayloadType == 98 )

   952                 }

   953             }

   954     

   955         }

   956         

   957     EUNIT_ASSERT( audioCodecFound ) // At least one audiocodec found

   958     EUNIT_ASSERT( videoCodecFound ) // At least one videocodec found

   959     

   960     // Test removing of H.263 multiples (mode 2000 preferred)

   961     EUNIT_ASSERT( videoStream != NULL )

   962     for ( TInt i = videoStream->Codecs().Count() - 1; i >= 0; i-- )

   963         {

   964         videoStream->RemoveCodecL( 

   965             *const_cast<CMceVideoCodec*>( videoStream->Codecs()[ i ] ) );

   966         }

   967     CMceH263Codec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

   968     videoStream->AddCodecL( codecH2632000 );

   969     CleanupStack::Pop( codecH2632000 );

   970     

   971     CMceH263Codec* codecH2631998 = CMceH263Codec::NewLC( KMceSDPNameH2631998() );

   972     videoStream->AddCodecL( codecH2631998 );

   973     CleanupStack::Pop( codecH2631998 );

   974     

   975     iClipSession->AdjustStreamsAndCodecsL();

   976     

   977     // 1998 version should have been removed

   978     for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )

   979         {

   980         EUNIT_ASSERT( 

   981             !videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH2632000() ) );

   982         }

   983         

   984     // Test removing of multiples with different bitrates

   985     for ( TInt i = videoStream->Codecs().Count() - 1; i >= 0; i-- )

   986         {

   987         videoStream->RemoveCodecL( 

   988             *const_cast<CMceVideoCodec*>( videoStream->Codecs()[ i ] ) );

   989         }

   990     codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

   991     codecH2632000->SetMaxBitrateL( 64000 );

   992     videoStream->AddCodecL( codecH2632000 );

   993     CleanupStack::Pop( codecH2632000 );

   994     

   995     codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

   996     codecH2632000->SetMaxBitrateL( 128000 );

   997     videoStream->AddCodecL( codecH2632000 );

   998     CleanupStack::Pop( codecH2632000 );

   999     

  1000     iClipSession->AdjustStreamsAndCodecsL();

  1001     

  1002      // Lower bitrate version should have been removed

  1003     for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )

  1004         {

  1005         EUNIT_ASSERT( 

  1006             videoStream->Codecs()[ i ]->MaxBitRate() == 128000 );

  1007         }

  1008     

  1009     // Test for Configuration based codec removal. Magic uid not set.    

  1010     CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );    

  1011     videoStream->AddCodecL( codecAvc );

  1012     CleanupStack::Pop( codecAvc );         

  1013     iClipSession->AdjustStreamsAndCodecsL();   

  1014     TBool avcCodecFound(EFalse);

  1015     for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )

  1016       {      

  1017       if( !videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH264 ) )

  1018         {

  1019         avcCodecFound = ETrue;

  1020         }      

  1021       }

  1022     // AVC should present

  1023     EUNIT_ASSERT(avcCodecFound);

  1024     

  1025     // Test for Configuration based codec removal. Magic uid set.

  1026     // Store the real value and revert back later , so that other tests will not be affected.

  1027     TUid uid = MultimediaSharingSettings::EncodingDeviceL();    

  1028     TInt32 KMusDisableAVC = 0x0fffffff;

  1029     MultimediaSharingSettings::SetPropertyValueL( MusSettingsKeys::KEncodingDevice,KMusDisableAVC);

  1030     codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );    

  1031     videoStream->AddCodecL( codecAvc );

  1032     CleanupStack::Pop( codecAvc );  

  1033     codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

  1034     videoStream->AddCodecL( codecH2632000 );

  1035     CleanupStack::Pop( codecH2632000 );

  1036     iClipSession->AdjustStreamsAndCodecsL();    

  1037     for ( TInt i = 0; i < videoStream->Codecs().Count(); i++ )

  1038        {

  1039        // H264 ( AVC ) codec should be removed

  1040        EUNIT_ASSERT( 

  1041                    videoStream->Codecs()[ i ]->SdpName().CompareF( KMceSDPNameH264 ) );

  1042        }

  1043     

  1044     

  1045     MultimediaSharingSettings::SetPropertyValueL( MusSettingsKeys::KEncodingDevice,uid.iUid);

  1046     

  1047     

  1048     }

  1049 

  1050 

  1051 // -----------------------------------------------------------------------------

  1052 //

  1053 // -----------------------------------------------------------------------------

  1054 //  

  1055 void UT_CMusEngMceSession::UT_CMusEngMceSession_IncomingSessionL()

  1056     {

  1057     // New session should get rejected and deleted in any case, first failure

  1058     CMceInSession* inSession = CMceInSession::NewL( 

  1059                                       *iLiveSession->iManager, KNullDesC8 );

  1060     CleanupStack::PushL( inSession );

  1061     iLiveSession->IncomingSession( inSession, NULL );

  1062     CleanupStack::Pop( inSession );

  1063     

  1064     // And then succesfull case, this would leak memory if session was not

  1065     // deleted

  1066     inSession = CMceInSession::NewL( *iLiveSession->iManager, KNullDesC8 );

  1067     CleanupStack::PushL( inSession );

  1068     iLiveSession->IncomingSession( inSession, NULL );

  1069     CleanupStack::Pop( inSession );

  1070     }

  1071 

  1072 

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 // -----------------------------------------------------------------------------

  1076 //  

  1077 void UT_CMusEngMceSession::UT_CMusEngMceSession_IncomingUpdateL()

  1078     {

  1079     CMceInSession* inSession = CMceInSession::NewL( 

  1080                                       *iLiveSession->iManager, KNullDesC8 );

  1081     

  1082     // Try to update before having a session, session gets rejected and deleted

  1083     CleanupStack::PushL( inSession );

  1084     iLiveSession->IncomingUpdate( *inSession, inSession, NULL );

  1085     CleanupStack::Pop( inSession );

  1086     

  1087     

  1088     // Try to update with unknown session, session gets rejected and deleted

  1089     ESTABLISH_OUT_SESSION( iLiveSession )

  1090     

  1091     inSession = CMceInSession::NewL( 

  1092                                       *iLiveSession->iManager, KNullDesC8 );

  1093     CleanupStack::PushL( inSession );

  1094     iLiveSession->IncomingUpdate( *inSession, inSession, NULL );

  1095     CleanupStack::Pop( inSession );

  1096     

  1097     // Normal case, old session gets deleted. New session gets rejected.

  1098     

  1099     inSession = CMceInSession::NewL( 

  1100                                       *iLiveSession->iManager, KNullDesC8 );

  1101     CleanupStack::PushL( inSession );

  1102     iLiveSession->IncomingUpdate( *iLiveSession->iSession, inSession, NULL );

  1103     CleanupStack::Pop( inSession );

  1104     

  1105     EUNIT_ASSERT( iLiveSession->iSession == inSession )

  1106     EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::ETerminated )

  1107     

  1108     }

  1109         

  1110 

  1111 // -----------------------------------------------------------------------------

  1112 //

  1113 // -----------------------------------------------------------------------------

  1114 //  

  1115 void UT_CMusEngMceSession::UT_CMusEngMceSession_StreamStateChangedL()

  1116     {

  1117     // Try without a session, nothing happens

  1118     CMceAudioStream* audioStream = CMceAudioStream::NewLC();

  1119     iLiveSession->CMusEngMceSession::StreamStateChanged( *audioStream );

  1120     CleanupStack::PopAndDestroy( audioStream );

  1121     

  1122     // Simulate sending invite

  1123     iLiveSession->InviteL( KTestRecipientSipUri() );

  1124     

  1125     // No observer set, so expect nothing to be done, cannot be asserted

  1126     CMceMediaStream* changedStream = iLiveSession->iSession->Streams()[0];

  1127 

  1128     // Try all the stream states

  1129     

  1130     // EUninitialized, stream is created, unexpected change, nothing happens

  1131     changedStream->iState = CMceMediaStream::EUninitialized;

  1132     iLiveSession->CMusEngMceSession::StreamStateChanged( *changedStream );

  1133     EUNIT_ASSERT( iObserver->IsReseted() );

  1134