|
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 // CLASS HEADER |
|
20 #include "UT_CMusAvaDefaultOptionHandler.h" |
|
21 #include "musavaavailabilityobserver.h" |
|
22 #include "musavaavailabilityobserverimp.h" |
|
23 #include "musavasettingsimp.h" |
|
24 #include "musavaobserverimp.h" |
|
25 #include "musavadefaultoptionhandler.h" |
|
26 #include "musavasettingsobserverimp.h" |
|
27 #include "mussettingskeys.h" |
|
28 #include "mussettings.h" |
|
29 #include "muslogger.h" |
|
30 #include "musavacapabilitytesthelper.h" |
|
31 #include "CSipSseTestTls.h" |
|
32 #include "musavacapabilitycontext.h" |
|
33 |
|
34 |
|
35 |
|
36 // EXTERNAL INCLUDES |
|
37 #include <digia/eunit/eunitmacros.h> |
|
38 #include <sipstrings.h> |
|
39 #include <stringpool.h> |
|
40 #include <sipservertransaction.h> |
|
41 #include <siptransactionbase.h> |
|
42 #include <sipheaderbase.h> |
|
43 #include <SipStrConsts.h> |
|
44 #include <sipresponseelements.h> |
|
45 #include <sipmessageelements.h> |
|
46 #include <siprequestelements.h> |
|
47 #include <Uri8.h> |
|
48 // INTERNAL INCLUDES |
|
49 |
|
50 |
|
51 _LIT8( KMUSAVATESTSipAddress, "sip:test@10.20.30.40"); |
|
52 |
|
53 // CONSTRUCTION |
|
54 UT_CMusAvaDefaultOptionHandler* UT_CMusAvaDefaultOptionHandler::NewL() |
|
55 { |
|
56 UT_CMusAvaDefaultOptionHandler* self = UT_CMusAvaDefaultOptionHandler::NewLC(); |
|
57 CleanupStack::Pop(); |
|
58 |
|
59 return self; |
|
60 } |
|
61 |
|
62 UT_CMusAvaDefaultOptionHandler* UT_CMusAvaDefaultOptionHandler::NewLC() |
|
63 { |
|
64 UT_CMusAvaDefaultOptionHandler* self = new( ELeave ) UT_CMusAvaDefaultOptionHandler(); |
|
65 CleanupStack::PushL( self ); |
|
66 self->ConstructL(); |
|
67 |
|
68 return self; |
|
69 } |
|
70 |
|
71 // Destructor (virtual by CBase) |
|
72 UT_CMusAvaDefaultOptionHandler::~UT_CMusAvaDefaultOptionHandler() |
|
73 { |
|
74 } |
|
75 |
|
76 // Default constructor |
|
77 UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler() |
|
78 { |
|
79 } |
|
80 |
|
81 // Second phase construct |
|
82 void UT_CMusAvaDefaultOptionHandler::ConstructL() |
|
83 { |
|
84 // The ConstructL from the base class CEUnitTestSuiteClass must be called. |
|
85 // It generates the test case table. |
|
86 CEUnitTestSuiteClass::ConstructL(); |
|
87 } |
|
88 |
|
89 // METHODS |
|
90 |
|
91 void UT_CMusAvaDefaultOptionHandler::SetupL( ) |
|
92 { |
|
93 TRAP_IGNORE( SIPStrings::OpenL() ) |
|
94 CSipSseTestTls::OpenL(); |
|
95 iStorage = CSipSseTestTls::Storage(); |
|
96 MultimediaSharingSettings::SetOperatorVariantSettingL( MusSettingsKeys::EStandard ); |
|
97 MultimediaSharingSettings::SetEdgeDtmSupportSettingL( MusSettingsKeys::EDtmModeAllowed ); |
|
98 iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL(); |
|
99 iConcreteSettings = CMusAvaSettingsImp::NewL(); |
|
100 iSettingsObserverImp = CMusAvaSettingsObserverImp::NewL(); |
|
101 iConcreteSettings->SetObserver( *iSettingsObserverImp ); |
|
102 iOptionDefaultHandler = CMusAvaDefaultOptionHandler::NewL( *iAvailabilityObserver, |
|
103 *iConcreteSettings ); |
|
104 MultimediaSharingSettings::SetCapabilityQuerySettingL( |
|
105 MusSettingsKeys::ENoOptions ); |
|
106 } |
|
107 |
|
108 void UT_CMusAvaDefaultOptionHandler::SetupOpSpecificL( ) |
|
109 { |
|
110 TRAP_IGNORE( SIPStrings::OpenL() ) |
|
111 CSipSseTestTls::OpenL(); |
|
112 iStorage = CSipSseTestTls::Storage(); |
|
113 MultimediaSharingSettings::SetOperatorVariantSettingL( MusSettingsKeys::EOperatorSpecific ); |
|
114 MultimediaSharingSettings::SetEdgeDtmSupportSettingL( MusSettingsKeys::EDtmModeAllowed ); |
|
115 iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL(); |
|
116 iConcreteSettings = CMusAvaSettingsImp::NewL(); |
|
117 iSettingsObserverImp = CMusAvaSettingsObserverImp::NewL(); |
|
118 iConcreteSettings->SetObserver( *iSettingsObserverImp ); |
|
119 iOptionDefaultHandler = CMusAvaDefaultOptionHandler::NewL( *iAvailabilityObserver, |
|
120 *iConcreteSettings ); |
|
121 MultimediaSharingSettings::SetCapabilityQuerySettingL( |
|
122 MusSettingsKeys::ENoOptions ); |
|
123 } |
|
124 |
|
125 void UT_CMusAvaDefaultOptionHandler::Teardown( ) |
|
126 { |
|
127 if ( iStorage ) |
|
128 { |
|
129 iStorage->Clear(); |
|
130 CSipSseTestTls::Close(); |
|
131 iStorage = NULL; |
|
132 } |
|
133 |
|
134 SIPStrings::Close(); |
|
135 delete iAvailabilityObserver; |
|
136 delete iConcreteSettings; |
|
137 delete iSettingsObserverImp; |
|
138 delete iOptionDefaultHandler; |
|
139 } |
|
140 |
|
141 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_NewLL( ) |
|
142 { |
|
143 EUNIT_ASSERT( iOptionDefaultHandler ); |
|
144 } |
|
145 |
|
146 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_IncomingRequestL() |
|
147 { |
|
148 MultimediaSharingSettings::SetActivationSettingL( MusSettingsKeys::EAlwaysActive ); |
|
149 CSIPServerTransaction* serverTransaction = NULL; |
|
150 |
|
151 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
152 CleanupStack::PushL( serverTransaction ); |
|
153 |
|
154 TUriParser8 Uri; |
|
155 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
156 |
|
157 CUri8* uri = CUri8::NewLC( Uri ); |
|
158 |
|
159 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
160 CleanupStack::Pop( uri ); |
|
161 CleanupStack::PushL( requestelements ); |
|
162 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
163 serverTransaction->SetRequestElements( requestelements ); |
|
164 CleanupStack::Pop( requestelements ); |
|
165 |
|
166 TInt ret = iOptionDefaultHandler->IncomingRequest( serverTransaction ); |
|
167 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
168 EUNIT_ASSERT( ret == KErrNone ); |
|
169 |
|
170 CleanupStack::Pop( serverTransaction ); |
|
171 |
|
172 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) ); |
|
173 CleanupStack::PushL( serverTransaction ); |
|
174 ret = iOptionDefaultHandler->IncomingRequest( serverTransaction ); |
|
175 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
176 EUNIT_ASSERT( ret == KErrNotFound ); |
|
177 CleanupStack::PopAndDestroy( serverTransaction ); |
|
178 |
|
179 iSettingsObserverImp->iOptionAllowed = EFalse; |
|
180 iAvailabilityObserver->AvailabilityChanged( |
|
181 MMusAvaObserver::EMusAvaDefaultOptionHandler, |
|
182 MMusAvaObserver::EMusAvaStatusAvailable ); |
|
183 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
184 CleanupStack::PushL( serverTransaction ); |
|
185 |
|
186 uri = CUri8::NewLC( Uri ); |
|
187 |
|
188 requestelements = CSIPRequestElements::NewL( uri ); |
|
189 CleanupStack::Pop( uri ); |
|
190 CleanupStack::PushL( requestelements ); |
|
191 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
192 serverTransaction->SetRequestElements( requestelements ); |
|
193 CleanupStack::Pop( requestelements ); |
|
194 |
|
195 ret = iOptionDefaultHandler->IncomingRequest( serverTransaction ); |
|
196 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
197 EUNIT_ASSERT( ret == KErrNone ); |
|
198 |
|
199 CleanupStack::Pop( serverTransaction ); |
|
200 |
|
201 //IAP Request |
|
202 iAvailabilityObserver->AvailabilityChanged( |
|
203 MMusAvaObserver::EMusAvaDefaultOptionHandler, |
|
204 MMusAvaObserver::EMusAvaStatusNotExecuted ); |
|
205 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
206 CleanupStack::PushL( serverTransaction ); |
|
207 |
|
208 uri = CUri8::NewLC( Uri ); |
|
209 |
|
210 requestelements = CSIPRequestElements::NewL( uri ); |
|
211 CleanupStack::Pop( uri ); |
|
212 CleanupStack::PushL( requestelements ); |
|
213 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
214 serverTransaction->SetRequestElements( requestelements ); |
|
215 CleanupStack::Pop( requestelements ); |
|
216 |
|
217 ret = iOptionDefaultHandler->IncomingRequest( 1, serverTransaction ); |
|
218 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
219 EUNIT_ASSERT( ret == KErrNone ); |
|
220 |
|
221 CleanupStack::Pop( serverTransaction ); |
|
222 |
|
223 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) ); |
|
224 CleanupStack::PushL( serverTransaction ); |
|
225 ret = iOptionDefaultHandler->IncomingRequest( 1, serverTransaction ); |
|
226 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
227 EUNIT_ASSERT( ret == KErrNotFound ); |
|
228 CleanupStack::PopAndDestroy( serverTransaction ); |
|
229 |
|
230 iSettingsObserverImp->iOptionAllowed = EFalse; |
|
231 iAvailabilityObserver->AvailabilityChanged( |
|
232 MMusAvaObserver::EMusAvaOptionHandler, |
|
233 MMusAvaObserver::EMusAvaStatusAvailable ); |
|
234 serverTransaction = CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
235 CleanupStack::PushL( serverTransaction ); |
|
236 uri = CUri8::NewLC( Uri ); |
|
237 |
|
238 requestelements = CSIPRequestElements::NewL( uri ); |
|
239 CleanupStack::Pop( uri ); |
|
240 CleanupStack::PushL( requestelements ); |
|
241 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
242 serverTransaction->SetRequestElements( requestelements ); |
|
243 CleanupStack::Pop( requestelements ); |
|
244 ret = iOptionDefaultHandler->IncomingRequest( 1, serverTransaction ); |
|
245 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
246 EUNIT_ASSERT( ret == KErrNotFound ); |
|
247 CleanupStack::PopAndDestroy( serverTransaction ); |
|
248 } |
|
249 |
|
250 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_DoExecuteLL() |
|
251 { |
|
252 TRAPD( error, iOptionDefaultHandler->DoExecuteL() ); |
|
253 if ( error == KErrNoMemory ) User::Leave( error ); |
|
254 EUNIT_ASSERT( error == KErrNone ); |
|
255 EUNIT_ASSERT( iOptionDefaultHandler->State() == MMusAvaObserver::EMusAvaStatusAvailable ); |
|
256 } |
|
257 |
|
258 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_NameL() |
|
259 { |
|
260 EUNIT_ASSERT( iOptionDefaultHandler->Name() == MMusAvaObserver::EMusAvaDefaultOptionHandler ); |
|
261 } |
|
262 |
|
263 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_StatusL() |
|
264 { |
|
265 EUNIT_ASSERT( iOptionDefaultHandler->State() == MMusAvaObserver::EMusAvaStatusAvailable ); |
|
266 } |
|
267 |
|
268 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_StopL() |
|
269 { |
|
270 iOptionDefaultHandler->Stop(); |
|
271 } |
|
272 |
|
273 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_IncomingOptionRequestLL() |
|
274 { |
|
275 CSIPServerTransaction* serverTransaction = |
|
276 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
277 CleanupStack::PushL( serverTransaction ); |
|
278 |
|
279 TUriParser8 Uri; |
|
280 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
281 |
|
282 CUri8* uri = CUri8::NewLC( Uri ); |
|
283 |
|
284 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
285 CleanupStack::Pop( uri ); |
|
286 CleanupStack::PushL( requestelements ); |
|
287 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
288 serverTransaction->SetRequestElements( requestelements ); |
|
289 CleanupStack::Pop( requestelements ); |
|
290 |
|
291 MultimediaSharingSettings::SetActivationSettingL( MusSettingsKeys::EAlwaysActive ); |
|
292 TRAPD( ret, iOptionDefaultHandler->IncomingOptionRequestL( serverTransaction ) ); |
|
293 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
294 EUNIT_ASSERT( ret == KErrNone ); |
|
295 |
|
296 TUint statusCode = iStorage->iClientResponse->StatusCode(); |
|
297 EUNIT_ASSERT( statusCode == KMUSAVASIPTemporarilyUnavailable ); |
|
298 |
|
299 iSettingsObserverImp->iOptionAllowed = ETrue; |
|
300 iAvailabilityObserver->AvailabilityChanged( |
|
301 MMusAvaObserver::EMusAvaDefaultOptionHandler, |
|
302 MMusAvaObserver::EMusAvaStatusAvailable ); |
|
303 TRAP( ret, iOptionDefaultHandler->IncomingOptionRequestL( serverTransaction ) ); |
|
304 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
305 EUNIT_ASSERT( ret == KErrNone ); |
|
306 |
|
307 iSettingsObserverImp->iOptionAllowed = EFalse; |
|
308 MultimediaSharingSettings::SetActivationSettingL( MusSettingsKeys::EActiveInHomeNetworks ); |
|
309 TRAP( ret, iOptionDefaultHandler->IncomingOptionRequestL( serverTransaction ) ); |
|
310 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
311 EUNIT_ASSERT( ret == KErrNone ); |
|
312 |
|
313 MultimediaSharingSettings::SetActivationSettingL( MusSettingsKeys::ENever ); |
|
314 TRAP( ret, iOptionDefaultHandler->IncomingOptionRequestL( serverTransaction ) ); |
|
315 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
316 EUNIT_ASSERT( ret == KErrNone ); |
|
317 statusCode = iStorage->iClientResponse->StatusCode(); |
|
318 EUNIT_ASSERT( statusCode == KMUSAVASIPDecline ); |
|
319 |
|
320 CleanupStack::PopAndDestroy( serverTransaction ); |
|
321 } |
|
322 |
|
323 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_IncomingOptionRequestLOpSpecificL() |
|
324 { |
|
325 CSIPServerTransaction* serverTransaction = |
|
326 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
327 CleanupStack::PushL( serverTransaction ); |
|
328 TUriParser8 Uri; |
|
329 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
330 CUri8* uri = CUri8::NewLC( Uri ); |
|
331 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
332 CleanupStack::Pop( uri ); |
|
333 CleanupStack::PushL( requestelements ); |
|
334 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
335 serverTransaction->SetRequestElements( requestelements ); |
|
336 CleanupStack::Pop( requestelements ); |
|
337 |
|
338 TRAPD( ret, iOptionDefaultHandler->IncomingOptionRequestL( serverTransaction ) ); |
|
339 if ( ret == KErrNoMemory ) User::Leave( ret ); |
|
340 EUNIT_ASSERT( ret == KErrNone ); |
|
341 TUint statusCode = iStorage->iClientResponse->StatusCode(); |
|
342 EUNIT_ASSERT( statusCode == KMUSAVASIP200 ); |
|
343 |
|
344 CleanupStack::PopAndDestroy( serverTransaction ); |
|
345 |
|
346 } |
|
347 |
|
348 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_ResponseLL() |
|
349 { |
|
350 TInt statusCode = KMUSAVASIPDecline; |
|
351 RStringF reasonPhrase = |
|
352 SIPStrings::StringF( SipStrConsts::EPhraseDecline); |
|
353 CSIPResponseElements* respElem = |
|
354 CSIPResponseElements::NewL( statusCode, reasonPhrase ); |
|
355 CleanupStack::PushL( respElem ); |
|
356 |
|
357 CSIPServerTransaction* serverTransaction = |
|
358 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
359 CleanupStack::PushL( serverTransaction ); |
|
360 |
|
361 TUriParser8 Uri; |
|
362 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
363 |
|
364 CUri8* uri = CUri8::NewLC( Uri ); |
|
365 |
|
366 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
367 CleanupStack::Pop( uri ); |
|
368 CleanupStack::PushL( requestelements ); |
|
369 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
370 serverTransaction->SetRequestElements( requestelements ); |
|
371 CleanupStack::Pop( requestelements ); |
|
372 |
|
373 //This transaction is not client TR |
|
374 serverTransaction->iIsClientTransaction = ETrue; |
|
375 serverTransaction->iState = CSIPTransactionBase::ETerminated; |
|
376 TRAPD( error, iOptionDefaultHandler->ResponseL( respElem, serverTransaction ) ); |
|
377 if ( error == KErrNoMemory ) User::Leave( error ); |
|
378 EUNIT_ASSERT( error == KErrNotReady ); |
|
379 |
|
380 // Transaction state proceeding |
|
381 serverTransaction->ChangeState( CSIPTransactionBase::EProceeding ); |
|
382 TRAP( error, iOptionDefaultHandler->ResponseL( respElem, serverTransaction ) ); |
|
383 if ( error == KErrNoMemory ) User::Leave( error ); |
|
384 EUNIT_ASSERT( error == KErrNone ); |
|
385 |
|
386 CleanupStack::PopAndDestroy( serverTransaction ); |
|
387 CleanupStack::Pop( respElem ); |
|
388 |
|
389 //Sent response |
|
390 serverTransaction = |
|
391 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
392 CleanupStack::PushL( serverTransaction ); |
|
393 respElem = |
|
394 CSIPResponseElements::NewL( statusCode, reasonPhrase ); |
|
395 CleanupStack::PushL( respElem ); |
|
396 |
|
397 uri = CUri8::NewLC( Uri ); |
|
398 requestelements = CSIPRequestElements::NewL( uri ); |
|
399 CleanupStack::Pop( uri ); |
|
400 CleanupStack::PushL( requestelements ); |
|
401 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
402 serverTransaction->SetRequestElements( requestelements ); |
|
403 CleanupStack::Pop( requestelements ); |
|
404 |
|
405 serverTransaction->iIsClientTransaction = ETrue; |
|
406 serverTransaction->iState = CSIPTransactionBase::ETrying; |
|
407 iOptionDefaultHandler->ResponseL( respElem, serverTransaction ); |
|
408 CleanupStack::Pop( respElem ); |
|
409 statusCode = iStorage->iClientResponse->StatusCode(); |
|
410 EUNIT_ASSERT( statusCode == KMUSAVASIPDecline ); |
|
411 |
|
412 CleanupStack::PopAndDestroy( serverTransaction ); |
|
413 serverTransaction = NULL; |
|
414 |
|
415 // response not allowed |
|
416 serverTransaction = |
|
417 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EAck ) ); |
|
418 CleanupStack::PushL( serverTransaction ); |
|
419 respElem = |
|
420 CSIPResponseElements::NewL( statusCode, reasonPhrase ); |
|
421 CleanupStack::PushL( respElem ); |
|
422 |
|
423 TRAP( error, iOptionDefaultHandler->ResponseL( respElem, serverTransaction ) ); |
|
424 if ( error == KErrNoMemory ) User::Leave( error ); |
|
425 CleanupStack::PopAndDestroy( respElem ); |
|
426 EUNIT_ASSERT( error == KErrNotReady ); |
|
427 |
|
428 CleanupStack::PopAndDestroy( serverTransaction ); |
|
429 } |
|
430 |
|
431 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_NoCapabilityResponseLL() |
|
432 { |
|
433 CSIPServerTransaction* serverTransaction = |
|
434 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
435 CleanupStack::PushL( serverTransaction ); |
|
436 |
|
437 TUriParser8 Uri; |
|
438 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
439 |
|
440 CUri8* uri = CUri8::NewLC( Uri ); |
|
441 |
|
442 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
443 CleanupStack::Pop( uri ); |
|
444 CleanupStack::PushL( requestelements ); |
|
445 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
446 serverTransaction->SetRequestElements( requestelements ); |
|
447 CleanupStack::Pop( requestelements ); |
|
448 |
|
449 serverTransaction->iIsClientTransaction = ETrue; |
|
450 serverTransaction->iState = CSIPTransactionBase::ETrying; |
|
451 iSettingsObserverImp->iOptionAllowed = ETrue; |
|
452 iOptionDefaultHandler->NoCapabilityResponseL( serverTransaction, |
|
453 KMUSAVASIPTemporarilyUnavailable, |
|
454 SipStrConsts::EPhraseTemporarilyNotAvailable ); |
|
455 TUint statusCode = iStorage->iClientResponse->StatusCode(); |
|
456 EUNIT_ASSERT( statusCode == KMUSAVASIPTemporarilyUnavailable ); |
|
457 |
|
458 CleanupStack::PopAndDestroy( serverTransaction ); |
|
459 } |
|
460 |
|
461 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_NoCapabilityResponseLOpSpecificL() |
|
462 { |
|
463 CSIPServerTransaction* serverTransaction = |
|
464 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
465 CleanupStack::PushL( serverTransaction ); |
|
466 |
|
467 TUriParser8 Uri; |
|
468 User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) ); |
|
469 |
|
470 CUri8* uri = CUri8::NewLC( Uri ); |
|
471 |
|
472 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
473 CleanupStack::Pop( uri ); |
|
474 CleanupStack::PushL( requestelements ); |
|
475 requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
476 serverTransaction->SetRequestElements( requestelements ); |
|
477 CleanupStack::Pop( requestelements ); |
|
478 |
|
479 serverTransaction->iIsClientTransaction = ETrue; |
|
480 serverTransaction->iState = CSIPTransactionBase::ETrying; |
|
481 iSettingsObserverImp->iOptionAllowed = ETrue; |
|
482 iOptionDefaultHandler->NoCapabilityResponseL( serverTransaction, |
|
483 KMUSAVASIPTemporarilyUnavailable, |
|
484 SipStrConsts::EPhraseTemporarilyNotAvailable ); |
|
485 TUint statusCode = iStorage->iClientResponse->StatusCode(); |
|
486 EUNIT_ASSERT( statusCode == KMUSAVASIP200 ); |
|
487 |
|
488 CleanupStack::PopAndDestroy( serverTransaction ); |
|
489 } |
|
490 |
|
491 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_CreateResponseLL() |
|
492 { |
|
493 CSIPServerTransaction* serverTransaction = |
|
494 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
495 CleanupStack::PushL( serverTransaction ); |
|
496 TUriParser8 Uri; |
|
497 User::LeaveIfError( Uri.Parse( KMUSAVATESTSipAddress() ) ); |
|
498 |
|
499 CUri8* uri = CUri8::NewLC( Uri ); |
|
500 CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); |
|
501 CleanupStack::Pop( uri ); |
|
502 CleanupStack::PushL( requestelements ); |
|
503 serverTransaction->SetRequestElements( requestelements ); |
|
504 CleanupStack::Pop( requestelements ); |
|
505 |
|
506 //Sent response |
|
507 serverTransaction->iIsClientTransaction = ETrue; |
|
508 serverTransaction->iState = CSIPTransactionBase::ETrying; |
|
509 iSettingsObserverImp->iOptionAllowed = ETrue; |
|
510 CSIPResponseElements* resp = |
|
511 iOptionDefaultHandler->CreateResponseL( *serverTransaction ); |
|
512 CleanupStack::PopAndDestroy( serverTransaction ); |
|
513 CleanupStack::PushL( resp ); |
|
514 EUNIT_ASSERT( resp->MessageElements().Content().Length() > 0); |
|
515 EUNIT_ASSERT( resp->StatusCode() == KMUSAVASIP200 ); |
|
516 CleanupStack::PopAndDestroy( resp ); |
|
517 } |
|
518 |
|
519 |
|
520 void UT_CMusAvaDefaultOptionHandler::UT_CMusAvaDefaultOptionHandler_TimedOutL() |
|
521 { |
|
522 CSIPServerTransaction* serverTransaction = |
|
523 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EOptions ) ); |
|
524 EUNIT_ASSERT_EQUALS( |
|
525 iOptionDefaultHandler->TimedOut( *serverTransaction ), |
|
526 KErrNotSupported ); |
|
527 delete serverTransaction; |
|
528 } |
|
529 |
|
530 |
|
531 // TEST TABLE |
|
532 |
|
533 EUNIT_BEGIN_TEST_TABLE( |
|
534 UT_CMusAvaDefaultOptionHandler, |
|
535 "CMusAvaDefaultOptionHandler", |
|
536 "UNIT" ) |
|
537 |
|
538 EUNIT_TEST( |
|
539 "NewL - test ", |
|
540 "CMusAvaDefaultOptionHandler", |
|
541 "NewL", |
|
542 "FUNCTIONALITY", |
|
543 SetupL,UT_CMusAvaDefaultOptionHandler_NewLL, Teardown) |
|
544 |
|
545 EUNIT_TEST( |
|
546 "IncomingRequest - test ", |
|
547 "CMusAvaDefaultOptionHandler", |
|
548 "IncomingRequest", |
|
549 "FUNCTIONALITY", |
|
550 SetupL,UT_CMusAvaDefaultOptionHandler_IncomingRequestL, Teardown) |
|
551 |
|
552 EUNIT_TEST( |
|
553 "DoExecuteL - test ", |
|
554 "CMusAvaDefaultOptionHandler", |
|
555 "DoExecuteL", |
|
556 "FUNCTIONALITY", |
|
557 SetupL,UT_CMusAvaDefaultOptionHandler_DoExecuteLL, Teardown) |
|
558 |
|
559 EUNIT_TEST( |
|
560 "Name - test ", |
|
561 "CMusAvaDefaultOptionHandler", |
|
562 "Name", |
|
563 "FUNCTIONALITY", |
|
564 SetupL,UT_CMusAvaDefaultOptionHandler_NameL, Teardown) |
|
565 |
|
566 |
|
567 EUNIT_TEST( |
|
568 "Status - test ", |
|
569 "CMusAvaDefaultOptionHandler", |
|
570 "Status", |
|
571 "FUNCTIONALITY", |
|
572 SetupL,UT_CMusAvaDefaultOptionHandler_StatusL, Teardown) |
|
573 |
|
574 EUNIT_TEST( |
|
575 "Stop - test ", |
|
576 "CMusAvaDefaultOptionHandler", |
|
577 "Stop", |
|
578 "FUNCTIONALITY", |
|
579 SetupL,UT_CMusAvaDefaultOptionHandler_StopL, Teardown) |
|
580 |
|
581 EUNIT_TEST( |
|
582 "IncomingOptionRequestL - test ", |
|
583 "CMusAvaDefaultOptionHandler", |
|
584 "IncomingOptionRequestL", |
|
585 "FUNCTIONALITY", |
|
586 SetupL,UT_CMusAvaDefaultOptionHandler_IncomingOptionRequestLL, Teardown) |
|
587 |
|
588 EUNIT_TEST( |
|
589 "IncomingOptionRequestL - Op specific test ", |
|
590 "CMusAvaDefaultOptionHandler", |
|
591 "IncomingOptionRequestL", |
|
592 "FUNCTIONALITY", |
|
593 SetupOpSpecificL, UT_CMusAvaDefaultOptionHandler_IncomingOptionRequestLOpSpecificL, Teardown) |
|
594 |
|
595 EUNIT_TEST( |
|
596 "ResponseL - test ", |
|
597 "CMusAvaDefaultOptionHandler", |
|
598 "ResponseL", |
|
599 "FUNCTIONALITY", |
|
600 SetupL,UT_CMusAvaDefaultOptionHandler_ResponseLL, Teardown) |
|
601 |
|
602 EUNIT_TEST( |
|
603 "NoCapabilityResponseL - test ", |
|
604 "CMusAvaDefaultOptionHandler", |
|
605 "NoCapabilityResponseL", |
|
606 "FUNCTIONALITY", |
|
607 SetupL,UT_CMusAvaDefaultOptionHandler_NoCapabilityResponseLL, Teardown) |
|
608 |
|
609 EUNIT_TEST( |
|
610 "NoCapabilityResponseL Op specific- test ", |
|
611 "CMusAvaDefaultOptionHandler", |
|
612 "NoCapabilityResponseL", |
|
613 "FUNCTIONALITY", |
|
614 SetupOpSpecificL,UT_CMusAvaDefaultOptionHandler_NoCapabilityResponseLOpSpecificL, Teardown) |
|
615 |
|
616 EUNIT_TEST( |
|
617 "CreateResponseL - test ", |
|
618 "CMusAvaDefaultOptionHandler", |
|
619 "CreateResponseL", |
|
620 "FUNCTIONALITY", |
|
621 SetupL,UT_CMusAvaDefaultOptionHandler_CreateResponseLL, Teardown) |
|
622 |
|
623 EUNIT_TEST( |
|
624 "TimedOut - test ", |
|
625 "CMusAvaDefaultOptionHandler", |
|
626 "TimedOut", |
|
627 "FUNCTIONALITY", |
|
628 SetupL,UT_CMusAvaDefaultOptionHandler_TimedOutL, Teardown) |
|
629 |
|
630 |
|
631 EUNIT_END_TEST_TABLE |
|
632 |
|
633 // END OF FILE |