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_CMusAvaContactAvailability.h" |
|
21 #include "musavaavailabilityobserver.h" |
|
22 #include "musavaavailabilityobserverimp.h" |
|
23 #include "musavaobserver.h" |
|
24 #include "musavaobserverimp.h" |
|
25 #include "musavasettingsimp.h" |
|
26 #include "muslogger.h" |
|
27 #include "musavadefaultimp.h" |
|
28 #include "musavacapabilitytesthelper.h" |
|
29 #include "mussettings.h" |
|
30 |
|
31 // EXTERNAL INCLUDES |
|
32 #include <digia/eunit/eunitmacros.h> |
|
33 #include <CPbkContactItem.h> |
|
34 #include <CPbkContactEngine.h> |
|
35 #include <CPbkFieldInfo.h> |
|
36 #include <cntfldst.h> |
|
37 #include <cntfield.h> |
|
38 #include <PbkFields.hrh> |
|
39 #include <CPbkFieldsInfo.h> |
|
40 #include <cntfilt.h> |
|
41 #include <digia/eunit/eunitdecorators.h> |
|
42 |
|
43 // INTERNAL INCLUDES |
|
44 #include "musavacontactavailability.h" |
|
45 |
|
46 const TInt KNumberMatchingDigitsRequired( 7 ); |
|
47 |
|
48 _LIT(KNumberZero,""); |
|
49 _LIT(KNumber,"05012345678"); |
|
50 _LIT(KPlusNumber,"+3585012345678"); |
|
51 _LIT(KFirstName,"Matti"); |
|
52 _LIT(KLastName,"Meikalainen"); |
|
53 _LIT(KFirstLastName,"Matti Meikalainen"); |
|
54 _LIT(KLastFirstName,"Meikalainen Matti"); |
|
55 _LIT( KTelNumber, "12345" ); |
|
56 |
|
57 // CONSTRUCTION |
|
58 UT_CMusAvaContactAvailability* UT_CMusAvaContactAvailability::NewL() |
|
59 { |
|
60 UT_CMusAvaContactAvailability* self = UT_CMusAvaContactAvailability::NewLC(); |
|
61 CleanupStack::Pop(); |
|
62 |
|
63 return self; |
|
64 } |
|
65 |
|
66 UT_CMusAvaContactAvailability* UT_CMusAvaContactAvailability::NewLC() |
|
67 { |
|
68 UT_CMusAvaContactAvailability* self = new( ELeave ) UT_CMusAvaContactAvailability(); |
|
69 CleanupStack::PushL( self ); |
|
70 |
|
71 self->ConstructL(); |
|
72 |
|
73 return self; |
|
74 } |
|
75 |
|
76 // Destructor (virtual by CBase) |
|
77 UT_CMusAvaContactAvailability::~UT_CMusAvaContactAvailability() |
|
78 { |
|
79 TRAP_IGNORE( |
|
80 MultimediaSharingSettings::SetOperatorVariantSettingL( iSaveOperatorVariant ) ) |
|
81 } |
|
82 |
|
83 // Default constructor |
|
84 UT_CMusAvaContactAvailability::UT_CMusAvaContactAvailability() |
|
85 { |
|
86 } |
|
87 |
|
88 // Second phase construct |
|
89 void UT_CMusAvaContactAvailability::ConstructL() |
|
90 { |
|
91 // The ConstructL from the base class CEUnitTestSuiteClass must be called. |
|
92 // It generates the test case table. |
|
93 CEUnitTestSuiteClass::ConstructL(); |
|
94 iSaveOperatorVariant = MultimediaSharingSettings::OperatorVariantSettingL(); |
|
95 } |
|
96 |
|
97 // METHODS |
|
98 |
|
99 |
|
100 |
|
101 void UT_CMusAvaContactAvailability::SetupL( ) |
|
102 { |
|
103 MultimediaSharingSettings::SetOperatorVariantSettingL( |
|
104 MusSettingsKeys::EStandard ); |
|
105 |
|
106 iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL(); |
|
107 iConcreteSettings = CMusAvaSettingsImp::NewL(); |
|
108 iContactAvailability = CMusAvaContactAvailability::NewL( *iAvailabilityObserver, |
|
109 *iConcreteSettings ); |
|
110 } |
|
111 |
|
112 void UT_CMusAvaContactAvailability::SetupOpSpecificL() |
|
113 { |
|
114 MultimediaSharingSettings::SetOperatorVariantSettingL( |
|
115 MusSettingsKeys::EOperatorSpecific ); |
|
116 |
|
117 iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL(); |
|
118 iConcreteSettings = CMusAvaSettingsImp::NewL(); |
|
119 iContactAvailability = CMusAvaContactAvailability::NewL( *iAvailabilityObserver, |
|
120 *iConcreteSettings ); |
|
121 } |
|
122 |
|
123 void UT_CMusAvaContactAvailability::Teardown( ) |
|
124 { |
|
125 delete iContactAvailability; |
|
126 delete iAvailabilityObserver; |
|
127 delete iConcreteSettings; |
|
128 |
|
129 /* // obtain contact no in contacts DB |
|
130 TInt contactNo = iListBox->CurrentItemIndex(); |
|
131 contactNo = iPositionInContactsDB.operator[](contactNo); |
|
132 |
|
133 // connect to contact database |
|
134 CContactDatabase* contactsDb = CContactDatabase::OpenL(); |
|
135 CleanupStack::PushL(contactsDb); |
|
136 |
|
137 // set iterator for contacts DB |
|
138 TContactIter iter(*contactsDb); |
|
139 TContactItemId cardId; |
|
140 |
|
141 // index of contacts in contacs DB |
|
142 TInt round(0); |
|
143 |
|
144 // go to correct contact card |
|
145 while( ( cardId = iter.NextL() ) != KNullContactId ) |
|
146 { |
|
147 // if currect index is index of contact we're looking - break |
|
148 if(round == contactNo) |
|
149 break; |
|
150 round++; |
|
151 } |
|
152 |
|
153 // delete contact |
|
154 contactsDb->DeleteContactL(cardId); |
|
155 |
|
156 CleanupStack::PopAndDestroy(); // contactsDb |
|
157 |
|
158 // some function to recreate and redraw List Box should be called here |
|
159 // to reflect changes*/ |
|
160 } |
|
161 |
|
162 void UT_CMusAvaContactAvailability::UT_CMusAvaController_NewLL( ) |
|
163 { |
|
164 // EUNIT_ASSERT( iContactAvailability ); |
|
165 } |
|
166 |
|
167 void UT_CMusAvaContactAvailability::UT_CMusAvaController_DoExecuteLL() |
|
168 { |
|
169 // Non cont or phone number added to contact DB |
|
170 TRAPD( error, iContactAvailability->DoExecuteL( ) ); |
|
171 if ( error == KErrNoMemory ) User::Leave( KErrNoMemory ); |
|
172 TInt count = 0; |
|
173 EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count ); |
|
174 if ( count > 0 && error != KErrNone ) |
|
175 { |
|
176 User::Leave( KErrNoMemory ); |
|
177 } |
|
178 } |
|
179 |
|
180 |
|
181 void UT_CMusAvaContactAvailability::UT_CMusAvaController_DoExecuteL1_L() |
|
182 { |
|
183 CContactIdArray* contactIdArray = NULL; |
|
184 CPbkContactItem* contactItem = NULL; |
|
185 CPbkContactItem* contactItemTmp = NULL; |
|
186 |
|
187 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
188 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
189 CleanupStack::PushL( contactEngine ); |
|
190 |
|
191 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
192 CPbkContactItem* pbkItem = NULL; |
|
193 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
194 delete pbkItem; |
|
195 |
|
196 contactItem= contactEngine->CreateEmptyContactL(); |
|
197 CleanupStack::PushL( contactItem ); |
|
198 |
|
199 //contact |
|
200 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
201 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
202 |
|
203 contactEngine->AddNewContactL( *contactItem ); |
|
204 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
205 |
|
206 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
207 |
|
208 TRAPD( error, iContactAvailability->DoExecuteL() ); |
|
209 if ( error == KErrNoMemory ) User::Leave( error ); |
|
210 TInt count; |
|
211 EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count ); |
|
212 if ( count > 0 && error != KErrNone ) |
|
213 { |
|
214 User::Leave( KErrNoMemory ); |
|
215 } |
|
216 CleanupStack::PopAndDestroy( contactItem ); |
|
217 CleanupStack::PopAndDestroy( contactEngine ); |
|
218 } |
|
219 |
|
220 |
|
221 void UT_CMusAvaContactAvailability::UT_CMusAvaController_DoExecuteL2_L() |
|
222 { |
|
223 CContactIdArray* contactIdArray = NULL; |
|
224 CPbkContactItem* contactItem = NULL; |
|
225 CPbkContactItem* contactItemTmp = NULL; |
|
226 |
|
227 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
228 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
229 CleanupStack::PushL( contactEngine ); |
|
230 |
|
231 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
232 CPbkContactItem* pbkItem = NULL; |
|
233 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
234 delete pbkItem; |
|
235 |
|
236 contactItem= contactEngine->CreateEmptyContactL(); |
|
237 CleanupStack::PushL( contactItem ); |
|
238 |
|
239 CContactTextField* urlAtSignField = |
|
240 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdSIPID ); |
|
241 if ( urlAtSignField ) |
|
242 { |
|
243 urlAtSignField->SetTextL( _L("sip:test@10.21.30.50") ); |
|
244 } |
|
245 else |
|
246 { |
|
247 EUNIT_ASSERT( !urlAtSignField ); |
|
248 } |
|
249 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
250 |
|
251 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
252 |
|
253 TRAPD( error, iContactAvailability->DoExecuteL() ); |
|
254 EUNIT_ASSERT( error == KErrNoMemory || error == KErrNone ); |
|
255 if ( error == KErrNoMemory ) User::Leave( error ); |
|
256 TInt count; |
|
257 EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count ); |
|
258 if ( count > 0 && error != KErrNone ) |
|
259 { |
|
260 User::Leave( KErrNoMemory ); |
|
261 } |
|
262 |
|
263 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
264 |
|
265 TRAP( error, iContactAvailability->DoExecuteL() ); |
|
266 if ( error == KErrNoMemory ) User::Leave( error ); |
|
267 EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count ); |
|
268 if ( count > 0 && error != KErrNone ) |
|
269 { |
|
270 User::Leave( KErrNoMemory ); |
|
271 } |
|
272 |
|
273 CleanupStack::PopAndDestroy( contactItem ); |
|
274 CleanupStack::PopAndDestroy( contactEngine ); |
|
275 } |
|
276 void UT_CMusAvaContactAvailability::UT_CMusAvaController_CallConnectedLL() |
|
277 { |
|
278 TRAPD( error, iContactAvailability->CallConnectedL( KTelNumber ) ); |
|
279 if ( error == KErrNone ) |
|
280 { |
|
281 EUNIT_ASSERT_EQUALS( iContactAvailability->State(), |
|
282 MMusAvaObserver::EMusAvaStatusAvailable ); |
|
283 EUNIT_ASSERT_EQUALS( iConcreteSettings->TelNumber(), KTelNumber ); |
|
284 } |
|
285 } |
|
286 void UT_CMusAvaContactAvailability::UT_CMusAvaController_NameL() |
|
287 { |
|
288 EUNIT_ASSERT( iContactAvailability->Name() == MMusAvaObserver::EMusAvaNameContactStatus ); |
|
289 } |
|
290 |
|
291 void UT_CMusAvaContactAvailability::UT_CMusAvaController_StatusL() |
|
292 { |
|
293 EUNIT_ASSERT( iContactAvailability->State() == MMusAvaObserver::EMusAvaStatusNotExecuted ); |
|
294 } |
|
295 |
|
296 void UT_CMusAvaContactAvailability::UT_CMusAvaController_StopL() |
|
297 { |
|
298 //EUNIT_ASSERT( iContactAvailability->Stop() == KErrNone ); |
|
299 } |
|
300 |
|
301 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ActiveCallLL() |
|
302 { |
|
303 //No prefix |
|
304 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
305 CleanupStack::PushL( array ); |
|
306 |
|
307 iConcreteSettings->SetTelNumberL( KNumber ); |
|
308 EUNIT_ASSERT( !iContactAvailability->ActiveCallL( array ) ); |
|
309 EUNIT_ASSERT( array->MdcaCount() == 0 ); |
|
310 |
|
311 |
|
312 //Prefix |
|
313 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
314 EUNIT_ASSERT( iContactAvailability->ActiveCallL( array ) ); |
|
315 EUNIT_ASSERT( array->Count() == 1 ) |
|
316 array->Reset(); |
|
317 |
|
318 |
|
319 //No number |
|
320 iConcreteSettings->ReleseTelNumberL(); |
|
321 EUNIT_ASSERT( !iContactAvailability->ActiveCallL( array ) ); |
|
322 EUNIT_ASSERT( array->MdcaCount() == 0 ); |
|
323 CleanupStack::PopAndDestroy( array ); |
|
324 } |
|
325 |
|
326 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ActiveCallLOpSpecificL() |
|
327 { |
|
328 //No prefix |
|
329 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
330 CleanupStack::PushL( array ); |
|
331 |
|
332 iConcreteSettings->SetTelNumberL( KNumber ); |
|
333 EUNIT_ASSERT( iContactAvailability->ActiveCallL( array ) ); |
|
334 EUNIT_ASSERT( array->MdcaCount() == 1 ); |
|
335 array->Reset(); |
|
336 |
|
337 //Prefix |
|
338 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
339 EUNIT_ASSERT( iContactAvailability->ActiveCallL( array ) ); |
|
340 EUNIT_ASSERT( array->Count() == 1 ) |
|
341 array->Reset(); |
|
342 |
|
343 //No number |
|
344 iConcreteSettings->ReleseTelNumberL(); |
|
345 EUNIT_ASSERT( !iContactAvailability->ActiveCallL( array ) ); |
|
346 EUNIT_ASSERT( array->MdcaCount() == 0 ); |
|
347 CleanupStack::PopAndDestroy( array ); |
|
348 } |
|
349 |
|
350 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ContactLL() |
|
351 { |
|
352 CContactIdArray* contactIdArray = NULL; |
|
353 CPbkContactItem* contactItem = NULL; |
|
354 |
|
355 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
356 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
357 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
358 CleanupStack::PushL( contactEngine ); |
|
359 |
|
360 // Non cont or phone number added to contact DB |
|
361 TBool ret; |
|
362 TRAPD( error, ret = iContactAvailability->ContactL( contactIdArray, *contactEngine ) ); |
|
363 if ( error == KErrNoMemory ) User::Leave( error ); |
|
364 EUNIT_ASSERT( !ret ); |
|
365 EUNIT_ASSERT( contactIdArray == NULL ); |
|
366 |
|
367 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
368 contactItem= contactEngine->CreateEmptyContactL(); |
|
369 CleanupStack::PushL( contactItem ); |
|
370 |
|
371 //contact |
|
372 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
373 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
374 |
|
375 contactEngine->AddNewContactL( *contactItem ); |
|
376 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
377 |
|
378 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
379 |
|
380 TRAP( error, ret = iContactAvailability->ContactL( contactIdArray, *contactEngine ) ); |
|
381 if ( error == KErrNoMemory ) User::Leave( error ); |
|
382 EUNIT_ASSERT( ret ); |
|
383 EUNIT_ASSERT( contactIdArray != NULL ); |
|
384 |
|
385 delete contactIdArray; |
|
386 contactIdArray = NULL; |
|
387 |
|
388 CleanupStack::PopAndDestroy( contactItem ); |
|
389 CleanupStack::PopAndDestroy( contactEngine ); |
|
390 |
|
391 } |
|
392 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ContactArrayLL() |
|
393 { |
|
394 CContactIdArray* array = NULL; |
|
395 |
|
396 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
397 CPbkContactEngine* pbkContactEngine = CPbkContactEngine::NewL(); |
|
398 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
399 CleanupStack::PushL( pbkContactEngine ); |
|
400 |
|
401 //No number found |
|
402 TInt ret = NULL; |
|
403 TRAPD( error, ret = iContactAvailability->ContactArrayL( array, |
|
404 *pbkContactEngine ) ); |
|
405 if ( error == KErrNoMemory ) User::Leave( error ); |
|
406 EUNIT_ASSERT( error == KErrNone ); |
|
407 EUNIT_ASSERT( ret == KErrNotFound ); |
|
408 EUNIT_ASSERT( array == NULL ); |
|
409 //Number length 0 |
|
410 iConcreteSettings->SetTelNumberL( _L("") ); |
|
411 TRAP( error, ret = iContactAvailability->ContactArrayL( array, |
|
412 *pbkContactEngine ) ); |
|
413 if ( error == KErrNoMemory ) User::Leave( error ); |
|
414 EUNIT_ASSERT( error == KErrNone ); |
|
415 EUNIT_ASSERT( ret == KErrNotFound ); |
|
416 EUNIT_ASSERT( array == NULL ); |
|
417 //Number found |
|
418 iConcreteSettings->SetTelNumberL( KNumber ); |
|
419 TRAP( error, ret = iContactAvailability->ContactArrayL( array, |
|
420 *pbkContactEngine ) ); |
|
421 if ( error == KErrNoMemory ) User::Leave( error ); |
|
422 EUNIT_ASSERT( ret == KErrNone ); |
|
423 EUNIT_ASSERT( array != NULL ); |
|
424 EUNIT_ASSERT( array->Count() > 0 ); |
|
425 |
|
426 CleanupStack::PopAndDestroy( pbkContactEngine ); |
|
427 |
|
428 delete array; |
|
429 array = NULL; |
|
430 } |
|
431 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ContactItemL() |
|
432 { |
|
433 CPbkContactItem* tmpItem = NULL; |
|
434 CContactIdArray* tmpContactIdArray = NULL; |
|
435 |
|
436 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
437 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
438 CleanupStack::PushL( contactEngine ); |
|
439 |
|
440 CPbkContactItem* contactItem= contactEngine->CreateEmptyContactL(); |
|
441 CleanupStack::PushL( contactItem ); |
|
442 |
|
443 // CContactIdArray == 0 |
|
444 //tmpContactIdArray = CContactIdArray::NewLC(); |
|
445 //EUNIT_ASSERT_EQUALS( KErrNotFound, iContactAvailability->ContactItem( |
|
446 //*tmpContactIdArray, tmpItem ) ); |
|
447 //CleanupStack::PopAndDestroy( ); |
|
448 |
|
449 |
|
450 // CContactIdArray > 0 |
|
451 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
452 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
453 contactEngine->AddNewContactL( *contactItem ); |
|
454 |
|
455 CContactDatabase* contactDatabase = CContactDatabase::OpenL(); |
|
456 CleanupStack::PushL( contactDatabase ); |
|
457 CCntFilter* newFilter = CCntFilter::NewL(); |
|
458 CleanupStack::PushL( newFilter ); |
|
459 newFilter->Reset(); |
|
460 newFilter->SetContactFilterTypeALL( ETrue ); |
|
461 contactDatabase->FilterDatabaseL( *newFilter ); |
|
462 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
463 |
|
464 //CContactIdArray* tmpaArray = newFilter->iIds; |
|
465 //Item found |
|
466 |
|
467 TInt err = iContactAvailability->ContactItem( *( newFilter->iIds ), tmpItem, *contactEngine ); |
|
468 // NOTE: Multiple contact id's could be in database and KErrNotSupported is |
|
469 // returned if more than one. Maybe first run could get result KErrNone and |
|
470 // then KErrNotSupported |
|
471 EUNIT_ASSERT( ( KErrNotSupported == err ) || ( KErrNone == err ) ); |
|
472 |
|
473 //EUNIT_ASSERT( tmpItem != NULL ); |
|
474 //delete tmpaArray; |
|
475 //contactDatabase->CommitContactL( *tmpItem ); |
|
476 delete tmpItem; |
|
477 //tmpItem = NULL; |
|
478 //End test |
|
479 |
|
480 CleanupStack::PopAndDestroy( newFilter ); |
|
481 |
|
482 contactDatabase->CloseTables(); |
|
483 |
|
484 CleanupStack::PopAndDestroy( contactDatabase ); |
|
485 CleanupStack::PopAndDestroy( contactItem ); |
|
486 CleanupStack::PopAndDestroy( contactEngine ); |
|
487 |
|
488 |
|
489 |
|
490 } |
|
491 void UT_CMusAvaContactAvailability::UT_CMusAvaController_PhoneResulutionLL() |
|
492 { |
|
493 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
494 CleanupStack::PushL( array ); |
|
495 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
496 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
497 CleanupStack::PushL( contactEngine ); |
|
498 CPbkContactItem* contactItem = contactEngine->CreateEmptyContactL(); |
|
499 CleanupStack::PushL( contactItem ); |
|
500 |
|
501 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
502 CPbkContactItem* pbkItem = NULL; |
|
503 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
504 delete pbkItem; |
|
505 |
|
506 //No prefix |
|
507 contactItem->RemoveDefaultPhoneNumberField(); |
|
508 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
509 iConcreteSettings->SetTelNumberL( KNumber ); |
|
510 TBool ret; |
|
511 TRAPD( error, ret = iContactAvailability->PhoneResolutionL( *contactItem, array ) ); |
|
512 if ( error == KErrNoMemory ) User::Leave( error ); |
|
513 EUNIT_ASSERT ( !ret ); |
|
514 |
|
515 EUNIT_ASSERT( array->MdcaCount() == 0); |
|
516 |
|
517 //Prefix |
|
518 iConcreteSettings->SetTelNumberL( KPlusNumber ); |
|
519 |
|
520 TRAP( error, ret = iContactAvailability->PhoneResolutionL( *contactItem, array ) ); |
|
521 if ( error == KErrNoMemory ) User::Leave( error ); |
|
522 EUNIT_ASSERT ( ret ); |
|
523 EUNIT_ASSERT( array->MdcaCount() > 0 ); |
|
524 //remove object from the array |
|
525 array->Reset(); |
|
526 |
|
527 ///Number plan is in national mode |
|
528 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
529 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
530 fieldMobile->TextStorage()->SetTextL( KNumber() ); |
|
531 contactEngine->AddNewContactL( *contactItem ); |
|
532 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
533 |
|
534 iConcreteSettings->ReleseTelNumberL(); |
|
535 TRAP( error, ret = iContactAvailability->PhoneResolutionL( *contactItem, array ) ); |
|
536 if ( error == KErrNoMemory ) User::Leave( error ); |
|
537 EUNIT_ASSERT ( !ret ); |
|
538 EUNIT_ASSERT( array->MdcaCount() == 0 ); |
|
539 |
|
540 |
|
541 //Number plan is in internatiolan mode |
|
542 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
543 contactItem->RemoveDefaultPhoneNumberField(); |
|
544 fieldMobile = contactItem->FindField( EPbkFieldIdPhoneNumberMobile ); |
|
545 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
546 contactEngine->AddNewContactL( *contactItem ); |
|
547 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
548 iConcreteSettings->ReleseTelNumberL(); |
|
549 TRAP( error, ret = iContactAvailability->PhoneResolutionL( *contactItem, array ) ); |
|
550 if ( error == KErrNoMemory ) User::Leave( error ); |
|
551 EUNIT_ASSERT ( ret ); |
|
552 EUNIT_ASSERT( array->MdcaCount() > 0 ); |
|
553 |
|
554 CleanupStack::PopAndDestroy( contactItem ); |
|
555 CleanupStack::PopAndDestroy( contactEngine ); |
|
556 CleanupStack::PopAndDestroy( array ); |
|
557 } |
|
558 |
|
559 |
|
560 |
|
561 |
|
562 |
|
563 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ContactIdL() |
|
564 { |
|
565 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
566 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
567 CleanupStack::PushL( contactEngine ); |
|
568 |
|
569 CPbkContactItem* contactItem = NULL; |
|
570 |
|
571 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
572 TRAP_IGNORE( contactItem = contactEngine->ReadContactL( 1 ) ); |
|
573 delete contactItem; |
|
574 |
|
575 contactItem = contactEngine->CreateEmptyContactL(); |
|
576 CleanupStack::PushL( contactItem ); |
|
577 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
578 |
|
579 //Contact field not created |
|
580 EUNIT_ASSERT( !iContactAvailability->ContactId( *contactItem, EPbkFieldIdSIPID ) ); |
|
581 |
|
582 //Contact URi not defined |
|
583 CContactTextField* urlFieldNotDefined = |
|
584 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdShareView ); |
|
585 if ( urlFieldNotDefined ) |
|
586 { |
|
587 urlFieldNotDefined->SetTextL( _L("sip:10.21.32.51") ); |
|
588 } |
|
589 else |
|
590 { |
|
591 EUNIT_ASSERT( !urlFieldNotDefined ); |
|
592 } |
|
593 |
|
594 EUNIT_ASSERT( !iContactAvailability->ContactId( *contactItem, EPbkFieldIdShareView ) ); |
|
595 |
|
596 //Contact field not found |
|
597 CContactTextField* urlField = |
|
598 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdShareView ); |
|
599 if ( urlField ) |
|
600 { |
|
601 urlField->SetTextL( _L("test@10.21.32.51") ); |
|
602 } |
|
603 else |
|
604 { |
|
605 EUNIT_ASSERT( !urlField ); |
|
606 } |
|
607 |
|
608 EUNIT_ASSERT( !iContactAvailability->ContactId( *contactItem, EPbkFieldIdSIPID ) ); |
|
609 |
|
610 //Contact field found |
|
611 EUNIT_ASSERT( iContactAvailability->ContactId( *contactItem, EPbkFieldIdShareView ) ); |
|
612 |
|
613 CleanupStack::PopAndDestroy( contactItem ); |
|
614 CleanupStack::PopAndDestroy( contactEngine ); |
|
615 } |
|
616 |
|
617 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ContactIdSearchL() |
|
618 { |
|
619 CPbkContactItem* contactItem = NULL; |
|
620 CContactIdArray* contactIdArray = NULL; |
|
621 CContactTextField* phoneNumberMobiled = NULL; |
|
622 CContactTextField* country = NULL; |
|
623 CContactTextField* urlFieldNotDefined = NULL; |
|
624 CPbkContactEngine* contactEngine = NULL; |
|
625 |
|
626 |
|
627 //No contact ////////////////////////////////////////////////////////////// |
|
628 //General info |
|
629 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
630 contactEngine = CPbkContactEngine::NewL(); |
|
631 CleanupStack::PushL( contactEngine ); |
|
632 |
|
633 //Clear contacts |
|
634 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
635 KNumber(), |
|
636 KNumberMatchingDigitsRequired ); |
|
637 CleanupStack::PushL( contactIdArray ); |
|
638 contactEngine->DeleteContactsL( *contactIdArray ); |
|
639 |
|
640 CleanupStack::PopAndDestroy( contactIdArray ); |
|
641 |
|
642 |
|
643 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
644 TRAP_IGNORE( contactItem = contactEngine->ReadContactL( 1 ) ); |
|
645 delete contactItem; |
|
646 |
|
647 AddToMyContact( *contactEngine, |
|
648 KNumber(), |
|
649 EPbkFieldIdPhoneNumberMobile, |
|
650 _L("nokia"), |
|
651 EPbkFieldIdCompanyName ); |
|
652 |
|
653 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
654 KNumber(), |
|
655 KNumberMatchingDigitsRequired ); |
|
656 CleanupStack::PushL( contactIdArray ); |
|
657 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
658 |
|
659 EUNIT_ASSERT( |
|
660 iContactAvailability->ContactIdSearch( *contactIdArray, *contactEngine ) == |
|
661 EPbkFieldIdNone ); |
|
662 |
|
663 contactEngine->DeleteContactsL( *contactIdArray ); |
|
664 CleanupStack::PopAndDestroy( contactIdArray ); |
|
665 |
|
666 // Field Phone number general found ///////////////////////////////////////////////////////// |
|
667 |
|
668 //Clear contacts |
|
669 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
670 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
671 KNumber(), |
|
672 KNumberMatchingDigitsRequired ); |
|
673 CleanupStack::PushL( contactIdArray ); |
|
674 contactEngine->DeleteContactsL( *contactIdArray ); |
|
675 |
|
676 CleanupStack::PopAndDestroy( contactIdArray ); |
|
677 |
|
678 AddToMyContact( *contactEngine, |
|
679 KNumber(), |
|
680 EPbkFieldIdPhoneNumberMobile, |
|
681 _L("+35805123456789"), |
|
682 EPbkFieldIdPhoneNumberGeneral ); |
|
683 |
|
684 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
685 KNumber(), |
|
686 KNumberMatchingDigitsRequired ); |
|
687 |
|
688 CleanupStack::PushL( contactIdArray ); |
|
689 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
690 |
|
691 EUNIT_ASSERT( |
|
692 iContactAvailability->ContactIdSearch( *contactIdArray, *contactEngine ) == |
|
693 EPbkFieldIdNone ); |
|
694 //EUNIT_ASSERT( ret == EPbkFieldIdPhoneNumberGeneral ); |
|
695 contactEngine->DeleteContactsL( *contactIdArray ); |
|
696 CleanupStack::PopAndDestroy( contactIdArray ); |
|
697 |
|
698 // Field SIP id found ///////////////////////////////////////////////////////// |
|
699 |
|
700 //Clear contacts |
|
701 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
702 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
703 KNumber(), |
|
704 KNumberMatchingDigitsRequired ); |
|
705 CleanupStack::PushL( contactIdArray ); |
|
706 contactEngine->DeleteContactsL( *contactIdArray ); |
|
707 |
|
708 CleanupStack::PopAndDestroy( contactIdArray ); |
|
709 |
|
710 AddToMyContact( *contactEngine, |
|
711 KNumber(), |
|
712 EPbkFieldIdPhoneNumberMobile, |
|
713 _L("test@10.21.32.51"), |
|
714 EPbkFieldIdSIPID ); |
|
715 |
|
716 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
717 KNumber(), |
|
718 KNumberMatchingDigitsRequired ); |
|
719 |
|
720 CleanupStack::PushL( contactIdArray ); |
|
721 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
722 |
|
723 TPbkFieldId ret = iContactAvailability->ContactIdSearch( *contactIdArray, *contactEngine ); |
|
724 if ( ret == EPbkFieldIdNone ) |
|
725 { |
|
726 User::Leave( KErrNoMemory ); |
|
727 } |
|
728 EUNIT_ASSERT( ret == EPbkFieldIdSIPID ); |
|
729 contactEngine->DeleteContactsL( *contactIdArray ); |
|
730 CleanupStack::PopAndDestroy( contactIdArray ); |
|
731 |
|
732 // Share View found |
|
733 //Clear contacts |
|
734 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
735 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
736 KNumber(), |
|
737 KNumberMatchingDigitsRequired ); |
|
738 CleanupStack::PushL( contactIdArray ); |
|
739 contactEngine->DeleteContactsL( *contactIdArray ); |
|
740 |
|
741 CleanupStack::PopAndDestroy( contactIdArray ); |
|
742 |
|
743 AddToMyContact( *contactEngine, |
|
744 KNumber(), |
|
745 EPbkFieldIdPhoneNumberMobile, |
|
746 _L("test@10.21.32.51"), |
|
747 EPbkFieldIdShareView ); |
|
748 |
|
749 contactIdArray = contactEngine->MatchPhoneNumberL( |
|
750 KNumber(), |
|
751 KNumberMatchingDigitsRequired ); |
|
752 |
|
753 CleanupStack::PushL( contactIdArray ); |
|
754 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
755 |
|
756 ret = iContactAvailability->ContactIdSearch( *contactIdArray, *contactEngine ); |
|
757 if ( ret == EPbkFieldIdNone ) |
|
758 { |
|
759 User::Leave( KErrNoMemory ); |
|
760 } |
|
761 EUNIT_ASSERT( ret == EPbkFieldIdShareView ); |
|
762 |
|
763 contactEngine->DeleteContactsL( *contactIdArray ); |
|
764 CleanupStack::PopAndDestroy( contactIdArray ); |
|
765 CleanupStack::PopAndDestroy( contactEngine ); |
|
766 } |
|
767 |
|
768 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ResolveAddressesLL() |
|
769 { |
|
770 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
771 CleanupStack::PushL( array ); |
|
772 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
773 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
774 CleanupStack::PushL( contactEngine ); |
|
775 |
|
776 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
777 CPbkContactItem* pbkItem = NULL; |
|
778 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
779 delete pbkItem; |
|
780 |
|
781 CPbkContactItem* contactItem= contactEngine->CreateEmptyContactL(); |
|
782 CleanupStack::PushL( contactItem ); |
|
783 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
784 |
|
785 //Test cases |
|
786 //Sip Uri without At sign |
|
787 CContactTextField* urlSipField = |
|
788 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdSIPID ); |
|
789 |
|
790 |
|
791 if ( urlSipField ) |
|
792 { |
|
793 urlSipField->SetTextL( _L("sip:10.21.32.51") ); |
|
794 } |
|
795 else |
|
796 { |
|
797 EUNIT_ASSERT( !urlSipField ); |
|
798 } |
|
799 |
|
800 TBool ret; |
|
801 TRAPD( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
802 array, |
|
803 EPbkFieldIdSIPID ) ); |
|
804 if ( error == KErrNoMemory ) User::Leave( error ); |
|
805 EUNIT_ASSERT ( !ret ); |
|
806 EUNIT_ASSERT( array->Count() == 0 ); |
|
807 |
|
808 |
|
809 //Undefined Uri |
|
810 CContactTextField* urlUndefinedField = |
|
811 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdPushToTalk ); |
|
812 if ( urlUndefinedField ) |
|
813 { |
|
814 urlUndefinedField->SetTextL( _L("test@10.21.32.51") ); |
|
815 } |
|
816 else |
|
817 { |
|
818 EUNIT_ASSERT( !urlUndefinedField ); |
|
819 } |
|
820 contactEngine->AddNewContactL( *contactItem ); |
|
821 TRAP( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
822 array, |
|
823 EPbkFieldIdSIPID ) ); |
|
824 if ( error == KErrNoMemory ) User::Leave( error ); |
|
825 EUNIT_ASSERT ( !ret ); |
|
826 |
|
827 EUNIT_ASSERT( array->Count() == 0 ); |
|
828 |
|
829 //Sip Uri |
|
830 CContactTextField* urlAtSignField = |
|
831 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdSIPID ); |
|
832 if ( urlAtSignField ) |
|
833 { |
|
834 urlAtSignField->SetTextL( _L("sip:test@10.21.32.51") ); |
|
835 } |
|
836 else |
|
837 { |
|
838 EUNIT_ASSERT( !urlAtSignField ); |
|
839 } |
|
840 contactEngine->AddNewContactL( *contactItem ); |
|
841 TRAP( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
842 array, |
|
843 EPbkFieldIdSIPID ) ); |
|
844 if ( error == KErrNoMemory ) User::Leave( error ); |
|
845 EUNIT_ASSERT ( ret ); |
|
846 EUNIT_ASSERT( array->Count() > 0 ); |
|
847 |
|
848 //Clear array |
|
849 array->Reset(); |
|
850 |
|
851 //ShareView Uri |
|
852 CContactTextField* urlShareViewField = |
|
853 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdShareView ); |
|
854 if ( urlShareViewField ) |
|
855 { |
|
856 urlShareViewField->SetTextL( _L("test@10.21.32.51") ); |
|
857 } |
|
858 else |
|
859 { |
|
860 EUNIT_ASSERT( !urlShareViewField ); |
|
861 } |
|
862 |
|
863 TRAP( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
864 array, |
|
865 EPbkFieldIdShareView ) ); |
|
866 if ( error == KErrNoMemory ) User::Leave( error ); |
|
867 EUNIT_ASSERT ( ret ); |
|
868 EUNIT_ASSERT( array != NULL ); |
|
869 EUNIT_ASSERT( array->Count() > 0 ); |
|
870 array->Reset(); |
|
871 |
|
872 |
|
873 //End test |
|
874 CleanupStack::PopAndDestroy( contactItem ); |
|
875 CleanupStack::PopAndDestroy( contactEngine ); |
|
876 CleanupStack::PopAndDestroy( array ); |
|
877 |
|
878 } |
|
879 |
|
880 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ResolveAddressesLOpSpecificL() |
|
881 { |
|
882 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
883 CleanupStack::PushL( array ); |
|
884 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
885 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
886 CleanupStack::PushL( contactEngine ); |
|
887 |
|
888 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
889 CPbkContactItem* pbkItem = NULL; |
|
890 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
891 delete pbkItem; |
|
892 |
|
893 CPbkContactItem* contactItem= contactEngine->CreateEmptyContactL(); |
|
894 CleanupStack::PushL( contactItem ); |
|
895 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
896 |
|
897 //Test cases |
|
898 //Sip Uri without test string |
|
899 CContactTextField* urlAtSignField = |
|
900 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdSIPID ); |
|
901 if ( urlAtSignField ) |
|
902 { |
|
903 urlAtSignField->SetTextL( _L("sip:test@10.21.32.51") ); |
|
904 } |
|
905 else |
|
906 { |
|
907 EUNIT_ASSERT( !urlAtSignField ); |
|
908 } |
|
909 contactEngine->AddNewContactL( *contactItem ); |
|
910 TBool ret; |
|
911 TRAPD( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
912 array, |
|
913 EPbkFieldIdSIPID ) ); |
|
914 if ( error == KErrNoMemory ) User::Leave( error ); |
|
915 EUNIT_ASSERT ( !ret ); |
|
916 EUNIT_ASSERT_EQUALS( array->Count(), 0 ); |
|
917 |
|
918 //Clear array |
|
919 array->Reset(); |
|
920 |
|
921 //Sip Uri with test string (*#) |
|
922 urlAtSignField = |
|
923 EditableContactFieldL( *contactEngine, *contactItem, EPbkFieldIdSIPID ); |
|
924 if ( urlAtSignField ) |
|
925 { |
|
926 urlAtSignField->SetTextL( _L("sip:test*#@10.21.32.51") ); |
|
927 } |
|
928 else |
|
929 { |
|
930 EUNIT_ASSERT( !urlAtSignField ); |
|
931 } |
|
932 contactEngine->AddNewContactL( *contactItem ); |
|
933 TRAP( error, ret = iContactAvailability->ResolveAddressesL( *contactItem, |
|
934 array, |
|
935 EPbkFieldIdSIPID ) ); |
|
936 if ( error == KErrNoMemory ) User::Leave( error ); |
|
937 EUNIT_ASSERT ( ret ); |
|
938 EUNIT_ASSERT( array->Count() > 0 ); |
|
939 |
|
940 //Clear array |
|
941 array->Reset(); |
|
942 |
|
943 //End test |
|
944 CleanupStack::PopAndDestroy( contactItem ); |
|
945 CleanupStack::PopAndDestroy( contactEngine ); |
|
946 CleanupStack::PopAndDestroy( array ); |
|
947 |
|
948 } |
|
949 |
|
950 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ResolvePhoneContactLL() |
|
951 { |
|
952 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
953 CleanupStack::PushL( array ); |
|
954 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
955 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
956 CleanupStack::PushL( contactEngine ); |
|
957 |
|
958 CPbkContactItem* contactItem= contactEngine->CreateEmptyContactL(); |
|
959 CleanupStack::PushL( contactItem ); |
|
960 ///Number plan is in national mode |
|
961 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
962 fieldMobile->TextStorage()->SetTextL(_L("0401234567")); |
|
963 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
964 |
|
965 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
966 EUNIT_ASSERT( array->MdcaCount() == 0 ); |
|
967 //Number plan is in internatiolan mode |
|
968 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
969 contactItem->RemoveDefaultPhoneNumberField(); |
|
970 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
971 fieldMobile->TextStorage()->SetTextL(_L("+358401234567")); |
|
972 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
973 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
974 EUNIT_ASSERT( array->MdcaCount() > 0 ); |
|
975 array->Reset(); |
|
976 |
|
977 //tel uri |
|
978 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
979 contactItem->RemoveDefaultPhoneNumberField(); |
|
980 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
981 fieldMobile->TextStorage()->SetTextL(_L("tel:+358401234567")); |
|
982 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
983 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
984 EUNIT_ASSERT( array->Count() == 0 ); |
|
985 |
|
986 //End test |
|
987 CleanupStack::PopAndDestroy( contactItem ); |
|
988 CleanupStack::PopAndDestroy( contactEngine ); |
|
989 CleanupStack::PopAndDestroy( array ); |
|
990 } |
|
991 |
|
992 void UT_CMusAvaContactAvailability::UT_CMusAvaController_ResolvePhoneContactLOpSpecificL() |
|
993 { |
|
994 CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 10 ); |
|
995 CleanupStack::PushL( array ); |
|
996 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
997 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
998 CleanupStack::PushL( contactEngine ); |
|
999 |
|
1000 CPbkContactItem* contactItem= contactEngine->CreateEmptyContactL(); |
|
1001 CleanupStack::PushL( contactItem ); |
|
1002 ///Number plan is in national mode |
|
1003 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1004 fieldMobile->TextStorage()->SetTextL(_L("0401234567")); |
|
1005 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1006 |
|
1007 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
1008 EUNIT_ASSERT( array->MdcaCount() > 0 ); |
|
1009 //Number plan is in internatiolan mode |
|
1010 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1011 contactItem->RemoveDefaultPhoneNumberField(); |
|
1012 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1013 fieldMobile->TextStorage()->SetTextL(_L("+358401234567")); |
|
1014 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1015 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
1016 EUNIT_ASSERT( array->MdcaCount() > 0 ); |
|
1017 array->Reset(); |
|
1018 |
|
1019 //tel uri |
|
1020 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1021 contactItem->RemoveDefaultPhoneNumberField(); |
|
1022 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1023 fieldMobile->TextStorage()->SetTextL(_L("tel:+358401234567")); |
|
1024 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1025 iContactAvailability->ResolvePhoneContactL( *contactItem, array ); |
|
1026 EUNIT_ASSERT( array->Count() > 0 ); |
|
1027 |
|
1028 //End test |
|
1029 CleanupStack::PopAndDestroy( contactItem ); |
|
1030 CleanupStack::PopAndDestroy( contactEngine ); |
|
1031 CleanupStack::PopAndDestroy( array ); |
|
1032 } |
|
1033 |
|
1034 CContactTextField* UT_CMusAvaContactAvailability::EditableContactFieldL( |
|
1035 CPbkContactEngine& aContactEngine, |
|
1036 CPbkContactItem& aContact, |
|
1037 TPbkFieldId aFieldId ) |
|
1038 { |
|
1039 /* CContactDatabase* contactDatabase = NULL; |
|
1040 contactDatabase = CContactDatabase::OpenL(); |
|
1041 CleanupStack::PushL( contactDatabase ); |
|
1042 CCntFilter* newFilter = CCntFilter::NewLC(); |
|
1043 newFilter->Reset(); |
|
1044 newFilter->SetContactFilterTypeALL( ETrue ); |
|
1045 contactDatabase->FilterDatabaseL( *newFilter ); |
|
1046 |
|
1047 CContactIdArray* contactsId = newFilter->iIds; |
|
1048 if ( contactsId->Count() ) |
|
1049 { |
|
1050 aContactEngine.DeleteContactsL( *contactsId ); |
|
1051 } |
|
1052 //contactDatabase->CommitContactL(): |
|
1053 |
|
1054 CleanupStack::PopAndDestroy( 2 ); |
|
1055 CleanupStack::PopAndDestroy( contactDatabase );*/ |
|
1056 |
|
1057 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1058 const CPbkFieldsInfo& fieldsInfo = aContactEngine.FieldsInfo(); |
|
1059 // Try to get the SIP URI storage field for this contact |
|
1060 TPbkContactItemField* itemField = aContact.FindField( aFieldId ); |
|
1061 |
|
1062 if ( !itemField ) |
|
1063 { |
|
1064 CPbkFieldInfo* fieldInfo = fieldsInfo.Find( aFieldId ); |
|
1065 // Add field to this contact |
|
1066 if ( fieldInfo ) |
|
1067 { |
|
1068 CleanupStack::PushL( fieldInfo ); |
|
1069 // Contact takes ownership of the field. |
|
1070 aContact.AddFieldL( *fieldInfo ); |
|
1071 CleanupStack::Pop( fieldInfo ); |
|
1072 itemField = aContact.FindField( aFieldId ); |
|
1073 if ( itemField ) |
|
1074 { |
|
1075 return itemField->TextStorage(); |
|
1076 } |
|
1077 else |
|
1078 { |
|
1079 EUNIT_ASSERT( !itemField ); |
|
1080 } |
|
1081 } |
|
1082 else |
|
1083 { |
|
1084 EUNIT_ASSERT( !fieldInfo ); |
|
1085 } |
|
1086 } |
|
1087 else |
|
1088 { |
|
1089 return itemField->TextStorage(); |
|
1090 } |
|
1091 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1092 return NULL; // Should never reach here, just to avoid warnings. |
|
1093 } |
|
1094 |
|
1095 void UT_CMusAvaContactAvailability::AddFields( CPbkContactEngine& aContactEngine, |
|
1096 CPbkContactItem& contact, |
|
1097 const TDesC& aText, |
|
1098 TPbkFieldId aFieldId ) |
|
1099 { |
|
1100 const CPbkFieldsInfo& fieldsInfo = aContactEngine.FieldsInfo(); |
|
1101 // Try to get the storage field for this contact |
|
1102 TPbkContactItemField* itemField = contact.FindField( aFieldId ); |
|
1103 |
|
1104 if ( itemField == NULL ) |
|
1105 { |
|
1106 CPbkFieldInfo* fieldInfo = fieldsInfo.Find( aFieldId ); |
|
1107 // Add field to this contact |
|
1108 if ( fieldInfo ) |
|
1109 { |
|
1110 CleanupStack::PushL( fieldInfo ); |
|
1111 // Contact takes ownership of the field. |
|
1112 contact.AddFieldL( *fieldInfo ); |
|
1113 CleanupStack::Pop( fieldInfo ); |
|
1114 itemField = contact.FindField( aFieldId ); |
|
1115 if ( itemField ) |
|
1116 { |
|
1117 itemField->TextStorage()->SetTextL( aText ); |
|
1118 } |
|
1119 else |
|
1120 { |
|
1121 EUNIT_ASSERT( !itemField ); |
|
1122 } |
|
1123 } |
|
1124 else |
|
1125 { |
|
1126 EUNIT_ASSERT( !fieldInfo ); |
|
1127 } |
|
1128 } |
|
1129 else |
|
1130 { |
|
1131 // Set some default fields |
|
1132 itemField->TextStorage()->SetTextL(aText ); |
|
1133 } |
|
1134 } |
|
1135 |
|
1136 void UT_CMusAvaContactAvailability::AddToMyContact( CPbkContactEngine& aContactEngine, |
|
1137 const TDesC& aText, |
|
1138 TPbkFieldId aFieldId, |
|
1139 const TDesC& aText2, |
|
1140 TPbkFieldId aFieldId2 ) |
|
1141 { |
|
1142 // Create a contact with few default fields |
|
1143 // All the default fields are empty and won't be displayed |
|
1144 // until some information is stored in them |
|
1145 /*CPbkContactItem* contact = aContactEngine.CreateEmptyContactL(); |
|
1146 CleanupStack::PushL( contact ); |
|
1147 |
|
1148 // Set some default fields |
|
1149 contact->FindField( aFieldId )->TextStorage()->SetTextL(aText ); |
|
1150 // Set some default fields |
|
1151 contact->FindField( aFieldId2 )->TextStorage()->SetTextL(aText2 ); |
|
1152 |
|
1153 // Store the contact to the phonebook |
|
1154 aContactEngine.AddNewContactL( *contact ); |
|
1155 CleanupStack::PopAndDestroy( contact );*/ |
|
1156 |
|
1157 /*CPbkContactItem* contact = aContactEngine.CreateEmptyContactL(); |
|
1158 CleanupStack::PushL( contact ); |
|
1159 |
|
1160 const CPbkFieldsInfo& fieldsInfo = aContactEngine.FieldsInfo(); |
|
1161 // Try to get the storage field for this contact |
|
1162 TPbkContactItemField* itemField = contact->FindField( aFieldId ); |
|
1163 |
|
1164 if ( itemField == NULL ) |
|
1165 { |
|
1166 CPbkFieldInfo* fieldInfo = fieldsInfo.Find( aFieldId ); |
|
1167 // Add field to this contact |
|
1168 if ( fieldInfo ) |
|
1169 { |
|
1170 CleanupStack::PushL( fieldInfo ); |
|
1171 // Contact takes ownership of the field. |
|
1172 contact->AddFieldL( *fieldInfo ); |
|
1173 CleanupStack::Pop( fieldInfo ); |
|
1174 itemField = contact->FindField( aFieldId ); |
|
1175 if ( itemField ) |
|
1176 { |
|
1177 itemField->TextStorage()->SetTextL( aText ); |
|
1178 } |
|
1179 else |
|
1180 { |
|
1181 EUNIT_ASSERT( !itemField ); |
|
1182 } |
|
1183 } |
|
1184 else |
|
1185 { |
|
1186 EUNIT_ASSERT( !fieldInfo ); |
|
1187 } |
|
1188 } |
|
1189 else |
|
1190 { |
|
1191 // Set some default fields |
|
1192 itemField->TextStorage()->SetTextL(aText ); |
|
1193 } |
|
1194 // Store the contact to the phonebook |
|
1195 aContactEngine.AddNewContactL( *contact ); |
|
1196 CleanupStack::PopAndDestroy( contact );*/ |
|
1197 |
|
1198 CPbkContactItem* contact = aContactEngine.CreateEmptyContactL(); |
|
1199 CleanupStack::PushL( contact ); |
|
1200 |
|
1201 AddFields( aContactEngine, *contact, aText, aFieldId ); |
|
1202 AddFields( aContactEngine, *contact, aText2, aFieldId2 ); |
|
1203 // Store the contact to the phonebook |
|
1204 aContactEngine.AddNewContactL( *contact ); |
|
1205 CleanupStack::PopAndDestroy( contact ); |
|
1206 |
|
1207 } |
|
1208 |
|
1209 void UT_CMusAvaContactAvailability::UT_CMusAvaController_IsExistAlreadyL() |
|
1210 { |
|
1211 _LIT( KTestUri1, "sip:1@test.net"); |
|
1212 _LIT( KTestUri2, "sip:2@test.net"); |
|
1213 _LIT( KTestUri3, "sip:3@test.net"); |
|
1214 _LIT( KTestUri5, "sip:5@test.net"); |
|
1215 |
|
1216 TBufC16<16> str1(KTestUri1); |
|
1217 HBufC16* ptr1; |
|
1218 ptr1 = str1.AllocLC(); |
|
1219 |
|
1220 TBufC16<16> str2(KTestUri2); |
|
1221 HBufC16* ptr2; |
|
1222 ptr2 = str2.AllocLC(); |
|
1223 |
|
1224 TBufC16<16> str3(KTestUri3); |
|
1225 HBufC16* ptr3; |
|
1226 ptr3 = str3.AllocLC(); |
|
1227 |
|
1228 CDesCArrayFlat* array = new( ELeave ) CDesCArrayFlat(1); |
|
1229 CleanupStack::PushL(array); |
|
1230 array->AppendL(*ptr1); |
|
1231 array->AppendL(*ptr2); |
|
1232 array->AppendL(*ptr3); |
|
1233 |
|
1234 TBool exist = EFalse; |
|
1235 |
|
1236 // Test 1 : |
|
1237 exist = iContactAvailability->IsExistAlready(*array,KTestUri1); |
|
1238 EUNIT_ASSERT(exist); |
|
1239 // Test 2 : |
|
1240 exist = iContactAvailability->IsExistAlready(*array,KTestUri5); |
|
1241 EUNIT_ASSERT(!exist); |
|
1242 |
|
1243 array->Reset(); |
|
1244 CleanupStack::PopAndDestroy(array); |
|
1245 CleanupStack::PopAndDestroy(ptr3); |
|
1246 CleanupStack::PopAndDestroy(ptr2); |
|
1247 CleanupStack::PopAndDestroy(ptr1); |
|
1248 } |
|
1249 |
|
1250 void UT_CMusAvaContactAvailability::UT_CMusAvaController_UpdateContactNameLL() |
|
1251 { |
|
1252 CPbkContactItem* contactItem = NULL; |
|
1253 |
|
1254 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1255 CPbkContactEngine* contactEngine = CPbkContactEngine::NewL(); |
|
1256 CleanupStack::PushL( contactEngine ); |
|
1257 |
|
1258 // dummy initialization, other ways CPbkContactEngine leaks memory |
|
1259 CPbkContactItem* pbkItem = NULL; |
|
1260 TRAP_IGNORE( pbkItem = contactEngine->ReadContactL( 1 ) ); |
|
1261 delete pbkItem; |
|
1262 |
|
1263 contactItem= contactEngine->CreateEmptyContactL(); |
|
1264 CleanupStack::PushL( contactItem ); |
|
1265 |
|
1266 //contact firstname && iBeginWithFirstName = ETrue |
|
1267 TPbkContactItemField* fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1268 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1269 |
|
1270 TPbkContactItemField* fieldMobile1 = contactItem->FindField(EPbkFieldIdFirstName); |
|
1271 fieldMobile1->TextStorage()->SetTextL( KFirstName() ); |
|
1272 |
|
1273 contactEngine->AddNewContactL( *contactItem ); |
|
1274 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1275 |
|
1276 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1277 |
|
1278 iContactAvailability->iBeginWithFirstName = ETrue; |
|
1279 TRAPD( error, |
|
1280 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1281 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1282 EUNIT_ASSERT( error == KErrNone ); |
|
1283 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KFirstName ) == NULL ); |
|
1284 |
|
1285 CleanupStack::PopAndDestroy( contactItem ); |
|
1286 CContactIdArray* array = NULL; |
|
1287 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1288 CleanupStack::PushL( array ); |
|
1289 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1290 CleanupStack::PopAndDestroy( array ); |
|
1291 |
|
1292 //contact firstname && iBeginWithFirstName = EFalse |
|
1293 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1294 contactItem= contactEngine->CreateEmptyContactL(); |
|
1295 CleanupStack::PushL( contactItem ); |
|
1296 |
|
1297 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1298 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1299 |
|
1300 fieldMobile1 = contactItem->FindField(EPbkFieldIdFirstName); |
|
1301 fieldMobile1->TextStorage()->SetTextL( KFirstName() ); |
|
1302 |
|
1303 contactEngine->AddNewContactL( *contactItem ); |
|
1304 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1305 |
|
1306 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1307 |
|
1308 iContactAvailability->iBeginWithFirstName = EFalse; |
|
1309 TRAP( error, |
|
1310 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1311 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1312 EUNIT_ASSERT( error == KErrNone ); |
|
1313 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KFirstName ) == NULL ); |
|
1314 |
|
1315 CleanupStack::PopAndDestroy( contactItem ); |
|
1316 array = NULL; |
|
1317 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1318 CleanupStack::PushL( array ); |
|
1319 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1320 CleanupStack::PopAndDestroy( array ); |
|
1321 |
|
1322 //contact lastname && iBeginWithFirstName = ETrue |
|
1323 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1324 contactItem= contactEngine->CreateEmptyContactL(); |
|
1325 CleanupStack::PushL( contactItem ); |
|
1326 |
|
1327 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1328 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1329 |
|
1330 fieldMobile1 = contactItem->FindField(EPbkFieldIdLastName); |
|
1331 fieldMobile1->TextStorage()->SetTextL( KLastName() ); |
|
1332 |
|
1333 contactEngine->AddNewContactL( *contactItem ); |
|
1334 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1335 |
|
1336 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1337 |
|
1338 iContactAvailability->iBeginWithFirstName = ETrue; |
|
1339 TRAP( error, |
|
1340 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1341 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1342 EUNIT_ASSERT( error == KErrNone ); |
|
1343 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KLastName ) == NULL ); |
|
1344 |
|
1345 CleanupStack::PopAndDestroy( contactItem ); |
|
1346 array = NULL; |
|
1347 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1348 CleanupStack::PushL( array ); |
|
1349 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1350 CleanupStack::PopAndDestroy( array ); |
|
1351 |
|
1352 //contact lastname && iBeginWithFirstName = EFalse |
|
1353 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1354 contactItem= contactEngine->CreateEmptyContactL(); |
|
1355 CleanupStack::PushL( contactItem ); |
|
1356 |
|
1357 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1358 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1359 |
|
1360 fieldMobile1 = contactItem->FindField(EPbkFieldIdLastName); |
|
1361 fieldMobile1->TextStorage()->SetTextL( KLastName() ); |
|
1362 |
|
1363 contactEngine->AddNewContactL( *contactItem ); |
|
1364 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1365 |
|
1366 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1367 |
|
1368 iContactAvailability->iBeginWithFirstName = EFalse; |
|
1369 TRAP( error, |
|
1370 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1371 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1372 EUNIT_ASSERT( error == KErrNone ); |
|
1373 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KLastName ) == NULL ); |
|
1374 |
|
1375 CleanupStack::PopAndDestroy( contactItem ); |
|
1376 array = NULL; |
|
1377 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1378 CleanupStack::PushL( array ); |
|
1379 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1380 CleanupStack::PopAndDestroy( array ); |
|
1381 |
|
1382 //contact firstname && lastname && iBeginWithFirstName = ETrue |
|
1383 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1384 contactItem= contactEngine->CreateEmptyContactL(); |
|
1385 CleanupStack::PushL( contactItem ); |
|
1386 |
|
1387 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1388 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1389 |
|
1390 fieldMobile1 = contactItem->FindField(EPbkFieldIdFirstName); |
|
1391 fieldMobile1->TextStorage()->SetTextL( KFirstName() ); |
|
1392 |
|
1393 TPbkContactItemField* fieldMobile2 = contactItem->FindField(EPbkFieldIdLastName); |
|
1394 fieldMobile2->TextStorage()->SetTextL( KLastName() ); |
|
1395 |
|
1396 contactEngine->AddNewContactL( *contactItem ); |
|
1397 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1398 |
|
1399 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1400 |
|
1401 iContactAvailability->iBeginWithFirstName = ETrue; |
|
1402 TRAP( error, |
|
1403 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1404 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1405 EUNIT_ASSERT( error == KErrNone ); |
|
1406 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KFirstLastName ) == NULL ); |
|
1407 // |
|
1408 CleanupStack::PopAndDestroy( contactItem ); |
|
1409 array = NULL; |
|
1410 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1411 CleanupStack::PushL( array ); |
|
1412 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1413 CleanupStack::PopAndDestroy( array ); |
|
1414 |
|
1415 //contact firstname && lastname && iBeginWithFirstName = EFalse |
|
1416 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1417 contactItem= contactEngine->CreateEmptyContactL(); |
|
1418 CleanupStack::PushL( contactItem ); |
|
1419 |
|
1420 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1421 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1422 |
|
1423 fieldMobile1 = contactItem->FindField(EPbkFieldIdFirstName); |
|
1424 fieldMobile1->TextStorage()->SetTextL( KFirstName() ); |
|
1425 |
|
1426 fieldMobile2 = contactItem->FindField(EPbkFieldIdLastName); |
|
1427 fieldMobile2->TextStorage()->SetTextL( KLastName() ); |
|
1428 |
|
1429 contactEngine->AddNewContactL( *contactItem ); |
|
1430 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1431 |
|
1432 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1433 |
|
1434 iContactAvailability->iBeginWithFirstName = EFalse; |
|
1435 TRAP( error, |
|
1436 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1437 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1438 EUNIT_ASSERT( error == KErrNone ); |
|
1439 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KLastFirstName ) == NULL ); |
|
1440 |
|
1441 CleanupStack::PopAndDestroy( contactItem ); |
|
1442 array = NULL; |
|
1443 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1444 CleanupStack::PushL( array ); |
|
1445 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1446 CleanupStack::PopAndDestroy( array ); |
|
1447 |
|
1448 // contact name only contain 1 character |
|
1449 _LIT(KNameWithOneChar,"M"); |
|
1450 for (int i = 0; i < 1; ++i ) |
|
1451 { |
|
1452 EUNIT_DISABLE_ALLOC_DECORATOR; |
|
1453 contactItem= contactEngine->CreateEmptyContactL(); |
|
1454 CleanupStack::PushL( contactItem ); |
|
1455 |
|
1456 fieldMobile = contactItem->FindField(EPbkFieldIdPhoneNumberMobile); |
|
1457 fieldMobile->TextStorage()->SetTextL( KPlusNumber() ); |
|
1458 |
|
1459 fieldMobile1 = contactItem->FindField(EPbkFieldIdFirstName); |
|
1460 fieldMobile1->TextStorage()->SetTextL( KNameWithOneChar() ); |
|
1461 |
|
1462 contactEngine->AddNewContactL( *contactItem ); |
|
1463 EUNIT_ENABLE_ALLOC_DECORATOR; |
|
1464 |
|
1465 iConcreteSettings->SetTelNumberL( KPlusNumber() ); |
|
1466 |
|
1467 iContactAvailability->iBeginWithFirstName = i; |
|
1468 TRAP( error, |
|
1469 iContactAvailability->UpdateContactNameL( contactItem->ContactItem() ) ); |
|
1470 if ( error == KErrNoMemory ) User::Leave( error ); |
|
1471 EUNIT_ASSERT( error == KErrNone ); |
|
1472 EUNIT_ASSERT( iContactAvailability->iContactName->Compare( KNameWithOneChar ) == -1 ); |
|
1473 |
|
1474 CleanupStack::PopAndDestroy( contactItem ); |
|
1475 array = NULL; |
|
1476 iContactAvailability->ContactArrayL( array, *contactEngine ); |
|
1477 CleanupStack::PushL( array ); |
|
1478 contactEngine->DeleteContactsL( *array, ETrue ); |
|
1479 CleanupStack::PopAndDestroy( array ); |
|
1480 } |
|
1481 |
|
1482 CleanupStack::PopAndDestroy( contactEngine ); |
|
1483 } |
|
1484 // TEST TABLE |
|
1485 |
|
1486 EUNIT_BEGIN_TEST_TABLE( |
|
1487 UT_CMusAvaContactAvailability, |
|
1488 "CMusAvaContactAvailability", |
|
1489 "UNIT" ) |
|
1490 |
|
1491 EUNIT_TEST( |
|
1492 "NewL - test ", |
|
1493 "CMusAvaContactAvailability", |
|
1494 "NewL", |
|
1495 "FUNCTIONALITY", |
|
1496 SetupL, UT_CMusAvaController_NewLL, Teardown) |
|
1497 |
|
1498 EUNIT_TEST( |
|
1499 "DoExecuteL - test ", |
|
1500 "CMusAvaContactAvailability", |
|
1501 "DoExecuteL", |
|
1502 "FUNCTIONALITY", |
|
1503 SetupL, UT_CMusAvaController_DoExecuteLL, Teardown) |
|
1504 |
|
1505 EUNIT_TEST( |
|
1506 "DoExecuteL_1 - test ", |
|
1507 "CMusAvaContactAvailability", |
|
1508 "DoExecuteL_1", |
|
1509 "FUNCTIONALITY", |
|
1510 SetupL, UT_CMusAvaController_DoExecuteL1_L, Teardown) |
|
1511 |
|
1512 EUNIT_TEST( |
|
1513 "DoExecuteL_2 - test ", |
|
1514 "CMusAvaContactAvailability", |
|
1515 "DoExecuteL_2", |
|
1516 "FUNCTIONALITY", |
|
1517 SetupL, UT_CMusAvaController_DoExecuteL2_L, Teardown) |
|
1518 |
|
1519 EUNIT_TEST( |
|
1520 "Name - test ", |
|
1521 "CMusAvaController", |
|
1522 "Name", |
|
1523 "FUNCTIONALITY", |
|
1524 SetupL, UT_CMusAvaController_NameL, Teardown) |
|
1525 |
|
1526 EUNIT_TEST( |
|
1527 "Status - test ", |
|
1528 "CMusAvaController", |
|
1529 "Status", |
|
1530 "FUNCTIONALITY", |
|
1531 SetupL, UT_CMusAvaController_StatusL, Teardown) |
|
1532 |
|
1533 EUNIT_TEST( |
|
1534 "Stop - test ", |
|
1535 "CMusAvaController", |
|
1536 "Stop", |
|
1537 "FUNCTIONALITY", |
|
1538 SetupL, UT_CMusAvaController_StopL, Teardown) |
|
1539 |
|
1540 EUNIT_TEST( |
|
1541 "ActiveCallL - test ", |
|
1542 "CMusAvaContactAvailability", |
|
1543 "ActiveCallL", |
|
1544 "FUNCTIONALITY", |
|
1545 SetupL, UT_CMusAvaController_ActiveCallLL, Teardown) |
|
1546 |
|
1547 EUNIT_TEST( |
|
1548 "ActiveCallL OpSpecific - test ", |
|
1549 "CMusAvaContactAvailability", |
|
1550 "ActiveCallL", |
|
1551 "FUNCTIONALITY", |
|
1552 SetupOpSpecificL, UT_CMusAvaController_ActiveCallLOpSpecificL, Teardown) |
|
1553 |
|
1554 EUNIT_TEST( |
|
1555 "ContactL - test ", |
|
1556 "CMusAvaContactAvailability", |
|
1557 "ContactL", |
|
1558 "FUNCTIONALITY", |
|
1559 SetupL, UT_CMusAvaController_ContactLL, Teardown) |
|
1560 |
|
1561 EUNIT_TEST( |
|
1562 "ContactArrayL - test ", |
|
1563 "CMusAvaContactAvailability", |
|
1564 "ContactArrayL", |
|
1565 "FUNCTIONALITY", |
|
1566 SetupL, UT_CMusAvaController_ContactArrayLL, Teardown) |
|
1567 |
|
1568 EUNIT_TEST( |
|
1569 "ContactItem - test ", |
|
1570 "CMusAvaContactAvailability", |
|
1571 "ContactItem", |
|
1572 "FUNCTIONALITY", |
|
1573 SetupL, UT_CMusAvaController_ContactItemL, Teardown) |
|
1574 |
|
1575 EUNIT_TEST( |
|
1576 "PhoneResolutionL - test ", |
|
1577 "CMusAvaContactAvailability", |
|
1578 "PhoneResolutionL", |
|
1579 "FUNCTIONALITY", |
|
1580 SetupL, UT_CMusAvaController_PhoneResulutionLL, Teardown) |
|
1581 |
|
1582 EUNIT_TEST( |
|
1583 "ContactIdSearch - test ", |
|
1584 "CMusAvaContactAvailability", |
|
1585 "ContactIdSearch", |
|
1586 "FUNCTIONALITY", |
|
1587 SetupL, UT_CMusAvaController_ContactIdSearchL, Teardown) |
|
1588 |
|
1589 EUNIT_TEST( |
|
1590 "ContactId - test ", |
|
1591 "CMusAvaContactAvailability", |
|
1592 "ContactId", |
|
1593 "FUNCTIONALITY", |
|
1594 SetupL, UT_CMusAvaController_ContactIdL, Teardown) |
|
1595 |
|
1596 EUNIT_TEST( |
|
1597 "ResolveAddressesL - test ", |
|
1598 "CMusAvaContactAvailability", |
|
1599 "ResolveAddressesL", |
|
1600 "FUNCTIONALITY", |
|
1601 SetupL, UT_CMusAvaController_ResolveAddressesLL, Teardown) |
|
1602 |
|
1603 EUNIT_TEST( |
|
1604 "ResolveAddressesL OpSpecific- test ", |
|
1605 "CMusAvaContactAvailability", |
|
1606 "ResolveAddressesL", |
|
1607 "FUNCTIONALITY", |
|
1608 SetupOpSpecificL, UT_CMusAvaController_ResolveAddressesLOpSpecificL, Teardown) |
|
1609 |
|
1610 EUNIT_TEST( |
|
1611 "ResolvePhoneContactL - test ", |
|
1612 "CMusAvaContactAvailability", |
|
1613 "ResolvePhoneContactL", |
|
1614 "FUNCTIONALITY", |
|
1615 SetupL, UT_CMusAvaController_ResolvePhoneContactLL, Teardown) |
|
1616 |
|
1617 EUNIT_TEST( |
|
1618 "ResolvePhoneContactL OpSpecific - test ", |
|
1619 "CMusAvaContactAvailability", |
|
1620 "ResolvePhoneContactL", |
|
1621 "FUNCTIONALITY", |
|
1622 SetupOpSpecificL, UT_CMusAvaController_ResolvePhoneContactLOpSpecificL, Teardown) |
|
1623 |
|
1624 EUNIT_TEST( |
|
1625 "IsExistAlready - test ", |
|
1626 "CMusAvaContactAvailability", |
|
1627 "IsExistAlready", |
|
1628 "FUNCTIONALITY", |
|
1629 SetupL, UT_CMusAvaController_IsExistAlreadyL, Teardown) |
|
1630 |
|
1631 EUNIT_TEST( |
|
1632 "UpdateContactNameL - test ", |
|
1633 "CMusAvaContactAvailability", |
|
1634 "UpdateContactNameL", |
|
1635 "FUNCTIONALITY", |
|
1636 SetupL, UT_CMusAvaController_UpdateContactNameLL, Teardown) |
|
1637 |
|
1638 EUNIT_TEST( |
|
1639 "UpdateContactNameL - test ", |
|
1640 "CMusAvaContactAvailability", |
|
1641 "UpdateContactNameL", |
|
1642 "FUNCTIONALITY", |
|
1643 SetupL, UT_CMusAvaController_CallConnectedLL, Teardown) |
|
1644 EUNIT_END_TEST_TABLE |
|
1645 |
|
1646 // END OF FILE |
|
1647 |
|