contentstorage/castorage/tsrc/t_castorage/src/castoragetestadd.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     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  * castoragetestadd.cpp
       
    19  *
       
    20  *  Created on: 2009-08-05
       
    21  *      Author: michal.czerwiec
       
    22  */
       
    23 
       
    24 
       
    25 #include "castoragetest.h"
       
    26 #include "castoragefactory.h"
       
    27 #include "castorage.h"
       
    28 #include "cainnerentry.h"
       
    29 #include "casqlquery.h"
       
    30 #include "casqlitestorage.h"
       
    31 #include "castoragetestsqlcommands.h"
       
    32 #include "caarraycleanup.inl"
       
    33 #include <QMap>
       
    34 #include <QString>
       
    35 
       
    36 // ============================ MEMBER FUNCTIONS ===============================
       
    37 
       
    38 // ---------------------------------------------------------------------------
       
    39 //
       
    40 // ---------------------------------------------------------------------------
       
    41 //
       
    42 void CCAStorageTest::testAdd()
       
    43 {
       
    44     __UHEAP_MARK;
       
    45     TInt entryId(0);
       
    46 
       
    47     TRAPD(err,
       
    48           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
    49           innerEntry->SetTextL(KTestName);
       
    50           innerEntry->SetEntryTypeNameL(KTypeName);
       
    51           innerEntry->SetFlags(flag);
       
    52           innerEntry->SetRole(CCaInnerQuery::Group);
       
    53           mStorage->AddL(innerEntry);
       
    54           entryId = innerEntry->GetId();
       
    55 
       
    56           CleanupStack::PopAndDestroy(innerEntry);
       
    57          );
       
    58 
       
    59     QCOMPARE(err, KErrNone);
       
    60     QVERIFY(entryId > 0);
       
    61 
       
    62     __UHEAP_MARKEND;
       
    63 
       
    64 }
       
    65 // ---------------------------------------------------------------------------
       
    66 //
       
    67 // ---------------------------------------------------------------------------
       
    68 //
       
    69 void CCAStorageTest::testAddEmptyIcon()
       
    70 {
       
    71     TInt entryId(0);
       
    72     __UHEAP_MARK;
       
    73     TRAPD(err,
       
    74           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
    75           innerEntry->SetTextL(KTestName);
       
    76           innerEntry->SetEntryTypeNameL(KTypeName);
       
    77           innerEntry->SetFlags(flag);
       
    78           innerEntry->SetRole(CCaInnerQuery::Group);
       
    79           innerEntry->SetIconDataL(KNullDesC, KNullDesC, KNullDesC);
       
    80           mStorage->AddL(innerEntry);
       
    81           entryId = innerEntry->GetId();
       
    82           CleanupStack::PopAndDestroy(innerEntry);
       
    83          );
       
    84     QCOMPARE(err, KErrNone);
       
    85     QVERIFY(entryId > 0);
       
    86 
       
    87     __UHEAP_MARKEND;
       
    88 }
       
    89 
       
    90 // ---------------------------------------------------------------------------
       
    91 //
       
    92 void CCAStorageTest::testAddWithIcon()
       
    93 {
       
    94     __UHEAP_MARK;
       
    95     TInt entryId(0);
       
    96     TInt iconId(0);
       
    97     TRAPD(err,
       
    98           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
    99           innerEntry->SetTextL(KTestName);
       
   100           innerEntry->SetEntryTypeNameL(KTypeName);
       
   101           innerEntry->SetFlags(flag);
       
   102           innerEntry->SetRole(CCaInnerQuery::Group);
       
   103           innerEntry->SetIconDataL(_L("qtg_large_applications_user"), KNullDesC, KNullDesC);
       
   104           mStorage->AddL(innerEntry);
       
   105 
       
   106           entryId = innerEntry->GetId();
       
   107           iconId = innerEntry->GetIconId();
       
   108 
       
   109           CleanupStack::PopAndDestroy(innerEntry);
       
   110          );
       
   111 
       
   112     QCOMPARE(err, KErrNone);
       
   113 
       
   114     QVERIFY(entryId > 0);
       
   115     QVERIFY(iconId > 0);
       
   116 
       
   117 
       
   118     __UHEAP_MARKEND;
       
   119 }
       
   120 
       
   121 // ---------------------------------------------------------------------------
       
   122 //
       
   123 void CCAStorageTest::testAddWithExistingIcon()
       
   124 {
       
   125     __UHEAP_MARK;
       
   126     TInt entryId1(0);
       
   127     TInt iconId1(0);
       
   128     TInt entryId2(0);
       
   129     TInt iconId2(0);
       
   130     TInt countIconsAfterFirstAdd (0);
       
   131     TInt countIconsAfterSecondAdd (0);
       
   132 
       
   133     TRAPD(err,
       
   134           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   135           innerEntry->SetTextL(KTestName);
       
   136           innerEntry->SetEntryTypeNameL(KTypeName);
       
   137           innerEntry->SetFlags(flag);
       
   138           innerEntry->SetRole(CCaInnerQuery::Group);
       
   139           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   140           mStorage->AddL(innerEntry);
       
   141 
       
   142           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   143           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   144           query->PrepareL();
       
   145           query->ExecuteL(countIconsAfterFirstAdd);
       
   146           CleanupStack::PopAndDestroy(query);
       
   147 
       
   148           // Add second entry with the some icon
       
   149           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   150           innerEntry2->SetTextL(KTestName2);
       
   151           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   152           innerEntry2->SetFlags(flag);
       
   153           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   154           innerEntry2->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   155           mStorage->AddL(innerEntry2);
       
   156 
       
   157           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   158           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   159           query->PrepareL();
       
   160           query->ExecuteL(countIconsAfterSecondAdd);
       
   161           CleanupStack::PopAndDestroy(query);
       
   162           
       
   163           entryId1 = innerEntry->GetId();
       
   164           iconId1 = innerEntry->GetIconId();
       
   165 
       
   166           entryId2 = innerEntry2->GetId();
       
   167           iconId2 = innerEntry2->GetIconId();
       
   168 
       
   169           CleanupStack::PopAndDestroy(innerEntry2);
       
   170           CleanupStack::PopAndDestroy(innerEntry);
       
   171          );
       
   172 
       
   173     QCOMPARE(err, KErrNone);
       
   174 
       
   175     // No new icon created; Icon which is the same should be shared by newly added entries
       
   176     QCOMPARE(countIconsAfterFirstAdd, countIconsAfterSecondAdd);
       
   177 
       
   178     QVERIFY(entryId1 > 0);
       
   179     QVERIFY(iconId1 > 0);
       
   180     QVERIFY(entryId2 > 0);
       
   181     QVERIFY(iconId2 > 0);
       
   182     QVERIFY(!(entryId1 == entryId2));
       
   183     QCOMPARE(iconId1, iconId2);
       
   184 
       
   185     __UHEAP_MARKEND;
       
   186 }
       
   187 
       
   188 // ---------------------------------------------------------------------------
       
   189 //
       
   190 void CCAStorageTest::testAddWithExistingIconOnlyFileName()
       
   191 {
       
   192     __UHEAP_MARK;
       
   193     TInt entryId1(0);
       
   194     TInt iconId1(0);
       
   195     TInt entryId2(0);
       
   196     TInt iconId2(0);
       
   197     TInt countIconsAfterFirstAdd (0);
       
   198     TInt countIconsAfterSecondAdd (0);
       
   199 
       
   200     TRAPD(err,
       
   201           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   202           innerEntry->SetTextL(KTestName);
       
   203           innerEntry->SetEntryTypeNameL(KTypeName);
       
   204           innerEntry->SetFlags(flag);
       
   205           innerEntry->SetRole(CCaInnerQuery::Group);
       
   206           innerEntry->SetIconDataL(_L("qtg_large_applications_user"), KNullDesC, KNullDesC);
       
   207           mStorage->AddL(innerEntry);
       
   208 
       
   209           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   210           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   211           query->PrepareL();
       
   212           query->ExecuteL(countIconsAfterFirstAdd);
       
   213           CleanupStack::PopAndDestroy(query);
       
   214 
       
   215           // Add second entry with the some icon
       
   216           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   217           innerEntry2->SetTextL(KTestName2);
       
   218           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   219           innerEntry2->SetFlags(flag);
       
   220           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   221           innerEntry2->SetIconDataL(_L("qtg_large_applications_user"), KNullDesC, KNullDesC);
       
   222           mStorage->AddL(innerEntry2);
       
   223 
       
   224           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   225           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   226           query->PrepareL();
       
   227           query->ExecuteL(countIconsAfterSecondAdd);
       
   228           CleanupStack::PopAndDestroy(query);
       
   229           
       
   230           entryId1 = innerEntry->GetId();
       
   231           iconId1 = innerEntry->GetIconId();
       
   232 
       
   233           entryId2 = innerEntry2->GetId();
       
   234           iconId2 = innerEntry2->GetIconId();
       
   235 
       
   236           CleanupStack::PopAndDestroy(innerEntry2);
       
   237           CleanupStack::PopAndDestroy(innerEntry);
       
   238           
       
   239          );
       
   240 
       
   241     QCOMPARE(err, KErrNone);
       
   242 
       
   243     // No new icon created; Icon which is the same should be shared by newly added entries
       
   244     QCOMPARE(countIconsAfterFirstAdd, countIconsAfterSecondAdd);
       
   245     
       
   246 
       
   247     QVERIFY(entryId1 > 0);
       
   248     QVERIFY(iconId1 > 0);
       
   249     QVERIFY(entryId2 > 0);
       
   250     QVERIFY(iconId2 > 0);
       
   251     QVERIFY(!(entryId1 == entryId2));
       
   252     QCOMPARE(iconId1, iconId2);
       
   253 
       
   254 
       
   255     __UHEAP_MARKEND;
       
   256 }
       
   257 
       
   258 // ---------------------------------------------------------------------------
       
   259 //
       
   260 void CCAStorageTest::testAddWithPartlyMatchingIcon()
       
   261 {
       
   262     __UHEAP_MARK;
       
   263     TInt entryId1(0);
       
   264     TInt iconId1(0);
       
   265     TInt entryId2(0);
       
   266     TInt iconId2(0);
       
   267     TInt countIconsAfterFirstAdd (0);
       
   268     TInt countIconsAfterSecondAdd (0);
       
   269 
       
   270     TRAPD(err,
       
   271           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   272           innerEntry->SetTextL(KTestName);
       
   273           innerEntry->SetEntryTypeNameL(KTypeName);
       
   274           innerEntry->SetFlags(flag);
       
   275           innerEntry->SetRole(CCaInnerQuery::Group);
       
   276           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   277           mStorage->AddL(innerEntry);
       
   278 
       
   279           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   280           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   281           query->PrepareL();
       
   282           query->ExecuteL(countIconsAfterFirstAdd);
       
   283           CleanupStack::PopAndDestroy(query);
       
   284 
       
   285           // Add second entry with the some icon
       
   286           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   287           innerEntry2->SetTextL(KTestName2);
       
   288           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   289           innerEntry2->SetFlags(flag);
       
   290           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   291           innerEntry2->SetIconDataL(_L("filename"), _L("skinId2"), _L("111111111"));
       
   292           mStorage->AddL(innerEntry2);
       
   293 
       
   294           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   295           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   296           query->PrepareL();
       
   297           query->ExecuteL(countIconsAfterSecondAdd);
       
   298           CleanupStack::PopAndDestroy(query);
       
   299           
       
   300           entryId1 = innerEntry->GetId();
       
   301           iconId1 = innerEntry->GetIconId();
       
   302 
       
   303           entryId2 = innerEntry2->GetId();
       
   304           iconId2 = innerEntry2->GetIconId();
       
   305 
       
   306           CleanupStack::PopAndDestroy(innerEntry2);
       
   307           CleanupStack::PopAndDestroy(innerEntry);
       
   308          );
       
   309 
       
   310     QCOMPARE(err, KErrNone);
       
   311 
       
   312     // New icon should be added
       
   313     QCOMPARE(countIconsAfterSecondAdd - countIconsAfterFirstAdd, 1);
       
   314 
       
   315     QVERIFY(entryId1 > 0);
       
   316     QVERIFY(iconId1 > 0);
       
   317     QVERIFY(entryId2 > 0);
       
   318     QVERIFY(iconId2 > 0);
       
   319     QVERIFY(!(entryId1 == entryId2));
       
   320     QVERIFY(!(iconId1 == iconId2));
       
   321 
       
   322     __UHEAP_MARKEND;
       
   323 }
       
   324 
       
   325 
       
   326 // ---------------------------------------------------------------------------
       
   327 //
       
   328 void CCAStorageTest::testAddWithPartlyMatchingIconNotAllParams()
       
   329 {
       
   330     __UHEAP_MARK;
       
   331     TInt entryId1(0);
       
   332     TInt iconId1(0);
       
   333     TInt entryId2(0);
       
   334     TInt iconId2(0);
       
   335     TInt countIconsAfterFirstAdd (0);
       
   336     TInt countIconsAfterSecondAdd (0);
       
   337 
       
   338     TRAPD(err,
       
   339           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   340           innerEntry->SetTextL(KTestName);
       
   341           innerEntry->SetEntryTypeNameL(KTypeName);
       
   342           innerEntry->SetFlags(flag);
       
   343           innerEntry->SetRole(CCaInnerQuery::Group);
       
   344           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), KNullDesC);
       
   345           mStorage->AddL(innerEntry);
       
   346 
       
   347           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   348           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   349           query->PrepareL();
       
   350           query->ExecuteL(countIconsAfterFirstAdd);
       
   351           CleanupStack::PopAndDestroy(query);
       
   352 
       
   353           // Add second entry with the some icon
       
   354           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   355           innerEntry2->SetTextL(KTestName2);
       
   356           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   357           innerEntry2->SetFlags(flag);
       
   358           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   359           innerEntry2->SetIconDataL(KNullDesC, _L("skinId"), KNullDesC);
       
   360           mStorage->AddL(innerEntry2);
       
   361 
       
   362           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   363           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   364           query->PrepareL();
       
   365           query->ExecuteL(countIconsAfterSecondAdd);
       
   366           CleanupStack::PopAndDestroy(query);
       
   367           
       
   368           entryId1 = innerEntry->GetId();
       
   369           iconId1 = innerEntry->GetIconId();
       
   370 
       
   371           entryId2 = innerEntry2->GetId();
       
   372           iconId2 = innerEntry2->GetIconId();
       
   373 
       
   374           CleanupStack::PopAndDestroy(innerEntry2);
       
   375           CleanupStack::PopAndDestroy(innerEntry);
       
   376          );
       
   377 
       
   378     QCOMPARE(err, KErrNone);
       
   379 
       
   380     // New icon should be added
       
   381     QCOMPARE(countIconsAfterSecondAdd - countIconsAfterFirstAdd, 1);
       
   382 
       
   383     QVERIFY(entryId1 > 0);
       
   384     QVERIFY(iconId1 > 0);
       
   385     QVERIFY(entryId2 > 0);
       
   386     QVERIFY(iconId2 > 0);
       
   387     QVERIFY(!(entryId1 == entryId2));
       
   388     QVERIFY(!(iconId1 == iconId2));
       
   389 
       
   390     __UHEAP_MARKEND;
       
   391 }
       
   392 
       
   393 
       
   394 // ---------------------------------------------------------------------------
       
   395 //
       
   396 void CCAStorageTest::testAddWithNotCompleteIcon()
       
   397 {
       
   398     TInt entryId(0);
       
   399     TInt iconId(0);
       
   400     __UHEAP_MARK;
       
   401     TRAPD(err,
       
   402           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   403           innerEntry->SetTextL(KTestName);
       
   404           innerEntry->SetEntryTypeNameL(KTypeName);
       
   405           innerEntry->SetFlags(flag);
       
   406           innerEntry->SetRole(CCaInnerQuery::Group);
       
   407           innerEntry->SetIconDataL(_L("fake"), KNullDesC, KNullDesC);
       
   408           mStorage->AddL(innerEntry);
       
   409 
       
   410           entryId = innerEntry->GetId();
       
   411           iconId = innerEntry->GetIconId();
       
   412 
       
   413           CleanupStack::PopAndDestroy(innerEntry);
       
   414          );
       
   415 
       
   416     QCOMPARE(err, KErrNone);
       
   417     QVERIFY(entryId > 0);
       
   418     QVERIFY(iconId > 0);
       
   419 
       
   420     __UHEAP_MARKEND;
       
   421 }
       
   422 
       
   423 // ---------------------------------------------------------------------------
       
   424 //
       
   425 void CCAStorageTest::testAddUpdateIcon()
       
   426 {
       
   427     TInt entryId(0);
       
   428     TInt iconId(0);
       
   429     TInt updatedEntryId(0);
       
   430     TInt updatedIconId(0);
       
   431     TInt countIconsAfterAdd (0);
       
   432     TInt countIconsAfterUpdate (0);
       
   433 
       
   434     RBuf updatedIconFileName;
       
   435     RBuf updatedIconSkinId;
       
   436     RBuf updatedIconAppId;
       
   437     TInt updatedIconIdFormIcon(0);
       
   438 
       
   439     __UHEAP_MARK;
       
   440     updatedIconFileName.CreateL( KMaxFileName );
       
   441     updatedIconSkinId.CreateL( KMaxFileName );
       
   442     updatedIconAppId.CreateL( KMaxUidName );
       
   443 
       
   444     TRAPD(err,
       
   445           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   446           innerEntry->SetTextL(KTestName);
       
   447           innerEntry->SetEntryTypeNameL(KTypeName);
       
   448           innerEntry->SetFlags(flag);
       
   449           innerEntry->SetRole(CCaInnerQuery::Group);
       
   450           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   451           mStorage->AddL(innerEntry);
       
   452           
       
   453           // Check db after add with icon
       
   454           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   455           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   456           query->PrepareL();
       
   457           query->ExecuteL(countIconsAfterAdd);
       
   458           CleanupStack::PopAndDestroy(query);
       
   459           
       
   460           entryId = innerEntry->GetId();
       
   461           iconId = innerEntry->GetIconId();
       
   462 
       
   463           innerEntry->SetTextL(KTestNameUpdate);
       
   464           innerEntry->SetFlags(flagUpdate);
       
   465           innerEntry->SetIconDataL( _L("filename2"), _L("skinId2"), _L("537001519"));
       
   466           mStorage->AddL(innerEntry);
       
   467 
       
   468           // Check db after update with icon
       
   469           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   470           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   471           query->PrepareL();
       
   472           query->ExecuteL(countIconsAfterUpdate);
       
   473           CleanupStack::PopAndDestroy(query);
       
   474           
       
   475           updatedEntryId = innerEntry->GetId();
       
   476           updatedIconId = innerEntry->GetIconId();
       
   477 
       
   478           updatedIconFileName = innerEntry->Icon()->FileName();
       
   479           updatedIconSkinId= innerEntry->Icon()->SkinId();
       
   480           updatedIconAppId = innerEntry->Icon()->ApplicationId();
       
   481           updatedIconIdFormIcon = innerEntry->Icon()->Id();
       
   482 
       
   483 
       
   484 
       
   485           CleanupStack::PopAndDestroy(innerEntry);
       
   486          );
       
   487     QCOMPARE(err, KErrNone);
       
   488     QVERIFY(entryId > 0);
       
   489     QVERIFY(iconId > 0);
       
   490     QCOMPARE(updatedEntryId, entryId);
       
   491     QCOMPARE(updatedIconId, iconId);
       
   492     QCOMPARE(updatedIconIdFormIcon, updatedIconId);
       
   493     QVERIFY(!updatedIconFileName.Compare(_L("filename2")));
       
   494     QVERIFY(!updatedIconSkinId.Compare(_L("skinId2")));
       
   495     QVERIFY(!updatedIconAppId.Compare(_L("537001519")));
       
   496 
       
   497     // No new icon should be added to DB
       
   498     QCOMPARE(countIconsAfterAdd, countIconsAfterUpdate);
       
   499 
       
   500     
       
   501     updatedIconFileName.Close();
       
   502     updatedIconSkinId.Close();
       
   503     updatedIconAppId.Close();    
       
   504     __UHEAP_MARKEND;
       
   505 }
       
   506 
       
   507 // ---------------------------------------------------------------------------
       
   508 //
       
   509 void CCAStorageTest::testAddUpdateIconOnlyFewParams()
       
   510 {
       
   511     TInt entryId(0);
       
   512     TInt iconId(0);
       
   513     TInt updatedEntryId(0);
       
   514     TInt updatedIconId(0);
       
   515     TInt countIconsAfterAdd (0);
       
   516     TInt countIconsAfterUpdate (0);
       
   517 
       
   518 
       
   519     RBuf updatedIconFileName;
       
   520     RBuf updatedIconSkinId;
       
   521     RBuf updatedIconAppId;
       
   522     TInt updatedIconIdFormIcon(0);
       
   523 
       
   524     __UHEAP_MARK;
       
   525     updatedIconFileName.CreateL( KMaxFileName );
       
   526     updatedIconSkinId.CreateL( KMaxFileName );
       
   527     updatedIconAppId.CreateL( KMaxUidName );
       
   528 
       
   529     TRAPD(err,
       
   530           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   531           innerEntry->SetTextL(KTestName);
       
   532           innerEntry->SetEntryTypeNameL(KTypeName);
       
   533           innerEntry->SetFlags(flag);
       
   534           innerEntry->SetRole(CCaInnerQuery::Group);
       
   535           innerEntry->SetIconDataL(_L("filename"), KNullDesC, _L("268458321"));
       
   536           mStorage->AddL(innerEntry);
       
   537 
       
   538           // Check db after add with icon
       
   539           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   540           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   541           query->PrepareL();
       
   542           query->ExecuteL(countIconsAfterAdd);
       
   543           CleanupStack::PopAndDestroy(query);
       
   544 
       
   545           
       
   546           entryId = innerEntry->GetId();
       
   547           iconId = innerEntry->GetIconId();
       
   548 
       
   549           innerEntry->SetTextL(KTestNameUpdate);
       
   550           innerEntry->SetFlags(flagUpdate);
       
   551           innerEntry->SetIconDataL( _L("filename2"), KNullDesC, _L("537001519"));
       
   552           mStorage->AddL(innerEntry);
       
   553           
       
   554           // Check db after update with icon
       
   555           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   556           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   557           query->PrepareL();
       
   558           query->ExecuteL(countIconsAfterUpdate);
       
   559           CleanupStack::PopAndDestroy(query);
       
   560           
       
   561 
       
   562           updatedEntryId = innerEntry->GetId();
       
   563           updatedIconId = innerEntry->GetIconId();
       
   564 
       
   565           updatedIconFileName = innerEntry->Icon()->FileName();
       
   566           updatedIconSkinId= innerEntry->Icon()->SkinId();
       
   567           updatedIconAppId = innerEntry->Icon()->ApplicationId();
       
   568           updatedIconIdFormIcon = innerEntry->Icon()->Id();
       
   569 
       
   570 
       
   571 
       
   572           CleanupStack::PopAndDestroy(innerEntry);
       
   573          );
       
   574     QCOMPARE(err, KErrNone);
       
   575     QVERIFY(entryId > 0);
       
   576     QVERIFY(iconId > 0);
       
   577     QCOMPARE(updatedEntryId, entryId);
       
   578     QCOMPARE(updatedIconId, iconId);
       
   579     QCOMPARE(updatedIconIdFormIcon, updatedIconId);
       
   580     QVERIFY(!updatedIconFileName.Compare(_L("filename2")));
       
   581     QVERIFY(!updatedIconSkinId.Compare(KNullDesC));
       
   582     QVERIFY(!updatedIconAppId.Compare(_L("537001519")));
       
   583     // No new icon should be added to DB
       
   584     QCOMPARE(countIconsAfterAdd, countIconsAfterUpdate);
       
   585     
       
   586     updatedIconFileName.Close();
       
   587     updatedIconSkinId.Close();
       
   588     updatedIconAppId.Close();    
       
   589     __UHEAP_MARKEND;
       
   590 }
       
   591 
       
   592 
       
   593 
       
   594 // ---------------------------------------------------------------------------
       
   595 //
       
   596 void CCAStorageTest::testAddUpdateWithEmptyIcon()
       
   597 {
       
   598     TInt countIconsAfterAdd(0);
       
   599     TInt countIconsAfterUpdateWithEmptyIcon(0);
       
   600     TInt entryId(0);
       
   601     TInt iconId(0);
       
   602     __UHEAP_MARK;
       
   603     TRAPD(err,
       
   604           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   605           innerEntry->SetTextL(KTestName);
       
   606           innerEntry->SetEntryTypeNameL(KTypeName);
       
   607           innerEntry->SetFlags(flag);
       
   608           innerEntry->SetRole(CCaInnerQuery::Group);
       
   609           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   610           // Add entry with icon - not null icon
       
   611           mStorage->AddL(innerEntry);
       
   612 
       
   613           // Check db after add with icon
       
   614           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   615           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   616           query->PrepareL();
       
   617 
       
   618           query->ExecuteL(countIconsAfterAdd);
       
   619 
       
   620 
       
   621           CleanupStack::PopAndDestroy(query);
       
   622 
       
   623           entryId = innerEntry->GetId();
       
   624           iconId = innerEntry->GetIconId();
       
   625 
       
   626           //CCaInnerEntry::TIconAttributes attr;
       
   627           innerEntry->SetTextL(KTestNameUpdate);
       
   628           innerEntry->SetFlags(flagUpdate);
       
   629           //innerEntry->SetIconId( 0 );
       
   630           innerEntry->SetIconDataL(KNullDesC, KNullDesC, KNullDesC);
       
   631           //attr = innerEntry->GetIcon();
       
   632           // Update entry with empty icon
       
   633           mStorage->AddL(innerEntry);
       
   634 
       
   635           // Check db after update with empty icon
       
   636           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   637           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   638           query->PrepareL();
       
   639           query->ExecuteL(countIconsAfterUpdateWithEmptyIcon);
       
   640 
       
   641           CleanupStack::PopAndDestroy(query);
       
   642           CleanupStack::PopAndDestroy(innerEntry);
       
   643          );
       
   644 
       
   645     QCOMPARE(err, KErrNone);
       
   646 
       
   647     QVERIFY(entryId > 0);
       
   648     QVERIFY(iconId > 0);
       
   649     // icon should be removed from db because we set params to NULL
       
   650     QCOMPARE(countIconsAfterAdd - countIconsAfterUpdateWithEmptyIcon, 1);
       
   651 
       
   652     __UHEAP_MARKEND;
       
   653 }
       
   654 
       
   655 // ---------------------------------------------------------------------------
       
   656 //
       
   657 void CCAStorageTest::testAddUpdateWithEmptyIconAdvanced()
       
   658 {
       
   659     TInt countIconsAfterAdd(0);
       
   660     TInt countIconsAfterUpdateWithEmptyIcon(0);
       
   661     TInt entryId(0);
       
   662     TInt iconId(0);
       
   663     __UHEAP_MARK;
       
   664     TRAPD(err,
       
   665           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   666           innerEntry->SetTextL(KTestName);
       
   667           innerEntry->SetEntryTypeNameL(KTypeName);
       
   668           innerEntry->SetFlags(flag);
       
   669           innerEntry->SetRole(CCaInnerQuery::Group);
       
   670           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   671           // Add entry with icon - not null icon
       
   672           mStorage->AddL(innerEntry);
       
   673 
       
   674           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   675           innerEntry2->SetTextL(KTestName2);
       
   676           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   677           innerEntry2->SetFlags(flag);
       
   678           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   679           innerEntry2->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   680 
       
   681           // Add second entry with the some icon - not null icon
       
   682           mStorage->AddL(innerEntry2);
       
   683 
       
   684           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   685           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   686           query->PrepareL();
       
   687 
       
   688           query->ExecuteL(countIconsAfterAdd);
       
   689           CleanupStack::PopAndDestroy(query);
       
   690 
       
   691           entryId = innerEntry->GetId();
       
   692 
       
   693           iconId = innerEntry->GetIconId();
       
   694 
       
   695           innerEntry->SetTextL(KTestNameUpdate);
       
   696           innerEntry->SetFlags(flagUpdate);
       
   697           //innerEntry->SetIconId( 0 );
       
   698           innerEntry->SetIconDataL(KNullDesC, KNullDesC, KNullDesC);
       
   699           // Update entry with empty icon
       
   700           mStorage->AddL(innerEntry);
       
   701 
       
   702 
       
   703           // Check db after update with empty icon
       
   704 
       
   705           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   706           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   707           query->PrepareL();
       
   708           query->ExecuteL(countIconsAfterUpdateWithEmptyIcon);
       
   709           CleanupStack::PopAndDestroy(query);
       
   710           CleanupStack::PopAndDestroy(innerEntry2);
       
   711           CleanupStack::PopAndDestroy(innerEntry);
       
   712          );
       
   713     QCOMPARE(err, KErrNone);
       
   714 
       
   715     QVERIFY(entryId > 0);
       
   716     QVERIFY(iconId > 0);
       
   717 
       
   718     // icon shouldn't be removed from db because it is use by other entry
       
   719     QCOMPARE(countIconsAfterUpdateWithEmptyIcon, countIconsAfterAdd);
       
   720 
       
   721     __UHEAP_MARKEND;
       
   722 }
       
   723 
       
   724 
       
   725 // ---------------------------------------------------------------------------
       
   726 //
       
   727 void CCAStorageTest::testAddUpdateWithExistingIcon()
       
   728 {
       
   729     TInt countIconsAfterAdd(0);
       
   730     TInt countIconsAfterUpdateWithEmptyIcon(0);
       
   731     TInt entryId(0);
       
   732     TInt iconId(0);
       
   733     __UHEAP_MARK;
       
   734     TRAPD(err,
       
   735           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   736           innerEntry->SetTextL(KTestName);
       
   737           innerEntry->SetEntryTypeNameL(KTypeName);
       
   738           innerEntry->SetFlags(flag);
       
   739           innerEntry->SetRole(CCaInnerQuery::Group);
       
   740           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("158321"));
       
   741           // Add entry with icon - not null icon
       
   742           mStorage->AddL(innerEntry);
       
   743 
       
   744           CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
       
   745           innerEntry2->SetTextL(KTestName2);
       
   746           innerEntry2->SetEntryTypeNameL(KTypeName);
       
   747           innerEntry2->SetFlags(flag);
       
   748           innerEntry2->SetRole(CCaInnerQuery::Group);
       
   749           innerEntry2->SetIconDataL(_L("filename2"), _L("skinId2"), KNullDesC);
       
   750 
       
   751           // Add second entry with the some icon - not null icon
       
   752           mStorage->AddL(innerEntry2);
       
   753 
       
   754           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   755           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   756           query->PrepareL();
       
   757 
       
   758           query->ExecuteL(countIconsAfterAdd);
       
   759           CleanupStack::PopAndDestroy(query);
       
   760 
       
   761           entryId = innerEntry->GetId();
       
   762 
       
   763           iconId = innerEntry->GetIconId();
       
   764 
       
   765           innerEntry->SetTextL(KTestNameUpdate);
       
   766           innerEntry->SetFlags(flagUpdate);
       
   767           //innerEntry->SetIconId( 0 );
       
   768           innerEntry->SetIconDataL(_L("filename2"), _L("skinId2"), KNullDesC);
       
   769           // Update entry with empty icon
       
   770           mStorage->AddL(innerEntry);
       
   771 
       
   772 
       
   773           // Check db after update with empty icon
       
   774 
       
   775           query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   776           query->SetQueryL(KSQLGetIdCountFromIconTable);
       
   777           query->PrepareL();
       
   778           query->ExecuteL(countIconsAfterUpdateWithEmptyIcon);
       
   779           CleanupStack::PopAndDestroy(query);
       
   780           CleanupStack::PopAndDestroy(innerEntry2);
       
   781           CleanupStack::PopAndDestroy(innerEntry);
       
   782          );
       
   783     QCOMPARE(err, KErrNone);
       
   784 
       
   785     QVERIFY(entryId > 0);
       
   786     QVERIFY(iconId > 0);
       
   787 
       
   788     // icon shouldn't be removed from db because it is use by other entry
       
   789     QCOMPARE(countIconsAfterUpdateWithEmptyIcon, countIconsAfterAdd);
       
   790 
       
   791     __UHEAP_MARKEND;
       
   792 }
       
   793 
       
   794 
       
   795 
       
   796 // ---------------------------------------------------------------------------
       
   797 //
       
   798 void CCAStorageTest::testAddAttributes()
       
   799 {
       
   800     TInt err(KErrGeneral);
       
   801     __UHEAP_MARK;
       
   802     TRAP(err,
       
   803          CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
       
   804          RPointerArray<CCaInnerEntry> innerEntryArray;
       
   805          CleanupResetAndDestroyPushL(innerEntryArray);
       
   806          innerEntryArray.AppendL(innerEntry);
       
   807 
       
   808          innerEntry->SetTextL(KTestName);
       
   809          innerEntry->SetEntryTypeNameL(KTypeName);
       
   810          innerEntry->SetFlags(flag);
       
   811          innerEntry->SetRole(CCaInnerQuery::Group);
       
   812          innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   813 
       
   814          innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
       
   815          innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
       
   816          innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
       
   817 
       
   818          mStorage->AddL(innerEntry);
       
   819          // check status
       
   820          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   821          query->SetQueryL(KSQLCheckAttribute);
       
   822          query->SetTableType(CCaSqlQuery::EAttributeTable);
       
   823          query->PrepareL();
       
   824          query->BindEntryIdL(innerEntry->GetId());
       
   825          RPointerArray<CCaInnerEntry> entryArray;
       
   826          CleanupResetAndDestroyPushL(entryArray);
       
   827          TInt count = query->ExecuteL(entryArray, CCaSqlQuery::EAttribute);
       
   828          query->CloseStatement();
       
   829          CleanupStack::PopAndDestroy(&entryArray);
       
   830 
       
   831          if (innerEntry->GetId() > 0)
       
   832          if (innerEntry->GetIconId() > 0)
       
   833         if (innerEntry->GetAttributes().Count() == count) {
       
   834             err = KErrNone;
       
   835         } else
       
   836             err = KErrArgument;
       
   837             else
       
   838                 err = KErrNotFound;
       
   839                 else
       
   840                     err = KErrNotFound;
       
   841 
       
   842                     if (!err) {
       
   843                         query->SetQueryL(KSQLGetAttribute);
       
   844                             query->SetTableType(CCaSqlQuery::EAttributeTable);
       
   845                             query->PrepareL();
       
   846                             query->BindValuesForAddAttributeL(innerEntry, NULL);
       
   847                             query->ExecuteL(innerEntryArray, CCaSqlQuery::EAttribute);
       
   848                             query->CloseStatement();
       
   849                             RCaEntryAttrArray attributes = innerEntry->GetAttributes();
       
   850 
       
   851                             if (!(
       
   852                                         (attributes[0])->Name().Compare(KAttrName_1)
       
   853                                         && (attributes[0])->Value().Compare(KAttrValue_1)
       
   854                                         && (attributes[1])->Name().Compare(KAttrName_2)
       
   855                                         && (attributes[1])->Value().Compare(KAttrValue_2)
       
   856                                         && (attributes[2])->Name().Compare(KAttrName_3)
       
   857                                         && (attributes[2])->Value().Compare(KAttrValue_3)
       
   858                                     ))
       
   859                                 err = KErrNone;
       
   860                             else
       
   861                                 err = KErrNotSupported;
       
   862                         }
       
   863 
       
   864     CleanupStack::PopAndDestroy(query);
       
   865     CleanupStack::PopAndDestroy(&innerEntryArray);
       
   866         );
       
   867 
       
   868     __UHEAP_MARKEND;
       
   869     QCOMPARE(err, KErrNone);
       
   870 }
       
   871 // ---------------------------------------------------------------------------
       
   872 //
       
   873 void CCAStorageTest::testUpdateAttributes()
       
   874 {
       
   875     TInt err(KErrGeneral);
       
   876     __UHEAP_MARK;
       
   877 //    TRAP(err,
       
   878          CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
       
   879          RPointerArray<CCaInnerEntry> innerEntryArray;
       
   880          CleanupResetAndDestroyPushL(innerEntryArray);
       
   881          innerEntryArray.AppendL(innerEntry);
       
   882 
       
   883          innerEntry->SetTextL(KTestName);
       
   884          innerEntry->SetEntryTypeNameL(KTypeName);
       
   885          innerEntry->SetFlags(flag);
       
   886          innerEntry->SetRole(CCaInnerQuery::Group);
       
   887          innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   888 
       
   889          innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
       
   890          innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
       
   891          innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
       
   892 
       
   893          mStorage->AddL(innerEntry);
       
   894          // check status
       
   895          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
   896          query->SetQueryL(KSQLCheckAttribute);
       
   897          query->SetTableType(CCaSqlQuery::EAttributeTable);
       
   898          query->PrepareL();
       
   899          query->BindEntryIdL(innerEntry->GetId());
       
   900          RPointerArray<CCaInnerEntry> entryArray;
       
   901          CleanupResetAndDestroyPushL(entryArray);
       
   902          TInt count = query->ExecuteL(entryArray, CCaSqlQuery::EAttribute);
       
   903          query->CloseStatement();
       
   904          CleanupStack::PopAndDestroy(&entryArray);
       
   905 
       
   906          if (innerEntry->GetId() > 0)
       
   907          if (innerEntry->GetIconId() > 0)
       
   908         if (innerEntry->GetAttributes().Count() == count) {
       
   909             err = KErrNone;
       
   910         } else
       
   911             err = KErrArgument;
       
   912             else
       
   913                 err = KErrNotFound;
       
   914                 else
       
   915                     err = KErrNotFound;
       
   916 
       
   917                     if (!err) {
       
   918                         innerEntry->AddAttributeL(KAttrName_2, KAttrName_1);
       
   919                             mStorage->AddL(innerEntry);
       
   920                             // check status
       
   921                             query->SetQueryL(KSQLCheckAttribute);
       
   922                             query->SetTableType(CCaSqlQuery::EAttributeTable);
       
   923                             query->PrepareL();
       
   924                             query->BindEntryIdL(innerEntry->GetId());
       
   925                             RPointerArray<CCaInnerEntry> entryArray;
       
   926                             CleanupResetAndDestroyPushL(entryArray);
       
   927                             TInt count = query->ExecuteL(entryArray, CCaSqlQuery::EAttribute);
       
   928                             query->CloseStatement();
       
   929                             CleanupStack::PopAndDestroy(&entryArray);
       
   930 
       
   931                             RCaEntryAttrArray attributes = innerEntry->GetAttributes();
       
   932                             if (innerEntry->GetAttributes().Count() == count) {
       
   933                                 if (!(
       
   934                                             (attributes[0])->Name().Compare(KAttrName_1)
       
   935                                             && (attributes[0])->Value().Compare(KAttrValue_1)
       
   936                                             && (attributes[1])->Name().Compare(KAttrName_2)
       
   937                                             && (attributes[1])->Value().Compare(KAttrValue_1)
       
   938                                             && (attributes[2])->Name().Compare(KAttrName_3)
       
   939                                             && (attributes[2])->Value().Compare(KAttrValue_3)
       
   940                                 )) {
       
   941                                     innerEntry->RemoveAttributeL(KAttrName_1);
       
   942                                     innerEntry->RemoveAttributeL(KAttrName_2);
       
   943                                     innerEntry->RemoveAttributeL(KAttrName_3);
       
   944                                     query->SetQueryL(KSQLGetAttribute);
       
   945                                     query->SetTableType(CCaSqlQuery::EAttributeTable);
       
   946                                     query->PrepareL();
       
   947                                     query->BindValuesForAddAttributeL(innerEntry, NULL);
       
   948                                     query->ExecuteL(innerEntryArray, CCaSqlQuery::EAttribute);
       
   949                                     query->CloseStatement();
       
   950 
       
   951                                     RCaEntryAttrArray newAttributes = innerEntry->GetAttributes();
       
   952                                     if (!(
       
   953                                                 (newAttributes[0])->Name().Compare(KAttrName_1)
       
   954                                                 && (newAttributes[0])->Value().Compare(KAttrValue_1)
       
   955                                                 && (newAttributes[1])->Name().Compare(KAttrName_2)
       
   956                                                 && (newAttributes[1])->Value().Compare(KAttrValue_1)
       
   957                                                 && (newAttributes[2])->Name().Compare(KAttrName_3)
       
   958                                                 && (newAttributes[2])->Value().Compare(KAttrValue_3)
       
   959                                             ))
       
   960                                         err = KErrNone;
       
   961                                     else
       
   962                                         err = KErrNotSupported;
       
   963                                 } else {
       
   964                                     err = KErrNotReady;
       
   965                                 }
       
   966                             } else
       
   967                                 err = KErrNotReady;
       
   968                         }
       
   969 
       
   970     CleanupStack::PopAndDestroy(query);
       
   971     CleanupStack::PopAndDestroy(&innerEntryArray);
       
   972 //        );
       
   973     __UHEAP_MARKEND;
       
   974     QCOMPARE(err, KErrNone);
       
   975 }
       
   976 // ---------------------------------------------------------------------------
       
   977 //
       
   978 void CCAStorageTest::testDeleteAttributes()
       
   979 {
       
   980     TInt entryId(0);
       
   981     TInt iconId(0);
       
   982     TInt attributesACount(0);
       
   983     TInt queryAResultCount(0);
       
   984     TInt attributesBCount(0);
       
   985     TInt queryBResultCount(0);
       
   986     __UHEAP_MARK;
       
   987     TRAPD(err,
       
   988           // A query section starts
       
   989           CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
       
   990           innerEntry->SetTextL(KTestName);
       
   991           innerEntry->SetEntryTypeNameL(KTypeName);
       
   992           innerEntry->SetFlags(flag);
       
   993           innerEntry->SetRole(CCaInnerQuery::Group);
       
   994           innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
       
   995 
       
   996           innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
       
   997           innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
       
   998           innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
       
   999 
       
  1000           mStorage->AddL(innerEntry);
       
  1001           // check status
       
  1002           CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
       
  1003           query->SetQueryL(KSQLCheckAttribute);
       
  1004           query->SetTableType(CCaSqlQuery::EAttributeTable);
       
  1005           query->PrepareL();
       
  1006           query->BindEntryIdL(innerEntry->GetId());
       
  1007           RPointerArray<CCaInnerEntry> entryArray;
       
  1008           CleanupResetAndDestroyPushL(entryArray);
       
  1009           queryAResultCount = query->ExecuteL(entryArray, CCaSqlQuery::EAttribute);
       
  1010           query->CloseStatement();
       
  1011           CleanupStack::PopAndDestroy(&entryArray);
       
  1012 
       
  1013     if (!err) {
       
  1014     entryId = innerEntry->GetId();
       
  1015         iconId = innerEntry->GetIconId();
       
  1016         attributesACount = innerEntry->GetAttributes().Count();
       
  1017 
       
  1018         // B query section starts
       
  1019 
       
  1020         innerEntry->RemoveAttributeL(KAttrName_1);
       
  1021         innerEntry->RemoveAttributeL(KAttrName_2);
       
  1022         innerEntry->RemoveAttributeL(KAttrName_3);
       
  1023         mStorage->AddL(innerEntry);
       
  1024         // check status
       
  1025         query->SetQueryL(KSQLCheckAttribute);
       
  1026         query->SetTableType(CCaSqlQuery::EAttributeTable);
       
  1027         query->PrepareL();
       
  1028         query->BindEntryIdL(innerEntry->GetId());
       
  1029         RPointerArray<CCaInnerEntry> entryArray;
       
  1030         CleanupResetAndDestroyPushL(entryArray);
       
  1031         queryBResultCount= query->ExecuteL(entryArray, CCaSqlQuery::EAttribute);
       
  1032         query->CloseStatement();
       
  1033         CleanupStack::PopAndDestroy(&entryArray);
       
  1034         attributesBCount = innerEntry->GetAttributes().Count();
       
  1035     }
       
  1036     CleanupStack::PopAndDestroy(query);
       
  1037     CleanupStack::PopAndDestroy(innerEntry);
       
  1038          );
       
  1039     __UHEAP_MARKEND;
       
  1040 
       
  1041     QVERIFY(entryId > 0);
       
  1042     QVERIFY(iconId > 0);
       
  1043     QCOMPARE(queryAResultCount, attributesACount);
       
  1044     QCOMPARE(queryBResultCount, 0);
       
  1045     QCOMPARE(queryBResultCount, attributesBCount);
       
  1046 }
       
  1047 // end of file