1 /*

     2 * Copyright (c) 2006 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 the License "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 

    20 

    21 // INCLUDE FILES

    22 #include <e32math.h>

    23 #include "FavouritesEngineTest.h"

    24 

    25 // EXTERNAL DATA STRUCTURES

    26 // None

    27 

    28 // EXTERNAL FUNCTION PROTOTYPES  

    29 // None

    30 

    31 // CONSTANTS

    32 // None

    33 

    34 // MACROS

    35 // None

    36 

    37 // LOCAL CONSTANTS AND MACROS

    38 // None

    39 

    40 // MODULE DATA STRUCTURES

    41 // None

    42 

    43 // LOCAL FUNCTION PROTOTYPES

    44 // None

    45 

    46 // FORWARD DECLARATIONS

    47 // None

    48 

    49 // ==================== LOCAL FUNCTIONS =======================================

    50 

    51 

    52 // ============================ MEMBER FUNCTIONS ===============================

    53 

    54 /*

    55 -------------------------------------------------------------------------------

    56 

    57     Class: CFavouritesEngineTest

    58 

    59     Method: DbOpenTestL

    60 

    61     Description: Test opening the Favourites Db by using the Open method.

    62   

    63     Parameters:  TTestResult& aErrorDescription: out:   

    64                     Test result and on error case a short description of error

    65 

    66     Return Values: TInt: Always KErrNone to indicate that test was valid

    67 

    68     Errors/Exceptions: None

    69 

    70     Status: Approved

    71 

    72 -------------------------------------------------------------------------------

    73 */

    74 TInt CFavouritesEngineTest::DbOpenTestL( TTestResult& aResult )

    75     {

    76     /* Simple server connect */

    77     _LIT( KDefinition ,"State");

    78     _LIT( KData ,"Test the Db Open method");

    79     TestModuleIf().Printf( 0, KDefinition, KData );

    80 

    81     TInt result = iFavouritesDb.Open( iFavouritesSession, KTestDbName );

    82     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

    83 

    84     _LIT( KData2 ,"Finished");

    85     TestModuleIf().Printf( 0, KDefinition, KData2 );

    86     

    87     if (result == KErrNone)

    88 	    {

    89 	    _LIT( KDescription , "Test case passed");

    90 	    aResult.SetResult( KErrNone, KDescription );

    91 	    }

    92     else

    93 	    {

    94 	    _LIT( KDescription , "Test case failed");

    95 	    aResult.SetResult( KErrGeneral, KDescription );

    96 	    }

    97 

    98     CleanupStack::PopAndDestroy(); // iFavouritesDb

    99     iFavouritesSession.DeleteDatabase( KTestDbName );

   100 

   101     // Case was executed

   102     return KErrNone;

   103     }

   104 

   105 /*

   106 -------------------------------------------------------------------------------

   107 

   108     Class: CFavouritesEngineTest

   109 

   110     Method: DbVersionTestL

   111 

   112     Description: Test the Favourites Db Version method.

   113   

   114     Parameters:  TTestResult& aErrorDescription: out:   

   115                     Test result and on error case a short description of error

   116 

   117     Return Values: TInt: Always KErrNone to indicate that test was valid

   118 

   119     Errors/Exceptions: None

   120 

   121     Status: Approved

   122 

   123 -------------------------------------------------------------------------------

   124 */

   125 TInt CFavouritesEngineTest::DbVersionTestL( TTestResult& aResult )

   126     {

   127     /* Simple server connect */

   128     _LIT( KDefinition ,"State");

   129     _LIT( KData ,"Test the Db Version method");

   130     TestModuleIf().Printf( 0, KDefinition, KData );

   131 

   132     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   133     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   134 

   135     TVersion dbVersion = iFavouritesDb.Version();

   136     

   137     _LIT( KData2 ,"Finished");

   138     TestModuleIf().Printf( 0, KDefinition, KData2 );

   139     

   140     if (dbVersion.iMajor > 0)

   141 	    {

   142 	    _LIT( KDescription , "Test case passed");

   143 	    aResult.SetResult( KErrNone, KDescription );

   144 	    }

   145     else

   146 	    {

   147 	    _LIT( KDescription , "Test case failed");

   148 	    aResult.SetResult( KErrGeneral, KDescription );

   149 	    }

   150 

   151     CleanupStack::PopAndDestroy(); // iFavouritesDb

   152     iFavouritesSession.DeleteDatabase( KTestDbName );

   153 

   154     // Case was executed

   155     return KErrNone;

   156     }

   157 

   158 /*

   159 -------------------------------------------------------------------------------

   160 

   161     Class: CFavouritesEngineTest

   162 

   163     Method: DbIsDamagedTestL

   164 

   165     Description: Test the Favourites Db IsDamaged method.

   166   

   167     Parameters:  TTestResult& aErrorDescription: out:   

   168                     Test result and on error case a short description of error

   169 

   170     Return Values: TInt: Always KErrNone to indicate that test was valid

   171 

   172     Errors/Exceptions: None

   173 

   174     Status: Approved

   175 

   176 -------------------------------------------------------------------------------

   177 */

   178 TInt CFavouritesEngineTest::DbIsDamagedTestL( TTestResult& aResult )

   179     {

   180     /* Simple server connect */

   181     _LIT( KDefinition ,"State");

   182     _LIT( KData ,"Test the Db IsDamaged method");

   183     TestModuleIf().Printf( 0, KDefinition, KData );

   184 

   185     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   186     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   187 

   188     TBool isDbDamaged = EFalse;

   189     

   190     TInt result = iFavouritesDb.IsDamaged(isDbDamaged);

   191     

   192     _LIT( KData2 ,"Finished");

   193     TestModuleIf().Printf( 0, KDefinition, KData2 );

   194     

   195     if (result == KErrNone)

   196 	    {

   197 	    _LIT( KDescription , "Test case passed");

   198 	    aResult.SetResult( KErrNone, KDescription );

   199 	    }

   200     else

   201 	    {

   202 	    _LIT( KDescription , "Test case failed");

   203 	    aResult.SetResult( KErrGeneral, KDescription );

   204 	    }

   205 

   206     CleanupStack::PopAndDestroy(); // iFavouritesDb

   207     iFavouritesSession.DeleteDatabase( KTestDbName );

   208 

   209     // Case was executed

   210     return KErrNone;

   211     }

   212 

   213 /*

   214 -------------------------------------------------------------------------------

   215 

   216     Class: CFavouritesEngineTest

   217 

   218     Method: DbRecoverTestL

   219 

   220     Description: Test the Favourites Db Recover method.

   221   

   222     Parameters:  TTestResult& aErrorDescription: out:   

   223                     Test result and on error case a short description of error

   224 

   225     Return Values: TInt: Always KErrNone to indicate that test was valid

   226 

   227     Errors/Exceptions: None

   228 

   229     Status: Approved

   230 

   231 -------------------------------------------------------------------------------

   232 */

   233 TInt CFavouritesEngineTest::DbRecoverTestL( TTestResult& aResult )

   234     {

   235     /* Simple server connect */

   236     _LIT( KDefinition ,"State");

   237     _LIT( KData ,"Test the Db Recover method");

   238     TestModuleIf().Printf( 0, KDefinition, KData );

   239 

   240     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   241     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   242     

   243     TInt result = iFavouritesDb.Recover();

   244 

   245     _LIT( KData2 ,"Finished");

   246     TestModuleIf().Printf( 0, KDefinition, KData2 );

   247     

   248     if (result == KErrNone)

   249 	    {

   250 	    _LIT( KDescription , "Test case passed");

   251 	    aResult.SetResult( KErrNone, KDescription );

   252 	    }

   253     else

   254 	    {

   255 	    _LIT( KDescription , "Test case failed");

   256 	    aResult.SetResult( KErrGeneral, KDescription );

   257 	    }

   258 

   259     CleanupStack::PopAndDestroy(); // iFavouritesDb

   260     iFavouritesSession.DeleteDatabase( KTestDbName );

   261 

   262     // Case was executed

   263     return KErrNone;

   264     }

   265 

   266 /*

   267 -------------------------------------------------------------------------------

   268 

   269     Class: CFavouritesEngineTest

   270 

   271     Method: DbCompactTestL

   272 

   273     Description: Test the Favourites Db Compact method.

   274   

   275     Parameters:  TTestResult& aErrorDescription: out:   

   276                     Test result and on error case a short description of error

   277 

   278     Return Values: TInt: Always KErrNone to indicate that test was valid

   279 

   280     Errors/Exceptions: None

   281 

   282     Status: Approved

   283 

   284 -------------------------------------------------------------------------------

   285 */

   286 TInt CFavouritesEngineTest::DbCompactTestL( TTestResult& aResult )

   287     {

   288     /* Simple server connect */

   289     _LIT( KDefinition ,"State");

   290     _LIT( KData ,"Test the Db Compact method");

   291     TestModuleIf().Printf( 0, KDefinition, KData );

   292 

   293     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   294     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   295     

   296     TInt result = iFavouritesDb.Compact();

   297 

   298     _LIT( KData2 ,"Finished");

   299     TestModuleIf().Printf( 0, KDefinition, KData2 );

   300     

   301     if (result == KErrNone)

   302 	    {

   303 	    _LIT( KDescription , "Test case passed");

   304 	    aResult.SetResult( KErrNone, KDescription );

   305 	    }

   306     else

   307 	    {

   308 	    _LIT( KDescription , "Test case failed");

   309 	    aResult.SetResult( KErrGeneral, KDescription );

   310 	    }

   311 

   312     CleanupStack::PopAndDestroy(); // iFavouritesDb

   313     iFavouritesSession.DeleteDatabase( KTestDbName );

   314 

   315     // Case was executed

   316     return KErrNone;

   317     }

   318 

   319 /*

   320 -------------------------------------------------------------------------------

   321 

   322     Class: CFavouritesEngineTest

   323 

   324     Method: DbSizeTestL

   325 

   326     Description: Test the Favourites Db Size method.

   327   

   328     Parameters:  TTestResult& aErrorDescription: out:   

   329                     Test result and on error case a short description of error

   330 

   331     Return Values: TInt: Always KErrNone to indicate that test was valid

   332 

   333     Errors/Exceptions: None

   334 

   335     Status: Approved

   336 

   337 -------------------------------------------------------------------------------

   338 */

   339 TInt CFavouritesEngineTest::DbSizeTestL( TTestResult& aResult )

   340     {

   341     /* Simple server connect */

   342     _LIT( KDefinition ,"State");

   343     _LIT( KData ,"Test the Db Size method");

   344     TestModuleIf().Printf( 0, KDefinition, KData );

   345 

   346     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   347     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   348     

   349     RDbDatabase::TSize dbSize;

   350     

   351     TInt result = iFavouritesDb.Size(dbSize);

   352 

   353     _LIT( KData2 ,"Finished");

   354     TestModuleIf().Printf( 0, KDefinition, KData2 );

   355     

   356     if (result == KErrNone)

   357 	    {

   358 	    _LIT( KDescription , "Test case passed");

   359 	    aResult.SetResult( KErrNone, KDescription );

   360 	    }

   361     else

   362 	    {

   363 	    _LIT( KDescription , "Test case failed");

   364 	    aResult.SetResult( KErrGeneral, KDescription );

   365 	    }

   366 

   367     CleanupStack::PopAndDestroy(); // iFavouritesDb

   368     iFavouritesSession.DeleteDatabase( KTestDbName );

   369 

   370     // Case was executed

   371     return KErrNone;

   372     }

   373 

   374 /*

   375 -------------------------------------------------------------------------------

   376 

   377     Class: CFavouritesEngineTest

   378 

   379     Method: DbUpdateStatsTestL

   380 

   381     Description: Test the Favourites Db UpdateStats method.

   382   

   383     Parameters:  TTestResult& aErrorDescription: out:   

   384                     Test result and on error case a short description of error

   385 

   386     Return Values: TInt: Always KErrNone to indicate that test was valid

   387 

   388     Errors/Exceptions: None

   389 

   390     Status: Approved

   391 

   392 -------------------------------------------------------------------------------

   393 */

   394 TInt CFavouritesEngineTest::DbUpdateStatsTestL( TTestResult& aResult )

   395     {

   396     /* Simple server connect */

   397     _LIT( KDefinition ,"State");

   398     _LIT( KData ,"Test the Db UpdateStats method");

   399     TestModuleIf().Printf( 0, KDefinition, KData );

   400 

   401     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   402     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   403     

   404     TInt result = iFavouritesDb.UpdateStats();

   405 

   406     _LIT( KData2 ,"Finished");

   407     TestModuleIf().Printf( 0, KDefinition, KData2 );

   408     

   409     if (result == KErrNone)

   410 	    {

   411 	    _LIT( KDescription , "Test case passed");

   412 	    aResult.SetResult( KErrNone, KDescription );

   413 	    }

   414     else

   415 	    {

   416 	    _LIT( KDescription , "Test case failed");

   417 	    aResult.SetResult( KErrGeneral, KDescription );

   418 	    }

   419 

   420     CleanupStack::PopAndDestroy(); // iFavouritesDb

   421     iFavouritesSession.DeleteDatabase( KTestDbName );

   422 

   423     // Case was executed

   424     return KErrNone;

   425     }

   426 

   427 /*

   428 -------------------------------------------------------------------------------

   429 

   430     Class: CFavouritesEngineTest

   431 

   432     Method: DbBeginTestL

   433 

   434     Description: Test the Favourites Db Begin method.

   435   

   436     Parameters:  TTestResult& aErrorDescription: out:   

   437                     Test result and on error case a short description of error

   438 

   439     Return Values: TInt: Always KErrNone to indicate that test was valid

   440 

   441     Errors/Exceptions: None

   442 

   443     Status: Approved

   444 

   445 -------------------------------------------------------------------------------

   446 */

   447 TInt CFavouritesEngineTest::DbBeginTestL( TTestResult& aResult )

   448     {

   449     /* Simple server connect */

   450     _LIT( KDefinition ,"State");

   451     _LIT( KData ,"Test the Db Begin method");

   452     TestModuleIf().Printf( 0, KDefinition, KData );

   453 

   454     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   455     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   456     

   457     TInt result = iFavouritesDb.Begin(EFalse);

   458 

   459     _LIT( KData2 ,"Finished");

   460     TestModuleIf().Printf( 0, KDefinition, KData2 );

   461     

   462     if (result == KErrNone)

   463 	    {

   464 	    _LIT( KDescription , "Test case passed");

   465 	    aResult.SetResult( KErrNone, KDescription );

   466 	    }

   467     else

   468 	    {

   469 	    _LIT( KDescription , "Test case failed");

   470 	    aResult.SetResult( KErrGeneral, KDescription );

   471 	    }

   472 

   473     CleanupStack::PopAndDestroy(); // iFavouritesDb

   474     iFavouritesSession.DeleteDatabase( KTestDbName );

   475 

   476     // Case was executed

   477     return KErrNone;

   478     }

   479 

   480 /*

   481 -------------------------------------------------------------------------------

   482 

   483     Class: CFavouritesEngineTest

   484 

   485     Method: DbCommitTestL

   486 

   487     Description: Test the Favourites Db Commit method.

   488   

   489     Parameters:  TTestResult& aErrorDescription: out:   

   490                     Test result and on error case a short description of error

   491 

   492     Return Values: TInt: Always KErrNone to indicate that test was valid

   493 

   494     Errors/Exceptions: None

   495 

   496     Status: Approved

   497 

   498 -------------------------------------------------------------------------------

   499 */

   500 TInt CFavouritesEngineTest::DbCommitTestL( TTestResult& aResult )

   501     {

   502     /* Simple server connect */

   503     _LIT( KDefinition ,"State");

   504     _LIT( KData ,"Test the Db Commit method");

   505     TestModuleIf().Printf( 0, KDefinition, KData );

   506 

   507     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   508     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   509     

   510     iFavouritesDb.Begin(EFalse);

   511     TInt result = iFavouritesDb.Commit();

   512 

   513     _LIT( KData2 ,"Finished");

   514     TestModuleIf().Printf( 0, KDefinition, KData2 );

   515     

   516     if (result == KErrNone)

   517 	    {

   518 	    _LIT( KDescription , "Test case passed");

   519 	    aResult.SetResult( KErrNone, KDescription );

   520 	    }

   521     else

   522 	    {

   523 	    _LIT( KDescription , "Test case failed");

   524 	    aResult.SetResult( KErrGeneral, KDescription );

   525 	    }

   526 

   527     CleanupStack::PopAndDestroy(); // iFavouritesDb

   528     iFavouritesSession.DeleteDatabase( KTestDbName );

   529 

   530     // Case was executed

   531     return KErrNone;

   532     }

   533 

   534 /*

   535 -------------------------------------------------------------------------------

   536 

   537     Class: CFavouritesEngineTest

   538 

   539     Method: DbRollbackTestL

   540 

   541     Description: Test the Favourites Db Rollback method.

   542   

   543     Parameters:  TTestResult& aErrorDescription: out:   

   544                     Test result and on error case a short description of error

   545 

   546     Return Values: TInt: Always KErrNone to indicate that test was valid

   547 

   548     Errors/Exceptions: None

   549 

   550     Status: Approved

   551 

   552 -------------------------------------------------------------------------------

   553 */

   554 TInt CFavouritesEngineTest::DbRollbackTestL( TTestResult& aResult )

   555     {

   556     /* Simple server connect */

   557     _LIT( KDefinition ,"State");

   558     _LIT( KData ,"Test the Db Rollback method");

   559     TestModuleIf().Printf( 0, KDefinition, KData );

   560 

   561     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   562     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   563     

   564     iFavouritesDb.Begin(EFalse);

   565     CreateItemL( iItem1 );

   566     iFavouritesDb.Add( *iItem1, EFalse );

   567     

   568     TInt result = KErrNone;

   569     TRAP(result, iFavouritesDb.Rollback());

   570 

   571     _LIT( KData2 ,"Finished");

   572     TestModuleIf().Printf( 0, KDefinition, KData2 );

   573     

   574     if (result == KErrNone)

   575 	    {

   576 	    _LIT( KDescription , "Test case passed");

   577 	    aResult.SetResult( KErrNone, KDescription );

   578 	    }

   579     else

   580 	    {

   581 	    _LIT( KDescription , "Test case failed");

   582 	    aResult.SetResult( KErrGeneral, KDescription );

   583 	    }

   584 

   585     CleanupStack::PopAndDestroy(); // iFavouritesDb

   586     iFavouritesSession.DeleteDatabase( KTestDbName );

   587 

   588     delete iItem1;

   589     iItem1 = NULL;

   590     

   591     // Case was executed

   592     return KErrNone;

   593     }

   594 

   595 /*

   596 -------------------------------------------------------------------------------

   597 

   598     Class: CFavouritesEngineTest

   599 

   600     Method: DbCleanupRollbackPushLTestL

   601 

   602     Description: Test the Favourites Db CleanupRollbackPushL method.

   603   

   604     Parameters:  TTestResult& aErrorDescription: out:   

   605                     Test result and on error case a short description of error

   606 

   607     Return Values: TInt: Always KErrNone to indicate that test was valid

   608 

   609     Errors/Exceptions: None

   610 

   611     Status: Approved

   612 

   613 -------------------------------------------------------------------------------

   614 */

   615 TInt CFavouritesEngineTest::DbCleanupRollbackPushLTestL( TTestResult& aResult )

   616     {

   617     /* Simple server connect */

   618     _LIT( KDefinition ,"State");

   619     _LIT( KData ,"Test the Db CleanupRollbackPushL method");

   620     TestModuleIf().Printf( 0, KDefinition, KData );

   621 

   622     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   623     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   624     

   625     iFavouritesDb.Begin(EFalse);

   626     iFavouritesDb.CleanupRollbackPushL();

   627     CreateItemL( iItem1 );

   628     iFavouritesDb.Add( *iItem1, EFalse );

   629     TInt result = iFavouritesDb.Commit();

   630 

   631     _LIT( KData2 ,"Finished");

   632     TestModuleIf().Printf( 0, KDefinition, KData2 );

   633     

   634     if (result == KErrNone)

   635 	    {

   636 	    _LIT( KDescription , "Test case passed");

   637 	    aResult.SetResult( KErrNone, KDescription );

   638 	    }

   639     else

   640 	    {

   641 	    _LIT( KDescription , "Test case failed");

   642 	    aResult.SetResult( KErrGeneral, KDescription );

   643 	    }

   644 

   645     CleanupStack::Pop(); // RollbackPush

   646     CleanupStack::PopAndDestroy(); // iFavouritesDb

   647     iFavouritesSession.DeleteDatabase( KTestDbName );

   648 

   649     delete iItem1;

   650     iItem1 = NULL;

   651     

   652     // Case was executed

   653     return KErrNone;

   654     }

   655 

   656 /*

   657 -------------------------------------------------------------------------------

   658 

   659     Class: CFavouritesEngineTest

   660 

   661     Method: DbGetTestL

   662 

   663     Description: Test the Favourites Db Get method.

   664   

   665     Parameters:  TTestResult& aErrorDescription: out:   

   666                     Test result and on error case a short description of error

   667 

   668     Return Values: TInt: Always KErrNone to indicate that test was valid

   669 

   670     Errors/Exceptions: None

   671 

   672     Status: Approved

   673 

   674 -------------------------------------------------------------------------------

   675 */

   676 TInt CFavouritesEngineTest::DbGetTestL( TTestResult& aResult )

   677     {

   678     /* Simple server connect */

   679     _LIT( KDefinition ,"State");

   680     _LIT( KData ,"Test the Db Get method");

   681     TestModuleIf().Printf( 0, KDefinition, KData );

   682 

   683     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   684     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   685 

   686     CreatePopulatedDbL();

   687     

   688     CFavouritesItem* item = CFavouritesItem::NewLC();

   689 

   690     TInt result = iFavouritesDb.Get( iItem1->Uid(), *item );

   691 

   692     _LIT( KData2 ,"Finished");

   693     TestModuleIf().Printf( 0, KDefinition, KData2 );

   694 

   695     if (result == KErrNone)

   696 	    {

   697 	    _LIT( KDescription , "Test case passed");

   698 	    aResult.SetResult( KErrNone, KDescription );

   699 	    }

   700     else

   701 	    {

   702 	    _LIT( KDescription , "Test case failed");

   703 	    aResult.SetResult( KErrGeneral, KDescription );

   704 	    }

   705 

   706     CleanupStack::PopAndDestroy(2); // iFavouritesDb, item

   707     iFavouritesSession.DeleteDatabase( KTestDbName );

   708 

   709     // Case was executed

   710     return KErrNone;

   711     }

   712 

   713 /*

   714 -------------------------------------------------------------------------------

   715 

   716     Class: CFavouritesEngineTest

   717 

   718     Method: DbGetAllTestL

   719 

   720     Description: Test the Favourites Db GetAll method.

   721   

   722     Parameters:  TTestResult& aErrorDescription: out:   

   723                     Test result and on error case a short description of error

   724 

   725     Return Values: TInt: Always KErrNone to indicate that test was valid

   726 

   727     Errors/Exceptions: None

   728 

   729     Status: Approved

   730 

   731 -------------------------------------------------------------------------------

   732 */

   733 TInt CFavouritesEngineTest::DbGetAllTestL( TTestResult& aResult )

   734     {

   735     /* Simple server connect */

   736     _LIT( KDefinition ,"State");

   737     _LIT( KData ,"Test the Db GetAll method");

   738     TestModuleIf().Printf( 0, KDefinition, KData );

   739 

   740     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   741     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   742 

   743     CreatePopulatedDbL();

   744     

   745     CFavouritesItemList* list = new (ELeave) CFavouritesItemList();

   746 

   747     TInt result = iFavouritesDb.GetAll( *list, KFavouritesRootUid );

   748 

   749     _LIT( KData2 ,"Finished");

   750     TestModuleIf().Printf( 0, KDefinition, KData2 );

   751 

   752     if (result == KErrNone)

   753 	    {

   754 	    _LIT( KDescription , "Test case passed");

   755 	    aResult.SetResult( KErrNone, KDescription );

   756 	    }

   757     else

   758 	    {

   759 	    _LIT( KDescription , "Test case failed");

   760 	    aResult.SetResult( KErrGeneral, KDescription );

   761 	    }

   762 

   763     delete list;

   764     CleanupStack::PopAndDestroy(); // iFavouritesDb

   765     iFavouritesSession.DeleteDatabase( KTestDbName );

   766 

   767     // Case was executed

   768     return KErrNone;

   769     }

   770 

   771 /*

   772 -------------------------------------------------------------------------------

   773 

   774     Class: CFavouritesEngineTest

   775 

   776     Method: DbGetUidsTestL

   777 

   778     Description: Test the Favourites Db GetUids method.

   779   

   780     Parameters:  TTestResult& aErrorDescription: out:   

   781                     Test result and on error case a short description of error

   782 

   783     Return Values: TInt: Always KErrNone to indicate that test was valid

   784 

   785     Errors/Exceptions: None

   786 

   787     Status: Approved

   788 

   789 -------------------------------------------------------------------------------

   790 */

   791 TInt CFavouritesEngineTest::DbGetUidsTestL( TTestResult& aResult )

   792     {

   793     /* Simple server connect */

   794     _LIT( KDefinition ,"State");

   795     _LIT( KData ,"Test the Db GetUids method");

   796     TestModuleIf().Printf( 0, KDefinition, KData );

   797 

   798     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   799     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   800 

   801     CreatePopulatedDbL();

   802 

   803     CArrayFix<TInt>* uids = new (ELeave) CArrayFixFlat<TInt>( 1 );

   804 

   805     TInt result = iFavouritesDb.GetUids( *uids, KFavouritesRootUid, CFavouritesItem::ENone, NULL, KFavouritesNullContextId );

   806 

   807     _LIT( KData2 ,"Finished");

   808     TestModuleIf().Printf( 0, KDefinition, KData2 );

   809 

   810     if (result == KErrNone)

   811 	    {

   812 	    _LIT( KDescription , "Test case passed");

   813 	    aResult.SetResult( KErrNone, KDescription );

   814 	    }

   815     else

   816 	    {

   817 	    _LIT( KDescription , "Test case failed");

   818 	    aResult.SetResult( KErrGeneral, KDescription );

   819 	    }

   820 

   821     delete uids;

   822     CleanupStack::PopAndDestroy(); // iFavouritesDb

   823     iFavouritesSession.DeleteDatabase( KTestDbName );

   824 

   825     // Case was executed

   826     return KErrNone;

   827     }

   828 

   829 /*

   830 -------------------------------------------------------------------------------

   831 

   832     Class: CFavouritesEngineTest

   833 

   834     Method: DbPreferredUidTestL

   835 

   836     Description: Test the Favourites Db PreferredUid method.

   837   

   838     Parameters:  TTestResult& aErrorDescription: out:   

   839                     Test result and on error case a short description of error

   840 

   841     Return Values: TInt: Always KErrNone to indicate that test was valid

   842 

   843     Errors/Exceptions: None

   844 

   845     Status: Approved

   846 

   847 -------------------------------------------------------------------------------

   848 */

   849 TInt CFavouritesEngineTest::DbPreferredUidTestL( TTestResult& aResult )

   850     {

   851     /* Simple server connect */

   852     _LIT( KDefinition ,"State");

   853     _LIT( KData ,"Test the Db PreferredUid method");

   854     TestModuleIf().Printf( 0, KDefinition, KData );

   855 

   856     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   857     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   858 

   859     CreatePopulatedDbL();

   860 

   861     iFavouritesDb.SetPreferredUid(iItemFolder1->Uid(), 222);

   862     TInt preferredUid;

   863     iFavouritesDb.PreferredUid( iItemFolder1->Uid(), preferredUid );

   864 

   865     _LIT( KData2 ,"Finished");

   866     TestModuleIf().Printf( 0, KDefinition, KData2 );

   867 

   868     if (preferredUid == 222)

   869 	    {

   870 	    _LIT( KDescription , "Test case passed");

   871 	    aResult.SetResult( KErrNone, KDescription );

   872 	    }

   873     else

   874 	    {

   875 	    _LIT( KDescription , "Test case failed");

   876 	    aResult.SetResult( KErrGeneral, KDescription );

   877 	    }

   878 

   879     CleanupStack::PopAndDestroy(); // iFavouritesDb

   880     iFavouritesSession.DeleteDatabase( KTestDbName );

   881 

   882     // Case was executed

   883     return KErrNone;

   884     }

   885 

   886 /*

   887 -------------------------------------------------------------------------------

   888 

   889     Class: CFavouritesEngineTest

   890 

   891     Method: DbDeleteTestL

   892 

   893     Description: Test the Favourites Db Delete method.

   894   

   895     Parameters:  TTestResult& aErrorDescription: out:   

   896                     Test result and on error case a short description of error

   897 

   898     Return Values: TInt: Always KErrNone to indicate that test was valid

   899 

   900     Errors/Exceptions: None

   901 

   902     Status: Approved

   903 

   904 -------------------------------------------------------------------------------

   905 */

   906 TInt CFavouritesEngineTest::DbDeleteTestL( TTestResult& aResult )

   907     {

   908     /* Simple server connect */

   909     _LIT( KDefinition ,"State");

   910     _LIT( KData ,"Test the Db Delete method");

   911     TestModuleIf().Printf( 0, KDefinition, KData );

   912 

   913     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   914     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   915 

   916     CreatePopulatedDbL();

   917 

   918     TInt countBeforeDelete;

   919     iFavouritesDb.Count(countBeforeDelete, KFavouritesNullUid, CFavouritesItem::ENone, NULL, KFavouritesNullContextId);

   920     iFavouritesDb.Delete( iItem3->Uid() );

   921     TInt countAfterDelete;

   922     iFavouritesDb.Count(countAfterDelete, KFavouritesNullUid, CFavouritesItem::ENone, NULL, KFavouritesNullContextId);

   923 

   924     _LIT( KData2 ,"Finished");

   925     TestModuleIf().Printf( 0, KDefinition, KData2 );

   926 

   927     if (countAfterDelete == countBeforeDelete - 1)

   928 	    {

   929 	    _LIT( KDescription , "Test case passed");

   930 	    aResult.SetResult( KErrNone, KDescription );

   931 	    }

   932     else

   933 	    {

   934 	    _LIT( KDescription , "Test case failed");

   935 	    aResult.SetResult( KErrGeneral, KDescription );

   936 	    }

   937 

   938     CleanupStack::PopAndDestroy(); // iFavouritesDb

   939     iFavouritesSession.DeleteDatabase( KTestDbName );

   940 

   941     // Case was executed

   942     return KErrNone;

   943     }

   944 

   945 /*

   946 -------------------------------------------------------------------------------

   947 

   948     Class: CFavouritesEngineTest

   949 

   950     Method: DbUpdateTestL

   951 

   952     Description: Test the Favourites Db Update method.

   953   

   954     Parameters:  TTestResult& aErrorDescription: out:   

   955                     Test result and on error case a short description of error

   956 

   957     Return Values: TInt: Always KErrNone to indicate that test was valid

   958 

   959     Errors/Exceptions: None

   960 

   961     Status: Approved

   962 

   963 -------------------------------------------------------------------------------

   964 */

   965 TInt CFavouritesEngineTest::DbUpdateTestL( TTestResult& aResult )

   966     {

   967     /* Simple server connect */

   968     _LIT( KDefinition ,"State");

   969     _LIT( KData ,"Test the Db Update method");

   970     TestModuleIf().Printf( 0, KDefinition, KData );

   971 

   972     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

   973     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

   974 

   975     CreatePopulatedDbL();

   976 

   977     CFavouritesItem* updateItem = CFavouritesItem::NewLC();

   978 

   979     InitItemL( updateItem );

   980     updateItem->SetParentFolder(iItemFolder1->Uid());

   981     TInt result = iFavouritesDb.Update(*updateItem, iItem6->Uid(), EFalse);

   982 

   983     _LIT( KData2 ,"Finished");

   984     TestModuleIf().Printf( 0, KDefinition, KData2 );

   985 

   986     if (result == KErrNone)

   987 	    {

   988 	    _LIT( KDescription , "Test case passed");

   989 	    aResult.SetResult( KErrNone, KDescription );

   990 	    }

   991     else

   992 	    {

   993 	    _LIT( KDescription , "Test case failed");

   994 	    aResult.SetResult( KErrGeneral, KDescription );

   995 	    }

   996 

   997     CleanupStack::PopAndDestroy(2); // iFavouritesDb, updateItem

   998     iFavouritesSession.DeleteDatabase( KTestDbName );

   999 

  1000     // Case was executed

  1001     return KErrNone;

  1002     }

  1003 

  1004 /*

  1005 -------------------------------------------------------------------------------

  1006 

  1007     Class: CFavouritesEngineTest

  1008 

  1009     Method: DbAddTestL

  1010 

  1011     Description: Test the Favourites Db Add method.

  1012   

  1013     Parameters:  TTestResult& aErrorDescription: out:   

  1014                     Test result and on error case a short description of error

  1015 

  1016     Return Values: TInt: Always KErrNone to indicate that test was valid

  1017 

  1018     Errors/Exceptions: None

  1019 

  1020     Status: Approved

  1021 

  1022 -------------------------------------------------------------------------------

  1023 */

  1024 TInt CFavouritesEngineTest::DbAddTestL( TTestResult& aResult )

  1025     {

  1026     /* Simple server connect */

  1027     _LIT( KDefinition ,"State");

  1028     _LIT( KData ,"Test the Db Add method");

  1029     TestModuleIf().Printf( 0, KDefinition, KData );

  1030 

  1031     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

  1032     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

  1033 

  1034     CreatePopulatedDbL();

  1035 

  1036     CFavouritesItem* itemToAdd = CFavouritesItem::NewLC();

  1037     InitItemL( itemToAdd );

  1038 

  1039     TInt countBeforeAdd;

  1040     iFavouritesDb.Count(countBeforeAdd, KFavouritesNullUid, CFavouritesItem::ENone, NULL, KFavouritesNullContextId);

  1041     iFavouritesDb.Add( *itemToAdd, EFalse );

  1042     TInt countAfterAdd;

  1043     iFavouritesDb.Count(countAfterAdd, KFavouritesNullUid, CFavouritesItem::ENone, NULL, KFavouritesNullContextId);

  1044 

  1045     _LIT( KData2 ,"Finished");

  1046     TestModuleIf().Printf( 0, KDefinition, KData2 );

  1047 

  1048     if (countAfterAdd == countBeforeAdd + 1)

  1049 	    {

  1050 	    _LIT( KDescription , "Test case passed");

  1051 	    aResult.SetResult( KErrNone, KDescription );

  1052 	    }

  1053     else

  1054 	    {

  1055 	    _LIT( KDescription , "Test case failed");

  1056 	    aResult.SetResult( KErrGeneral, KDescription );

  1057 	    }

  1058 

  1059     CleanupStack::PopAndDestroy(2); // iFavouritesDb, itemToAdd

  1060     iFavouritesSession.DeleteDatabase( KTestDbName );

  1061 

  1062     // Case was executed

  1063     return KErrNone;

  1064     }

  1065 

  1066 /*

  1067 -------------------------------------------------------------------------------

  1068 

  1069     Class: CFavouritesEngineTest

  1070 

  1071     Method: DbSetHomepageTestL

  1072 

  1073     Description: Test the Favourites Db SetHomepage method.

  1074   

  1075     Parameters:  TTestResult& aErrorDescription: out:   

  1076                     Test result and on error case a short description of error

  1077 

  1078     Return Values: TInt: Always KErrNone to indicate that test was valid

  1079 

  1080     Errors/Exceptions: None

  1081 

  1082     Status: Approved

  1083 

  1084 -------------------------------------------------------------------------------

  1085 */

  1086 TInt CFavouritesEngineTest::DbSetHomepageTestL( TTestResult& aResult )

  1087     {

  1088     /* Simple server connect */

  1089     _LIT( KDefinition ,"State");

  1090     _LIT( KData ,"Test the Db SetHomepage method");

  1091     TestModuleIf().Printf( 0, KDefinition, KData );

  1092 

  1093     iFavouritesDb.Open( iFavouritesSession, KTestDbName );

  1094     CleanupClosePushL<RFavouritesDb>( iFavouritesDb );

  1095 

  1096     CFavouritesItem* homepageItem = CFavouritesItem::NewLC();

  1097     InitItemL( homepageItem );

  1098     

  1099     TInt result = iFavouritesDb.SetHomepage(*homepageItem);

  1100 

  1101     _LIT( KData2 ,"Finished");

  1102     TestModuleIf().Printf( 0, KDefinition, KData2 );

  1103     

  1104     if (result == KErrNone)

  1105 	    {

  1106 	    _LIT( KDescription , "Test case passed");

  1107 	    aResult.SetResult( KErrNone, KDescription );

  1108 	    }

  1109     else

  1110 	    {

  1111 	    _LIT( KDescription , "Test case failed");

  1112 	    aResult.SetResult( KErrGeneral, KDescription );

  1113 	    }

  1114 

  1115     CleanupStack::PopAndDestroy(2); // iFavouritesDb, homepageItem

  1116     iFavouritesSession.DeleteDatabase( KTestDbName );

  1117 

  1118     // Case was executed

  1119     return KErrNone;

  1120     }

  1121 

  1122 /*

  1123 -------------------------------------------------------------------------------

  1124 

  1125     Class: CFavouritesEngineTest

  1126 

  1127     Method: DbSetLastVisitedTestL

  1128 

  1129     Description: Test the Favourites Db SetLastVisited method.

  1130   

  1131     Parameters:  TTestResult& aErrorDescription: out:   

  1132                     Test result and on error case a short description of error

  1133 

  1134     Return Values: TInt: Always KErrNone to indicate that test was valid