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  */