1 /* |
|
2 * Copyright (c) 2009 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: This file contains STIFUnit implementation. |
|
15 * |
|
16 */ |
|
17 |
|
18 /** |
|
19 * STIF_UNIT_INCLUDE SECTION - put all #includes between STIF_UNIT_INCLUDE_SECTION |
|
20 * and STIF_UNIT_INCLUDE_SECTION_END |
|
21 */ |
|
22 #ifdef STIF_UNIT_INCLUDE_SECTION |
|
23 |
|
24 |
|
25 #endif //STIF_UNIT_INCLUDE_SECTION_END |
|
26 |
|
27 /** |
|
28 * GLOBAL VARIABLES SECTION |
|
29 */ |
|
30 #ifdef TEST_VAR_DECLARATIONS |
|
31 /** |
|
32 * Example of variable common for some test cases |
|
33 */ |
|
34 |
|
35 #endif |
|
36 /** |
|
37 * END OF GLOBAL VARIABLES SECTION |
|
38 */ |
|
39 |
|
40 |
|
41 /** |
|
42 * TEST CASES SECTION |
|
43 */ |
|
44 #ifdef TEST_CASES |
|
45 /** |
|
46 * STIF_SETUP defines activities needed before every test case. |
|
47 */ |
|
48 STIF_SETUP |
|
49 { |
|
50 /** Example of use of STIF_SETUP - a variable common for some test cases is initialized |
|
51 */ |
|
52 |
|
53 |
|
54 } |
|
55 |
|
56 /** |
|
57 * STIF_TEARDOWN defines activities needed after every test case |
|
58 */ |
|
59 STIF_TEARDOWN |
|
60 { |
|
61 /** Example of use of STIF_TEARDOWN - a variable common for some test cases is destroyed |
|
62 */ |
|
63 |
|
64 } |
|
65 |
|
66 /** |
|
67 * STIF_TESTDEFINE defines a test case |
|
68 * |
|
69 * Example test case - length of string is checked. |
|
70 * The only argument of macro is a name of test case. |
|
71 */ |
|
72 STIF_TESTDEFINE(t_CreateCommand_login) |
|
73 { |
|
74 vimpstengine_stub engin; |
|
75 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
76 TInt data = 1; |
|
77 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELoginService,&data) ; |
|
78 //delete factory; |
|
79 //factory = NULL; |
|
80 TInt comm_sent = ELoginService; |
|
81 TInt comm_recev = commd->CommandId(); |
|
82 commd->ExecuteLD(); |
|
83 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
84 } |
|
85 |
|
86 |
|
87 STIF_TESTDEFINE(t_CreateCommand_logout) |
|
88 { |
|
89 vimpstengine_stub engin; |
|
90 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
91 TInt data = 1; |
|
92 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELogoutService,&data) ; |
|
93 TInt comm_sent = ELogoutService; |
|
94 TInt comm_recev = commd->CommandId(); |
|
95 commd->ExecuteLD(); |
|
96 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
97 } |
|
98 |
|
99 STIF_TESTDEFINE(t_CreateCommand_LaunchCCA) |
|
100 { |
|
101 vimpstengine_stub engin; |
|
102 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
103 TLaunchCCAData data; |
|
104 data.iIndex = 1; |
|
105 data.iConnection = MCCAConnectionStub::NewL(); |
|
106 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELaunchCCA,&data) ; |
|
107 TInt comm_sent = ELaunchCCA; |
|
108 TInt comm_recev = commd->CommandId(); |
|
109 //commd->ExecuteLD(); |
|
110 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
111 } |
|
112 |
|
113 STIF_TESTDEFINE(t_CreateCommand_AddContact) |
|
114 { |
|
115 vimpstengine_stub engin; |
|
116 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
117 TInt data = 1; |
|
118 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EAddContact,&data) ; |
|
119 TInt comm_sent = EAddContact; |
|
120 TInt comm_recev = commd->CommandId(); |
|
121 commd->ExecuteLD(); |
|
122 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
123 } |
|
124 |
|
125 STIF_TESTDEFINE(t_CreateCommand_DeleteContact) |
|
126 { |
|
127 vimpstengine_stub engin; |
|
128 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
129 TInt data = 1; |
|
130 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EDeleteContact,&data) ; |
|
131 delete factory; |
|
132 factory = NULL; |
|
133 TInt comm_sent = EDeleteContact; |
|
134 TInt comm_recev = commd->CommandId(); |
|
135 commd->ExecuteLD(); |
|
136 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
137 } |
|
138 |
|
139 |
|
140 STIF_TESTDEFINE(t_CreateCommand_ChangeOwnStatus) |
|
141 { |
|
142 vimpstengine_stub engin; |
|
143 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
144 TStatusAndStatusText status; |
|
145 _LIT(KStatusMsg,"away"); |
|
146 status.iStatusText.Copy(KStatusMsg); |
|
147 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnStatus,&status) ; |
|
148 delete factory; |
|
149 factory = NULL; |
|
150 TInt comm_sent = EChangeOwnStatus; |
|
151 TInt comm_recev = commd->CommandId(); |
|
152 commd->ExecuteLD(); |
|
153 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
154 } |
|
155 |
|
156 STIF_TESTDEFINE(t_CreateCommand_ChangeOwnMessage) |
|
157 { |
|
158 vimpstengine_stub engin; |
|
159 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
160 |
|
161 TStatusAndStatusText status; |
|
162 _LIT(KStatusMsg,"away"); |
|
163 status.iStatusText.Copy(KStatusMsg); |
|
164 |
|
165 TInt data = 1; |
|
166 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnMessage,&status) ; |
|
167 delete factory; |
|
168 factory = NULL; |
|
169 TInt comm_sent = EChangeOwnMessage; |
|
170 TInt comm_recev = commd->CommandId(); |
|
171 commd->ExecuteLD(); |
|
172 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
173 } |
|
174 |
|
175 STIF_TESTDEFINE(t_CreateCommand_Search) |
|
176 { |
|
177 vimpstengine_stub engin; |
|
178 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
179 RArray<TVIMPSTSearchKeyData> aKeyDataArray; |
|
180 |
|
181 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ESearch,&aKeyDataArray) ; |
|
182 delete factory; |
|
183 factory = NULL; |
|
184 TInt comm_sent = ESearch; |
|
185 TInt comm_recev = commd->CommandId(); |
|
186 commd->ExecuteLD(); |
|
187 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
188 } |
|
189 |
|
190 |
|
191 STIF_TESTDEFINE(t_CreateCommand_FriendRejected) |
|
192 { |
|
193 vimpstengine_stub engin; |
|
194 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
195 _LIT(KContactId,"contact"); |
|
196 TBufC<10> buf (KContactId); |
|
197 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EFriendRejected, &buf) ; |
|
198 delete factory; |
|
199 factory = NULL; |
|
200 TInt comm_sent = EFriendRejected; |
|
201 TInt comm_recev = commd->CommandId(); |
|
202 commd->ExecuteLD(); |
|
203 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
204 } |
|
205 |
|
206 |
|
207 STIF_TESTDEFINE(t_CreateCommand_ChangeOwnAvtar) |
|
208 { |
|
209 vimpstengine_stub engin; |
|
210 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
211 TAvatarData data; |
|
212 |
|
213 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnAvtar,&data) ; |
|
214 delete factory; |
|
215 factory = NULL; |
|
216 TInt comm_sent = EChangeOwnAvtar; |
|
217 TInt comm_recev = commd->CommandId(); |
|
218 commd->ExecuteLD(); |
|
219 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
220 } |
|
221 |
|
222 |
|
223 STIF_TESTDEFINE(t_CreateCommand_CloseConversation) |
|
224 { |
|
225 vimpstengine_stub engin; |
|
226 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
227 _LIT(KContactId,"contact"); |
|
228 TBufC<10> buf(KContactId); |
|
229 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECloseConversation,&buf) ; |
|
230 delete factory; |
|
231 factory = NULL; |
|
232 TInt comm_sent = ECloseConversation; |
|
233 TInt comm_recev = commd->CommandId(); |
|
234 commd->ExecuteLD(); |
|
235 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
236 } |
|
237 |
|
238 |
|
239 STIF_TESTDEFINE(t_CreateCommand_AddToPbk) |
|
240 { |
|
241 vimpstengine_stub engin; |
|
242 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
243 |
|
244 vimpststoragecontact_stub store; |
|
245 |
|
246 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EAddToPbk,&store) ; |
|
247 delete factory; |
|
248 factory = NULL; |
|
249 TInt comm_sent = EAddToPbk; |
|
250 TInt comm_recev = commd->CommandId(); |
|
251 commd->ExecuteLD(); |
|
252 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
253 } |
|
254 |
|
255 |
|
256 STIF_TESTDEFINE(t_CreateCommand_CancelLogin) |
|
257 { |
|
258 vimpstengine_stub engin; |
|
259 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
260 TInt data = 1; |
|
261 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECancelLogin,&data) ; |
|
262 delete factory; |
|
263 factory = NULL; |
|
264 TInt comm_sent = ECancelLogin; |
|
265 TInt comm_recev = commd->CommandId(); |
|
266 commd->ExecuteLD(); |
|
267 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
268 } |
|
269 |
|
270 STIF_TESTDEFINE(t_CreateCommand_ProcessAcceptedContactNew) |
|
271 { |
|
272 vimpstengine_stub engin; |
|
273 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
274 TVPbkSelectedData iSelectedData; |
|
275 |
|
276 _LIT8(KContactId,"contact"); |
|
277 TPtrC8 buddy = KContactId(); |
|
278 iSelectedData.iPackedLinks = buddy.AllocL(); |
|
279 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessAcceptedContactNew,&iSelectedData) ; |
|
280 //delete factory; |
|
281 //factory = NULL; |
|
282 TInt comm_sent = ECmdProcessAcceptedContactNew; |
|
283 TInt comm_recev = commd->CommandId(); |
|
284 commd->ExecuteLD(); |
|
285 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
286 } |
|
287 STIF_TESTDEFINE(t_CreateCommand_ProcessSelectedContactNew) |
|
288 { |
|
289 vimpstengine_stub engin; |
|
290 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
291 TVPbkSelectedData iSelectedData; |
|
292 |
|
293 _LIT8(KContactId,"contact"); |
|
294 TPtrC8 buddy = KContactId(); |
|
295 iSelectedData.iPackedLinks = buddy.AllocL(); |
|
296 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessSelectedContactNew,&iSelectedData) ; |
|
297 //delete factory; |
|
298 //factory = NULL; |
|
299 TInt comm_sent = ECmdProcessSelectedContactNew; |
|
300 TInt comm_recev = commd->CommandId(); |
|
301 commd->ExecuteLD(); |
|
302 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
303 } |
|
304 STIF_TESTDEFINE(t_CreateCommand_ProcessAcceptedContactExist) |
|
305 { |
|
306 vimpstengine_stub engin; |
|
307 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
308 TVPbkSelectedData iSelectedData; |
|
309 |
|
310 _LIT8(KContactId,"contact"); |
|
311 TPtrC8 buddy = KContactId(); |
|
312 iSelectedData.iPackedLinks = buddy.AllocL(); |
|
313 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessAcceptedContactExist,&iSelectedData) ; |
|
314 //delete factory; |
|
315 //factory = NULL; |
|
316 TInt comm_sent = ECmdProcessAcceptedContactExist; |
|
317 TInt comm_recev = commd->CommandId(); |
|
318 commd->ExecuteLD(); |
|
319 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
320 } |
|
321 STIF_TESTDEFINE(t_CreateCommand_ProcessSelectedContactExist) |
|
322 { |
|
323 vimpstengine_stub engin; |
|
324 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
325 TVPbkSelectedData iSelectedData; |
|
326 |
|
327 _LIT8(KContactId,"contact"); |
|
328 TPtrC8 buddy = KContactId(); |
|
329 iSelectedData.iPackedLinks = buddy.AllocL(); |
|
330 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessSelectedContactExist,&iSelectedData) ; |
|
331 //delete factory; |
|
332 //factory = NULL; |
|
333 TInt comm_sent = ECmdProcessSelectedContactExist; |
|
334 TInt comm_recev = commd->CommandId(); |
|
335 commd->ExecuteLD(); |
|
336 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
337 } |
|
338 |
|
339 //============================ExecuteLD--------------------- |
|
340 |
|
341 STIF_TESTDEFINE(t_ExeCommand_login) |
|
342 { |
|
343 vimpstengine_stub engin; |
|
344 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
345 TInt data = 1; |
|
346 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELoginService,&data) ; |
|
347 TInt comm_sent = ELoginService; |
|
348 TInt comm_recev = commd->CommandId(); |
|
349 vimpstcmdobserver_stub ob; |
|
350 commd->AddObserver(ob); |
|
351 commd->ExecuteLD(); |
|
352 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
353 } |
|
354 |
|
355 |
|
356 STIF_TESTDEFINE(t_ExeCommand_logout) |
|
357 { |
|
358 vimpstengine_stub engin; |
|
359 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
360 TInt data = 1; |
|
361 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELogoutService,&data) ; |
|
362 TInt comm_sent = ELogoutService; |
|
363 TInt comm_recev = commd->CommandId(); |
|
364 vimpstcmdobserver_stub ob; |
|
365 commd->AddObserver(ob); |
|
366 commd->ExecuteLD(); |
|
367 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
368 } |
|
369 |
|
370 STIF_TESTDEFINE(t_ExeCommand_LaunchCCA) |
|
371 {/* |
|
372 vimpstengine_stub engin; |
|
373 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
374 TLaunchCCAData data; |
|
375 data.iIndex = 2; |
|
376 //TInt data = 1; |
|
377 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ELaunchCCA,&data) ; |
|
378 TInt comm_sent = ELaunchCCA; |
|
379 TInt comm_recev = commd->CommandId(); |
|
380 vimpstcmdobserver_stub ob; |
|
381 commd->AddObserver(ob); |
|
382 //commd->iIndex = 0; |
|
383 commd->ExecuteLD(); |
|
384 STIF_ASSERT_EQUALS(comm_sent, comm_recev );*/ |
|
385 } |
|
386 STIF_TESTDEFINE(t_ExeCommand_AddContact) |
|
387 { |
|
388 vimpstengine_stub engin; |
|
389 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
390 TInt data = 1; |
|
391 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EAddContact,&data) ; |
|
392 TInt comm_sent = EAddContact; |
|
393 TInt comm_recev = commd->CommandId(); |
|
394 vimpstcmdobserver_stub ob; |
|
395 commd->AddObserver(ob); |
|
396 commd->ExecuteLD(); |
|
397 |
|
398 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
399 } |
|
400 |
|
401 STIF_TESTDEFINE(t_ExeCommand_DeleteContact) |
|
402 { |
|
403 vimpstengine_stub engin; |
|
404 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
405 TInt data = 1; |
|
406 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EDeleteContact,&data) ; |
|
407 delete factory; |
|
408 factory = NULL; |
|
409 TInt comm_sent = EDeleteContact; |
|
410 TInt comm_recev = commd->CommandId(); |
|
411 vimpstcmdobserver_stub ob; |
|
412 commd->AddObserver(ob); |
|
413 commd->ExecuteLD(); |
|
414 |
|
415 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
416 } |
|
417 |
|
418 |
|
419 STIF_TESTDEFINE(t_ExeCommand_ChangeOwnStatus) |
|
420 { |
|
421 vimpstengine_stub engin; |
|
422 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
423 TStatusAndStatusText status; |
|
424 _LIT(KStatusMsg,"away"); |
|
425 status.iStatusText.Copy(KStatusMsg); |
|
426 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnStatus,&status) ; |
|
427 delete factory; |
|
428 factory = NULL; |
|
429 TInt comm_sent = EChangeOwnStatus; |
|
430 TInt comm_recev = commd->CommandId(); |
|
431 vimpstcmdobserver_stub ob; |
|
432 commd->AddObserver(ob); |
|
433 commd->ExecuteLD(); |
|
434 |
|
435 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
436 } |
|
437 |
|
438 STIF_TESTDEFINE(t_ExeCommand_ChangeOwnMessage) |
|
439 { |
|
440 vimpstengine_stub engin; |
|
441 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
442 |
|
443 TStatusAndStatusText status; |
|
444 _LIT(KStatusMsg,"away"); |
|
445 status.iStatusText.Copy(KStatusMsg); |
|
446 |
|
447 TInt data = 1; |
|
448 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnMessage,&status) ; |
|
449 delete factory; |
|
450 factory = NULL; |
|
451 TInt comm_sent = EChangeOwnMessage; |
|
452 TInt comm_recev = commd->CommandId(); |
|
453 vimpstcmdobserver_stub ob; |
|
454 commd->AddObserver(ob); |
|
455 commd->ExecuteLD(); |
|
456 |
|
457 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
458 } |
|
459 |
|
460 STIF_TESTDEFINE(t_ExeCommand_Search) |
|
461 { |
|
462 vimpstengine_stub engin; |
|
463 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
464 RArray<TVIMPSTSearchKeyData> aKeyDataArray; |
|
465 |
|
466 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ESearch,&aKeyDataArray) ; |
|
467 delete factory; |
|
468 factory = NULL; |
|
469 TInt comm_sent = ESearch; |
|
470 TInt comm_recev = commd->CommandId(); |
|
471 vimpstcmdobserver_stub ob; |
|
472 commd->AddObserver(ob); |
|
473 commd->ExecuteLD(); |
|
474 |
|
475 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
476 } |
|
477 |
|
478 |
|
479 STIF_TESTDEFINE(t_ExeCommand_FriendRejected) |
|
480 { |
|
481 vimpstengine_stub engin; |
|
482 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
483 _LIT(KContactId,"contact"); |
|
484 TBufC<10> buf (KContactId); |
|
485 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EFriendRejected, &buf) ; |
|
486 delete factory; |
|
487 factory = NULL; |
|
488 TInt comm_sent = EFriendRejected; |
|
489 TInt comm_recev = commd->CommandId(); |
|
490 vimpstcmdobserver_stub ob; |
|
491 commd->AddObserver(ob); |
|
492 commd->ExecuteLD(); |
|
493 |
|
494 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
495 } |
|
496 |
|
497 |
|
498 STIF_TESTDEFINE(t_ExeCommand_ChangeOwnAvtar) |
|
499 { |
|
500 vimpstengine_stub engin; |
|
501 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
502 TAvatarData data; |
|
503 |
|
504 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EChangeOwnAvtar,&data) ; |
|
505 delete factory; |
|
506 factory = NULL; |
|
507 TInt comm_sent = EChangeOwnAvtar; |
|
508 TInt comm_recev = commd->CommandId(); |
|
509 vimpstcmdobserver_stub ob; |
|
510 commd->AddObserver(ob); |
|
511 commd->ExecuteLD(); |
|
512 |
|
513 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
514 } |
|
515 |
|
516 |
|
517 STIF_TESTDEFINE(t_ExeCommand_CloseConversation) |
|
518 { |
|
519 vimpstengine_stub engin; |
|
520 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
521 _LIT(KContactId,"contact"); |
|
522 TBufC<10> buf(KContactId); |
|
523 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECloseConversation,&buf) ; |
|
524 delete factory; |
|
525 factory = NULL; |
|
526 TInt comm_sent = ECloseConversation; |
|
527 TInt comm_recev = commd->CommandId(); |
|
528 vimpstcmdobserver_stub ob; |
|
529 commd->AddObserver(ob); |
|
530 commd->ExecuteLD(); |
|
531 |
|
532 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
533 } |
|
534 |
|
535 |
|
536 STIF_TESTDEFINE(t_ExeCommand_AddToPbk) |
|
537 { |
|
538 vimpstengine_stub engin; |
|
539 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
540 |
|
541 vimpststoragecontact_stub store; |
|
542 |
|
543 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EAddToPbk,&store) ; |
|
544 delete factory; |
|
545 factory = NULL; |
|
546 TInt comm_sent = EAddToPbk; |
|
547 TInt comm_recev = commd->CommandId(); |
|
548 vimpstcmdobserver_stub ob; |
|
549 commd->AddObserver(ob); |
|
550 commd->ExecuteLD(); |
|
551 |
|
552 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
553 } |
|
554 |
|
555 |
|
556 STIF_TESTDEFINE(t_ExeCommand_CancelLogin) |
|
557 { |
|
558 vimpstengine_stub engin; |
|
559 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
560 TInt data = 1; |
|
561 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECancelLogin,&data) ; |
|
562 delete factory; |
|
563 factory = NULL; |
|
564 TInt comm_sent = ECancelLogin; |
|
565 TInt comm_recev = commd->CommandId(); |
|
566 vimpstcmdobserver_stub ob; |
|
567 commd->AddObserver(ob); |
|
568 commd->ExecuteLD(); |
|
569 |
|
570 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
571 } |
|
572 |
|
573 //Test case for Block/unblock... |
|
574 |
|
575 STIF_TESTDEFINE(t_CreateCommand_BlockContact) |
|
576 { |
|
577 vimpstengine_stub engin; |
|
578 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
579 _LIT(KContactId,"contact"); |
|
580 TBufC<10> buf (KContactId); |
|
581 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdBlockContact, &buf) ; |
|
582 delete factory; |
|
583 factory = NULL; |
|
584 TInt comm_sent = ECmdBlockContact; |
|
585 TInt comm_recev = commd->CommandId(); |
|
586 |
|
587 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
588 } |
|
589 |
|
590 STIF_TESTDEFINE(t_CreateCommand_UnBlockContact) |
|
591 { |
|
592 vimpstengine_stub engin; |
|
593 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
594 _LIT(KContactId,"contact"); |
|
595 TBufC<10> buf (KContactId); |
|
596 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdUnBlockContact, &buf) ; |
|
597 delete factory; |
|
598 factory = NULL; |
|
599 TInt comm_sent = ECmdUnBlockContact; |
|
600 TInt comm_recev = commd->CommandId(); |
|
601 |
|
602 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
603 } |
|
604 |
|
605 STIF_TESTDEFINE(t_ExecuteCommand_BlockContact) |
|
606 { |
|
607 vimpstengine_stub engin; |
|
608 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
609 _LIT(KContactId,"contact"); |
|
610 TBufC<10> buf (KContactId); |
|
611 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdBlockContact, &buf) ; |
|
612 delete factory; |
|
613 factory = NULL; |
|
614 vimpstcmdobserver_stub observer; |
|
615 commd->AddObserver(observer); |
|
616 TInt comm_sent = ECmdBlockContact; |
|
617 TInt comm_recev = commd->CommandId(); |
|
618 TRAPD(err,commd->ExecuteLD()); |
|
619 |
|
620 STIF_ASSERT_EQUALS(err, KErrNone ); |
|
621 } |
|
622 |
|
623 STIF_TESTDEFINE(t_ExecuteCommand_UnBlockContact) |
|
624 { |
|
625 vimpstengine_stub engin; |
|
626 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
627 _LIT(KContactId,"contact"); |
|
628 TBufC<10> buf (KContactId); |
|
629 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdUnBlockContact, &buf) ; |
|
630 delete factory; |
|
631 factory = NULL; |
|
632 vimpstcmdobserver_stub observer; |
|
633 commd->AddObserver(observer); |
|
634 TInt comm_sent = ECmdUnBlockContact; |
|
635 TInt comm_recev = commd->CommandId(); |
|
636 TRAPD(err,commd->ExecuteLD()); |
|
637 |
|
638 STIF_ASSERT_EQUALS(err, KErrNone); |
|
639 } |
|
640 STIF_TESTDEFINE(t_ExecuteCommand_FetchBlockContactList) |
|
641 { |
|
642 vimpstengine_stub engin; |
|
643 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
644 _LIT(KContactId,"contact"); |
|
645 TBufC<10> buf (KContactId); |
|
646 MVIMPSTCmd* commd = factory->CreateCommandForIdL(EFetchBlockedList) ; |
|
647 delete factory; |
|
648 factory = NULL; |
|
649 vimpstcmdobserver_stub observer; |
|
650 commd->AddObserver(observer); |
|
651 TInt comm_sent = EFetchBlockedList; |
|
652 TInt comm_recev = commd->CommandId(); |
|
653 TRAPD(err,commd->ExecuteLD()); |
|
654 |
|
655 STIF_ASSERT_EQUALS(err, KErrNone); |
|
656 } |
|
657 STIF_TESTDEFINE(t_ExecuteCommand_ProcessAcceptedContactNew) |
|
658 { |
|
659 vimpstengine_stub engin; |
|
660 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
661 TVPbkSelectedData iSelectedData; |
|
662 |
|
663 _LIT8(KPackedlink,"packedlink"); |
|
664 TPtrC8 link = KPackedlink(); |
|
665 iSelectedData.iPackedLinks = link.AllocL(); |
|
666 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessAcceptedContactNew,&iSelectedData) ; |
|
667 //delete factory; |
|
668 //factory = NULL; |
|
669 vimpstcmdobserver_stub observer; |
|
670 commd->AddObserver(observer); |
|
671 TInt comm_sent = ECmdProcessAcceptedContactNew; |
|
672 TInt comm_recev = commd->CommandId(); |
|
673 commd->ExecuteLD(); |
|
674 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
675 } |
|
676 |
|
677 STIF_TESTDEFINE(t_ExecuteCommand_ProcessSelectedContactNew) |
|
678 { |
|
679 vimpstengine_stub engin; |
|
680 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
681 TVPbkSelectedData iSelectedData; |
|
682 |
|
683 _LIT8(KPackedlink,"packedlink"); |
|
684 TPtrC8 link = KPackedlink(); |
|
685 iSelectedData.iPackedLinks = link.AllocL(); |
|
686 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessSelectedContactNew,&iSelectedData) ; |
|
687 //delete factory; |
|
688 //factory = NULL; |
|
689 vimpstcmdobserver_stub observer; |
|
690 commd->AddObserver(observer); |
|
691 TInt comm_sent = ECmdProcessSelectedContactNew; |
|
692 TInt comm_recev = commd->CommandId(); |
|
693 commd->ExecuteLD(); |
|
694 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
695 } |
|
696 |
|
697 STIF_TESTDEFINE(t_ExecuteCommand_ProcessAcceptedContactExist) |
|
698 { |
|
699 vimpstengine_stub engin; |
|
700 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
701 TVPbkSelectedData iSelectedData; |
|
702 |
|
703 _LIT8(KPackedlink,"packedlink"); |
|
704 TPtrC8 link = KPackedlink(); |
|
705 iSelectedData.iPackedLinks = link.AllocL(); |
|
706 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessAcceptedContactExist,&iSelectedData) ; |
|
707 //delete factory; |
|
708 //factory = NULL; |
|
709 vimpstcmdobserver_stub observer; |
|
710 commd->AddObserver(observer); |
|
711 TInt comm_sent = ECmdProcessAcceptedContactExist; |
|
712 TInt comm_recev = commd->CommandId(); |
|
713 commd->ExecuteLD(); |
|
714 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
715 } |
|
716 |
|
717 STIF_TESTDEFINE(t_ExecuteCommand_ProcessSelectedContactExist) |
|
718 { |
|
719 vimpstengine_stub engin; |
|
720 CVIMPSTCmdFactory *factory = CVIMPSTCmdFactory::NewL(engin); |
|
721 TVPbkSelectedData iSelectedData; |
|
722 |
|
723 _LIT8(KPackedlink,"packedlink"); |
|
724 TPtrC8 link = KPackedlink(); |
|
725 iSelectedData.iPackedLinks = link.AllocL(); |
|
726 MVIMPSTCmd* commd = factory->CreateCommandForIdL(ECmdProcessSelectedContactExist,&iSelectedData) ; |
|
727 //delete factory; |
|
728 //factory = NULL; |
|
729 vimpstcmdobserver_stub observer; |
|
730 commd->AddObserver(observer); |
|
731 TInt comm_sent = ECmdProcessSelectedContactExist; |
|
732 TInt comm_recev = commd->CommandId(); |
|
733 commd->ExecuteLD(); |
|
734 STIF_ASSERT_EQUALS(comm_sent, comm_recev ); |
|
735 } |
|
736 |
|
737 #endif |
|
738 /** |
|
739 * END OF TEST CASES SECTION |
|
740 */ |
|