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_musengtwowayrecvsession.h"

    21 #include "musengstubs.h"

    22 #include "musengtestdefs.h"

    23 #include "musengtwowayrecvsession.h"

    24 #include "musengmceutils.h"

    25 #include "mussessionproperties.h"

    26 #include "contactenginestub.h"

    27 #include "musenglivevideoplayer.h"

    28 

    29 //  SYSTEM INCLUDES

    30 #include <eunitmacros.h>

    31 

    32 #include <mceinsession.h>

    33 #include <mcestreambundle.h>

    34 #include <mcevideostream.h>

    35 #include <mceaudiostream.h>

    36 #include <mcertpsource.h>

    37 #include <mcedisplaysink.h>

    38 #include <mcespeakersink.h>

    39 #include <mcecamerasource.h>

    40 #include <mcefilesource.h>

    41 #include <mcertpsink.h>

    42 #include <mceaudiocodec.h>

    43 #include <mceh263codec.h>

    44 #include <mceavccodec.h>

    45 #include <musmanager.h>

    46 

    47 #include <audiopreference.h>

    48 

    49 // Incoming session may be rejected silently due memory running out. Ensure that 

    50 // incoming session was handled fully by using this macro.

    51 #define MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L \

    52 __ASSERT_ALWAYS( iReceiveSession->iSession && \

    53 iReceiveSession->iSession->iState != CMceSession::ETerminated, User::Leave( KErrNoMemory ) );

    54 

    55 

    56 // -----------------------------------------------------------------------------

    57 //

    58 // -----------------------------------------------------------------------------

    59 //

    60 UT_CMusEngTwoWayRecvSession* UT_CMusEngTwoWayRecvSession::NewL()

    61     {

    62     UT_CMusEngTwoWayRecvSession* self = UT_CMusEngTwoWayRecvSession::NewLC();

    63     CleanupStack::Pop( self );

    64     return self;

    65     }

    66 

    67 

    68 // -----------------------------------------------------------------------------

    69 //

    70 // -----------------------------------------------------------------------------

    71 // 

    72 UT_CMusEngTwoWayRecvSession* UT_CMusEngTwoWayRecvSession::NewLC()

    73     {

    74     UT_CMusEngTwoWayRecvSession* self = new( ELeave ) UT_CMusEngTwoWayRecvSession();

    75     CleanupStack::PushL( self );

    76     self->ConstructL();

    77     return self;

    78     }

    79 

    80 

    81 // -----------------------------------------------------------------------------

    82 //

    83 // -----------------------------------------------------------------------------

    84 //

    85 UT_CMusEngTwoWayRecvSession::~UT_CMusEngTwoWayRecvSession()

    86     {

    87     // NOP

    88     }

    89 

    90 

    91 // -----------------------------------------------------------------------------

    92 // Default constructor

    93 // -----------------------------------------------------------------------------

    94 //

    95 UT_CMusEngTwoWayRecvSession::UT_CMusEngTwoWayRecvSession()

    96     {

    97     // NOP

    98     }

    99 

   100 

   101 // -----------------------------------------------------------------------------

   102 // Second phase construct

   103 // -----------------------------------------------------------------------------

   104 //

   105 void UT_CMusEngTwoWayRecvSession::ConstructL()

   106     {

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

   108     // It generates the test case table.

   109     CEUnitTestSuiteClass::ConstructL();

   110     }

   111     

   112 

   113 // -----------------------------------------------------------------------------

   114 //

   115 // -----------------------------------------------------------------------------

   116 //

   117 void UT_CMusEngTwoWayRecvSession::SetupL(  )

   118     {

   119     iLcSessionObserver = new( ELeave )CLcSessionObserverStub;

   120     iReceiveSession = CMusEngTwoWayRecvSession::NewL();

   121     iReceiveSession->SetLcSessionObserver( iLcSessionObserver );

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 //

   126 // -----------------------------------------------------------------------------

   127 //

   128 void UT_CMusEngTwoWayRecvSession::Teardown(  )

   129     {

   130     delete iReceiveSession;

   131     delete iLcSessionObserver;

   132     PropertyHelper::Close();

   133     }

   134 

   135 

   136 // TEST HELPERS

   137 

   138 // -----------------------------------------------------------------------------

   139 //

   140 // -----------------------------------------------------------------------------

   141 //

   142 CMceVideoStream* UT_CMusEngTwoWayRecvSession::ConstructVideoInStreamLC()

   143     {

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

   145     

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

   147     CleanupStack::Pop();

   148     

   149     videoStream->AddSinkL( 

   150                 CMceDisplaySink::NewLC( *iReceiveSession->iManager ) );

   151     CleanupStack::Pop();    

   152     

   153     return videoStream;

   154     }

   155 

   156 

   157 // -----------------------------------------------------------------------------

   158 //

   159 // -----------------------------------------------------------------------------

   160 //

   161 CMceVideoStream* UT_CMusEngTwoWayRecvSession::ConstructVideoOutStreamLC()

   162     {

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

   164        

   165     videoStream->SetSourceL( 

   166                 CMceCameraSource::NewLC( *iReceiveSession->iManager ) );

   167     CleanupStack::Pop();

   168     

   169     videoStream->AddSinkL( CMceRtpSink::NewLC() );

   170     CleanupStack::Pop();

   171     

   172     return videoStream;

   173     }    

   174 

   175 

   176 // -----------------------------------------------------------------------------

   177 //

   178 // -----------------------------------------------------------------------------

   179 //   

   180 CMceAudioStream* UT_CMusEngTwoWayRecvSession::ConstructAudioInStreamLC()

   181     {

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

   183    

   184     audioStream->SetSourceL( CMceRtpSource::NewLC() );

   185     CleanupStack::Pop();

   186     

   187     audioStream->AddSinkL( CMceSpeakerSink::NewLC() );

   188     CleanupStack::Pop();

   189     

   190     return audioStream;

   191     }

   192 

   193 

   194 // -----------------------------------------------------------------------------

   195 //

   196 // -----------------------------------------------------------------------------

   197 //   

   198 CMceAudioStream* UT_CMusEngTwoWayRecvSession::ConstructAudioOutStreamLC()

   199     {

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

   201 

   202     audioStream->SetSourceL( 

   203         CMceFileSource::NewLC( *iReceiveSession->iManager, KNullDesC() ) );

   204     CleanupStack::Pop();

   205     

   206     audioStream->AddSinkL( CMceRtpSink::NewLC() );

   207     CleanupStack::Pop();

   208 

   209     return audioStream;

   210 

   211     }

   212                                                  

   213 

   214 // -----------------------------------------------------------------------------

   215 // Helper to construct incoming sessions.

   216 // -----------------------------------------------------------------------------

   217 //

   218 CMceInSession* UT_CMusEngTwoWayRecvSession::ConstructInSessionLC( 

   219                                              TInt aVideoStreamCount,

   220                                              TInt aAudioStreamCount,

   221                                              TBool aConstructSinks )

   222     {

   223     CMceInSession* inSession = CMceInSession::NewL( 

   224                                         *(iReceiveSession->iManager), 

   225                                         KTestOriginator() );

   226     CleanupStack::PushL( inSession );

   227                                         

   228     for ( TInt i = 0; i < aVideoStreamCount; ++i )

   229         {

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

   231         

   232         CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

   233         videoStream->SetSourceL( rtpSource );

   234         CleanupStack::Pop( rtpSource );

   235         

   236         if ( aConstructSinks )

   237             {

   238             CMceDisplaySink* display = CMceDisplaySink::NewLC( 

   239                                                 *(iReceiveSession->iManager) );

   240             videoStream->AddSinkL( display );

   241             CleanupStack::Pop( display );

   242             }

   243         

   244         inSession->AddStreamL( videoStream );

   245         CleanupStack::Pop( videoStream );

   246         }

   247     

   248     for ( TInt i = 0; i < aAudioStreamCount; ++i )

   249         {

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

   251         

   252         CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

   253         audioStream->SetSourceL( rtpSource );

   254         CleanupStack::Pop( rtpSource );

   255         

   256         if ( aConstructSinks )

   257             {

   258             CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC();

   259             audioStream->AddSinkL( speaker );

   260             CleanupStack::Pop( speaker );

   261             }

   262         

   263         inSession->AddStreamL( audioStream );

   264         CleanupStack::Pop( audioStream );

   265         }    

   266     

   267     return inSession;

   268     }

   269                                              

   270 // -----------------------------------------------------------------------------

   271 // Helper to construct incoming two-way video session.

   272 // -----------------------------------------------------------------------------

   273 //

   274 CMceInSession* UT_CMusEngTwoWayRecvSession::ConstructTwoWayInSessionLC( TBool aConstructSinks )

   275     {

   276     CMceInSession* inSession = CMceInSession::NewL( 

   277                                         *(iReceiveSession->iManager), 

   278                                         KTestOriginator() );

   279     CleanupStack::PushL( inSession );

   280                                         

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

   282         

   283     CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

   284     videoStream->SetSourceL( rtpSource );

   285     CleanupStack::Pop( rtpSource );

   286     

   287     if ( aConstructSinks )

   288         {

   289         CMceDisplaySink* display = CMceDisplaySink::NewLC( 

   290                                             *(iReceiveSession->iManager) );

   291         videoStream->AddSinkL( display );

   292         CleanupStack::Pop( display );

   293         }

   294     

   295     CMceVideoStream* videoOutStream = CMceVideoStream::NewLC();

   296           

   297     CMceCameraSource* cameraSource = CMceCameraSource::NewLC( *(iReceiveSession->iManager) );

   298     videoOutStream->SetSourceL( cameraSource );

   299     CleanupStack::Pop( cameraSource );

   300       

   301     if ( aConstructSinks )

   302         {

   303         CMceRtpSink* rtpSink = CMceRtpSink::NewLC();

   304         videoOutStream->AddSinkL( rtpSink );

   305         CleanupStack::Pop( rtpSink );

   306         }

   307     videoStream->BindL( videoOutStream );

   308     CleanupStack::Pop( videoOutStream );

   309     

   310     inSession->AddStreamL( videoStream );

   311     CleanupStack::Pop( videoStream );

   312     

   313     return inSession;

   314     }                                             

   315 

   316 

   317 // TEST CASES

   318 

   319 

   320 // -----------------------------------------------------------------------------

   321 //

   322 // -----------------------------------------------------------------------------

   323 //

   324 void UT_CMusEngTwoWayRecvSession::UT_NewLL(  )

   325     {

   326     EUNIT_ASSERT( iReceiveSession );

   327     EUNIT_ASSERT( !iReceiveSession->iSession );

   328     EUNIT_ASSERT( iReceiveSession->iMceManagerUid == 

   329                   TUid::Uid(CMusManager::ESipInviteDesired2WayVideo) );

   330     }

   331 

   332 

   333 

   334 // -----------------------------------------------------------------------------

   335 //

   336 // -----------------------------------------------------------------------------

   337 //

   338 void UT_CMusEngTwoWayRecvSession::UT_EnableDisplayLL()

   339     {

   340     TRAPD( error, iReceiveSession->EnableDisplayL( ETrue ) );

   341     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   342     EUNIT_ASSERT( error == KErrNotReady );

   343     

   344     TMceTransactionDataContainer container;

   345     CMceInSession* inSession = ConstructTwoWayInSessionLC();

   346     iReceiveSession->IncomingSession( inSession, &container );

   347     CleanupStack::Pop( inSession );

   348     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   349     

   350     CMceDisplaySink* display = 

   351                     MusEngMceUtils::GetDisplayL( *(iReceiveSession->iSession) );

   352     

   353     CMceDisplaySink* receivingDisplay = 

   354                     MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   355     

   356     // Disable

   357     iReceiveSession->EnableDisplayL( EFalse );

   358     

   359     EUNIT_ASSERT( !display->iIsEnabled );

   360     EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

   361     

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

   363     

   364     iReceiveSession->EnableDisplayL( EFalse );

   365     

   366     EUNIT_ASSERT( !display->iIsEnabled );

   367     EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

   368 

   369     // Enable

   370     

   371     iReceiveSession->EnableDisplayL( ETrue );

   372     

   373     EUNIT_ASSERT( display->iIsEnabled );

   374     EUNIT_ASSERT( receivingDisplay->iIsEnabled );

   375     

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

   377     

   378     iReceiveSession->EnableDisplayL( ETrue );

   379     

   380     EUNIT_ASSERT( display->iIsEnabled );

   381     EUNIT_ASSERT( receivingDisplay->iIsEnabled );

   382         

   383     // Session does not have sending stream (viewfinder does not exist)

   384     //

   385     delete iReceiveSession->iSession;

   386     iReceiveSession->iSession = NULL;

   387     inSession = ConstructInSessionLC( 1, 0 );

   388     iReceiveSession->IncomingSession( inSession, &container );

   389     CleanupStack::Pop( inSession );

   390     display = MusEngMceUtils::GetVfDisplay( *(iReceiveSession->iSession) );  

   391     EUNIT_ASSERT( display == NULL );

   392     receivingDisplay = MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   393     iReceiveSession->EnableDisplayL( EFalse );

   394     EUNIT_ASSERT( !receivingDisplay->iIsEnabled );  

   395 

   396     }

   397 

   398 // -----------------------------------------------------------------------------

   399 //

   400 // -----------------------------------------------------------------------------

   401 //

   402 void UT_CMusEngTwoWayRecvSession::UT_SetOrientationLL()

   403     {

   404     // Try without session, fails

   405     EUNIT_ASSERT_SPECIFIC_LEAVE( iReceiveSession->SetOrientationL( 

   406                                                CMusEngMceSession::EPortrait ), 

   407                                 KErrNotReady )

   408     

   409     TMceTransactionDataContainer container;

   410     CMceInSession* inSession = ConstructTwoWayInSessionLC();

   411     iReceiveSession->IncomingSession( inSession, &container );

   412     CleanupStack::Pop( inSession );

   413     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   414     

   415     CMceDisplaySink* display = 

   416                    MusEngMceUtils::GetDisplayL( *iReceiveSession->iSession );

   417     

   418     CMceDisplaySink* receivingDisplay = 

   419                    MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   420        

   421     

   422     // Check the initial state

   423     display->iRotation = CMceDisplaySink::ENone;

   424     receivingDisplay->iRotation = CMceDisplaySink::ENone;

   425     EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

   426                         CMusEngMceSession::EPortrait )      

   427                         

   428     // Successfully change orientation

   429     

   430     iReceiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

   431     EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

   432                         CMusEngMceSession::ELandscape )

   433     

   434     EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::EClockwise90Degree );

   435     EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::EClockwise90Degree );

   436     

   437     iReceiveSession->SetOrientationL( CMusEngMceSession::EPortrait );

   438     EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

   439                         CMusEngMceSession::EPortrait )          

   440     

   441     EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::ENone );

   442     EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::ENone );

   443     

   444     // Session does not have sending stream (viewfinder does not exist)

   445     delete iReceiveSession->iSession;

   446     iReceiveSession->iSession = NULL;

   447     inSession = ConstructInSessionLC( 1, 0 );

   448     iReceiveSession->IncomingSession( inSession, &container );

   449     CleanupStack::Pop( inSession );

   450     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   451     display = MusEngMceUtils::GetVfDisplay( *(iReceiveSession->iSession) );  

   452     EUNIT_ASSERT( display == NULL );

   453     receivingDisplay = MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   454     iReceiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

   455     EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::EClockwise90Degree );

   456     }

   457 

   458 // -----------------------------------------------------------------------------

   459 //

   460 // -----------------------------------------------------------------------------

   461 //

   462 void UT_CMusEngTwoWayRecvSession::UT_OrientationLL()

   463     {

   464     // Try without session, fails

   465     EUNIT_ASSERT_SPECIFIC_LEAVE( iReceiveSession->OrientationL(), 

   466                                 KErrNotReady )

   467     

   468     TMceTransactionDataContainer container;

   469     CMceInSession* inSession = ConstructTwoWayInSessionLC();

   470     iReceiveSession->IncomingSession( inSession, &container );

   471     CleanupStack::Pop( inSession );

   472     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   473     

   474     CMceDisplaySink* receivingDisplay = 

   475          MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   476     receivingDisplay->iRotation = CMceDisplaySink::ENone;

   477     

   478     EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

   479                            CMusEngMceSession::EPortrait )      

   480     

   481     receivingDisplay->iRotation = CMceDisplaySink::EClockwise90Degree;

   482         

   483     EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

   484                                CMusEngMceSession::ELandscape ) 

   485     }

   486 

   487 // -----------------------------------------------------------------------------

   488 //

   489 // -----------------------------------------------------------------------------

   490 //

   491 void UT_CMusEngTwoWayRecvSession::UT_SetLocalRectLL()

   492     {

   493     // Does nothing real before session establishment

   494     TRect rect1( 100, 200, 300, 500 );

   495     iReceiveSession->SetSecondaryRectL( rect1 ); 

   496     

   497     EUNIT_ASSERT( rect1 == iReceiveSession->iLocalRect );

   498     

   499     // Local rect changing affects to viewfinder display sink not to receiving video

   500     //

   501     TMceTransactionDataContainer container;

   502     CMceInSession* inSession = ConstructTwoWayInSessionLC();

   503     iReceiveSession->IncomingSession( inSession, &container );

   504     CleanupStack::Pop( inSession );

   505     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   506     

   507     CMceDisplaySink* vfDisplay = 

   508                    MusEngMceUtils::GetDisplayL( *( iReceiveSession->iSession ) );

   509     CMceDisplaySink* receivingDisplay = 

   510                    MusEngMceUtils::GetReceivingDisplayL( *( iReceiveSession->iSession ) );

   511 

   512     EUNIT_ASSERT( vfDisplay->DisplayRectL() == iReceiveSession->iLocalRect );

   513     EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iReceiveSession->iLocalRect );

   514         

   515     TRect rect2( 200, 200, 300, 500 );

   516     iReceiveSession->SetSecondaryRectL( rect2 ); 

   517     EUNIT_ASSERT( rect2 == iReceiveSession->iLocalRect );

   518     EUNIT_ASSERT( vfDisplay->DisplayRectL() == iReceiveSession->iLocalRect );

   519     EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iReceiveSession->iLocalRect );

   520     

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

   522     

   523     iReceiveSession->iSession->iState = CMceSession::ETerminated;

   524     

   525     TRect rect3( 300, 300, 400, 600 );

   526     

   527     iReceiveSession->SetSecondaryRectL( rect3 ); 

   528     

   529     EUNIT_ASSERT( vfDisplay->DisplayRectL() != rect3 )

   530     }

   531 

   532 // -----------------------------------------------------------------------------

   533 //

   534 // -----------------------------------------------------------------------------

   535 //

   536 void UT_CMusEngTwoWayRecvSession::UT_SetRectsLL()

   537     {

   538     // Does nothing real before session establishment

   539     TRect localrect1( 100, 200, 300, 400 );

   540     TRect remoterect1( 100, 200, 300, 500 );

   541     iReceiveSession->SetRectsL( remoterect1, localrect1 ); 

   542     

   543     EUNIT_ASSERT( localrect1 == iReceiveSession->iLocalRect );

   544     EUNIT_ASSERT( remoterect1 == iReceiveSession->iRect );

   545     

   546     // Local rect changing affects to viewfinder display sink and remote rect to

   547     // receiving video display sink

   548     //

   549     TMceTransactionDataContainer container;

   550     CMceInSession* inSession = ConstructTwoWayInSessionLC();

   551     iReceiveSession->IncomingSession( inSession, &container );

   552     CleanupStack::Pop( inSession );

   553     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   554     

   555     CMceDisplaySink* vfDisplay = 

   556                    MusEngMceUtils::GetDisplayL( *( iReceiveSession->iSession ) );

   557     CMceDisplaySink* receivingDisplay = 

   558                    MusEngMceUtils::GetReceivingDisplayL( *( iReceiveSession->iSession ) );

   559 

   560     TRect localrect2( 200, 200, 300, 400 );

   561     TRect remoterect2( 200, 200, 300, 500 );

   562     EUNIT_ASSERT( vfDisplay->DisplayRectL() != localrect2 );

   563     EUNIT_ASSERT( receivingDisplay->DisplayRectL() != remoterect2 );

   564 

   565     iReceiveSession->SetRectsL( remoterect2, localrect2 ); 

   566     EUNIT_ASSERT( localrect2 == iReceiveSession->iLocalRect );

   567     EUNIT_ASSERT( remoterect2 == iReceiveSession->iRect );

   568     EUNIT_ASSERT( vfDisplay->DisplayRectL() == iReceiveSession->iLocalRect );

   569     EUNIT_ASSERT( receivingDisplay->DisplayRectL() == iReceiveSession->iRect );

   570     

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

   572     

   573     iReceiveSession->iSession->iState = CMceSession::ETerminated;

   574     

   575     TRect localrect3( 300, 200, 300, 400 );

   576     TRect remoterect3( 300, 200, 300, 500 );

   577     

   578     iReceiveSession->SetRectsL( remoterect3, localrect3 );

   579     

   580     EUNIT_ASSERT( vfDisplay->DisplayRectL() != localrect3 )

   581     EUNIT_ASSERT( receivingDisplay->DisplayRectL() != remoterect3 );

   582     

   583     // Session does not have sending stream (viewfinder does not exist)

   584     

   585     TRect localrect4( 400, 200, 300, 400 );

   586     TRect remoterect4( 400, 200, 300, 500 );

   587     delete iReceiveSession->iSession;

   588     iReceiveSession->iSession = NULL;

   589     inSession = ConstructInSessionLC( 1, 0 );

   590     iReceiveSession->IncomingSession( inSession, &container );

   591     CleanupStack::Pop( inSession );

   592     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   593     vfDisplay = MusEngMceUtils::GetVfDisplay( *(iReceiveSession->iSession) );  

   594     EUNIT_ASSERT( vfDisplay == NULL );

   595     receivingDisplay = MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

   596     iReceiveSession->SetRectsL( remoterect4, localrect4 );

   597     EUNIT_ASSERT( localrect4 == iReceiveSession->iLocalRect );

   598     EUNIT_ASSERT( remoterect4 == iReceiveSession->iRect );

   599     EUNIT_ASSERT( receivingDisplay->DisplayRectL() == iReceiveSession->iRect );

   600     }

   601 

   602 // -----------------------------------------------------------------------------

   603 //

   604 // -----------------------------------------------------------------------------

   605 //

   606 void UT_CMusEngTwoWayRecvSession::UT_CameraL()

   607     {

   608     // Camera cannot be used without MCE session

   609     //

   610     EUNIT_ASSERT_LEAVE( iReceiveSession->Camera().ChangeCameraL( 

   611             TMusEngCameraHandler::EFrontCamera ) );

   612     

   613     // Camera cannot be used without video out stream

   614     //

   615     TMceTransactionDataContainer container;

   616     CMceInSession* inSession = ConstructInSessionLC( 1, 0 );

   617     iReceiveSession->IncomingSession( inSession, &container );

   618     CleanupStack::Pop( inSession );

   619     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   620     EUNIT_ASSERT_LEAVE( iReceiveSession->Camera().ChangeCameraL( 

   621             TMusEngCameraHandler::EFrontCamera ) );

   622     

   623     // Camera can be used when video out stream exists

   624     //

   625     delete iReceiveSession->iSession;

   626     iReceiveSession->iSession = NULL;

   627     inSession = ConstructTwoWayInSessionLC();

   628     iReceiveSession->IncomingSession( inSession, &container );

   629     CleanupStack::Pop( inSession );

   630     MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

   631     iReceiveSession->Camera().ChangeCameraL( 

   632             TMusEngCameraHandler::EFrontCamera );

   633     }

   634 

   635 // -----------------------------------------------------------------------------

   636 //

   637 // -----------------------------------------------------------------------------

   638 //

   639 void UT_CMusEngTwoWayRecvSession::UT_LocalVideoPlayerL()

   640     {

   641     EUNIT_ASSERT( iReceiveSession->LocalVideoPlayer() == 

   642                   iReceiveSession->iLiveVideoPlayer )

   643     }

   644    

   645 // -----------------------------------------------------------------------------

   646 //

   647 // -----------------------------------------------------------------------------

   648 //

   649 void UT_CMusEngTwoWayRecvSession::UT_HandleSessionStateChangedL()

   650     {

   651     // Unknown session, let the base class handle 

   652     CMceInSession* inSession = ConstructInSessionLC( 1, 1 );

   653 

   654     iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

   655     

   656     // Simulate incoming session

   657     TMceTransactionDataContainer container;

   658     

   659     iReceiveSession->IncomingSession( inSession, &container ); 

   660     CleanupStack::Pop( inSession );

   661     

   662     // Session is in state EReserving, let the base class handle

   663     iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

   664     

   665     // The normal cases:

   666     

   667     // 1 ) First transition to state EProceeding, user and remote end should

   668     //     be notified

   669     inSession->iState = CMceSession::EProceeding;

   670     iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

   671     EUNIT_ASSERT_EQUALS( TInt( iLcSessionObserver->iCalledFunction ),

   672                          TInt( CLcSessionObserverStub::ESessionStateChanged ) )

   673     EUNIT_ASSERT( iReceiveSession->iRingLCalled )

   674     iLcSessionObserver->Reset();

   675     

   676     // 2 ) Now simulate second transition to EProceeding state which can happen

   677     //     if we force 100rel to be used. User and remote end should not be 

   678     //     notified anymore but change should be ignored.

   679     inSession->iState = CMceSession::EProceeding;

   680     iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

   681     EUNIT_ASSERT_EQUALS( TInt( CLcSessionObserverStub::EUnknown ),

   682                          TInt( iLcSessionObserver->iCalledFunction ) )

   683     }

   684 

   685 

   686 // -----------------------------------------------------------------------------

   687 //

   688 // -----------------------------------------------------------------------------

   689 // 

   690 void UT_CMusEngTwoWayRecvSession::UT_AdjustVideoCodecLL()

   691     {

   692     CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

   693     CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

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

   695     CMceVideoCodec* codecUnknown = CMceH263Codec::NewLC( KNullDesC8() );

   696     

   697     iReceiveSession->AdjustVideoCodecL( *codecH263, KMceRTPSource );

   698     iReceiveSession->AdjustVideoCodecL( *codecH2632000, KMceRTPSource );

   699     iReceiveSession->AdjustVideoCodecL( *codecAvc, KMceRTPSource );

   700     iReceiveSession->AdjustVideoCodecL( *codecUnknown, KMceRTPSource );

   701     

   702     EUNIT_ASSERT_EQUALS( codecH263->KeepAliveTimer(), 6 )

   703     EUNIT_ASSERT_EQUALS( codecH263->KeepAlivePayloadType(), 96 )

   704     EUNIT_ASSERT_EQUALS( codecH263->KeepAliveData(), KNullDesC8() )

   705     

   706     EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveTimer(), 6 )

   707     EUNIT_ASSERT_EQUALS( codecH2632000->KeepAlivePayloadType(), 96 )

   708     EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveData(), KNullDesC8() )

   709     

   710     EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveTimer(), 6 )

   711     EUNIT_ASSERT_EQUALS( codecAvc->KeepAlivePayloadType(), 98 )

   712     EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveData(), KNullDesC8() )

   713     

   714     EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveTimer(), 6 )

   715     EUNIT_ASSERT_EQUALS( codecUnknown->KeepAlivePayloadType(), 0 )

   716     EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveData(), KNullDesC8() )

   717                 

   718     CleanupStack::PopAndDestroy( codecUnknown );

   719     CleanupStack::PopAndDestroy( codecAvc );

   720     CleanupStack::PopAndDestroy( codecH2632000 );

   721     CleanupStack::PopAndDestroy( codecH263 );

   722     }

   723     

   724 

   725 // -----------------------------------------------------------------------------

   726 //

   727 // -----------------------------------------------------------------------------

   728 // 

   729 void UT_CMusEngTwoWayRecvSession::UT_AdjustAudioCodecLL()

   730     {

   731     CMceAudioCodec* codec = 

   732                 iReceiveSession->iManager->SupportedAudioCodecs()[0]->CloneL();

   733     CleanupStack::PushL( codec );

   734     iReceiveSession->AdjustAudioCodecL( *codec );

   735     

   736     // Test keepalive timer

   737     

   738     TUint8 keepAliveTimer = codec->KeepAliveTimer();

   739     EUNIT_ASSERT( codec->KeepAliveTimer() == 6 )

   740     EUNIT_ASSERT( codec->KeepAlivePayloadType() == 97 )

   741     EUNIT_ASSERT( codec->KeepAliveData() == KNullDesC8() )

   742 

   743     // Test that base class has been called

   744     

   745     EUNIT_ASSERT( codec->iMMFPriority == KAudioPrioritySwisPlayback )

   746     EUNIT_ASSERT( codec->iMMFPriorityPreference == KAudioPrefSwisPlayback )

   747     

   748     CleanupStack::PopAndDestroy( codec );

   749     }

   750 

   751 

   752 // -----------------------------------------------------------------------------

   753 //

   754 // -----------------------------------------------------------------------------

   755 // 

   756 void UT_CMusEngTwoWayRecvSession::UT_DoCodecSelectionLL()

   757     {    

   758     // Check that Non-Interleaved AVC is preferred over single NAL 

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

   760     

   761     CMceVideoCodec* codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   762     codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; 

   763     videoStream->AddCodecL( codecAvcSingleNal );

   764     CleanupStack::Pop( codecAvcSingleNal );

   765     

   766     CMceVideoCodec* codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   767     codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved;

   768     videoStream->AddCodecL( codecAvcNonInterleaved );

   769     CleanupStack::Pop( codecAvcNonInterleaved );

   770     

   771     iReceiveSession->DoCodecSelectionL( *videoStream );

   772     

   773     EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

   774     EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() )

   775     EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(),

   776                          KMceAvcModeNonInterleaved )

   777     

   778     CleanupStack::PopAndDestroy( videoStream );

   779                          

   780     // Check that Single NAL AVC is preferred over H263

   781     videoStream = CMceVideoStream::NewLC();

   782     

   783     CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

   784     videoStream->AddCodecL( codecH263 );

   785     CleanupStack::Pop( codecH263 );

   786     

   787     codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   788     codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; 

   789     videoStream->AddCodecL( codecAvcSingleNal );

   790     CleanupStack::Pop( codecAvcSingleNal );

   791 

   792     iReceiveSession->DoCodecSelectionL( *videoStream );

   793     

   794     EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

   795     EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() )

   796     EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(),

   797                          KMceAvcModeSingleNal )

   798                          

   799     CleanupStack::PopAndDestroy( videoStream );

   800     

   801     // Check that H263 codecs without AVC are handled correctly (in base class)

   802     videoStream = CMceVideoStream::NewLC();

   803     

   804     codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

   805     videoStream->AddCodecL( codecH263 );

   806     CleanupStack::Pop( codecH263 );

   807     

   808     CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );   

   809     videoStream->AddCodecL( codecH2632000 );

   810     CleanupStack::Pop( codecH2632000 );

   811     

   812     iReceiveSession->DoCodecSelectionL( *videoStream );

   813     

   814     EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

   815     

   816     CleanupStack::PopAndDestroy( videoStream );

   817     

   818     // Check that AVC non-interleaved with best bitrate is preferred

   819     videoStream = CMceVideoStream::NewLC();

   820     

   821     codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   822     codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved;

   823     codecAvcNonInterleaved->SetMaxBitrateL( 80000 );

   824     videoStream->AddCodecL( codecAvcNonInterleaved );

   825     CleanupStack::Pop( codecAvcNonInterleaved );

   826     

   827     CMceVideoCodec* codecAvcNonInterleaved128 = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   828     codecAvcNonInterleaved128->iCodecMode = KMceAvcModeNonInterleaved;

   829     codecAvcNonInterleaved128->SetMaxBitrateL( 128000 );

   830     videoStream->AddCodecL( codecAvcNonInterleaved128 );

   831     CleanupStack::Pop( codecAvcNonInterleaved128 );

   832     

   833     iReceiveSession->DoCodecSelectionL( *videoStream );

   834     

   835     EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

   836     EUNIT_ASSERT( videoStream->Codecs()[0] == codecAvcNonInterleaved128 )

   837 

   838     CleanupStack::PopAndDestroy( videoStream );

   839     

   840     // Check that in case of several AVC single NALs, the best bitrate is preferred

   841     videoStream = CMceVideoStream::NewLC();

   842     

   843     codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   844     codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal;

   845     codecAvcSingleNal->SetMaxBitrateL( 80000 );

   846     videoStream->AddCodecL( codecAvcSingleNal );

   847     CleanupStack::Pop( codecAvcSingleNal );

   848     

   849     CMceVideoCodec* codecAvcSingleNal128 = CMceAvcCodec::NewLC( KMceSDPNameH264() );

   850     codecAvcSingleNal128->iCodecMode = KMceAvcModeSingleNal;

   851     codecAvcSingleNal128->SetMaxBitrateL( 128000 );

   852     videoStream->AddCodecL( codecAvcSingleNal128 );

   853     CleanupStack::Pop( codecAvcSingleNal128 );

   854     

   855     iReceiveSession->DoCodecSelectionL( *videoStream );

   856     

   857     EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

   858     EUNIT_ASSERT( videoStream->Codecs()[0] == codecAvcSingleNal128 )

   859 

   860     CleanupStack::PopAndDestroy( videoStream );

   861    

   862     }

   863             

   864 

   865 // -----------------------------------------------------------------------------

   866 //

   867 // -----------------------------------------------------------------------------

   868 //    

   869 void UT_CMusEngTwoWayRecvSession::UT_IncomingSessionL()

   870     {

   871     _LIT8( KMusEngSwisTestIdentifier, "Require: precondition" );

   872     _LIT8( KMusEngTestHeader, "Some header" );

   873 

   874     TMceTransactionDataContainer container;

   875     

   876     // Simulate SWIS 2.2 invite. There are no streams, so completion fails and 

   877     // session gets rejected. Still prenotification has been given.

   878     CMceInSession* inSession = ConstructInSessionLC( 0, 0 );

   879     CDesC8Array* headers = new ( ELeave ) CDesC8ArrayFlat( 2 );

   880     CleanupStack::PushL( headers );

   881     headers->AppendL( KMusEngTestHeader() );

   882     headers->AppendL( KMusEngSwisTestIdentifier() );

   883     container.SetHeaders( headers );

   884     CleanupStack::Pop( headers );

   885     iReceiveSession->IncomingSession( inSession, &container );    

   886     CleanupStack::Pop( inSession );

   887     container.Clear();

   888     

   889     EUNIT_ASSERT( iReceiveSession->iSession );

   890     EUNIT_ASSERT( iReceiveSession->iSession->iState == 

   891                   CMceSession::ETerminated );

   892     

   893     EUNIT_ASSERT( iReceiveSession->iSession->i100RelUsage == 

   894                   KMce100RelRequired )

   895     EUNIT_ASSERT( !iReceiveSession->iRingLCalled )              

   896 

   897     // Try again with valid session, normal case

   898     inSession = ConstructInSessionLC( 1, 0 );

   899     iReceiveSession->IncomingSession( inSession, &container );    

   900     CleanupStack::Pop( inSession );

   901     

   902     EUNIT_ASSERT( iReceiveSession->iSession );

   903     // Next state depends on success of completion of session structure.

   904     // When using alloc failure state is ETerminated, in succesfull case it is

   905     // EReserving. However it is set to "normal" state EReserving after 

   906     // assertion

   907     EUNIT_ASSERT( iReceiveSession->iSession->iState == 

   908                   CMceSession::EReserving ||

   909                   iReceiveSession->iSession->iState == 

   910                   CMceSession::ETerminated );

   911     iReceiveSession->iSession->iState = CMceSession::EReserving;

   912     

   913     // Try again without container, new session gets terminated and deleted

   914     inSession = ConstructInSessionLC( 1, 0 );

   915     iReceiveSession->IncomingSession( inSession, NULL );    

   916     CleanupStack::Pop( inSession );

   917     

   918     EUNIT_ASSERT( iReceiveSession->iSession );

   919     EUNIT_ASSERT( iReceiveSession->iSession != inSession );

   920     EUNIT_ASSERT( iReceiveSession->iSession->iState == 

   921                   CMceSession::EReserving );

   922                                

   923     // Try again when there is session pending, new session gets terminated

   924     // and deleted

   925     inSession = ConstructInSessionLC( 1, 0 );

   926     iReceiveSession->IncomingSession( inSession, &container );    

   927     CleanupStack::Pop( inSession );

   928     

   929     EUNIT_ASSERT( iReceiveSession->iSession );

   930     EUNIT_ASSERT( iReceiveSession->iSession != inSession );

   931     EUNIT_ASSERT( iReceiveSession->iSession->iState == 

   932                   CMceSession::EReserving );

   933     }

   934 

   935 // -----------------------------------------------------------------------------

   936 //

   937 // -----------------------------------------------------------------------------

   938 //

   939 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithoutSessionL()

   940     {

   941     TRAPD( error, iReceiveSession->CompleteSessionStructureL() );

   942     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   943     EUNIT_ASSERT( error == KErrNotReady );

   944     }

   945 

   946 

   947 // -----------------------------------------------------------------------------

   948 //

   949 // -----------------------------------------------------------------------------

   950 //

   951 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithoutStreamsL()

   952     {

   953     CMceInSession* inSession = ConstructInSessionLC( 0, 0 );

   954     iReceiveSession->iSession = inSession; // Transfers ownership

   955     CleanupStack::Pop( inSession );

   956     

   957     TRAPD( error, iReceiveSession->CompleteSessionStructureL() );

   958     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   959     EUNIT_ASSERT( error == KErrCorrupt );

   960     }

   961 

   962 

   963 // -----------------------------------------------------------------------------

   964 //

   965 // -----------------------------------------------------------------------------

   966 //

   967 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithOutgoingStreamL()

   968     {    

   969     // Stream will be removed.

   970     CMceInSession* inSession = ConstructInSessionLC( 0, 0 );

   971     

   972     inSession->AddStreamL( ConstructVideoOutStreamLC() );

   973     CleanupStack::Pop();

   974     

   975     iReceiveSession->iSession = inSession; // Transfers ownership

   976     CleanupStack::Pop( inSession );

   977     

   978     TRAPD( error, iReceiveSession->CompleteSessionStructureL() )

   979     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   980     EUNIT_ASSERT( error == KErrCorrupt );

   981     EUNIT_ASSERT( inSession->Streams().Count() == 0 );

   982     EUNIT_ASSERT( inSession->Bundles().Count() == 0 );

   983     }

   984 

   985 

   986 // -----------------------------------------------------------------------------

   987 //

   988 // -----------------------------------------------------------------------------

   989 //

   990 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithVideoInL()

   991     {

   992     CMceInSession* inSession = ConstructInSessionLC( 1, 0 );

   993 

   994     iReceiveSession->iSession = inSession; // Transfers ownership

   995     CleanupStack::Pop( inSession );

   996 

   997     iReceiveSession->CompleteSessionStructureL();

   998 

   999     EUNIT_ASSERT( inSession->Streams().Count() == 1 );

  1000     EUNIT_ASSERT( inSession->Streams()[0]->IsEnabled() )

  1001     EUNIT_ASSERT( inSession->Streams()[0]->Type() == KMceVideo )

  1002     EUNIT_ASSERT( inSession->Streams()[0]->Sinks().Count() == 1 )

  1003     EUNIT_ASSERT( inSession->Streams()[0]->Sinks()[0]->Type() == 

  1004                   KMceDisplaySink )

  1005     

  1006     // No audio, bundle is not constructed

  1007     EUNIT_ASSERT( inSession->Bundles().Count() == 0 )

  1008 

  1009     }

  1010 

  1011 

  1012 // -----------------------------------------------------------------------------

  1013 // Two-way video in incoming session. Incoming stream is the main stream.

  1014 // Both directions are enabled. Local viewfinder stream is added to display

  1015 // outgoing video locally

  1016 // -----------------------------------------------------------------------------

  1017 //

  1018 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithVideoOutBoundToVideoInL()

  1019     {    

  1020     CMceInSession* inSession = ConstructInSessionLC( 1, 0 );

  1021 

  1022     CMceVideoStream* videoOut = ConstructVideoOutStreamLC();

  1023     inSession->Streams()[0]->BindL( videoOut );

  1024     CleanupStack::Pop( videoOut );

  1025     

  1026     iReceiveSession->iSession = inSession; // Transfers ownership

  1027     CleanupStack::Pop( inSession );

  1028 

  1029     iReceiveSession->CompleteSessionStructureL();

  1030 

  1031     EUNIT_ASSERT( inSession->Streams().Count() == 2 );

  1032 

  1033     CMceMediaStream* videoIn = inSession->Streams()[0];

  1034      

  1035     EUNIT_ASSERT( videoIn->IsEnabled() )

  1036     EUNIT_ASSERT( videoIn->Type() == KMceVideo )

  1037     EUNIT_ASSERT( videoIn->Sinks().Count() == 1 )

  1038     EUNIT_ASSERT( videoIn->Sinks()[0]->Type() == KMceDisplaySink )

  1039 

  1040     EUNIT_ASSERT( videoIn->BoundStream() )

  1041     EUNIT_ASSERT( videoIn->BoundStreamL().IsEnabled() )    

  1042     

  1043     CMceMediaStream* videoVf = inSession->Streams()[1];

  1044     EUNIT_ASSERT( videoVf->IsEnabled() )

  1045     EUNIT_ASSERT( videoVf->Type() == KMceVideo )

  1046     EUNIT_ASSERT( videoVf->Sinks().Count() == 1 )

  1047     EUNIT_ASSERT( videoVf->Sinks()[0]->Type() == KMceDisplaySink )

  1048     EUNIT_ASSERT( videoVf->Source()->Type() == KMceCameraSource )

  1049   

  1050     // No audio, bundle is not constructed

  1051     EUNIT_ASSERT( inSession->Bundles().Count() == 0 )

  1052     }

  1053 

  1054 

  1055 // -----------------------------------------------------------------------------

  1056 // Two-way video in incoming session. Incoming stream is the bound stream.

  1057 // Both directions are enabled. Local viewfinder stream is added to display

  1058 // outgoing video locally

  1059 // -----------------------------------------------------------------------------

  1060 //

  1061 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithVideoInBoundToVideoOutL()

  1062     {

  1063     CMceInSession* inSession = ConstructInSessionLC( 0, 0 );

  1064 

  1065     CMceVideoStream* videoOut = ConstructVideoOutStreamLC();

  1066 

  1067     CMceVideoStream* videoIn = ConstructVideoInStreamLC();

  1068     videoOut->BindL( videoIn );

  1069     CleanupStack::Pop( videoIn );

  1070     

  1071     inSession->AddStreamL( videoOut );

  1072     CleanupStack::Pop( videoOut );

  1073     

  1074     iReceiveSession->iSession = inSession; // Transfers ownership

  1075     CleanupStack::Pop( inSession );

  1076 

  1077     iReceiveSession->CompleteSessionStructureL();

  1078 

  1079     EUNIT_ASSERT( inSession->Streams().Count() == 2 );

  1080     EUNIT_ASSERT( videoOut->IsEnabled() )

  1081     EUNIT_ASSERT( videoOut->Type() == KMceVideo )

  1082     EUNIT_ASSERT( videoOut->Sinks().Count() == 1 )

  1083     EUNIT_ASSERT( videoOut->Sinks()[0]->Type() == KMceRTPSink )

  1084     EUNIT_ASSERT( videoOut->Sinks()[0]->IsEnabled() )

  1085 

  1086     EUNIT_ASSERT( videoOut->BoundStream() )

  1087     EUNIT_ASSERT( videoOut->BoundStreamL().IsEnabled() )

  1088     EUNIT_ASSERT( videoOut->BoundStreamL().Type() == KMceVideo )

  1089     EUNIT_ASSERT( videoOut->BoundStreamL().Sinks().Count() == 1 )

  1090     EUNIT_ASSERT( videoOut->BoundStreamL().Sinks()[0]->Type() == 

  1091                   KMceDisplaySink )   

  1092     EUNIT_ASSERT( videoOut->BoundStreamL().Sinks()[0]->IsEnabled() )

  1093     

  1094     CMceMediaStream* videoVf = inSession->Streams()[1];

  1095     EUNIT_ASSERT( videoVf->IsEnabled() )

  1096     EUNIT_ASSERT( videoVf->Type() == KMceVideo )

  1097     EUNIT_ASSERT( videoVf->Sinks().Count() == 1 )

  1098     EUNIT_ASSERT( videoVf->Sinks()[0]->Type() == KMceDisplaySink )

  1099     EUNIT_ASSERT( videoVf->Source()->Type() == KMceCameraSource )

  1100     

  1101     // No audio, bundle is not constructed

  1102     EUNIT_ASSERT( inSession->Bundles().Count() == 0 )

  1103     }

  1104 

  1105 

  1106 // -----------------------------------------------------------------------------

  1107 // Construct 3 video instreams:

  1108 // 0. Without bound stream

  1109 // 1. Bounds video out stream

  1110 // 2. Bounded by video out stream

  1111 // Bound stream should be selected and vf stream is added

  1112 // -----------------------------------------------------------------------------

  1113 //    

  1114 void UT_CMusEngTwoWayRecvSession::UT_CompleteSessionStructureL_WithMultipleVideoInsL()

  1115     {

  1116     // construct session and stream 0

  1117     CMceInSession* inSession = ConstructInSessionLC( 2, 0 );

  1118     

  1119     // finish constructing stream 1

  1120     CMceVideoStream* videoOut = ConstructVideoOutStreamLC();

  1121     inSession->Streams()[1]->BindL( videoOut );

  1122     CleanupStack::Pop( videoOut );

  1123 

  1124     // finish constructing stream 2

  1125     videoOut = ConstructVideoOutStreamLC();

  1126 

  1127     CMceVideoStream* videoIn = ConstructVideoInStreamLC();

  1128     videoOut->BindL( videoIn );

  1129     CleanupStack::Pop( videoIn );

  1130     

  1131     inSession->AddStreamL( videoOut );

  1132     CleanupStack::Pop( videoOut );

  1133     

  1134     // Transfers ownership