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:  Main test class for hspluginmodel library.

    15 *

    16 */

    17 

    18 

    19 #include "t_caclient.h"

    20 #include "caservice.h"

    21 #include "caquery.h"

    22 

    23 // ---------------------------------------------------------------------------

    24 // ---------------------------------------------------------------------------

    25 //

    26 void TestCaClient::TestGetEntry()

    27 {

    28     {

    29         CaEntry item;

    30         item.setText("testName");

    31         item.setAttribute("attrName1", "attrVal1");

    32         item.setEntryTypeName("test");

    33         item.setFlags(RemovableEntryFlag);

    34 

    35         CaIconDescription iconDescription;

    36         iconDescription.setFilename("iconFileName");

    37         iconDescription.setSkinId("iconSkinId");

    38         iconDescription.setApplicationId("268458321");

    39         item.setIconDescription(iconDescription);

    40 

    41         QSharedPointer<CaService> service = CaService::instance();

    42         QSharedPointer<CaEntry> resultItem = service->createEntry(item);

    43 

    44         QVERIFY(!resultItem.isNull());

    45         // entry from storage

    46         QSharedPointer<CaEntry> storageItem1 = service->getEntry(resultItem->id());

    47         QCOMPARE(service->lastError(), NoErrorCode);

    48         QVERIFY(storageItem1);

    49         QCOMPARE(storageItem1->role(), ItemEntryRole);

    50         QCOMPARE(QString("testName"),storageItem1->text());

    51         QCOMPARE(QString("test"),storageItem1->entryTypeName());

    52         QCOMPARE(QString("attrVal1"),storageItem1->attribute("attrName1"));

    53         QCOMPARE(item.flags(),storageItem1->flags());

    54         QCOMPARE(iconDescription.filename(),storageItem1->iconDescription().filename());

    55         QCOMPARE(iconDescription.skinId(),storageItem1->iconDescription().skinId());

    56         QCOMPARE(iconDescription.applicationId(),storageItem1->iconDescription().applicationId());

    57         QSharedPointer<CaEntry> storageItem2 = service->getEntry(9999);

    58         QVERIFY(service->lastError() !=  NoErrorCode);

    59         QVERIFY(!storageItem2);

    60 

    61         //Cleanup

    62         service->removeEntry(*resultItem);

    63 

    64     }

    65 }

    66 

    67 // ---------------------------------------------------------------------------

    68 // ---------------------------------------------------------------------------

    69 //

    70 void TestCaClient::TestGetEntriesByIds()

    71 {

    72     {

    73         CaEntry item;

    74         item.setText("testName1");

    75         item.setAttribute("attrName1", "attrVal1");

    76         item.setEntryTypeName("test");

    77         item.setFlags(RemovableEntryFlag);

    78 

    79         QSharedPointer<CaService> service = CaService::instance();

    80         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item);

    81         item.setText("testName2");

    82         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item);

    83         item.setText("testName3");

    84         QSharedPointer<CaEntry> resultItem3 = service->createEntry(item);

    85         QVERIFY(!resultItem1.isNull());

    86         QVERIFY(!resultItem2.isNull());

    87         QVERIFY(!resultItem3.isNull());

    88 

    89         QList<int> ids;

    90         ids.append(resultItem1->id());

    91         ids.append(resultItem3->id());

    92         ids.append(resultItem2->id());

    93 

    94         QList< QSharedPointer<CaEntry> > entries = service->getEntries(ids) ;

    95         QCOMPARE(entries.count(), 3);

    96         QCOMPARE(service->lastError(), NoErrorCode);

    97 

    98         QVERIFY(entries.at(0));

    99         QCOMPARE(entries.at(0)->role(), ItemEntryRole);

   100         QCOMPARE(QString("testName1"),entries.at(0)->text());

   101         QCOMPARE(QString("test"),entries.at(0)->entryTypeName());

   102         QCOMPARE(QString("attrVal1"),entries.at(0)->attribute("attrName1"));

   103         QCOMPARE(item.flags(),entries.at(0)->flags());

   104         QVERIFY(entries.at(1));

   105         QCOMPARE(entries.at(1)->role(), ItemEntryRole);

   106         QCOMPARE(QString("testName3"),entries.at(1)->text());

   107         QCOMPARE(QString("test"),entries.at(1)->entryTypeName());

   108         QCOMPARE(QString("attrVal1"),entries.at(1)->attribute("attrName1"));

   109         QCOMPARE(item.flags(),entries.at(1)->flags());

   110         QVERIFY(entries.at(2));

   111         QCOMPARE(entries.at(2)->role(), ItemEntryRole);

   112         QCOMPARE(QString("testName2"),entries.at(2)->text());

   113         QCOMPARE(QString("test"),entries.at(2)->entryTypeName());

   114         QCOMPARE(QString("attrVal1"),entries.at(2)->attribute("attrName1"));

   115         QCOMPARE(item.flags(),entries.at(2)->flags());

   116 

   117         QCOMPARE(entries.at(0)->id(),resultItem1->id());

   118         QCOMPARE(entries.at(1)->id(),resultItem3->id());

   119         QCOMPARE(entries.at(2)->id(),resultItem2->id());

   120 

   121         QList<int> ids2;

   122         ids2.append(resultItem1->id());

   123         ids2.append(9999);

   124 

   125         QList< QSharedPointer<CaEntry> > entries2 = service->getEntries(ids2) ;

   126         QCOMPARE(entries2.count(), 1);

   127         QVERIFY(service->lastError() != NoErrorCode);

   128 

   129         //Cleanup

   130         service->removeEntry(*resultItem1);

   131         service->removeEntry(*resultItem2);

   132         service->removeEntry(*resultItem3);

   133     }

   134 }

   135 

   136 // ---------------------------------------------------------------------------

   137 // ---------------------------------------------------------------------------

   138 //

   139 void TestCaClient::TestGetEntriesByRole()

   140 {

   141     {

   142         //CHECK INITIAL STATE IN DB

   143         QSharedPointer<CaService> service = CaService::instance();

   144         CaQuery query;

   145         query.setEntryRoles(ItemEntryRole);

   146         QList< QSharedPointer<CaEntry> > items = service->getEntries(query);

   147         int itemsCountBefore = items.count();

   148         query.setEntryRoles(GroupEntryRole);

   149         QList<QSharedPointer<CaEntry> > groups = service->getEntries(query);

   150         int groupsCountBefore = groups.count();

   151         query.setEntryRoles(ItemEntryRole | GroupEntryRole);

   152         QList<QSharedPointer<CaEntry> > itemsOrGroups = service->getEntries(query);

   153         int itemsOrGroupsCountBefore = itemsOrGroups.count();

   154 

   155 

   156         //ADD TO STORAGE

   157         CaEntry item;

   158         item.setText("testName_item");

   159         item.setAttribute("attrName1_item", "attrVal1_item");

   160         item.setEntryTypeName("test_item");

   161         item.setFlags(RemovableEntryFlag);

   162         CaEntry group(GroupEntryRole);

   163         group.setText("testName_group");

   164         group.setAttribute("attrName1_group", "attrVal1_group");

   165         group.setEntryTypeName("test_group");

   166         group.setFlags(RemovableEntryFlag);

   167 

   168         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item);

   169         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(group);

   170         QVERIFY(!resultEntry1.isNull());

   171         QVERIFY(!resultEntry2.isNull());

   172 

   173         //GET RESULTS AFTER ADD

   174         query.setEntryRoles(ItemEntryRole);

   175         items = service->getEntries(query);

   176         QCOMPARE(service->lastError(), NoErrorCode);

   177 

   178         int itemsCountAfter = items.count();

   179         query.setEntryRoles(GroupEntryRole);

   180         groups = service->getEntries(query);

   181         QCOMPARE(service->lastError(), NoErrorCode);

   182 

   183         int groupsCountAfter = groups.count();

   184         query.setEntryRoles(ItemEntryRole | GroupEntryRole);

   185         itemsOrGroups = service->getEntries(query);

   186         QCOMPARE(service->lastError(), NoErrorCode);

   187         int itemsOrGroupsCountAfter = itemsOrGroups.count();

   188 

   189         //CHECK RESULTS

   190         QCOMPARE(itemsCountAfter, itemsCountBefore+1);

   191         QCOMPARE(groupsCountAfter, groupsCountBefore+1);

   192         QCOMPARE(itemsOrGroupsCountAfter, itemsOrGroupsCountBefore+2);

   193 

   194         //CLEANUP THE STORAGE AFTER THE TEST

   195         service->removeEntry(*resultEntry1);

   196         service->removeEntry(*resultEntry2);

   197     }

   198 }

   199 

   200 // ---------------------------------------------------------------------------

   201 // ---------------------------------------------------------------------------

   202 //

   203 void TestCaClient::TestGetEntriesByParent()

   204 {

   205     {

   206         //ADD TEST DATA TO THE STORAGE

   207         QSharedPointer<CaService> service = CaService::instance();

   208         CaEntry group(GroupEntryRole);

   209         group.setText("testName_group");

   210         group.setAttribute("attrName1_group", "attrVal1_group");

   211         group.setEntryTypeName("test_group");

   212         group.setFlags(RemovableEntryFlag);

   213         QSharedPointer<CaEntry> parentEntry = service->createEntry(group);

   214 

   215         QVERIFY(!parentEntry.isNull());

   216         CaEntry item;

   217         item.setText("testName_item");

   218         item.setAttribute("attrName1_item", "attrVal1_item");

   219         item.setEntryTypeName("test_item");

   220         item.setFlags(RemovableEntryFlag);

   221         QSharedPointer<CaEntry> childEntry = service->createEntry(item);

   222 

   223         QVERIFY(!childEntry.isNull());

   224 

   225         //PREPARE QUERY

   226         CaQuery query;

   227         query.setParentId(parentEntry->id());

   228         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query);

   229 

   230         int countBefore = entries.count();

   231 

   232         //APPEND ENTRY TO THE GROUP

   233         service->appendEntryToGroup(parentEntry->id(),childEntry->id());

   234         entries = service->getEntries(query);

   235         QCOMPARE(service->lastError(), NoErrorCode);

   236 

   237         int countAfter = entries.count();

   238 

   239         //CHECK RESULTS

   240         QCOMPARE(countBefore, 0);

   241         QCOMPARE(countAfter, 1);

   242 

   243         //CLEANUP THE STORAGE AFTER THE TEST

   244         service->removeEntry(*parentEntry);

   245         service->removeEntry(*childEntry);

   246     }

   247 }

   248 

   249 // ---------------------------------------------------------------------------

   250 // ---------------------------------------------------------------------------

   251 //

   252 void TestCaClient::TestGetEntriesByType1()

   253 {

   254     {

   255         //CHECK INITIAL STATE IN DB

   256         QSharedPointer<CaService> service = CaService::instance();

   257         CaQuery query;

   258         QStringList strList;

   259         strList << QString("WRONGTYPENAME");

   260         query.setEntryTypeNames(strList);

   261         QList< QSharedPointer<CaEntry> > entriesWrongType = service->getEntries(query);

   262         int countWrongBefore = entriesWrongType.count();

   263         strList.clear();

   264         strList << QString("WRONGTYPENAME");

   265         strList << QString("test_item1");

   266         strList << QString("test_item2");

   267         query.setEntryTypeNames(strList);

   268         QList< QSharedPointer<CaEntry> > entriesWrong12 = service->getEntries(query);

   269         int countWrong12Before = entriesWrong12.count();

   270         strList.clear();

   271         strList << QString("test_item1");

   272         query.setEntryTypeNames(strList);

   273         QList< QSharedPointer<CaEntry> > entries1 = service->getEntries(query);

   274         int count1Before = entries1.count();

   275         strList.clear();

   276         strList << QString("test_item2");

   277         query.setEntryTypeNames(strList);

   278         QList< QSharedPointer<CaEntry> > entries2 = service->getEntries(query);

   279         int count2Before = entries2.count();

   280         strList.clear();

   281         strList << QString("test_item1");

   282         strList << QString("test_item2");

   283         query.setEntryTypeNames(strList);

   284         QList< QSharedPointer<CaEntry> > entries12 = service->getEntries(query);

   285         int count12Before = entries12.count();

   286 

   287         //ADD TEST DATA TO THE STORAGE

   288         CaEntry item1;

   289         item1.setText("testName_item1");

   290         item1.setAttribute("attrName1_item", "attrVal1_item");

   291         item1.setEntryTypeName("test_item1");

   292         CaEntry item2;

   293         item2.setText("testName_item2");

   294         item2.setAttribute("attrName2_item", "attrVal2_item");

   295         item2.setEntryTypeName("test_item2");

   296         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   297         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   298         QVERIFY(!resultEntry1.isNull());

   299         QVERIFY(!resultEntry2.isNull());

   300 

   301         //GET STATE FROM THE STORAGE AFTER ADD

   302         strList.clear();

   303         strList << QString("WRONGTYPENAME");

   304         query.setEntryTypeNames(strList);

   305         query.setEntryTypeNames(strList);

   306         entriesWrongType = service->getEntries(query);

   307         int countWrongAfter = entriesWrongType.count();

   308         strList.clear();

   309         strList << QString("WRONGTYPENAME");

   310         strList << QString("test_item1");

   311         strList << QString("test_item2");

   312         query.setEntryTypeNames(strList);

   313         entriesWrong12 = service->getEntries(query);

   314         QCOMPARE(service->lastError(), NoErrorCode);

   315         int countWrong12After = entriesWrong12.count();

   316         strList.clear();

   317         strList << QString("test_item1");

   318         query.setEntryTypeNames(strList);

   319         entries1 = service->getEntries(query);

   320         QCOMPARE(service->lastError(), NoErrorCode);

   321         int count1After = entries1.count();

   322         strList.clear();

   323         strList << QString("test_item2");

   324         query.setEntryTypeNames(strList);

   325         entries2 = service->getEntries(query);

   326         QCOMPARE(service->lastError(), NoErrorCode);

   327         int count2After = entries2.count();

   328         strList.clear();

   329         strList << QString("test_item1");

   330         strList << QString("test_item2");

   331         query.setEntryTypeNames(strList);

   332         entries12 = service->getEntries(query);

   333         QCOMPARE(service->lastError(), NoErrorCode);

   334         int count12After = entries12.count();

   335 

   336         //CHECK RESULTS

   337         QCOMPARE(countWrongBefore,countWrongAfter);

   338         QCOMPARE(countWrong12Before+2,countWrong12After);

   339         QCOMPARE(count1Before+1,count1After);

   340         QCOMPARE(count2Before+1,count2After);

   341         QCOMPARE(count12Before+2,count12After);

   342 

   343         //CLEANUP THE STORAGE AFTER THE TEST

   344         service->removeEntry(*resultEntry1);

   345         service->removeEntry(*resultEntry2);

   346     }

   347 }

   348 

   349 // ---------------------------------------------------------------------------

   350 // ---------------------------------------------------------------------------

   351 //

   352 void TestCaClient::TestGetEntriesByType2()

   353 {

   354     {

   355         //CHECK INITIAL STATE IN DB

   356         QSharedPointer<CaService> service = CaService::instance();

   357         CaQuery query;

   358         QStringList strList;

   359         strList << QString("test_item1");

   360         query.setEntryTypeNames(strList);

   361         query.addEntryTypeName(QString("test_item2"));

   362         QList< QSharedPointer<CaEntry> > entries12 = service->getEntries(query);

   363         int count12Before = entries12.count();

   364 

   365         //ADD TEST DATA TO THE STORAGE

   366         CaEntry item1;

   367         item1.setText("testName_item1");

   368         item1.setAttribute("attrName1_item", "attrVal1_item");

   369         item1.setEntryTypeName("test_item1");

   370         CaEntry item2;

   371         item2.setText("testName_item2");

   372         item2.setAttribute("attrName2_item", "attrVal2_item");

   373         item2.setEntryTypeName("test_item2");

   374 

   375         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   376         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   377         QVERIFY(!resultEntry1.isNull());

   378         QVERIFY(!resultEntry2.isNull());

   379 

   380         //GET STATE FROM THE STORAGE AFTER ADD

   381         strList.clear();

   382         strList << QString("test_item1");

   383         query.setEntryTypeNames(strList);

   384         query.addEntryTypeName(QString("test_item2"));

   385         entries12 = service->getEntries(query);

   386         QCOMPARE(service->lastError(), NoErrorCode);

   387         int count12After = entries12.count();

   388 

   389         //CHECK RESULTS

   390         QCOMPARE(count12Before+2,count12After);

   391 

   392         //CLEANUP THE STORAGE AFTER THE TEST

   393         service->removeEntry(*resultEntry1);

   394         service->removeEntry(*resultEntry2);

   395     }

   396 }

   397 

   398 // ---------------------------------------------------------------------------

   399 // ---------------------------------------------------------------------------

   400 //

   401 void TestCaClient::TestGetEntriesByFlagsOn()

   402 {

   403     {

   404         //CHECK INITIAL STATE IN DB

   405         QSharedPointer<CaService> service = CaService::instance();

   406         CaQuery query1;

   407         query1.setFlagsOn(UninstallEntryFlag);

   408         CaQuery query2;

   409         query2.setFlagsOn(RemovableEntryFlag);

   410         CaQuery query3;

   411         query3.setFlagsOn(UninstallEntryFlag|RemovableEntryFlag);

   412         QList< QSharedPointer<CaEntry> > entriesSystem = service->getEntries(query1);

   413         int systemCountBefore = entriesSystem.count();

   414         QList< QSharedPointer<CaEntry> > entriesRemovable = service->getEntries(query2);

   415         int removableCountBefore = entriesRemovable.count();

   416         QList< QSharedPointer<CaEntry> > entriesSysRem = service->getEntries(query3);

   417         int sysremoveCountBefore = entriesSysRem.count();

   418         //ADD TO DB

   419         CaEntry item1;

   420         item1.setText("testName_item1");

   421         item1.setAttribute("attrName1_item", "attrVal1_item");

   422         item1.setEntryTypeName("test_item1");

   423         item1.setFlags(UninstallEntryFlag);

   424         CaEntry item2;

   425         item2.setText("testName_item2");

   426         item2.setAttribute("attrName2_item", "attrVal2_item");

   427         item2.setEntryTypeName("test_item2");

   428         item2.setFlags(UninstallEntryFlag | RemovableEntryFlag);

   429         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   430         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   431         QVERIFY(!resultEntry1.isNull());

   432         QVERIFY(!resultEntry2.isNull());

   433         //CHECK STATE IN THE STORAGE AFTER ADD

   434         entriesSystem = service->getEntries(query1);

   435         int systemCountAfter = entriesSystem.count();

   436         QCOMPARE(service->lastError(), NoErrorCode);

   437         entriesRemovable = service->getEntries(query2);

   438         QCOMPARE(service->lastError(), NoErrorCode);

   439         int removableCountAfter = entriesRemovable.count();

   440         entriesSysRem = service->getEntries(query3);

   441         QCOMPARE(service->lastError(), NoErrorCode);

   442         int sysremoveCountAfter = entriesSysRem.count();

   443         //CHECK RESULTS

   444         QCOMPARE(systemCountBefore+2,systemCountAfter);

   445         QCOMPARE(removableCountBefore+1,removableCountAfter);

   446         QCOMPARE(sysremoveCountBefore+1,sysremoveCountAfter);

   447         //CLEANUP THE STORAGE AFTER THE TEST

   448         service->removeEntry(*resultEntry1);

   449         service->removeEntry(*resultEntry2);

   450     }

   451 }

   452 

   453 // ---------------------------------------------------------------------------

   454 // ---------------------------------------------------------------------------

   455 //

   456 void TestCaClient::TestGetEntriesByFlagsOff()

   457 {

   458     {

   459         //GET INITIAL STATE FROM THE STORAGE

   460         QSharedPointer<CaService> service = CaService::instance();

   461         CaQuery query1;

   462         query1.setFlagsOff(UninstallEntryFlag);

   463         CaQuery query2;

   464         query2.setFlagsOff(RemovableEntryFlag);

   465         CaQuery query3;

   466         query3.setFlagsOff(UninstallEntryFlag|RemovableEntryFlag);

   467         QList< QSharedPointer<CaEntry> > entriesSystem = service->getEntries(query1);

   468         int systemCountBefore = entriesSystem.count();

   469         QList< QSharedPointer<CaEntry> > entriesRemovable = service->getEntries(query2);

   470         int removableCountBefore = entriesRemovable.count();

   471         QList< QSharedPointer<CaEntry> > entriesSysRem = service->getEntries(query3);

   472         int sysremoveCountBefore = entriesSysRem.count();

   473         //ADD TO DB

   474         CaEntry item1;

   475         item1.setText("testName_item1");

   476         item1.setAttribute("attrName1_item", "attrVal1_item");

   477         item1.setEntryTypeName("test_item1");

   478         item1.setFlags(UninstallEntryFlag);

   479         CaEntry item2;

   480         item2.setText("testName_item2");

   481         item2.setAttribute("attrName2_item", "attrVal2_item");

   482         item2.setEntryTypeName("test_item2");

   483         item2.setFlags(RemovableEntryFlag);

   484 

   485         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   486         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   487         QVERIFY(!resultEntry1.isNull());

   488         QVERIFY(!resultEntry2.isNull());

   489 

   490         //GET STATE FROM THE STORAGE AFTER ADD

   491         entriesSystem = service->getEntries(query1);

   492         int systemCountAfter = entriesSystem.count();

   493         entriesRemovable = service->getEntries(query2);

   494         int removableCountAfter = entriesRemovable.count();

   495         entriesSysRem = service->getEntries(query3);

   496         int sysremoveCountAfter = entriesSysRem.count();

   497         //CHECK RESULTS

   498         QCOMPARE(systemCountBefore+1,systemCountAfter);

   499         QCOMPARE(removableCountBefore+1,removableCountAfter);

   500         QCOMPARE(sysremoveCountBefore,sysremoveCountAfter);

   501         //CLEANUP THE STORAGE AFTER THE TEST

   502         service->removeEntry(*resultEntry1);

   503         service->removeEntry(*resultEntry2);

   504     }

   505 }

   506 

   507 // ---------------------------------------------------------------------------

   508 // ---------------------------------------------------------------------------

   509 //

   510 void TestCaClient::TestGetEntriesByFlagsOnOff()

   511 {

   512     {

   513         //GET INITIAL STATE FROM THE STORAGE

   514         QSharedPointer<CaService> service = CaService::instance();

   515         CaQuery query1;

   516         query1.setFlagsOn(UninstallEntryFlag);

   517         query1.setFlagsOff(RemovableEntryFlag);

   518         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   519         int entriesCount1 = entries.count();

   520         //ADD TO DB

   521         CaEntry item1;

   522         item1.setText("testName_item1");

   523         item1.setAttribute("attrName1_item", "attrVal1_item");

   524         item1.setEntryTypeName("test_item1");

   525         item1.setFlags(UninstallEntryFlag);

   526         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   527         QVERIFY(!resultEntry1.isNull());

   528         //GET STATE FROM THE STORAGE AFTER ADD

   529         entries = service->getEntries(query1);

   530         int entriesCount2 = entries.count();

   531         //ADD TO DB

   532         CaEntry item2;

   533         item2.setText("testName_item1");

   534         item2.setAttribute("attrName1_item", "attrVal1_item");

   535         item2.setEntryTypeName("test_item1");

   536         item2.setFlags(RemovableEntryFlag);

   537         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   538         QVERIFY(!resultEntry2.isNull());

   539         //GET STATE FROM THE STORAGE AFTER ADD

   540         entries = service->getEntries(query1);

   541         int entriesCount3 = entries.count();

   542         //ADD TO DB

   543         CaEntry item3;

   544         item3.setText("testName_item1");

   545         item3.setAttribute("attrName1_item", "attrVal1_item");

   546         item3.setEntryTypeName("test_item1");

   547         item3.setFlags(UninstallEntryFlag|RemovableEntryFlag);

   548         QSharedPointer<CaEntry> resultEntry3 = service->createEntry(item3);

   549         QVERIFY(!resultEntry3.isNull());

   550         //GET STATE FROM THE STORAGE AFTER ADD

   551         entries = service->getEntries(query1);

   552         int entriesCount4 = entries.count();

   553         //CHECK RESULTS

   554         QCOMPARE(entriesCount1+1,entriesCount2);

   555         QCOMPARE(entriesCount2,entriesCount3);

   556         QCOMPARE(entriesCount3,entriesCount4);

   557         //CLEANUP THE STORAGE AFTER THE TEST

   558         service->removeEntry(*resultEntry1);

   559         service->removeEntry(*resultEntry2);

   560         service->removeEntry(*resultEntry3);

   561     }

   562 }

   563 

   564 // ---------------------------------------------------------------------------

   565 // ---------------------------------------------------------------------------

   566 //

   567 void TestCaClient::TestGetEntriesByRoleParent()

   568 {

   569     {

   570         QSharedPointer<CaService> service = CaService::instance();

   571         //ADD PARENT ENTRY TO THE STORAGE

   572         CaEntry parent(GroupEntryRole);

   573         CaEntry parent2(GroupEntryRole);

   574         parent.setText(QString("text"));

   575         parent.setEntryTypeName(QString("type"));

   576         parent2.setText(QString("text"));

   577         parent2.setEntryTypeName(QString("type"));

   578         QSharedPointer<CaEntry> parentEntry = service->createEntry(parent);

   579         QVERIFY(!parentEntry.isNull());

   580         QSharedPointer<CaEntry> parentEntry2 = service->createEntry(parent2);

   581         QVERIFY(!parentEntry2.isNull());

   582 

   583         //GET INITIAL STATE FROM THE STORAGE

   584         CaQuery query1;

   585         query1.setEntryRoles(ItemEntryRole);

   586         query1.setParentId(parentEntry->id());

   587         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   588         int entriesCount1 = entries.count();

   589 

   590         //ADD TO DB (item, parent2)

   591         CaEntry item1;

   592         item1.setText(QString("Name"));

   593         item1.setEntryTypeName(QString("Type"));

   594         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   595         QVERIFY(!resultItem1.isNull());

   596         service->appendEntryToGroup(parentEntry2->id(),resultItem1->id());

   597         //GET STATE FROM THE STORAGE AFTER ADD

   598         entries = service->getEntries(query1);

   599         int entriesCount2 = entries.count();

   600         //ADD TO DB (group, parent2)

   601         CaEntry group1(GroupEntryRole);

   602         group1.setText(QString("text"));

   603         group1.setEntryTypeName(QString("type"));

   604         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group1);

   605         QVERIFY(!resultGroup1.isNull());

   606         service->appendEntryToGroup(parentEntry2->id(),resultGroup1->id());

   607         //GET STATE FROM THE STORAGE AFTER ADD

   608         entries = service->getEntries(query1);

   609         int entriesCount3 = entries.count();

   610         //ADD TO DB (item, parent1)

   611         service->appendEntryToGroup(parentEntry->id(),resultItem1->id());

   612         //GET STATE FROM THE STORAGE AFTER ADD

   613         entries = service->getEntries(query1);

   614         int entriesCount4 = entries.count();

   615         //ADD TO DB (group, parent1)

   616         service->appendEntryToGroup(parentEntry->id(),resultGroup1->id());

   617         //GET STATE FROM THE STORAGE AFTER ADD

   618         entries = service->getEntries(query1);

   619         int entriesCount5 = entries.count();

   620 

   621         //CHECK RESULTS

   622         QCOMPARE(entriesCount1,entriesCount2);

   623         QCOMPARE(entriesCount2,entriesCount3);

   624         QCOMPARE(entriesCount3+1, entriesCount4);

   625         QCOMPARE(entriesCount4, entriesCount5);

   626 

   627         //CLEANUP THE STORAGE AFTER THE TEST

   628         service->removeEntry(*resultItem1);

   629         service->removeEntry(*resultGroup1);

   630         service->removeEntry(*parentEntry);

   631         service->removeEntry(*parentEntry2);

   632     }

   633 }

   634 

   635 // ---------------------------------------------------------------------------

   636 // ---------------------------------------------------------------------------

   637 //

   638 void TestCaClient::TestGetEntriesByRoleType()

   639 {

   640     {

   641         //GET INITIAL STATE FROM THE STORAGE

   642         QSharedPointer<CaService> service = CaService::instance();

   643         CaQuery query1;

   644         query1.setEntryRoles(ItemEntryRole);

   645         query1.addEntryTypeName(QString("TestTypeName"));

   646         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   647         int entriesCount1 = entries.count();

   648         //ADD TO DB (item, typeOk)

   649         CaEntry item1;

   650         item1.setText(QString("Name"));

   651         item1.setEntryTypeName(QString("TestTypeName"));

   652         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   653         QVERIFY(!resultItem1.isNull());

   654         //GET STATE FROM THE STORAGE AFTER ADD

   655         entries = service->getEntries(query1);

   656         int entriesCount2 = entries.count();

   657         //ADD TO DB (item, typeWrong)

   658         CaEntry item2;

   659         item2.setText(QString("Name"));

   660         item2.setEntryTypeName(QString("TestTypeWRONG"));

   661         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

   662         QVERIFY(!resultItem2.isNull());

   663         //GET STATE FROM THE STORAGE AFTER ADD

   664         entries = service->getEntries(query1);

   665         int entriesCount3 = entries.count();

   666         //ADD TO DB (group, typeOk)

   667         CaEntry group1(GroupEntryRole);

   668         group1.setText(QString("text"));

   669         group1.setEntryTypeName(QString("TestTypeName"));

   670         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group1);

   671         QVERIFY(!resultGroup1.isNull());

   672         //GET STATE FROM THE STORAGE AFTER ADD

   673         entries = service->getEntries(query1);

   674         int entriesCount4 = entries.count();

   675         //ADD TO DB (group, typeWrong)

   676         CaEntry group2(GroupEntryRole);

   677         group2.setText(QString("text"));

   678         group2.setEntryTypeName(QString("TestTypeWRONG"));

   679         QSharedPointer<CaEntry> resultGroup2 = service->createEntry(group2);

   680         QVERIFY(!resultGroup2.isNull());

   681         //GET STATE FROM THE STORAGE AFTER ADD

   682         entries = service->getEntries(query1);

   683         int entriesCount5 = entries.count();

   684 

   685         //CHECK RESULTS

   686         QCOMPARE(entriesCount1+1,entriesCount2);

   687         QCOMPARE(entriesCount2,entriesCount3);

   688         QCOMPARE(entriesCount3, entriesCount4);

   689         QCOMPARE(entriesCount4, entriesCount5);

   690 

   691         //CLEANUP THE STORAGE AFTER THE TEST

   692         service->removeEntry(*resultItem1);

   693         service->removeEntry(*resultGroup1);

   694         service->removeEntry(*resultItem2);

   695         service->removeEntry(*resultGroup2);

   696     }

   697 }

   698 

   699 // ---------------------------------------------------------------------------

   700 // ---------------------------------------------------------------------------

   701 //

   702 void TestCaClient::TestGetEntriesByRoleFlags()

   703 {

   704     {

   705         //GET INITIAL STATE FROM THE STORAGE

   706         QSharedPointer<CaService> service = CaService::instance();

   707         CaQuery query1;

   708         query1.setEntryRoles(ItemEntryRole);

   709         query1.setFlagsOn(UninstallEntryFlag);

   710         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   711         int entriesCount1 = entries.count();

   712         //ADD TO DB (item, systemOn)

   713         CaEntry item1;

   714         item1.setFlags(UninstallEntryFlag);

   715         item1.setText(QString("Name"));

   716         item1.setEntryTypeName(QString("Name"));

   717         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   718         QVERIFY(!resultItem1.isNull());

   719         //GET STATE FROM THE STORAGE AFTER ADD

   720         entries = service->getEntries(query1);

   721         int entriesCount2 = entries.count();

   722         //ADD TO DB (item, systemOff)

   723         CaEntry item2;

   724         item2.setText(QString("Name"));

   725         item2.setEntryTypeName(QString("Name"));

   726         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

   727         QVERIFY(!resultItem2.isNull());

   728         //GET STATE FROM THE STORAGE AFTER ADD

   729         entries = service->getEntries(query1);

   730         int entriesCount3 = entries.count();

   731         //ADD TO DB(group, systemOn)

   732         CaEntry group1(GroupEntryRole);

   733         group1.setText(QString("text"));

   734         group1.setEntryTypeName(QString("type"));

   735         group1.setFlags(UninstallEntryFlag);

   736         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group1);

   737         QVERIFY(!resultGroup1.isNull());

   738         //GET STATE FROM THE STORAGE AFTER ADD

   739         entries = service->getEntries(query1);

   740         int entriesCount4 = entries.count();

   741         //ADD TO DB(group, systemoff)

   742         CaEntry group2(GroupEntryRole);

   743         group2.setText(QString("text"));

   744         group2.setEntryTypeName(QString("type"));

   745         QSharedPointer<CaEntry> resultGroup2 = service->createEntry(group2);

   746         QVERIFY(!resultGroup2.isNull());

   747         //GET STATE FROM THE STORAGE AFTER ADD

   748         entries = service->getEntries(query1);

   749         int entriesCount5 = entries.count();

   750         //CHECK RESULTS

   751         QCOMPARE(entriesCount1+1,entriesCount2);

   752         QCOMPARE(entriesCount2,entriesCount3);

   753         QCOMPARE(entriesCount3, entriesCount4);

   754         QCOMPARE(entriesCount4, entriesCount5);

   755         //CLEANUP THE STORAGE AFTER THE TEST

   756         service->removeEntry(*resultItem1);

   757         service->removeEntry(*resultGroup1);

   758         service->removeEntry(*resultItem2);

   759         service->removeEntry(*resultGroup2);

   760     }

   761 }

   762 

   763 // ---------------------------------------------------------------------------

   764 // ---------------------------------------------------------------------------

   765 //

   766 void TestCaClient::TestGetEntriesByParentType()

   767 {

   768     {

   769         QSharedPointer<CaService> service = CaService::instance();

   770         //ADD PARENT TO THE STORAGE

   771         CaEntry parent(GroupEntryRole);

   772         CaEntry parent2(GroupEntryRole);

   773         parent.setText(QString("text"));

   774         parent.setEntryTypeName(QString("type"));

   775         parent2.setText(QString("text"));

   776         parent2.setEntryTypeName(QString("type"));

   777         QSharedPointer<CaEntry> parentEntry = service->createEntry(parent);

   778         QVERIFY(!parentEntry.isNull());

   779         QSharedPointer<CaEntry> parentEntry2 = service->createEntry(parent2);

   780         QVERIFY(!parentEntry2.isNull());

   781 

   782         //GET INITIAL STATE FROM THE STORAGE

   783         CaQuery query1;

   784         query1.setParentId(parentEntry->id());

   785         query1.addEntryTypeName(QString("typeOK"));

   786         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   787         int entriesCount1 = entries.count();

   788         //ADD TO DB (parent1, typeok)

   789         CaEntry item1;

   790         item1.setText(QString("Name"));

   791         item1.setEntryTypeName(QString("typeOK"));

   792         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   793         QVERIFY(!resultItem1.isNull());

   794         service->appendEntryToGroup(parentEntry->id(),resultItem1->id());

   795         //GET STATE FROM THE STORAGE AFTER ADD

   796         entries = service->getEntries(query1);

   797         int entriesCount2 = entries.count();

   798         //ADD TO DB (parent1, typeWrong)

   799         CaEntry item2;

   800         item2.setText(QString("Name"));

   801         item2.setEntryTypeName(QString("typeWrong"));

   802         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

   803         QVERIFY(!resultItem2.isNull());

   804         service->appendEntryToGroup(parentEntry->id(),resultItem2->id());

   805         //GET STATE FROM THE STORAGE AFTER ADD

   806         entries = service->getEntries(query1);

   807         int entriesCount3 = entries.count();

   808         //ADD TO DB (parent2, typeOk)

   809         service->appendEntryToGroup(parentEntry2->id(),resultItem1->id());

   810         //GET STATE FROM THE STORAGE AFTER ADD

   811         entries = service->getEntries(query1);

   812         int entriesCount4 = entries.count();

   813         //ADD TO DB (parent2,typeWrong)

   814         service->appendEntryToGroup(parentEntry2->id(),resultItem2->id());

   815         //GET STATE FROM THE STORAGE AFTER ADD

   816         entries = service->getEntries(query1);

   817         int entriesCount5 = entries.count();

   818         //CHECK RESULTS

   819         QCOMPARE(entriesCount1+1,entriesCount2);

   820         QCOMPARE(entriesCount2,entriesCount3);

   821         QCOMPARE(entriesCount3, entriesCount4);

   822         QCOMPARE(entriesCount4, entriesCount5);

   823         //CLEANUP THE STORAGE AFTER THE TEST

   824         service->removeEntry(*resultItem1);

   825         service->removeEntry(*resultItem2);

   826         service->removeEntry(*parentEntry);

   827         service->removeEntry(*parentEntry2);

   828     }

   829 }

   830 

   831 // ---------------------------------------------------------------------------

   832 // ---------------------------------------------------------------------------

   833 //

   834 void TestCaClient::TestGetEntriesByParentFlags()

   835 {

   836     {

   837         QSharedPointer<CaService> service = CaService::instance();

   838         //ADD PARENT TO THE STORAGE

   839         CaEntry parent(GroupEntryRole);

   840         CaEntry parent2(GroupEntryRole);

   841         parent.setText(QString("text"));

   842         parent.setEntryTypeName(QString("type"));

   843         parent2.setText(QString("text"));

   844         parent2.setEntryTypeName(QString("type"));

   845         QSharedPointer<CaEntry> parentEntry = service->createEntry(parent);

   846         QVERIFY(!parentEntry.isNull());

   847         QSharedPointer<CaEntry> parentEntry2 = service->createEntry(parent2);

   848         QVERIFY(!parentEntry2.isNull());

   849 

   850         //GET INITIAL STATE FROM THE STORAGE

   851         CaQuery query1;

   852         query1.setParentId(parentEntry->id());

   853         query1.setFlagsOn(UninstallEntryFlag);

   854         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   855         int entriesCount1 = entries.count();

   856 

   857         //ADD TO DB (parent1, system)

   858         CaEntry item1;

   859         item1.setText(QString("Name"));

   860         item1.setEntryTypeName(QString("Type"));

   861         item1.setFlags(UninstallEntryFlag);

   862         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   863         QVERIFY(!resultItem1.isNull());

   864         service->appendEntryToGroup(parentEntry->id(),resultItem1->id());

   865         //GET STATE FROM THE STORAGE AFTER ADD

   866         entries = service->getEntries(query1);

   867         int entriesCount2 = entries.count();

   868         //ADD TO DB (parent1, not system)

   869         CaEntry item2;

   870         item2.setText(QString("Name"));

   871         item2.setEntryTypeName(QString("Type"));

   872         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

   873         QVERIFY(!resultItem2.isNull());

   874         service->appendEntryToGroup(parentEntry->id(),resultItem2->id());

   875         //GET STATE FROM THE STORAGE AFTER ADD

   876         entries = service->getEntries(query1);

   877         int entriesCount3 = entries.count();

   878         //ADD TO DB( parent2, system )

   879         service->appendEntryToGroup(parentEntry2->id(),resultItem1->id());

   880         //GET STATE FROM THE STORAGE AFTER ADD

   881         entries = service->getEntries(query1);

   882         int entriesCount4 = entries.count();

   883         //ADD TO DB (parent2, not system)

   884         service->appendEntryToGroup(parentEntry2->id(),resultItem2->id());

   885         //GET STATE FROM THE STORAGE AFTER ADD

   886         entries = service->getEntries(query1);

   887         int entriesCount5 = entries.count();

   888 

   889         //CHECK RESULTS

   890         QCOMPARE(entriesCount1+1,entriesCount2);

   891         QCOMPARE(entriesCount2,entriesCount3);

   892         QCOMPARE(entriesCount3, entriesCount4);

   893         QCOMPARE(entriesCount4, entriesCount5);

   894 

   895         //CLEANUP THE STORAGE AFTER THE TEST

   896         service->removeEntry(*parentEntry);

   897         service->removeEntry(*parentEntry2);

   898         service->removeEntry(*resultItem1);

   899         service->removeEntry(*resultItem2);

   900     }

   901 }

   902 

   903 // ---------------------------------------------------------------------------

   904 // ---------------------------------------------------------------------------

   905 //

   906 void TestCaClient::TestGetEntriesByTypeFlags()

   907 {

   908     {

   909         //GET INITIAL STATE FROM THE STORAGE

   910         QSharedPointer<CaService> service = CaService::instance();

   911         CaQuery query1;

   912         query1.addEntryTypeName(QString("TypeOK"));

   913         query1.setFlagsOn(UninstallEntryFlag);

   914         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   915         int entriesCount1 = entries.count();

   916 

   917         //ADD TO DB (typeOk, system)

   918         CaEntry item1;

   919         item1.setFlags(UninstallEntryFlag);

   920         item1.setEntryTypeName(QString("TypeOK"));

   921         item1.setText(QString("Name"));

   922         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

   923         QVERIFY(!resultItem1.isNull());

   924         //GET STATE FROM THE STORAGE AFTER ADD

   925         entries = service->getEntries(query1);

   926         int entriesCount2 = entries.count();

   927         //ADD TO DB(typeOk, not system)

   928         CaEntry item2;

   929         item2.setEntryTypeName(QString("TypeOK"));

   930         item2.setText(QString("Name"));

   931         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

   932         QVERIFY(!resultItem2.isNull());

   933         //GET STATE FROM THE STORAGE AFTER ADD

   934         entries = service->getEntries(query1);

   935         int entriesCount3 = entries.count();

   936         //ADD TO DB(typeWrong, system)

   937         CaEntry item3;

   938         item3.setFlags(UninstallEntryFlag);

   939         item3.setText(QString("Name"));

   940         item3.setEntryTypeName(QString("TypeWrong"));

   941         QSharedPointer<CaEntry> resultItem3 = service->createEntry(item3);

   942         QVERIFY(!resultItem3.isNull());

   943         //GET STATE FROM THE STORAGE AFTER ADD

   944         entries = service->getEntries(query1);

   945         int entriesCount4 = entries.count();

   946         //ADD TO DB(typeWrong, not system)

   947         CaEntry item4;

   948         item4.setEntryTypeName(QString("TypeWrong"));

   949         item4.setText(QString("Name"));

   950 

   951         QSharedPointer<CaEntry> resultItem4 = service->createEntry(item4);

   952         QVERIFY(!resultItem4.isNull());

   953         //GET STATE FROM THE STORAGE AFTER ADD

   954         entries = service->getEntries(query1);

   955         int entriesCount5 = entries.count();

   956 

   957         //CHECK RESULTS

   958         QCOMPARE(entriesCount1+1,entriesCount2);

   959         QCOMPARE(entriesCount2,entriesCount3);

   960         QCOMPARE(entriesCount3, entriesCount4);

   961         QCOMPARE(entriesCount4, entriesCount5);

   962         //CLEANUP THE STORAGE AFTER THE TEST

   963         service->removeEntry(*resultItem1);

   964         service->removeEntry(*resultItem2);

   965         service->removeEntry(*resultItem3);

   966         service->removeEntry(*resultItem4);

   967     }

   968 }

   969 

   970 // ---------------------------------------------------------------------------

   971 // ---------------------------------------------------------------------------

   972 //

   973 void TestCaClient::TestGetEntriesByRoleParentType()

   974 {

   975     {

   976         QSharedPointer<CaService> service = CaService::instance();

   977         //ADD PARENT TO THE STORAGE

   978         CaEntry parent(GroupEntryRole);

   979         CaEntry parent2(GroupEntryRole);

   980         parent.setText(QString("text"));

   981         parent.setEntryTypeName(QString("type"));

   982         parent2.setText(QString("text"));

   983         parent2.setEntryTypeName(QString("type"));

   984         QSharedPointer<CaEntry> parentEntry = service->createEntry(parent);

   985         QVERIFY(!parentEntry.isNull());

   986         QSharedPointer<CaEntry> parentEntry2 = service->createEntry(parent2);

   987         QVERIFY(!parentEntry2.isNull());

   988 

   989         //GET INITIAL STATE FROM THE STORAGE

   990         CaQuery query1;

   991         query1.setEntryRoles(ItemEntryRole);

   992         query1.setParentId(parentEntry->id());

   993         query1.addEntryTypeName(QString("TypeOK"));

   994         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

   995         int entriesCount1 = entries.count();

   996 

   997         //ADD TO DB ( item, parent1, typeOk)

   998         CaEntry item1;

   999         item1.setEntryTypeName(QString("TypeOK"));

  1000         item1.setText(QString("Name"));

  1001         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

  1002         QVERIFY(!resultItem1.isNull());

  1003         service->appendEntryToGroup(parentEntry->id(), resultItem1->id());

  1004         //GET STATE FROM THE STORAGE AFTER ADD

  1005         entries = service->getEntries(query1);

  1006         int entriesCount2= entries.count();

  1007         //ADD TO DB ( item, parent1, typeWrong)

  1008         CaEntry item2;

  1009         item2.setText(QString("Name"));

  1010         item2.setEntryTypeName(QString("TypeWRONG"));

  1011         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

  1012         QVERIFY(!resultItem2.isNull());

  1013         service->appendEntryToGroup(parentEntry->id(), resultItem2->id());

  1014         //GET STATE FROM THE STORAGE AFTER ADD

  1015         entries = service->getEntries(query1);

  1016         int entriesCount3 = entries.count();

  1017         //ADD TO DB ( item, parent2, typeOk)

  1018         service->appendEntryToGroup(parentEntry2->id(), resultItem1->id());

  1019         //GET STATE FROM THE STORAGE AFTER ADD

  1020         entries = service->getEntries(query1);

  1021         int entriesCount4 = entries.count();

  1022         //ADD TO DB ( group, parent1, typeOk)

  1023         CaEntry group1(GroupEntryRole);

  1024         group1.setText(QString("text"));

  1025         group1.setEntryTypeName(QString("TypeOK"));

  1026         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group1);

  1027         QVERIFY(!resultGroup1.isNull());

  1028         service->appendEntryToGroup(parentEntry->id(), resultGroup1->id());

  1029         //GET STATE FROM THE STORAGE AFTER ADD

  1030         entries = service->getEntries(query1);

  1031         int entriesCount5 = entries.count();

  1032 

  1033         //CHECK RESULTS

  1034         QCOMPARE(entriesCount1+1,entriesCount2);

  1035         QCOMPARE(entriesCount2,entriesCount3);

  1036         QCOMPARE(entriesCount3, entriesCount4);

  1037         QCOMPARE(entriesCount4, entriesCount5);

  1038         //CLEANUP THE STORAGE AFTER THE TEST

  1039         service->removeEntry(*resultItem1);

  1040         service->removeEntry(*resultItem2);

  1041         service->removeEntry(*resultGroup1);

  1042         service->removeEntry(*parentEntry);

  1043         service->removeEntry(*parentEntry2);

  1044     }

  1045 }

  1046 

  1047 // ---------------------------------------------------------------------------

  1048 // ---------------------------------------------------------------------------

  1049 //

  1050 void TestCaClient::TestGetEntriesByRoleParentFlags()

  1051 {

  1052     {

  1053         QSharedPointer<CaService> service = CaService::instance();

  1054         //ADD PARENT TO THE STORAGE

  1055         CaEntry parent(GroupEntryRole);

  1056         CaEntry parent2(GroupEntryRole);

  1057         parent.setText(QString("text"));

  1058         parent.setEntryTypeName(QString("type"));

  1059         parent2.setText(QString("text"));

  1060         parent2.setEntryTypeName(QString("type"));

  1061         QSharedPointer<CaEntry> parentEntry = service->createEntry(parent);

  1062         QVERIFY(!parentEntry.isNull());

  1063         QSharedPointer<CaEntry> parentEntry2 = service->createEntry(parent2);

  1064         QVERIFY(!parentEntry2.isNull());

  1065 

  1066         //GET INITIAL STATE FROM THE STORAGE

  1067         CaQuery query1;

  1068         query1.setEntryRoles(ItemEntryRole);

  1069         query1.setParentId(parentEntry->id());

  1070         query1.setFlagsOn(UninstallEntryFlag);

  1071         QList< QSharedPointer<CaEntry> > entries = service->getEntries(query1);

  1072         int entriesCount1 = entries.count();

  1073 

  1074         //ADD TO DB (item, parent1, system )

  1075         CaEntry item1;

  1076         item1.setText(QString("Name"));

  1077         item1.setEntryTypeName(QString("Type"));

  1078         item1.setFlags(UninstallEntryFlag);

  1079         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item1);

  1080         QVERIFY(!resultItem1.isNull());

  1081         service->appendEntryToGroup(parentEntry->id(), resultItem1->id());

  1082         //GET STATE FROM THE STORAGE AFTER ADD

  1083         entries = service->getEntries(query1);

  1084         int entriesCount2 = entries.count();

  1085         //ADD TO DB(item, parent1, not system )

  1086         CaEntry item2;

  1087         item2.setText(QString("Name"));

  1088         item2.setEntryTypeName(QString("Type"));

  1089         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item2);

  1090         QVERIFY(!resultItem2.isNull());

  1091         service->appendEntryToGroup(parentEntry->id(), resultItem2->id());

  1092         //GET STATE FROM THE STORAGE AFTER ADD

  1093         entries = service->getEntries(query1);

  1094         int entriesCount3 = entries.count();

  1095         //ADD TO DB(item, parent2 , system )

  1096         service->appendEntryToGroup(parentEntry2->id(), resultItem1->id());

  1097         //GET STATE FROM THE STORAGE AFTER ADD

  1098         entries = service->getEntries(query1);

  1099         int entriesCount4 = entries.count();

  1100         //ADD TO DB(group, parent1, system )

  1101         CaEntry group1(GroupEntryRole);

  1102         group1.setText(QString("text"));

  1103         group1.setEntryTypeName(QString("type"));

  1104         group1.setFlags(UninstallEntryFlag);

  1105         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group1);

  1106         QVERIFY(!resultGroup1.isNull());

  1107         service->appendEntryToGroup(parentEntry->id(), resultGroup1->id());

  1108 

  1109         //GET STATE FROM THE STORAGE AFTER ADD

  1110         entries = service->getEntries(query1);

  1111         int entriesCount5 = entries.count();

  1112 

  1113         //CHECK RESULTS

  1114         QCOMPARE(entriesCount1+1,entriesCount2);

  1115         QCOMPARE(entriesCount2,entriesCount3);

  1116         QCOMPARE(entriesCount3, entriesCount4);

  1117         QCOMPARE(entriesCount4, entriesCount5);

  1118 

  1119         //CLEANUP THE STORAGE AFTER THE TEST

  1120         service->removeEntry(*parentEntry);

  1121         service->removeEntry(*parentEntry2);

  1122         service->removeEntry(*resultItem1);

  1123         service->removeEntry(*resultItem2);

  1124         service->removeEntry(*resultGroup1);

  1125     }

  1126 }

  1127 

  1128 // ---------------------------------------------------------------------------

  1129 // ---------------------------------------------------------------------------

  1130 //

  1131 void TestCaClient::TestGetEntriesByParentTypeFlags()

  1132 {

  1133     {

  1134         QSharedPointer<CaService> service = CaService::instance();

  1135         //ADD PARENT TO THE STORAGE