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