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