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:

    15 *

    16 */

    17 /*

    18  * castoragetestremove.cpp

    19  *

    20  *  Created on: 2009-08-05

    21  *      Author: michal.czerwiec

    22  */

    23 

    24 #include "castoragetest.h"

    25 #include "castoragefactory.h"

    26 #include "castorage.h"

    27 #include "cainnerentry.h"

    28 #include "casqlquery.h"

    29 #include "casqlitestorage.h"

    30 #include "castoragetestsqlcommands.h"

    31 

    32 

    33 // ============================ MEMBER FUNCTIONS ===============================

    34 

    35 // ---------------------------------------------------------------------------

    36 //

    37 // ---------------------------------------------------------------------------

    38 //

    39 void CCAStorageTest::testRemoveOneEntryWithIcon()

    40 {

    41     TInt err(KErrGeneral);

    42     __UHEAP_MARK;

    43 //    TRAP(err,

    44          // Check database before remove

    45          CCaSqlQuery *query = CCaSqlQuery::NewL(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    46          CleanupStack::PushL(query);

    47          query->SetQueryL(KSQLGetIdCountFromEntryTable);

    48          query->PrepareL();

    49          TInt countEntriesBeforeRemove(0);

    50          query->ExecuteL(countEntriesBeforeRemove);

    51          CleanupStack::PopAndDestroy(query);

    52 

    53          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    54          query->SetQueryL(KSQLGetIdCountFromIconTable);

    55          query->PrepareL();

    56          TInt countIconsBeforeRemove(0);

    57          query->ExecuteL(countIconsBeforeRemove);

    58          CleanupStack::PopAndDestroy(query);

    59 

    60          // Remove from database

    61          RArray<TInt> entriesToRemoveArray;

    62          CleanupClosePushL(entriesToRemoveArray);

    63          // etry with id = 3 has icon

    64          TInt entryId = 3;

    65          entriesToRemoveArray.AppendL(entryId);

    66          mStorage->RemoveL(entriesToRemoveArray);

    67 

    68 

    69          // Check result after remove

    70          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    71          query->SetQueryL(KSQLGetIdCountFromEntryTable);

    72          query->PrepareL();

    73          TInt countEntriesAfterRemove(0);

    74          query->ExecuteL(countEntriesAfterRemove);

    75          CleanupStack::PopAndDestroy(query);

    76 

    77     if ((countEntriesBeforeRemove - countEntriesAfterRemove) == entriesToRemoveArray.Count()) {

    78         err = KErrNone;

    79     }

    80 

    81 query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    82 query->SetQueryL(KSQLGetIdCountFromIconTable);

    83 query->PrepareL();

    84 TInt countIconsAfterRemove(0);

    85 query->ExecuteL(countIconsAfterRemove);

    86 CleanupStack::PopAndDestroy(query);

    87 

    88 if (!err) {

    89     if ((countIconsBeforeRemove - countIconsAfterRemove) == 1) {

    90             err = KErrNone;

    91         } else {

    92             err = KErrGeneral;

    93         }

    94     }

    95 

    96     CleanupStack::PopAndDestroy(&entriesToRemoveArray);

    97 //        );

    98     __UHEAP_MARKEND;

    99     QCOMPARE(err, KErrNone);

   100 }

   101 

   102 void CCAStorageTest::testRemoveOneEntryWhenIconIsUseByOtherEntry()

   103 {

   104     TInt err(KErrGeneral);

   105     __UHEAP_MARK;

   106     TRAP(err,

   107          // Check database before remove

   108          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   109          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   110          query->PrepareL();

   111          TInt countEntriesBeforeRemove(0);

   112          query->ExecuteL(countEntriesBeforeRemove);

   113          CleanupStack::PopAndDestroy(query);

   114 

   115          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   116          query->SetQueryL(KSQLGetIdCountFromIconTable);

   117          query->PrepareL();

   118          TInt countIconsBeforeRemove(0);

   119          query->ExecuteL(countIconsBeforeRemove);

   120          CleanupStack::PopAndDestroy(query);

   121 

   122          // Remove from database

   123          RArray<TInt> entriesToRemoveArray;

   124          CleanupClosePushL(entriesToRemoveArray);

   125          // etry with id = 20 has same icon as entry with id = 21

   126          entriesToRemoveArray.AppendL(20);

   127          mStorage->RemoveL(entriesToRemoveArray);

   128 

   129 

   130          // Check result after remove

   131          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   132          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   133          query->PrepareL();

   134          TInt countEntriesAfterRemove(0);

   135          query->ExecuteL(countEntriesAfterRemove);

   136          CleanupStack::PopAndDestroy(query);

   137 

   138     if ((countEntriesBeforeRemove - countEntriesAfterRemove) == entriesToRemoveArray.Count()) {

   139     err = KErrNone;

   140 }

   141 

   142 query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   143 query->SetQueryL(KSQLGetIdCountFromIconTable);

   144 query->PrepareL();

   145 TInt countIconsAfterRemove(0);

   146 query->ExecuteL(countIconsAfterRemove);

   147 CleanupStack::PopAndDestroy(query);

   148 

   149 if (countIconsBeforeRemove == countIconsAfterRemove) {

   150     err = KErrNone;

   151 } else {

   152     err = KErrGeneral;

   153 }

   154 

   155 CleanupStack::PopAndDestroy(&entriesToRemoveArray);

   156     );

   157     __UHEAP_MARKEND;

   158     QCOMPARE(err, KErrNone);

   159 }

   160 

   161 void CCAStorageTest::testRemoveTwoEntriesWithSameIcon()

   162 {

   163     TInt err(KErrGeneral);

   164     __UHEAP_MARK;

   165     TRAP(err,

   166          // Check database before remove

   167          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   168          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   169          query->PrepareL();

   170          TInt countEntriesBeforeRemove(0);

   171          query->ExecuteL(countEntriesBeforeRemove);

   172          CleanupStack::PopAndDestroy(query);

   173 

   174          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   175          query->SetQueryL(KSQLGetIdCountFromIconTable);

   176          query->PrepareL();

   177          TInt countIconsBeforeRemove(0);

   178          query->ExecuteL(countIconsBeforeRemove);

   179          CleanupStack::PopAndDestroy(query);

   180 

   181          // Remove from database

   182          RArray<TInt> entriesToRemoveArray;

   183          CleanupClosePushL(entriesToRemoveArray);

   184          // both entries with same icon

   185          entriesToRemoveArray.AppendL(19);

   186          entriesToRemoveArray.AppendL(20);

   187          mStorage->RemoveL(entriesToRemoveArray);

   188 

   189          // Check result after remove

   190          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   191          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   192          query->PrepareL();

   193          TInt countEntriesAfterRemove(0);

   194          query->ExecuteL(countEntriesAfterRemove);

   195          CleanupStack::PopAndDestroy(query);

   196 

   197     if ((countEntriesBeforeRemove - countEntriesAfterRemove) == entriesToRemoveArray.Count()) {

   198     err = KErrNone;

   199 }

   200 

   201 query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   202 query->SetQueryL(KSQLGetIdCountFromIconTable);

   203 query->PrepareL();

   204 TInt countIconsAfterRemove(0);

   205 query->ExecuteL(countIconsAfterRemove);

   206 CleanupStack::PopAndDestroy(query);

   207 

   208 if (countIconsBeforeRemove - countIconsAfterRemove == 1) {

   209     err = KErrNone;

   210 } else {

   211     err = KErrGeneral;

   212 }

   213 

   214 CleanupStack::PopAndDestroy(&entriesToRemoveArray);

   215     );

   216     __UHEAP_MARKEND;

   217     QCOMPARE(err, KErrNone);

   218 }

   219 

   220 void CCAStorageTest::testRemoveOneEntryWithoutIcon()

   221 {

   222     TInt err(KErrGeneral);

   223     __UHEAP_MARK;

   224     TRAP(err,

   225          // Check database before remove

   226          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   227          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   228          query->PrepareL();

   229          TInt countEntriesBeforeRemove(0);

   230          query->ExecuteL(countEntriesBeforeRemove);

   231          CleanupStack::PopAndDestroy(query);

   232 

   233          // Remove from database

   234          RArray<TInt> entriesToRemoveArray;

   235          CleanupClosePushL(entriesToRemoveArray);

   236          // id = 12 app without icon

   237          TInt entryId = 12;

   238          entriesToRemoveArray.AppendL(entryId);

   239          mStorage->RemoveL(entriesToRemoveArray);

   240 

   241          // Check result after remove

   242          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   243          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   244          query->PrepareL();

   245          TInt countEntriesAfterRemove(0);

   246          query->ExecuteL(countEntriesAfterRemove);

   247          CleanupStack::PopAndDestroy(query);

   248 

   249     if ((countEntriesBeforeRemove - countEntriesAfterRemove) == entriesToRemoveArray.Count()) {

   250     err = KErrNone;

   251 }

   252 

   253 CleanupStack::PopAndDestroy(&entriesToRemoveArray);

   254     );

   255     __UHEAP_MARKEND;

   256     QCOMPARE(err, KErrNone);

   257 }

   258 

   259 void CCAStorageTest::testRemove5Entries()

   260 {

   261     TInt err(KErrGeneral);

   262     __UHEAP_MARK;

   263 

   264     TRAP(err,

   265          // Check database before remove

   266          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   267          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   268          query->PrepareL();

   269          TInt countEntriesBeforeRemove(0);

   270          query->ExecuteL(countEntriesBeforeRemove);

   271          CleanupStack::PopAndDestroy(query);

   272 

   273          // Remove from database

   274          RArray<TInt> entriesToRemoveArray;

   275          CleanupClosePushL(entriesToRemoveArray);

   276          // 5 entries

   277          entriesToRemoveArray.AppendL(4);

   278          entriesToRemoveArray.AppendL(5);

   279          entriesToRemoveArray.AppendL(10);

   280          entriesToRemoveArray.AppendL(13);

   281          entriesToRemoveArray.AppendL(14);

   282 

   283          mStorage->RemoveL(entriesToRemoveArray);

   284 

   285          // Check result after remove

   286          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   287          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   288          query->PrepareL();

   289          TInt countEntriesAfterRemove(0);

   290          query->ExecuteL(countEntriesAfterRemove);

   291          CleanupStack::PopAndDestroy(query);

   292 

   293     if ((countEntriesBeforeRemove - countEntriesAfterRemove) == entriesToRemoveArray.Count()) {

   294     err = KErrNone;

   295 }

   296 

   297 CleanupStack::PopAndDestroy(&entriesToRemoveArray);

   298     );

   299     __UHEAP_MARKEND;

   300     QCOMPARE(err, KErrNone);

   301 }

   302 

   303 void CCAStorageTest::testRemoveEntriesWithIdOutOFBound()

   304 {

   305     TInt err(KErrGeneral);

   306     __UHEAP_MARK;

   307     TRAP(err,

   308          // Check database before remove

   309          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   310          query->SetQueryL(KSQLGetIdCountFromEntryTable);

   311          query->PrepareL();

   312          TInt countEntriesBeforeRemove(0);

   313          query->ExecuteL(countEntriesBeforeRemove);

   314          CleanupStack::PopAndDestroy(query);

   315 

   316          // Remove from database

   317          RArray<TInt> entriesToRemoveArray;

   318          CleanupClosePushL(entriesToRemoveArray);

   319          // 5 entries

   320          entriesToRemoveArray.AppendL(4);

   321          entriesToRemoveArray.AppendL(5);

   322          entriesToRemoveArray.AppendL(56); // Id out of bound

   323          entriesToRemoveArray.AppendL(13);

   324          entriesToRemoveArray.AppendL(87); // Id out of bound

   325 

   326          // shold leave with KErrNotFound

   327          TRAPD(err2, mStorage->RemoveL(entriesToRemoveArray));

   328     if (err2 == KErrNotFound) {

   329     err = KErrNone;

   330 } else {

   331     err = KErrGeneral;

   332 }

   333 

   334 

   335 // Check result after remove

   336 query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   337 query->SetQueryL(KSQLGetIdCountFromEntryTable);

   338 query->PrepareL();

   339 TInt countEntriesAfterRemove(0);

   340 query->ExecuteL(countEntriesAfterRemove);

   341 CleanupStack::PopAndDestroy(query);

   342 

   343 if (countEntriesBeforeRemove == countEntriesAfterRemove) {

   344     err = KErrNone;

   345 } else {

   346     err = KErrGeneral;

   347 }

   348 

   349 CleanupStack::PopAndDestroy(&entriesToRemoveArray);

   350     );

   351     __UHEAP_MARKEND;

   352     QCOMPARE(err, KErrNone);

   353 }