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; |