|
1 /* |
|
2 * Copyright (c) 2004 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 |
|
20 |
|
21 // CLASS HEADER |
|
22 #include "UT_CMccRtpDataSink.h" |
|
23 |
|
24 // EXTERNAL INCLUDES |
|
25 #include <digia/eunit/EUnitMacros.h> |
|
26 #include <mmf/server/mmfbuffer.h> |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 // INTERNAL INCLUDES |
|
32 #include "rtpheader.h" |
|
33 #include "MccRtpDataSink.h" |
|
34 #include <mmf/server/mmfdatasink.h> |
|
35 #include <mmf/common/mmfcontrollerframework.h> |
|
36 #include "MmccEvents.h" |
|
37 #include "MccInternalCodecs.h" |
|
38 #include <mmf/server/mmfvideoframebuffer.h> |
|
39 #include "mccrtpkeepalivecontainer.h" |
|
40 #include "amrpayloadformatwrite.h" |
|
41 #include <srtpcryptocontext.h> |
|
42 #include <srtpmastersalt.h> |
|
43 #include <srtpstreamout.h> |
|
44 #include "mccunittestmacros.h" |
|
45 |
|
46 |
|
47 #define MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event )\ |
|
48 *reinterpret_cast<TMccRtcpEventDataPackage*>( &event.iEventData ) |
|
49 |
|
50 // CONSTANTS |
|
51 const TUint8 KPayloadType( 96 ); |
|
52 _LIT8(KRFC3711_TestMasterKey128bits, "E1F97A0D3E018BE0D64FA32C06DE4139"); |
|
53 _LIT8(KRFC3711_TestMasterSalt112bits, "0EC675AD498AFEEBB6960B3AABE6"); |
|
54 _LIT8(KTestMKI128Bits, "ABCDEF1234567890ABCDEF1234567890"); |
|
55 |
|
56 |
|
57 // CONSTRUCTION |
|
58 UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewL() |
|
59 { |
|
60 UT_CMccRtpDataSink* self = UT_CMccRtpDataSink::NewLC(); |
|
61 CleanupStack::Pop(); |
|
62 |
|
63 return self; |
|
64 } |
|
65 |
|
66 UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewLC() |
|
67 { |
|
68 UT_CMccRtpDataSink* self = new( ELeave ) UT_CMccRtpDataSink(); |
|
69 CleanupStack::PushL( self ); |
|
70 |
|
71 self->ConstructL(); |
|
72 |
|
73 return self; |
|
74 } |
|
75 |
|
76 // Destructor (virtual by CBase) |
|
77 UT_CMccRtpDataSink::~UT_CMccRtpDataSink() |
|
78 { |
|
79 } |
|
80 |
|
81 // Default constructor |
|
82 UT_CMccRtpDataSink::UT_CMccRtpDataSink() |
|
83 : iSession( 1 ) |
|
84 { |
|
85 } |
|
86 |
|
87 // Second phase construct |
|
88 void UT_CMccRtpDataSink::ConstructL() |
|
89 { |
|
90 // The ConstructL from the base class CEUnitTestSuiteClass must be called. |
|
91 // It generates the test case table. |
|
92 CEUnitTestSuiteClass::ConstructL(); |
|
93 } |
|
94 |
|
95 // METHODS |
|
96 |
|
97 // From MRtpErrNotify |
|
98 void UT_CMccRtpDataSink::ErrorNotify( TInt /*aErrCode*/ ) |
|
99 { |
|
100 } |
|
101 |
|
102 |
|
103 void UT_CMccRtpDataSink::SetupL() |
|
104 { |
|
105 iRtpApi = CRtpAPI::NewL( *this ); |
|
106 TUid dummyUid( TUid::Uid( 42 ) ); |
|
107 TBuf8<5> dummyBuf( _L8( "foo" ) ); |
|
108 iSink = static_cast<CMccRtpDataSink*>( |
|
109 CMccRtpDataSink::NewSinkL( dummyUid, dummyBuf ) ); |
|
110 |
|
111 MAsyncEventHandler* eventHandler = NULL; |
|
112 TRtpId rtpSessionId(0); |
|
113 iRtpKeepaliveMechanism = |
|
114 CMccRtpKeepaliveContainer::NewL( *eventHandler, |
|
115 *iRtpApi, |
|
116 rtpSessionId ); |
|
117 |
|
118 } |
|
119 |
|
120 void UT_CMccRtpDataSink::Teardown() |
|
121 { |
|
122 delete iRtpKeepaliveMechanism; |
|
123 |
|
124 if ( iSink ) |
|
125 { |
|
126 delete iSink; |
|
127 iSink = NULL; |
|
128 } |
|
129 if ( iSecSession) |
|
130 { |
|
131 delete iSecSession; |
|
132 iSecSession = NULL; |
|
133 } |
|
134 if ( iRtpApi ) |
|
135 { |
|
136 delete iRtpApi; |
|
137 iRtpApi = NULL; |
|
138 } |
|
139 } |
|
140 |
|
141 // HELPERS |
|
142 // |
|
143 |
|
144 void UT_CMccRtpDataSink::InitializeStreamL() |
|
145 { |
|
146 iSink->SinkThreadLogon( *this ); |
|
147 iSink->SetCurrentUser( this ); |
|
148 TMccRtpSessionParams params; |
|
149 params.iRtpAPI = iRtpApi; |
|
150 params.iSessionId = iSession; |
|
151 params.iEnableRTCP = ETrue; |
|
152 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
153 |
|
154 iSink->SetSessionParamsL( params ); |
|
155 |
|
156 TMccCodecInfo cInfo; |
|
157 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
158 |
|
159 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
160 } |
|
161 |
|
162 |
|
163 // TEST FUNCTIONS |
|
164 // |
|
165 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_MuteL() |
|
166 { |
|
167 const TUint8 KDtmfPayloadType( 98 ); |
|
168 TRtpSendHeader header; |
|
169 header.iPayloadType = KDtmfPayloadType; |
|
170 iSink->iState = MMccRtpInterface::ERtpStatePlaying; |
|
171 iSink->Mute( ETrue, KDtmfPayloadType ); |
|
172 EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) ); |
|
173 |
|
174 header.iPayloadType = 0; |
|
175 EUNIT_ASSERT( EFalse == iSink->SendingAllowed( header ) ); |
|
176 |
|
177 iSink->Mute( EFalse, KDtmfPayloadType ); |
|
178 EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) ); |
|
179 } |
|
180 |
|
181 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendMediaSignallingLL() |
|
182 { |
|
183 TMccEvent wrongEvent; |
|
184 wrongEvent.iEventCategory = KMccEventCategoryDtmf; |
|
185 // Wrong type of signal |
|
186 EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( wrongEvent ) ); |
|
187 |
|
188 TMccEvent event; |
|
189 event.iEventCategory = KMccEventCategoryRtcp; |
|
190 event.iEventType = KMccRtcpControl; |
|
191 |
|
192 TMccRtcpEventData data; |
|
193 TMccRtcpEventDataPackage dataPackage( data ); |
|
194 event.iEventData.Copy( dataPackage ); |
|
195 |
|
196 // No RTP API set |
|
197 EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
198 |
|
199 TMccRtpSessionParams params; |
|
200 params.iRtpAPI = iRtpApi; |
|
201 params.iSessionId = iSession; |
|
202 params.iEnableRTCP = EFalse; |
|
203 params.iRtpKeepalive= iRtpKeepaliveMechanism; |
|
204 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
205 |
|
206 // RTCP not enabled |
|
207 EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
208 |
|
209 params.iEnableRTCP = ETrue; |
|
210 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
211 |
|
212 // Wrong packet type |
|
213 EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
214 |
|
215 // Streams and RTP sender not constructed |
|
216 data.iRtcpPacketType = KRtcpAnyPacket; |
|
217 EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
218 |
|
219 TMccCodecInfo cInfo; |
|
220 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
221 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
222 MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone ); |
|
223 iSink->SetCurrentUser( this ); |
|
224 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
225 |
|
226 TMccRtcpEventDataPackage& eventDataPackage = MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event ); |
|
227 TMccRtcpEventData eventData; |
|
228 eventData.iRtcpPacketType = KRtcpSdesPacket; |
|
229 eventDataPackage = TMccRtcpEventDataPackage( eventData ); |
|
230 |
|
231 // No RTCP data, but does not leave because empty TRtpSdesParams |
|
232 // will be constructed from zero length RTCP data |
|
233 EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
234 |
|
235 TRtpSdesParams sdesParams; |
|
236 TPckgBuf<TRtpSdesParams> sdesPackage( sdesParams ); |
|
237 |
|
238 eventData.iRtcpPacketData.Copy( sdesPackage ); |
|
239 eventDataPackage = TMccRtcpEventDataPackage( eventData ); |
|
240 |
|
241 EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
242 |
|
243 TBuf<5> reason( _L( "foo" ) ); |
|
244 eventData.iRtcpPacketType = KRtcpByePacket; |
|
245 eventData.iRtcpPacketData.Copy( reason ); |
|
246 eventDataPackage = TMccRtcpEventDataPackage( eventData ); |
|
247 EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
248 |
|
249 TRtcpApp app; |
|
250 eventData.iRtcpPacketType = KRtcpAppPacket; |
|
251 TPckgBuf<TRtcpApp> appPackage( app ); |
|
252 eventData.iRtcpPacketData.Copy( appPackage ); |
|
253 eventDataPackage = TMccRtcpEventDataPackage( eventData ); |
|
254 |
|
255 EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) ); |
|
256 |
|
257 } |
|
258 |
|
259 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferLL() |
|
260 { |
|
261 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( NULL, NULL, TMediaId() ) ); |
|
262 } |
|
263 |
|
264 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogonL() |
|
265 { |
|
266 MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone ); |
|
267 iSink->SetCurrentUser( this ); |
|
268 } |
|
269 |
|
270 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogoffL() |
|
271 { |
|
272 iSink->SinkThreadLogoff(); |
|
273 |
|
274 TMccRtpSessionParams params; |
|
275 params.iRtpAPI = iRtpApi; |
|
276 params.iSessionId = iSession; |
|
277 params.iEnableRTCP = ETrue; |
|
278 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
279 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
280 iSink->SinkThreadLogoff(); |
|
281 |
|
282 // Reach more branches |
|
283 TUint8 redPt( 97 ); |
|
284 TMccCodecInfo cInfo; |
|
285 cInfo.iRedundancyCount = 1; |
|
286 cInfo.iRedundantPayload = redPt; |
|
287 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
288 |
|
289 MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone ); |
|
290 iSink->SetCurrentUser( this ); |
|
291 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
292 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
293 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
294 iSink->SinkThreadLogoff(); |
|
295 } |
|
296 |
|
297 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkDataTypeCodeL() |
|
298 { |
|
299 TMediaId mediaId( KUidMediaTypeMidi ); |
|
300 EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( mediaId ), TFourCC() ); |
|
301 |
|
302 iSink->SinkThreadLogoff(); |
|
303 TFourCC codec( ' ','A','M','R' ); |
|
304 TMediaId media2( KUidMediaTypeAudio ); |
|
305 iSink->SetSinkDataTypeCode( codec, media2 ); |
|
306 |
|
307 // The codecs SHOULD be equal |
|
308 EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media2 ), codec ); |
|
309 |
|
310 TFourCC codec2( ' H','2','6','3' ); |
|
311 TMediaId media3( KUidMediaTypeVideo ); |
|
312 iSink->SetSinkDataTypeCode( codec2, media3 ); |
|
313 |
|
314 // The codecs SHOULD be equal |
|
315 EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media3 ), codec2 ); |
|
316 } |
|
317 |
|
318 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SetSinkDataTypeCodeL() |
|
319 { |
|
320 TFourCC codec; |
|
321 TMediaId media( KUidMediaTypeMidi ); // wrong media type |
|
322 EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media ), KErrNotSupported ); |
|
323 |
|
324 // Set the correct media type |
|
325 TMediaId media2( KUidMediaTypeAudio ); |
|
326 EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media2 ), KErrNone ); |
|
327 TMediaId media3( KUidMediaTypeVideo ); |
|
328 EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media3 ), KErrNone ); |
|
329 } |
|
330 |
|
331 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_BufferFilledLL() |
|
332 { |
|
333 EUNIT_ASSERT_LEAVE( iSink->BufferFilledL( NULL ) ); |
|
334 } |
|
335 |
|
336 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CanCreateSinkBufferL() |
|
337 { |
|
338 EUNIT_ASSERT_EQUALS( iSink->CanCreateSinkBuffer(), EFalse ); |
|
339 } |
|
340 |
|
341 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CreateSinkBufferLL() |
|
342 { |
|
343 TBool dummy; |
|
344 EUNIT_ASSERT_LEAVE( iSink->CreateSinkBufferL( TMediaId(), dummy ) ); |
|
345 } |
|
346 |
|
347 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPrimeLL() |
|
348 { |
|
349 // Set wrong state |
|
350 iSink->SinkThreadLogoff(); |
|
351 EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() ); |
|
352 |
|
353 // Set correct state |
|
354 iSink->SinkThreadLogon( *this ); |
|
355 iSink->SetCurrentUser( this ); |
|
356 EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() ); |
|
357 |
|
358 TMccRtpSessionParams params; |
|
359 params.iRtpAPI = iRtpApi; |
|
360 params.iSessionId = iSession; |
|
361 params.iEnableRTCP = ETrue; |
|
362 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
363 iSink->SetSessionParamsL( params ); |
|
364 EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() ); |
|
365 |
|
366 TMccCodecInfo cInfo; |
|
367 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
368 |
|
369 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
370 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
371 EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == EFalse ); |
|
372 |
|
373 // "Secure session" |
|
374 iRtpKeepaliveMechanism->iStopped = ETrue; |
|
375 TInt fakeSecSession( 3 ); |
|
376 iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession ); |
|
377 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
378 EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue ) |
|
379 iSink->iSecSession = NULL; |
|
380 } |
|
381 |
|
382 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPlayLL() |
|
383 { |
|
384 // Wrong state |
|
385 EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() ); |
|
386 |
|
387 // Do it right |
|
388 InitializeStreamL(); |
|
389 |
|
390 iSink->SinkPrimeL(); |
|
391 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPlayL() ); |
|
392 |
|
393 // State downgrade is ignored |
|
394 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
395 EUNIT_ASSERT( MMccRtpInterface::ERtpStatePlaying == iSink->State() ); |
|
396 } |
|
397 |
|
398 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPauseLL() |
|
399 { |
|
400 // Wrong state |
|
401 EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() ); |
|
402 |
|
403 // Do it right |
|
404 InitializeStreamL(); |
|
405 |
|
406 iSink->SinkPrimeL(); |
|
407 iSink->SinkPlayL(); |
|
408 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPauseL() ); |
|
409 } |
|
410 |
|
411 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkStopLL() |
|
412 { |
|
413 // Do it right |
|
414 InitializeStreamL(); |
|
415 |
|
416 iSink->SinkPrimeL(); |
|
417 iSink->SinkPlayL(); |
|
418 EUNIT_ASSERT_NO_LEAVE( iSink->SinkStopL() ); |
|
419 } |
|
420 |
|
421 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_2L() |
|
422 { |
|
423 CMMFBuffer* buf( NULL ); |
|
424 TMediaId mediaId; |
|
425 TRtpSendHeader header; |
|
426 |
|
427 |
|
428 InitializeStreamL(); |
|
429 |
|
430 //initial srtp realted |
|
431 iRtpKeepaliveMechanism->iStopped = ETrue; |
|
432 TInt fakeSecSession( 3 ); |
|
433 iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession ); |
|
434 iSink->iSecureKeyExpired = ETrue; |
|
435 iSink->iState = MMccRtpInterface::ERtpStatePlaying; |
|
436 EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue ) |
|
437 |
|
438 //null buffer |
|
439 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
440 |
|
441 // Try different buffer types, null source |
|
442 CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL(); |
|
443 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
444 delete dataBuf; |
|
445 |
|
446 TBuf8<5> foo; |
|
447 foo.Format( _L8( "foo42" ) ); |
|
448 TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() ); |
|
449 TPtr8 ptr( fooPtr, foo.Length() ) ; |
|
450 CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr ); |
|
451 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
452 delete ptrBuf; |
|
453 |
|
454 CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL(); |
|
455 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported ); |
|
456 delete yuvBuf; |
|
457 |
|
458 // packet drop because of secure keyStream not playing |
|
459 CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink ); |
|
460 CleanupStack::PushL( source ); |
|
461 CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL(); |
|
462 CleanupStack::PushL( dataBuf2 ); |
|
463 EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) ); |
|
464 |
|
465 // Stream playing |
|
466 iSink->SinkPrimeL(); |
|
467 //becuase of secure key packet drop |
|
468 EUNIT_ASSERT_SPECIFIC_LEAVE(iSink->SinkPlayL(), KErrGeneral ); |
|
469 iSink->iSecureKeyExpired = EFalse; |
|
470 iSink->SinkPlayL(); |
|
471 //packet drop because of secure stream not there |
|
472 EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) ); |
|
473 CleanupStack::PopAndDestroy( dataBuf2 ); |
|
474 CleanupStack::PopAndDestroy( source ); |
|
475 iSink->iSecSession = NULL; |
|
476 |
|
477 } |
|
478 |
|
479 |
|
480 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_1L() |
|
481 { |
|
482 CMMFBuffer* buf( NULL ); |
|
483 TMediaId mediaId; |
|
484 TRtpSendHeader header; |
|
485 |
|
486 // No stream |
|
487 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
488 |
|
489 // NULL buffer |
|
490 InitializeStreamL(); |
|
491 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
492 |
|
493 // Try different buffer types, null source |
|
494 CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL(); |
|
495 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
496 delete dataBuf; |
|
497 |
|
498 TBuf8<5> foo; |
|
499 foo.Format( _L8( "foo42" ) ); |
|
500 TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() ); |
|
501 TPtr8 ptr( fooPtr, foo.Length() ) ; |
|
502 CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr ); |
|
503 EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) ); |
|
504 delete ptrBuf; |
|
505 |
|
506 CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL(); |
|
507 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported ); |
|
508 delete yuvBuf; |
|
509 |
|
510 // Stream not playing |
|
511 CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink ); |
|
512 CleanupStack::PushL( source ); |
|
513 CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL(); |
|
514 CleanupStack::PushL( dataBuf2 ); |
|
515 EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) ); |
|
516 |
|
517 // Stream playing |
|
518 iSink->SinkPrimeL(); |
|
519 iSink->SinkPlayL(); |
|
520 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) ); |
|
521 CleanupStack::PopAndDestroy( dataBuf2 ); |
|
522 CleanupStack::PopAndDestroy( source ); |
|
523 |
|
524 // TBD: test also scenario where failure occurs in rtp packet sending |
|
525 } |
|
526 |
|
527 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPReceiverReportL() |
|
528 { |
|
529 // No RTP API set |
|
530 EUNIT_ASSERT_EQUALS( iSink->SendRTCPReceiverReport(), KErrNotReady ); |
|
531 |
|
532 TMccRtpSessionParams params; |
|
533 params.iRtpAPI = iRtpApi; |
|
534 params.iSessionId = iSession; |
|
535 params.iEnableRTCP = ETrue; |
|
536 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
537 |
|
538 iSink->SetSessionParamsL( params ); |
|
539 |
|
540 EUNIT_ASSERT_NO_LEAVE( iSink->SendRTCPReceiverReport() ); |
|
541 } |
|
542 |
|
543 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPSenderReportL() |
|
544 { |
|
545 // No RTP API set |
|
546 EUNIT_ASSERT_EQUALS( iSink->SendRTCPSenderReport(), KErrNotReady ); |
|
547 |
|
548 TMccRtpSessionParams params; |
|
549 params.iRtpAPI = iRtpApi; |
|
550 params.iSessionId = iSession; |
|
551 params.iEnableRTCP = ETrue; |
|
552 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
553 |
|
554 iSink->SetSessionParamsL( params ); |
|
555 EUNIT_ASSERT_NO_LEAVE( iSink->SendRTCPSenderReport() ); |
|
556 } |
|
557 |
|
558 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPDataLL() |
|
559 { |
|
560 TBuf8<5> data; |
|
561 data.Format( _L8( "foo42" ) ); |
|
562 |
|
563 // No RTP API set |
|
564 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SendRTCPDataL( data ), KErrNotReady ); |
|
565 |
|
566 TMccRtpSessionParams params; |
|
567 params.iRtpAPI = iRtpApi; |
|
568 params.iSessionId = iSession; |
|
569 params.iEnableRTCP = ETrue; |
|
570 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
571 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
572 |
|
573 // No RTP sender constructed |
|
574 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SendRTCPDataL( data ), KErrNotReady ); |
|
575 |
|
576 // RTP sender constructed |
|
577 iSink->DoCreateStreamL(); |
|
578 iSink->SendRTCPDataL( data ); |
|
579 } |
|
580 |
|
581 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_ConstructSinkLL() |
|
582 { |
|
583 TBuf8<5> data; |
|
584 data.Format( _L8( "foo42" ) ); |
|
585 |
|
586 // Can't have init data |
|
587 EUNIT_ASSERT_LEAVE( iSink->ConstructSinkL( data ) ); |
|
588 |
|
589 EUNIT_ASSERT_NO_LEAVE( iSink->ConstructSinkL( KNullDesC8 ) ); |
|
590 } |
|
591 |
|
592 |
|
593 // FUNCTIONS INHERITED FROM CMccRtpInterface |
|
594 |
|
595 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PrepareLL() |
|
596 { |
|
597 TFourCC codec( ' ','A','M','R' ); |
|
598 |
|
599 // No session exists |
|
600 EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() ); |
|
601 |
|
602 iSink->SinkThreadLogon( *this ); |
|
603 iSink->SetCurrentUser( this ); |
|
604 TMccRtpSessionParams params; |
|
605 params.iRtpAPI = iRtpApi; |
|
606 params.iSessionId = iSession; |
|
607 params.iEnableRTCP = ETrue; |
|
608 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
609 |
|
610 iSink->SetSessionParamsL( params ); |
|
611 |
|
612 // No stream exists |
|
613 EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() ); |
|
614 |
|
615 TMccCodecInfo cInfo; |
|
616 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
617 |
|
618 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
619 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
620 |
|
621 // Create a comfort noise stream |
|
622 //codec = KMccFourCCIdG711; |
|
623 //EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); |
|
624 } |
|
625 |
|
626 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CreateStreamLL() |
|
627 { |
|
628 iSink->SinkThreadLogon( *this ); |
|
629 iSink->SetCurrentUser( this ); |
|
630 TMccRtpSessionParams params; |
|
631 params.iRtpAPI = iRtpApi; |
|
632 params.iSessionId = iSession; |
|
633 params.iEnableRTCP = ETrue; |
|
634 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
635 |
|
636 iSink->SetSessionParamsL( params ); |
|
637 |
|
638 TMccCodecInfo cInfo; |
|
639 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
640 |
|
641 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
642 |
|
643 // This should leave because the string is too short |
|
644 TBuf8<5> dummy; |
|
645 dummy.Format( _L8( "foo42" ) ); |
|
646 EUNIT_ASSERT_LEAVE( iSink->ConfigureL( dummy ) ); |
|
647 |
|
648 // Get a new sink |
|
649 //Teardown(); |
|
650 if( iRtpKeepaliveMechanism ) |
|
651 { |
|
652 delete iRtpKeepaliveMechanism; |
|
653 iRtpKeepaliveMechanism = NULL; |
|
654 } |
|
655 |
|
656 if ( iSink ) |
|
657 { |
|
658 delete iSink; |
|
659 iSink = NULL; |
|
660 } |
|
661 |
|
662 //SetupL(); |
|
663 TUid dummyUid( TUid::Uid( 42 ) ); |
|
664 TBuf8<5> dummyBuf( _L8( "foo" ) ); |
|
665 iSink = static_cast<CMccRtpDataSink*>( |
|
666 CMccRtpDataSink::NewSinkL( dummyUid, dummyBuf ) ); |
|
667 |
|
668 MAsyncEventHandler* eventHandler = NULL; |
|
669 TRtpId rtpSessionId(0); |
|
670 iRtpKeepaliveMechanism = |
|
671 CMccRtpKeepaliveContainer::NewL( *eventHandler, |
|
672 *iRtpApi, |
|
673 rtpSessionId ); |
|
674 |
|
675 iSink->SinkThreadLogon( *this ); |
|
676 iSink->SetCurrentUser( this ); |
|
677 TMccRtpSessionParams params2; |
|
678 params2.iRtpAPI = iRtpApi; |
|
679 params2.iSessionId = iSession; |
|
680 params2.iEnableRTCP = ETrue; |
|
681 params2.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
682 |
|
683 iSink->SetSessionParamsL( params2 ); |
|
684 |
|
685 TMccCodecInfo cInfo2; |
|
686 cInfo2.iFourCC = TFourCC( KMccFourCCIdG711 ); |
|
687 cInfo2.iEnableDTX = ETrue; |
|
688 cInfo2.iRedundantPayload = 97; |
|
689 cInfo2.iRedundancyCount = 1; |
|
690 cInfo2.iAlgoUsed = EGenRedUsed; |
|
691 TMccCodecInfoBuffer cInfoBuf2( cInfo2 ); |
|
692 |
|
693 EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf2 ) ); |
|
694 } |
|
695 |
|
696 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_RemoveStreamLL() |
|
697 { |
|
698 /* |
|
699 // No RTP API set |
|
700 EUNIT_ASSERT_LEAVE( iSink->RemoveStreamL( 42 ) ); |
|
701 |
|
702 // Do it right |
|
703 iSink->SinkThreadLogon( *this ); |
|
704 iSink->SetCurrentUser( this ); |
|
705 TMccRtpSessionParams params; |
|
706 params.iRtpAPI = iRtpApi; |
|
707 params.iSessionId = iSession; |
|
708 params.iEnableRTCP = ETrue; |
|
709 params.iEventHandler = this; |
|
710 iSink->SetSessionParamsL( params ); |
|
711 |
|
712 TMccRtpStreamParams strParams; |
|
713 strParams.iPayloadType = 96; |
|
714 strParams.iCodec = TFourCC( ' ','A','M','R' ); |
|
715 strParams.iSampleRate = 8000; |
|
716 strParams.iEnableVAD = EFalse; |
|
717 TRtpSSRC ssrc( 5 ); |
|
718 strParams.iSSRC = &ssrc; |
|
719 |
|
720 TUint32 stream( iSink->CreateStreamL( strParams ) ); |
|
721 |
|
722 EUNIT_ASSERT_NO_LEAVE( iSink->RemoveStreamL( stream ) ); |
|
723 */ |
|
724 } |
|
725 |
|
726 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PlayStreamLL() |
|
727 { |
|
728 // No stream |
|
729 EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() ); |
|
730 |
|
731 iSink->SinkThreadLogon( *this ); |
|
732 iSink->SetCurrentUser( this ); |
|
733 TMccRtpSessionParams params; |
|
734 params.iRtpAPI = iRtpApi; |
|
735 params.iSessionId = iSession; |
|
736 params.iEnableRTCP = ETrue; |
|
737 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
738 |
|
739 iSink->SetSessionParamsL( params ); |
|
740 |
|
741 TMccCodecInfo cInfo; |
|
742 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
743 |
|
744 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
745 |
|
746 // Wrong state |
|
747 EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() ); |
|
748 |
|
749 iSink->SinkPrimeL(); |
|
750 |
|
751 // Ok |
|
752 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPlayL() ); |
|
753 } |
|
754 |
|
755 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PauseStreamLL() |
|
756 { |
|
757 // No stream |
|
758 EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() ); |
|
759 |
|
760 iSink->SinkThreadLogon( *this ); |
|
761 iSink->SetCurrentUser( this ); |
|
762 TMccRtpSessionParams params; |
|
763 params.iRtpAPI = iRtpApi; |
|
764 params.iSessionId = iSession; |
|
765 params.iEnableRTCP = ETrue; |
|
766 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
767 |
|
768 iSink->SetSessionParamsL( params ); |
|
769 |
|
770 TMccCodecInfo cInfo; |
|
771 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
772 |
|
773 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
774 |
|
775 // Wrong state |
|
776 EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() ); |
|
777 |
|
778 iSink->SinkPrimeL(); |
|
779 iSink->SinkPlayL(); |
|
780 |
|
781 // Ok |
|
782 EUNIT_ASSERT_NO_LEAVE( iSink->SinkPauseL() ); |
|
783 } |
|
784 |
|
785 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StopStreamLL() |
|
786 { |
|
787 iSink->SinkThreadLogon( *this ); |
|
788 iSink->SetCurrentUser( this ); |
|
789 TMccRtpSessionParams params; |
|
790 params.iRtpAPI = iRtpApi; |
|
791 params.iSessionId = iSession; |
|
792 params.iEnableRTCP = ETrue; |
|
793 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
794 |
|
795 iSink->SetSessionParamsL( params ); |
|
796 |
|
797 TMccCodecInfo cInfo; |
|
798 TMccCodecInfoBuffer cInfoBuf( cInfo ); |
|
799 |
|
800 MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) ); |
|
801 iSink->SinkPrimeL(); |
|
802 iSink->SinkPlayL(); |
|
803 |
|
804 // Ok |
|
805 EUNIT_ASSERT_NO_LEAVE( iSink->SinkStopL() ); |
|
806 } |
|
807 |
|
808 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StartInactivityTimerLL() |
|
809 { |
|
810 TUint32 dummyTime( 0 ); |
|
811 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->StartInactivityTimerL( dummyTime ), |
|
812 KErrNotSupported ); |
|
813 } |
|
814 |
|
815 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StopInactivityTimerLL() |
|
816 { |
|
817 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->StopInactivityTimerL(), |
|
818 KErrNotSupported ); |
|
819 } |
|
820 |
|
821 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SetSessionParamsLL() |
|
822 { |
|
823 TMccRtpSessionParams params; |
|
824 params.iRtpAPI = iRtpApi; |
|
825 params.iSessionId = iSession; |
|
826 params.iEnableRTCP = ETrue; |
|
827 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
828 |
|
829 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
830 } |
|
831 |
|
832 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent1L() |
|
833 { |
|
834 //SetUp SecureSession |
|
835 TInetAddr destination; |
|
836 destination.Input(_L("127.0.0.1") ); |
|
837 iSecSession = CSRTPSession::NewL( destination ); |
|
838 |
|
839 //Set up MCCparams |
|
840 TMccRtpSessionParams params; |
|
841 params.iRtpAPI = iRtpApi; |
|
842 params.iSecSession = iSecSession; |
|
843 params.iSessionId = iSession; |
|
844 params.iEnableRTCP = EFalse; |
|
845 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
846 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
847 iSink->SinkThreadLogon( *this ); |
|
848 iSink->SetCurrentUser( this); |
|
849 |
|
850 iSink->SRTPMasterKeyStaleEvent( *iSecSession ); |
|
851 EUNIT_ASSERT( iSink->iSecureKeyExpired ); |
|
852 EUNIT_ASSERT_EQUALS( iEventType, KMccMasterKeyStaled ); |
|
853 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SinkPlayL(), KErrGeneral ); |
|
854 } |
|
855 |
|
856 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent2L() |
|
857 { |
|
858 this->iEventType = KErrNone; |
|
859 //SetUp SecureSession |
|
860 TInetAddr destination; |
|
861 destination.Input(_L("127.0.0.1") ); |
|
862 iSecSession = CSRTPSession::NewL( destination ); |
|
863 |
|
864 //Set up Secure Stream |
|
865 //Secure Context |
|
866 |
|
867 HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length()); |
|
868 CleanupStack::PushL( masterKey ); |
|
869 *masterKey = KRFC3711_TestMasterKey128bits; |
|
870 |
|
871 |
|
872 |
|
873 HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length()); |
|
874 CleanupStack::PushL( masterSalt); |
|
875 *masterSalt = KRFC3711_TestMasterSalt112bits; |
|
876 |
|
877 |
|
878 HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length()); |
|
879 CleanupStack::PushL( mki); |
|
880 *mki = KTestMKI128Bits; |
|
881 //Hex(*mki); |
|
882 |
|
883 CSRTPMasterKey* mKey = CSRTPMasterKey::NewL( *masterKey, *mki ); |
|
884 CleanupStack::PushL( mKey ); |
|
885 CSRTPMasterSalt* saltKey = CSRTPMasterSalt::NewL( *masterSalt ); |
|
886 CleanupStack::PushL( saltKey ); |
|
887 |
|
888 TSrtpCryptoParams srtpParams; |
|
889 CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, saltKey, srtpParams ); |
|
890 CleanupStack::Pop( saltKey ); |
|
891 CleanupStack::Pop( mKey ); |
|
892 |
|
893 CleanupStack::PopAndDestroy( mki ); |
|
894 CleanupStack::PopAndDestroy( masterSalt ); |
|
895 CleanupStack::PopAndDestroy( masterKey ); |
|
896 |
|
897 CleanupStack::PushL( context ); |
|
898 |
|
899 CSRTPStreamOut* srtpStream = CSRTPStreamOut::NewL( *iSecSession, iSink->GetSSRC(), context, *iSink ); |
|
900 CleanupStack::Pop( context ); |
|
901 CleanupStack::PushL( srtpStream ); |
|
902 |
|
903 //Set up MCCparams |
|
904 TMccRtpSessionParams params; |
|
905 params.iRtpAPI = iRtpApi; |
|
906 params.iSecSession = iSecSession; |
|
907 params.iSessionId = iSession; |
|
908 params.iEnableRTCP = EFalse; |
|
909 |
|
910 params.iRtpKeepalive = iRtpKeepaliveMechanism; |
|
911 EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) ); |
|
912 iSink->SinkThreadLogon( *this ); |
|
913 iSink->SetCurrentUser( this); |
|
914 |
|
915 //srtpStream is not equal |
|
916 iSink->SRTPMasterKeyStaleEvent( *srtpStream ); |
|
917 EUNIT_ASSERT( !iSink->iSecureKeyExpired ); |
|
918 EUNIT_ASSERT_NOT_EQUALS( this->iEventType, KMccMasterKeyStaled ); |
|
919 //srtpStream is equal |
|
920 iSink->iSrtpStream = srtpStream; |
|
921 iSink->SRTPMasterKeyStaleEvent( *srtpStream ); |
|
922 EUNIT_ASSERT( iSink->iSecureKeyExpired ); |
|
923 EUNIT_ASSERT_EQUALS( iEventType, KMccMasterKeyStaled ); |
|
924 EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SinkPlayL(), KErrGeneral ); |
|
925 CleanupStack::Pop( srtpStream ); |
|
926 } |
|
927 |
|
928 // TEST TABLE |
|
929 |
|
930 EUNIT_BEGIN_TEST_TABLE( |
|
931 UT_CMccRtpDataSink, |
|
932 "MccRtpDataSink", |
|
933 "UNIT" ) |
|
934 |
|
935 EUNIT_TEST( |
|
936 "MuteL - test ", |
|
937 "CMccRtpDataSink", |
|
938 "MuteL", |
|
939 "FUNCTIONALITY", |
|
940 SetupL, UT_CMccRtpDataSink_MuteL, Teardown) |
|
941 |
|
942 EUNIT_TEST( |
|
943 "SendMediaSignallingL - test ", |
|
944 "CMccRtpDataSink", |
|
945 "SendMediaSignallingL", |
|
946 "FUNCTIONALITY", |
|
947 SetupL, UT_CMccRtpDataSink_SendMediaSignallingLL, Teardown) |
|
948 |
|
949 EUNIT_TEST( |
|
950 "EmptyBufferL - test ", |
|
951 "CMccRtpDataSink", |
|
952 "EmptyBufferL", |
|
953 "FUNCTIONALITY", |
|
954 SetupL, UT_CMccRtpDataSink_EmptyBufferLL, Teardown) |
|
955 |
|
956 EUNIT_TEST( |
|
957 "SinkThreadLogon - test ", |
|
958 "CMccRtpDataSink", |
|
959 "SinkThreadLogon", |
|
960 "FUNCTIONALITY", |
|
961 SetupL, UT_CMccRtpDataSink_SinkThreadLogonL, Teardown) |
|
962 |
|
963 EUNIT_TEST( |
|
964 "SinkThreadLogoff - test ", |
|
965 "CMccRtpDataSink", |
|
966 "SinkThreadLogoff", |
|
967 "FUNCTIONALITY", |
|
968 SetupL, UT_CMccRtpDataSink_SinkThreadLogoffL, Teardown) |
|
969 |
|
970 EUNIT_TEST( |
|
971 "SinkDataTypeCode - test ", |
|
972 "CMccRtpDataSink", |
|
973 "SinkDataTypeCode", |
|
974 "FUNCTIONALITY", |
|
975 SetupL, UT_CMccRtpDataSink_SinkDataTypeCodeL, Teardown) |
|
976 |
|
977 EUNIT_TEST( |
|
978 "SetSinkDataTypeCode - test ", |
|
979 "CMccRtpDataSink", |
|
980 "SetSinkDataTypeCode", |
|
981 "FUNCTIONALITY", |
|
982 SetupL, UT_CMccRtpDataSink_SetSinkDataTypeCodeL, Teardown) |
|
983 |
|
984 EUNIT_TEST( |
|
985 "BufferFilledL - test ", |
|
986 "CMccRtpDataSink", |
|
987 "BufferFilledL", |
|
988 "FUNCTIONALITY", |
|
989 SetupL, UT_CMccRtpDataSink_BufferFilledLL, Teardown) |
|
990 |
|
991 EUNIT_TEST( |
|
992 "CanCreateSinkBuffer - test ", |
|
993 "CMccRtpDataSink", |
|
994 "CanCreateSinkBuffer", |
|
995 "FUNCTIONALITY", |
|
996 SetupL, UT_CMccRtpDataSink_CanCreateSinkBufferL, Teardown) |
|
997 |
|
998 EUNIT_TEST( |
|
999 "CreateSinkBufferL - test ", |
|
1000 "CMccRtpDataSink", |
|
1001 "CreateSinkBufferL", |
|
1002 "FUNCTIONALITY", |
|
1003 SetupL, UT_CMccRtpDataSink_CreateSinkBufferLL, Teardown) |
|
1004 |
|
1005 EUNIT_TEST( |
|
1006 "SinkPrimeL - test ", |
|
1007 "CMccRtpDataSink", |
|
1008 "SinkPrimeL", |
|
1009 "FUNCTIONALITY", |
|
1010 SetupL, UT_CMccRtpDataSink_SinkPrimeLL, Teardown) |
|
1011 |
|
1012 EUNIT_TEST( |
|
1013 "SinkPlayL - test ", |
|
1014 "CMccRtpDataSink", |
|
1015 "SinkPlayL", |
|
1016 "FUNCTIONALITY", |
|
1017 SetupL, UT_CMccRtpDataSink_SinkPlayLL, Teardown) |
|
1018 |
|
1019 EUNIT_TEST( |
|
1020 "SinkPauseL - test ", |
|
1021 "CMccRtpDataSink", |
|
1022 "SinkPauseL", |
|
1023 "FUNCTIONALITY", |
|
1024 SetupL, UT_CMccRtpDataSink_SinkPauseLL, Teardown) |
|
1025 |
|
1026 EUNIT_TEST( |
|
1027 "SinkStopL - test ", |
|
1028 "CMccRtpDataSink", |
|
1029 "SinkStopL", |
|
1030 "FUNCTIONALITY", |
|
1031 SetupL, UT_CMccRtpDataSink_SinkStopLL, Teardown) |
|
1032 |
|
1033 EUNIT_TEST( |
|
1034 "EmptyBufferL - test ", |
|
1035 "CMccRtpDataSink", |
|
1036 "EmptyBufferL", |
|
1037 "FUNCTIONALITY", |
|
1038 SetupL, UT_CMccRtpDataSink_EmptyBufferL_1L, Teardown) |
|
1039 |
|
1040 EUNIT_TEST( |
|
1041 "EmptyBuffer2L - test ", |
|
1042 "CMccRtpDataSink", |
|
1043 "EmptyBuffer2L", |
|
1044 "FUNCTIONALITY", |
|
1045 SetupL, UT_CMccRtpDataSink_EmptyBufferL_2L, Teardown) |
|
1046 |
|
1047 EUNIT_TEST( |
|
1048 "SendRTCPReceiverReport - test ", |
|
1049 "CMccRtpDataSink", |
|
1050 "SendRTCPReceiverReport", |
|
1051 "FUNCTIONALITY", |
|
1052 SetupL, UT_CMccRtpDataSink_SendRTCPReceiverReportL, Teardown) |
|
1053 |
|
1054 EUNIT_TEST( |
|
1055 "SendRTCPSenderReport - test ", |
|
1056 "CMccRtpDataSink", |
|
1057 "SendRTCPSenderReport", |
|
1058 "FUNCTIONALITY", |
|
1059 SetupL, UT_CMccRtpDataSink_SendRTCPSenderReportL, Teardown) |
|
1060 |
|
1061 EUNIT_TEST( |
|
1062 "SendRTCPDataL - test ", |
|
1063 "CMccRtpDataSink", |
|
1064 "SendRTCPDataL", |
|
1065 "FUNCTIONALITY", |
|
1066 SetupL, UT_CMccRtpDataSink_SendRTCPDataLL, Teardown) |
|
1067 |
|
1068 EUNIT_TEST( |
|
1069 "ConstructSinkL - test ", |
|
1070 "CMccRtpDataSink", |
|
1071 "ConstructSinkL", |
|
1072 "FUNCTIONALITY", |
|
1073 SetupL, UT_CMccRtpDataSink_ConstructSinkLL, Teardown) |
|
1074 |
|
1075 |
|
1076 // FUNCTIONS INHERITED FROM CMccRtpInterface |
|
1077 |
|
1078 EUNIT_TEST( |
|
1079 "PrepareL - test ", |
|
1080 "CMccRtpInterface", |
|
1081 "PrepareL", |
|
1082 "FUNCTIONALITY", |
|
1083 SetupL, UT_CMccRtpDataSink_PrepareLL, Teardown) |
|
1084 |
|
1085 EUNIT_TEST( |
|
1086 "CreateStreamL - test ", |
|
1087 "CMccRtpInterface", |
|
1088 "CreateStreamL", |
|
1089 "FUNCTIONALITY", |
|
1090 SetupL, UT_CMccRtpDataSink_CreateStreamLL, Teardown) |
|
1091 |
|
1092 EUNIT_TEST( |
|
1093 "RemoveStreamL - test ", |
|
1094 "CMccRtpInterface", |
|
1095 "RemoveStreamL", |
|
1096 "FUNCTIONALITY", |
|
1097 SetupL, UT_CMccRtpDataSink_RemoveStreamLL, Teardown) |
|
1098 |
|
1099 EUNIT_TEST( |
|
1100 "PlayStreamL - test ", |
|
1101 "CMccRtpInterface", |
|
1102 "PlayStreamL", |
|
1103 "FUNCTIONALITY", |
|
1104 SetupL, UT_CMccRtpDataSink_PlayStreamLL, Teardown) |
|
1105 |
|
1106 EUNIT_TEST( |
|
1107 "PauseStreamL - test ", |
|
1108 "CMccRtpInterface", |
|
1109 "PauseStreamL", |
|
1110 "FUNCTIONALITY", |
|
1111 SetupL, UT_CMccRtpDataSink_PauseStreamLL, Teardown) |
|
1112 |
|
1113 EUNIT_TEST( |
|
1114 "StopStreamL - test ", |
|
1115 "CMccRtpInterface", |
|
1116 "StopStreamL", |
|
1117 "FUNCTIONALITY", |
|
1118 SetupL, UT_CMccRtpDataSink_StopStreamLL, Teardown) |
|
1119 |
|
1120 EUNIT_TEST( |
|
1121 "StartInactivityTimerL - test ", |
|
1122 "CMccRtpInterface", |
|
1123 "StartInactivityTimerL", |
|
1124 "FUNCTIONALITY", |
|
1125 SetupL, UT_CMccRtpDataSink_StartInactivityTimerLL, Teardown) |
|
1126 |
|
1127 EUNIT_TEST( |
|
1128 "StopInactivityTimerL - test ", |
|
1129 "CMccRtpInterface", |
|
1130 "StopInactivityTimerL", |
|
1131 "FUNCTIONALITY", |
|
1132 SetupL, UT_CMccRtpDataSink_StopInactivityTimerLL, Teardown) |
|
1133 |
|
1134 EUNIT_TEST( |
|
1135 "SetSessionParamsL - test ", |
|
1136 "CMccRtpInterface", |
|
1137 "SetSessionParamsL", |
|
1138 "FUNCTIONALITY", |
|
1139 SetupL, UT_CMccRtpDataSink_SetSessionParamsLL, Teardown) |
|
1140 |
|
1141 EUNIT_TEST( |
|
1142 "SRTPMasterKeyStaleEvent1L - test ", |
|
1143 "CMccRtpDataSink", |
|
1144 "SRTPMasterKeyStaleEvent1L", |
|
1145 "FUNCTIONALITY", |
|
1146 SetupL, UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent1L, Teardown) |
|
1147 |
|
1148 EUNIT_TEST( |
|
1149 "SRTPMasterKeyStaleEvent2L - test ", |
|
1150 "CMccRtpDataSink", |
|
1151 "SRTPMasterKeyStaleEvent2L", |
|
1152 "FUNCTIONALITY", |
|
1153 SetupL, UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent2L, Teardown) |
|
1154 |
|
1155 EUNIT_END_TEST_TABLE |
|
1156 |
|
1157 // END OF FILE |