multimediacommscontroller/mmccsubcontroller/tsrc/ut_subcontroller/Src/UT_CMccRtpKeepalive.cpp
branchRCL_3
changeset 59 b0e4b01681c5
parent 42 817c922b90eb
equal deleted inserted replaced
55:f72c4fccd381 59:b0e4b01681c5
    81 //  METHODS
    81 //  METHODS
    82 
    82 
    83 
    83 
    84 void UT_CMccRtpKeepalive::SetupL()
    84 void UT_CMccRtpKeepalive::SetupL()
    85     {
    85     {
    86     iRtpMediaClock = CMccRtpMediaClock::NewL();
       
    87     
       
    88     iEventHandler = CMccTestEventHandler::NewL();
    86     iEventHandler = CMccTestEventHandler::NewL();
    89     iRtpApi = CRtpAPI::NewL( *iEventHandler );
    87     iRtpApi = CRtpAPI::NewL( *iEventHandler );
    90     TPckgBuf<TInt> params( 30000 );
    88     TPckgBuf<TInt> params( 30000 );
    91     iRtpSource = MDataSource::NewSourceL( KRtpDataSource, params );
    89     iRtpSource = MDataSource::NewSourceL( KRtpDataSource, params );
    92 	iRtpSink = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
    90 	iRtpSink = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
    93 	
    91 	
    94 	TMccCodecInfo codecInfo;
    92 	TMccCodecInfo codecInfo;
    95 	TMccCodecInfoBuffer infoBuffer( codecInfo );
    93 	TMccCodecInfoBuffer infoBuffer( codecInfo );
    96 	CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iRtpSource );
    94 	CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iRtpSource );
    97 	dSource->ConfigureL( infoBuffer, iRtpMediaClock );
    95 	dSource->ConfigureL( infoBuffer );
    98 	CMccRtpDataSink* dSink = static_cast<CMccRtpDataSink*>( iRtpSink );
    96 	CMccRtpDataSink* dSink = static_cast<CMccRtpDataSink*>( iRtpSink );
    99 	dSink->ConfigureL( infoBuffer, iRtpMediaClock );
    97 	dSink->ConfigureL( infoBuffer );
       
    98 	
       
    99 	iRtpMediaClock = CMccRtpMediaClock::NewL();
   100     } 
   100     } 
   101 
   101 
   102 void UT_CMccRtpKeepalive::Setup2L()
   102 void UT_CMccRtpKeepalive::Setup2L()
   103     {
   103     {
   104     iRtpMediaClock = CMccRtpMediaClock::NewL();
       
   105     
       
   106     iEventHandler = CMccTestEventHandler::NewL();
   104     iEventHandler = CMccTestEventHandler::NewL();
   107     iRtpApi = CRtpAPI::NewL( *iEventHandler );
   105     iRtpApi = CRtpAPI::NewL( *iEventHandler );
   108     TPckgBuf<TInt> params( 30000 );
   106     TPckgBuf<TInt> params( 30000 );
   109     iRtpSource = MDataSource::NewSourceL( KRtpDataSource, params );
   107     iRtpSource = MDataSource::NewSourceL( KRtpDataSource, params );
   110 	iRtpSink = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
   108 	iRtpSink = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
   111 	
   109 	
   112 	TMccCodecInfo codecInfo;
   110 	TMccCodecInfo codecInfo;
   113 	TMccCodecInfoBuffer infoBuffer( codecInfo );
   111 	TMccCodecInfoBuffer infoBuffer( codecInfo );
   114 	CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iRtpSource );
   112 	CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iRtpSource );
   115 	dSource->ConfigureL( infoBuffer, iRtpMediaClock );
   113 	dSource->ConfigureL( infoBuffer );
   116 	CMccRtpDataSink* dSink = static_cast<CMccRtpDataSink*>( iRtpSink );
   114 	CMccRtpDataSink* dSink = static_cast<CMccRtpDataSink*>( iRtpSink );
   117 	dSink->ConfigureL( infoBuffer, iRtpMediaClock );
   115 	dSink->ConfigureL( infoBuffer );
   118 	
   116 	
       
   117 	iRtpMediaClock = CMccRtpMediaClock::NewL();
   119 	iKeepaliveHandler = 
   118 	iKeepaliveHandler = 
   120 	    CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   119 	    CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   121 	    
   120 	    
   122     EUNIT_ASSERT_EQUALS( iKeepaliveHandler->PayloadType(), 96 );
   121     EUNIT_ASSERT_EQUALS( iKeepaliveHandler->PayloadType(), 96 );
   123     } 
   122     } 
   176         
   175         
   177         // Remote address set
   176         // Remote address set
   178         EUNIT_ASSERT_EQUALS( container->RemoteAddressSet(), KErrNone );
   177         EUNIT_ASSERT_EQUALS( container->RemoteAddressSet(), KErrNone );
   179         
   178         
   180         // Update valid case
   179         // Update valid case
   181         MCC_EUNIT_ASSERT_NO_LEAVE( container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo, *iRtpMediaClock ) );
   180         MCC_EUNIT_ASSERT_NO_LEAVE( container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo ) );
   182         
   181         
   183         // Update with keealive interval 0
   182         // Update with keealive interval 0
   184         codecInfo.iKeepaliveInterval = 0;
   183         codecInfo.iKeepaliveInterval = 0;
   185         MCC_EUNIT_ASSERT_NO_LEAVE( container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo, *iRtpMediaClock ) );
   184         MCC_EUNIT_ASSERT_NO_LEAVE( container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo ) );
   186         
   185         
   187         // Stop keepalive
   186         // Stop keepalive
   188         //
   187         //
   189         
   188         
   190         // First user
   189         // First user
   225         
   224         
   226         // Remote address set
   225         // Remote address set
   227         EUNIT_ASSERT_EQUALS( container->RemoteAddressSet(), KErrNone );
   226         EUNIT_ASSERT_EQUALS( container->RemoteAddressSet(), KErrNone );
   228         
   227         
   229         // Update valid case
   228         // Update valid case
   230         container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo, *iRtpMediaClock );
   229         container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo );
   231         
   230         
   232         // Update with keealive interval 0
   231         // Update with keealive interval 0
   233         codecInfo.iKeepaliveInterval = 0;
   232         codecInfo.iKeepaliveInterval = 0;
   234         container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo, *iRtpMediaClock );
   233         container->UpdateParamsL( *static_cast<CMccRtpDataSink*>( iRtpSink ), codecInfo );
   235         
   234         
   236         
   235         
   237         // Stop keepalive
   236         // Stop keepalive
   238         //
   237         //
   239         
   238         
   336 	        CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   335 	        CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   337 	        
   336 	        
   338 	    CleanupStack::PushL( keepaliveHandler );    
   337 	    CleanupStack::PushL( keepaliveHandler );    
   339     
   338     
   340         TUint8 keepalivePT(96); 
   339         TUint8 keepalivePT(96); 
   341         TUint32 keepaliveInterval(25000000);    
   340         TUint8 keepaliveInterval(25);    
   342         const TUint8 KAmrKeepAlivePayload[6] = 
   341         const TUint8 KAmrKeepAlivePayload[6] = 
   343         { 
   342         { 
   344         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   343         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   345         };
   344         };
   346         TBuf8<6> keepAliveData;
   345         TBuf8<6> keepAliveData;
   347         keepAliveData.Copy( KAmrKeepAlivePayload );
   346         keepAliveData.Copy( KAmrKeepAlivePayload );
   348         
   347         
   349         // Valid case
   348         // Valid case
   350         EUNIT_ASSERT_LEAVE( keepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ) );
   349         EUNIT_ASSERT_LEAVE( keepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ) );
   351 
   350 
   352         // Wrong payload type
   351         // Wrong payload type
   353         keepalivePT = 129;
   352         keepalivePT = 129;
   354         EUNIT_ASSERT_LEAVE( keepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ) );    
   353         EUNIT_ASSERT_LEAVE( keepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ) );    
   355         CleanupStack::PopAndDestroy( keepaliveHandler );
   354         CleanupStack::PopAndDestroy( keepaliveHandler );
   356         }
   355         }
   357     else
   356     else
   358         {
   357         {
   359         iKeepaliveHandler = 
   358         iKeepaliveHandler = 
   360      	    CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   359      	    CMccRtpKeepalive::NewL( *iEventHandler, *iRtpApi, TRtpId(), 96, 1000, KNullDesC8, ETrue );
   361         
   360         
   362         TUint8 keepalivePT(96); 
   361         TUint8 keepalivePT(96); 
   363         TUint32 keepaliveInterval(25000000);    
   362         TUint8 keepaliveInterval(25);    
   364         const TUint8 KAmrKeepAlivePayload[6] = 
   363         const TUint8 KAmrKeepAlivePayload[6] = 
   365         { 
   364         { 
   366         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   365         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   367         };
   366         };
   368         TBuf8<6> keepAliveData;
   367         TBuf8<6> keepAliveData;
   369         keepAliveData.Copy( KAmrKeepAlivePayload );
   368         keepAliveData.Copy( KAmrKeepAlivePayload );
   370         
   369         
   371         // Valid case
   370         // Valid case
   372         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ) );
   371         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ) );
   373 
   372 
   374         // Wrong payload type
   373         // Wrong payload type
   375         keepalivePT = 129;
   374         keepalivePT = 129;
   376         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ), KErrArgument );            
   375         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ), KErrArgument );            
   377         }
   376         }
   378     }
   377     }
   379 
   378 
   380 void UT_CMccRtpKeepalive::UT_CMccRtpKeepalive_StopKeepaliveL()
   379 void UT_CMccRtpKeepalive::UT_CMccRtpKeepalive_StopKeepaliveL()
   381     {
   380     {
   444         // Send completion ok when not active anymore, timer is started
   443         // Send completion ok when not active anymore, timer is started
   445         iKeepaliveHandler->Cancel();
   444         iKeepaliveHandler->Cancel();
   446         iKeepaliveHandler->iStatus = KErrNone;
   445         iKeepaliveHandler->iStatus = KErrNone;
   447         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   446         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   448         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->RunL() );
   447         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->RunL() );
   449         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::ESendingPending );
   448         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::EWaitingTimer );
   450         EUNIT_ASSERT( !iKeepaliveHandler->IsActive() );
   449         EUNIT_ASSERT( iKeepaliveHandler->IsActive() );
   451         
   450         
   452         // Completed in not supported state
   451         // Completed in not supported state
   453         iKeepaliveHandler->iStatus = KErrNone;
   452         iKeepaliveHandler->iStatus = KErrNone;
   454         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::EIdle;
   453         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::EIdle;
   455         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->RunL(), KErrArgument );
   454         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->RunL(), KErrArgument );
   471         { 
   470         { 
   472         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   471         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   473         };
   472         };
   474         TBuf8<6> keepAliveData;
   473         TBuf8<6> keepAliveData;
   475         keepAliveData.Copy( KAmrKeepAlivePayload );
   474         keepAliveData.Copy( KAmrKeepAlivePayload );
   476         EUNIT_ASSERT_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ) );
   475         EUNIT_ASSERT_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ) );
   477         
   476         
   478         // Send completion ok when not active anymore, timer is started
   477         // Send completion ok when not active anymore, timer is started
   479         iKeepaliveHandler->Cancel();
   478         iKeepaliveHandler->Cancel();
   480         iKeepaliveHandler->iStatus = KErrNone;
   479         iKeepaliveHandler->iStatus = KErrNone;
   481         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   480         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   482         iKeepaliveHandler->iRtpMediaClock = iRtpMediaClock;
       
   483         
       
   484         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->RunL() );
   481         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->RunL() );
   485         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::EWaitingTimer );
   482         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::EWaitingTimer );
   486         EUNIT_ASSERT( iKeepaliveHandler->IsActive() );
   483         EUNIT_ASSERT( iKeepaliveHandler->IsActive() );
   487      
   484      
   488         // Test RunError
   485         // Test RunError
   509         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::ESending );
   506         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::ESending );
   510         
   507         
   511         // Send completion ok when not active anymore, timer is started
   508         // Send completion ok when not active anymore, timer is started
   512         iKeepaliveHandler->Cancel();
   509         iKeepaliveHandler->Cancel();
   513         iKeepaliveHandler->iStatus = KErrNone;
   510         iKeepaliveHandler->iStatus = KErrNone;
   514         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;        
   511         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   515         iKeepaliveHandler->RunL();
   512         iKeepaliveHandler->RunL();
   516         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::ESendingPending );
   513         EUNIT_ASSERT( iKeepaliveHandler->iCurrentState == CMccRtpKeepalive::EWaitingTimer );
   517         EUNIT_ASSERT( !iKeepaliveHandler->IsActive() );
   514         EUNIT_ASSERT( iKeepaliveHandler->IsActive() );
   518         
   515         
   519         // Completed in not supported state
   516         // Completed in not supported state
   520         iKeepaliveHandler->iStatus = KErrNone;
   517         iKeepaliveHandler->iStatus = KErrNone;
   521         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::EIdle;
   518         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::EIdle;
   522         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->RunL(), KErrArgument );
   519         MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iKeepaliveHandler->RunL(), KErrArgument );
   538         { 
   535         { 
   539         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   536         0xF4, 0x00, 0x00, 0x00, 0x00, 0x00
   540         };
   537         };
   541         TBuf8<6> keepAliveData;
   538         TBuf8<6> keepAliveData;
   542         keepAliveData.Copy( KAmrKeepAlivePayload );
   539         keepAliveData.Copy( KAmrKeepAlivePayload );
   543         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData, iRtpMediaClock ) );
   540         MCC_EUNIT_ASSERT_NO_LEAVE( iKeepaliveHandler->UpdateParamsL( keepalivePT, keepaliveInterval, keepAliveData ) );
   544         
   541         
   545         // Send completion ok when not active anymore, timer is started
   542         // Send completion ok when not active anymore, timer is started
   546         iKeepaliveHandler->Cancel();
   543         iKeepaliveHandler->Cancel();
   547         iKeepaliveHandler->iStatus = KErrNone;
   544         iKeepaliveHandler->iStatus = KErrNone;
   548         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;
   545         iKeepaliveHandler->iCurrentState = CMccRtpKeepalive::ESending;