diff -r 3ab5c078b490 -r c63ee96dbe5f contentstorage/castorage/tsrc/t_castorage/src/castoragetestgetentries.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contentstorage/castorage/tsrc/t_castorage/src/castoragetestgetentries.cpp	Thu Sep 16 12:11:40 2010 +0100
@@ -0,0 +1,1480 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+/*
+ * castoragetestgetentries.cpp
+ *
+ *  Created on: 2009-08-05
+ *      Author: michal.czerwiec
+ */
+
+#include <e32cmn.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include <badesca.h>
+#include <e32math.h>
+#include <qglobal.h>
+
+#include "castoragetest.h"
+#include "cainnerquery.h"
+#include "castoragefactory.h"
+#include "castorage.h"
+#include "cainnerentry.h"
+#include "castoragetestsqlcommands.h"
+#include "casqlcommands.h"
+#include "casqlquery.h"
+#include "casqlitestorage.h"
+#include "cadef.h"
+
+
+// ---------------------------------------------------------------------------
+// Test that two data arrays have opposite order.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::verifyOppositeOrder(RPointerArray<CCaInnerEntry>& aArray1,
+        RPointerArray<CCaInnerEntry>& aArray2)
+{
+    TInt err;
+
+    __UHEAP_MARK;
+
+    err = (aArray1.Count() == aArray2.Count())? KErrNone : KErrWrongData;
+    if (!err) {
+        TInt count(aArray1.Count());
+        for (TInt i = 0; i < aArray1.Count(); i++) {
+            if (aArray1[i]->GetId() != aArray2[count-1-i]->GetId()) {
+                err = KErrWrongData;
+                break;
+            }
+        }
+    }
+
+    __UHEAP_MARKEND;
+
+    return err;
+}
+
+// ---------------------------------------------------------------------------
+// Test Sorting Order giving different attributes.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::testSortingBySortOrder(CCaInnerQuery::TSortAttribute sortAttr1,
+        CCaInnerQuery::TSortAttribute sortAttr2)
+{
+
+    __UHEAP_MARK;
+
+    TRAPD(err,
+          CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+          innerQuery1->SetSort(sortAttr1);
+
+          CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+          innerQuery2->SetSort(sortAttr2);
+
+          err = testSortingBySortOrder(innerQuery1,  innerQuery2);
+
+          CleanupStack::PopAndDestroy(innerQuery2);
+          CleanupStack::PopAndDestroy(innerQuery1);
+         );
+    __UHEAP_MARKEND;
+
+    return err;
+}
+
+
+// ---------------------------------------------------------------------------
+// Test Sorting Order giving different attributes.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::testSortingBySortOrder(CCaInnerQuery *aInnerQuery1,
+        CCaInnerQuery *aInnerQuery2)
+{
+    __UHEAP_MARK;
+    TInt err(KErrNone);
+    RPointerArray<CCaInnerEntry> resultArray;
+    TRAP(err,
+         CleanupResetAndDestroyPushL(resultArray);
+         mStorage->GetEntriesL(aInnerQuery1,resultArray);
+
+         RPointerArray<CCaInnerEntry> resultArrayDesc;
+         CleanupResetAndDestroyPushL(resultArrayDesc);
+         mStorage->GetEntriesL(aInnerQuery2,resultArrayDesc);
+
+         err = (resultArray.Count() > 0)? KErrNone : KErrWrongData;
+
+    if (err == KErrNone) {
+    err = (resultArrayDesc.Count() > 0)? KErrNone : KErrWrongData;
+    }
+
+    if (err == KErrNone) {
+    err = verifyOppositeOrder(resultArray, resultArrayDesc);
+    }
+    CleanupStack::PopAndDestroy(&resultArrayDesc);
+    CleanupStack::PopAndDestroy(&resultArray);
+        );
+
+
+    __UHEAP_MARKEND;
+
+    return err;
+}
+// ---------------------------------------------------------------------------
+// Test Select several entries by id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesById()
+{
+    __UHEAP_MARK;
+    {
+        QList<TInt> expectedIdList;
+        expectedIdList << 1 << 2 << 3 << 4 << 5 << 6;
+        QList<TInt> actualIdList;
+
+
+        TRAPD(err,
+              CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+              RArray<TInt> idArray;
+              CleanupClosePushL(idArray);
+              idArray.AppendL(expectedIdList[0]);
+              idArray.AppendL(expectedIdList[1]);
+              idArray.AppendL(expectedIdList[2]);
+              idArray.AppendL(expectedIdList[3]);
+              idArray.AppendL(expectedIdList[4]);
+              idArray.AppendL(expectedIdList[5]);
+
+              innerQuery->SetIdsL(idArray);
+
+              RPointerArray<CCaInnerEntry> resultArray;
+              CleanupResetAndDestroyPushL(resultArray);
+
+              mStorage->GetEntriesL(innerQuery,resultArray);
+
+              // check if the actual items were returned
+        for (TInt i = 0; i < resultArray.Count(); i++) {
+        actualIdList << resultArray[i]->GetId();
+        }
+
+        CleanupStack::PopAndDestroy(&resultArray);
+        CleanupStack::PopAndDestroy(&idArray);
+        CleanupStack::PopAndDestroy(innerQuery);
+             );
+
+
+        QCOMPARE(err, KErrNone);
+        QCOMPARE(actualIdList, expectedIdList);
+    }
+
+    __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by group id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByGroupId()
+{
+    TInt expectedGroupEntryCount(0);
+    TInt actualGroupEntryCount(0);
+
+    __UHEAP_MARK;
+
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+          // check before test entries count in sfecific group
+          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+          query->SetQueryL(KSQLGetEntriesCountFromSpecificGroup);
+          query->PrepareL();
+          query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
+
+          query->ExecuteL(expectedGroupEntryCount);
+
+          CleanupStack::PopAndDestroy(query);
+
+          innerQuery->SetParentId(KAllCollectionsGroupId);
+
+          // get entries from specific group
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+          mStorage->GetEntriesL(innerQuery, resultArray);
+
+          actualGroupEntryCount =  resultArray.Count();
+
+          CleanupStack::PopAndDestroy(&resultArray);
+          CleanupStack::PopAndDestroy(innerQuery);
+         );
+
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+    QCOMPARE(actualGroupEntryCount, expectedGroupEntryCount);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by group id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByTypeName()
+{
+    bool nonWidgetEntryFound(false);
+    const int expectedNumberOfWidgets(2);
+    int numberOfWidgetsFound(0);
+
+    __UHEAP_MARK;
+
+    _LIT(KTypeNameWidget, "Widget");
+
+    TRAPD(err,
+          // add 2 new entries - typename widget
+          CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+          innerEntry->SetTextL(KTestName1);
+          innerEntry->SetEntryTypeNameL(KTypeNameWidget);
+          innerEntry->SetFlags(flag);
+          innerEntry->SetRole(CCaInnerQuery::Item);
+          mStorage->AddL(innerEntry);
+          CleanupStack::PopAndDestroy(innerEntry);
+
+          innerEntry = CCaInnerEntry::NewLC();
+          innerEntry->SetTextL(KTestName2);
+          innerEntry->SetEntryTypeNameL(KTypeNameWidget);
+          innerEntry->SetFlags(flag);
+          innerEntry->SetRole(CCaInnerQuery::Item);
+          mStorage->AddL(innerEntry);
+          CleanupStack::PopAndDestroy(innerEntry);
+
+
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+          CDesC16ArrayFlat *typenameArray  = new(ELeave) CDesC16ArrayFlat(KDefaultGranularity);
+          CleanupStack::PushL(typenameArray);
+
+          TBufC<20> typeName(KTypeNameWidget);
+          typenameArray->AppendL(typeName);
+
+          innerQuery->SetEntryTypeNames(typenameArray);
+          CleanupStack::Pop(typenameArray);
+
+          // get entries from specific group
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+
+          // get entries - widgets
+          mStorage->GetEntriesL(innerQuery,resultArray);
+
+          numberOfWidgetsFound = resultArray.Count();
+          // check results
+    for (TInt i = 0; i < numberOfWidgetsFound; ++i) {
+    if ((resultArray[i]->GetEntryTypeName()).Compare(
+        KTypeNameWidget) != 0) {
+            nonWidgetEntryFound = true;
+        }
+    }
+
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+    QCOMPARE(numberOfWidgetsFound, expectedNumberOfWidgets);
+    QVERIFY(!nonWidgetEntryFound);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries sorted by name alphabetically.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByName()
+{
+    __UHEAP_MARK;
+    {
+        TInt entriesACount(0);
+        QMap<QString, bool> comparisonAResults;
+        TInt entriesBCount(0);
+        QMap<QString, bool> comparisonBResults;
+        bool orderCheckPassed(false);
+
+        TRAPD(err,
+              //    test ascending
+              CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+              innerQuery->SetSort(CCaInnerQuery::Name);
+              RPointerArray<CCaInnerEntry> resultArray;
+              CleanupResetAndDestroyPushL(resultArray);
+              mStorage->GetEntriesL(innerQuery,resultArray);
+
+              //    change all odd entries texts to be lower case
+        for (TInt i = 0; i < resultArray.Count(); ++i) {
+        if (resultArray[i]->GetId() % 2 == 1) {
+                RBuf tempBuf;
+                tempBuf.CleanupClosePushL();
+                tempBuf.CreateL(resultArray[i]->GetText());
+                tempBuf.LowerCase();
+                resultArray[i]->SetTextL(tempBuf);
+                CleanupStack::PopAndDestroy(&tempBuf);
+                mStorage->AddL(resultArray[i]);
+            }
+        }
+        //    fetch the table again
+        resultArray.ResetAndDestroy();
+        mStorage->GetEntriesL(innerQuery,resultArray);
+
+        entriesACount = resultArray.Count();
+
+        RBuf previousText;
+        previousText.CleanupClosePushL();
+        RBuf currentText;
+        currentText.CleanupClosePushL();
+        if (!err) {
+        for (TInt i = 0; i < resultArray.Count(); i++) {
+                currentText.CreateL(resultArray[i]->GetText());
+                currentText.LowerCase();
+
+                comparisonAResults[descToQString(currentText)] = true;
+
+                if (i!=0 && currentText.Compare(previousText) < 0) {
+                    comparisonAResults[descToQString(currentText)] = false;
+                    err = KErrWrongData;
+                    break;
+                }
+                currentText.Close();
+                previousText.Close();
+                previousText.CreateL(resultArray[i]->GetText());
+                previousText.LowerCase();
+            }
+        }
+        //    test descending
+        CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+        innerQuery2->SetSort(CCaInnerQuery::NameDesc);
+        RPointerArray<CCaInnerEntry> resultArrayDesc;
+        CleanupResetAndDestroyPushL(resultArrayDesc);
+        mStorage->GetEntriesL(innerQuery2,resultArrayDesc);
+
+        entriesBCount = resultArrayDesc.Count();
+
+        previousText.Close();
+        currentText.Close();
+
+        if (!err) {
+        for (TInt i = 0; i < resultArrayDesc.Count(); i++) {
+                currentText.CreateL(resultArrayDesc[i]->GetText());
+                currentText.LowerCase();
+
+                comparisonBResults[descToQString(currentText)] = true;
+
+                if (i!=0 && resultArrayDesc[i]->GetText().Compare(previousText) > 0) {
+                    comparisonBResults[descToQString(currentText)] = false;
+                    break;
+                }
+                currentText.Close();
+                previousText.Close();
+                previousText.CreateL(resultArrayDesc[i]->GetText());
+                previousText.LowerCase();
+            }
+        }
+
+        if (!err) {
+        orderCheckPassed = verifyOppositeOrder(resultArray, resultArrayDesc) == 0;
+        }
+
+        CleanupStack::PopAndDestroy(&resultArrayDesc);
+        CleanupStack::PopAndDestroy(innerQuery2);
+        CleanupStack::PopAndDestroy(&currentText);
+        CleanupStack::PopAndDestroy(&previousText);
+        CleanupStack::PopAndDestroy(&resultArray);
+        CleanupStack::PopAndDestroy(innerQuery);
+             );
+
+        QCOMPARE(err, KErrNone);
+        foreach(QString str, comparisonAResults.keys()) {
+            QVERIFY2(comparisonAResults[str], str.toUtf8());
+        };
+        QCOMPARE(comparisonAResults.size(), entriesACount);
+
+
+        foreach(QString str, comparisonAResults.keys()) {
+            QVERIFY2(comparisonBResults[str], str.toUtf8());
+        };
+        QCOMPARE(comparisonBResults.size(), entriesBCount);
+
+        QVERIFY(orderCheckPassed);
+    }
+    __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by created timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByCreatedTimestamp()
+{
+
+    __UHEAP_MARK;
+    {
+        QMap<int, bool> ascendingOrderCheckResults;
+        QMap<int, bool> descendingOrderCheckResults;
+
+        TRAPD(err,
+              //    check ascending
+              RPointerArray<CCaInnerEntry> resultArray;
+              CleanupResetAndDestroyPushL(resultArray);
+              CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+              innerQuery->SetSort(CCaInnerQuery::CreatedTimestamp);
+              mStorage->GetEntriesL(innerQuery,resultArray);
+              CleanupStack::PopAndDestroy(innerQuery);
+
+              TInt64 previousTimestamp(0);
+        for (TInt i = 0; i<resultArray.Count() ; i++) {
+        innerQuery = CCaInnerQuery::NewLC();
+            RArray<TInt> ids;
+            CleanupClosePushL(ids);
+            const TInt id = resultArray[i]->GetId();
+            ids.AppendL(id);
+            innerQuery->SetIdsL(ids);
+
+            TInt64 timestamp(0);
+            CCaSqlQuery *query = CCaSqlQuery::NewLC(STATIC_CAST(CCaSqLiteStorage *,mStorage)->iSqlDb);
+            query->SetQueryL(KSQLGetEntryTimestamp);
+            query->PrepareL();
+            query->BindIdsL(ids, KSQLEntryId);
+            query->ExecuteL(timestamp);
+
+            if (i != 0 && timestamp < previousTimestamp) {
+                ascendingOrderCheckResults[id] = false;
+                break;
+            }
+            previousTimestamp = timestamp;
+            CleanupStack::PopAndDestroy(query);
+            CleanupStack::PopAndDestroy(&ids);
+            CleanupStack::PopAndDestroy(innerQuery);
+        }
+
+        CleanupStack::PopAndDestroy(&resultArray);
+
+        //    check descending
+        CleanupResetAndDestroyPushL(resultArray);
+        innerQuery = CCaInnerQuery::NewLC();
+        innerQuery->SetSort(CCaInnerQuery::CreatedTimestampDesc);
+        mStorage->GetEntriesL(innerQuery,resultArray);
+        CleanupStack::PopAndDestroy(innerQuery);
+
+        previousTimestamp = 0;
+        for (TInt i = 0; i<resultArray.Count() ; i++) {
+        innerQuery = CCaInnerQuery::NewLC();
+            RArray<TInt> ids;
+            CleanupClosePushL(ids);
+            ids.AppendL(resultArray[i]->GetId());
+            const TInt id = ids[0];
+            innerQuery->SetIdsL(ids);
+
+            TInt64 timestamp(0);
+            CCaSqlQuery *query = CCaSqlQuery::NewLC(STATIC_CAST(CCaSqLiteStorage *,mStorage)->iSqlDb);
+            query->SetQueryL(KSQLGetEntryTimestamp);
+            query->PrepareL();
+            query->BindIdsL(ids, KSQLEntryId);
+            query->ExecuteL(timestamp);
+            if (i != 0 && timestamp > previousTimestamp) {
+                descendingOrderCheckResults[id] = false;
+                break;
+            }
+            previousTimestamp = timestamp;
+            CleanupStack::PopAndDestroy(query);
+            CleanupStack::PopAndDestroy(&ids);
+            CleanupStack::PopAndDestroy(innerQuery);
+        }
+
+        CleanupStack::PopAndDestroy(&resultArray);
+             );
+
+
+        QCOMPARE(err, KErrNone);
+        QCOMPARE(ascendingOrderCheckResults.size(), 0);
+        QCOMPARE(descendingOrderCheckResults.size(), 0);
+    }
+    __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByMostUsedTimestamp()
+{
+    __UHEAP_MARK;
+
+    const TInt mostUsedIds[3] = {14, 9, 2};
+
+    const TInt mostUsedIdsSize = sizeof(mostUsedIds) / sizeof(TInt);
+
+    TInt err(KErrNone);
+
+    TRAP(err,
+
+    for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+    for (TInt j = mostUsedIdsSize - i; j >= 0; --j) {
+            mStorage->TouchL(mostUsedIds[i], ETrue);
+        }
+    }
+
+    CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+    innerQuery1->SetSort(CCaInnerQuery::MostUsedDesc);
+    RPointerArray<CCaInnerEntry> resultArray;
+    CleanupResetAndDestroyPushL(resultArray);
+
+
+    // get entries - most used desscending
+    mStorage->GetEntriesL(innerQuery1, resultArray);
+
+    if (resultArray.Count() < mostUsedIdsSize) {
+    err = KErrNotFound;
+} else {
+    for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+            if (resultArray[i]->GetId() != mostUsedIds[i]) {
+                err = KErrGeneral;
+                break;
+            }
+        }
+    }
+
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery1);
+        );
+
+    QCOMPARE(err, KErrNone);
+
+
+    TRAP(err,
+         CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+         innerQuery1->SetSort(CCaInnerQuery::MostUsed);
+         RPointerArray<CCaInnerEntry> resultArray;
+         CleanupResetAndDestroyPushL(resultArray);
+
+
+         // get entries - most used desscending
+         mStorage->GetEntriesL(innerQuery1, resultArray);
+
+         const TInt resultCount = resultArray.Count();
+
+    if (resultCount  < mostUsedIdsSize) {
+    err = KErrNotFound;
+} else {
+    for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+            if (resultArray[resultCount - i - 1]->GetId() != mostUsedIds[i]) {
+                err = KErrGeneral;
+                break;
+            }
+        }
+    }
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery1);
+        );
+    __UHEAP_MARKEND;
+
+
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByLastUsedTimestamp()
+{
+    __UHEAP_MARK;
+
+    const TInt lastUsedIds[3] = {14, 9, 2};
+
+    const TInt lastUsedIdsSize = sizeof(lastUsedIds) / sizeof(TInt);
+
+    TInt err(KErrNone);
+
+    TRAP(err,
+
+    for (TInt i = lastUsedIdsSize - 1; i >= 0 ; --i) {
+    mStorage->TouchL(lastUsedIds[i], EFalse);
+    }
+
+    CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+    innerQuery->SetSort(CCaInnerQuery::LastUsedDesc);
+    RPointerArray<CCaInnerEntry> resultArray;
+    CleanupResetAndDestroyPushL(resultArray);
+
+
+    // get entries - last used descending
+    mStorage->GetEntriesL(innerQuery, resultArray);
+
+
+    if (resultArray.Count() < lastUsedIdsSize) {
+    err = KErrNotFound;
+} else {
+    for (TInt i = 0; i < lastUsedIdsSize; ++i) {
+            if (resultArray[i]->GetId() != lastUsedIds[i]) {
+                err = KErrGeneral;
+                break;
+            }
+        }
+    }
+
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery);
+        );
+
+
+    QCOMPARE(err, KErrNone);
+
+    TRAP(err,
+         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+         innerQuery->SetSort(CCaInnerQuery::LastUsed);
+         RPointerArray<CCaInnerEntry> resultArray;
+         CleanupResetAndDestroyPushL(resultArray);
+
+
+         // get entries - last used descending
+         mStorage->GetEntriesL(innerQuery, resultArray);
+
+         const TInt resultCount = resultArray.Count();
+
+    if (resultCount < lastUsedIdsSize) {
+    err = KErrNotFound;
+} else {
+    for (TInt i = 0; i < lastUsedIdsSize; ++i) {
+            if (resultArray[resultCount - 1 - i]->GetId() !=
+            lastUsedIds[i]) {
+                err = KErrGeneral;
+                break;
+            }
+        }
+    }
+
+
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery);
+        );
+
+    __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by default ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByDefault()
+{
+
+    __UHEAP_MARK;
+
+    TRAPD(err,
+
+          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+          query->SetQueryL(KSQLGetIdEntryFromSpecificGroup);
+          query->PrepareL();
+          query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
+          RArray<TInt> resultHelpArray;
+          CleanupClosePushL(resultHelpArray);
+          query->ExecuteL(resultHelpArray, CCaSqlQuery::EEntryTable);
+          query->CloseStatement();
+
+          CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+          innerQuery1->SetSort(CCaInnerQuery::Default);
+          innerQuery1->SetParentId(KAllCollectionsGroupId);
+
+          CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+          innerQuery2->SetSort(CCaInnerQuery::DefaultDesc);
+          innerQuery2->SetParentId(KAllCollectionsGroupId);
+
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+          // get entries - bu default from group
+          mStorage->GetEntriesL(innerQuery1, resultArray);
+
+          // check results - compare Entry_Id
+    for (TInt i=0; i<resultArray.Count(); i++) {
+    if (resultArray[i]->GetId() != resultHelpArray[i]) {
+            err = KErrWrongData;
+        }
+    }
+
+    if (!err) {
+    err = testSortingBySortOrder(innerQuery1, innerQuery2);
+    }
+
+    // clear after test
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(innerQuery2);
+    CleanupStack::PopAndDestroy(innerQuery1);
+    CleanupStack::PopAndDestroy(&resultHelpArray);
+    CleanupStack::PopAndDestroy(query);
+         );
+
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlags()
+{
+
+    __UHEAP_MARK;
+
+    TRAPD(err,
+
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+//    test all flags on in KMaxFlagsMask range
+    for (TUint flagsOnMask = 0; flagsOnMask <= KMaxFlagsMask; flagsOnMask++) {
+    RPointerArray<CCaInnerEntry> resultArray;
+    CleanupResetAndDestroyPushL(resultArray);
+        innerQuery->SetFlagsOn(flagsOnMask);
+        mStorage->GetEntriesL(innerQuery,resultArray);
+        TInt entryCount = resultArray.Count();
+        if (entryCount > 0) {
+            for (TInt j = 0; j < entryCount; j++) {
+                if (resultArray[j]->GetFlags() & flagsOnMask != flagsOnMask) {
+                    err = KErrWrongData;
+                }
+            }
+        }
+        innerQuery->SetFlagsOn(0);
+        CleanupStack::PopAndDestroy(&resultArray);
+    }
+
+//    test all flags off in KMaxFlagsMask range
+    for (TUint flagsOffMask = 0; flagsOffMask <= KMaxFlagsMask; flagsOffMask++) {
+    RPointerArray<CCaInnerEntry> resultArray;
+    CleanupResetAndDestroyPushL(resultArray);
+        innerQuery->SetFlagsOff(flagsOffMask);
+        mStorage->GetEntriesL(innerQuery,resultArray);
+        TInt entryCount = resultArray.Count();
+        if (entryCount > 0) {
+            for (TInt j = 0; j < entryCount; j++) {
+                if ((!resultArray[j]->GetFlags()) & flagsOffMask != flagsOffMask) {
+                    err = KErrWrongData;
+                }
+            }
+        }
+        innerQuery->SetFlagsOff(0);
+        CleanupStack::PopAndDestroy(&resultArray);
+    }
+
+//    test combination of flags on flags off
+    for (TUint flagsOnMask = 0; flagsOnMask <= KMaxFlagsMaskForCombinedTest; flagsOnMask++) {
+    for (TUint flagsOffMask = 0; flagsOffMask
+        <= KMaxFlagsMaskForCombinedTest; flagsOffMask++) {
+            RPointerArray<CCaInnerEntry> resultArray;
+            CleanupResetAndDestroyPushL(resultArray);
+            innerQuery->SetFlagsOff(flagsOffMask);
+            innerQuery->SetFlagsOn(flagsOnMask);
+            mStorage->GetEntriesL(innerQuery,resultArray);
+            TInt entryCount = resultArray.Count();
+            if (entryCount > 0) {
+                for (TInt j = 0; j < entryCount; j++) {
+                    if ((!resultArray[j]->GetFlags()) & flagsOffMask != flagsOffMask
+                    && resultArray[j]->GetFlags() & flagsOnMask != flagsOnMask) {
+                        err = KErrWrongData;
+                    }
+                }
+            }
+            innerQuery->SetFlagsOff(0);
+            innerQuery->SetFlagsOn(0);
+            CleanupStack::PopAndDestroy(&resultArray);
+        }
+    }
+
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries with flags which are on
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlagsOn()
+{
+
+    __UHEAP_MARK;
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+          RPointerArray<CCaInnerEntry> resultArrayTemp;
+          CleanupResetAndDestroyPushL(resultArrayTemp);
+          RArray<TInt> testEntries;
+          CleanupClosePushL(testEntries);
+
+          mStorage->GetEntriesL(innerQuery,resultArrayTemp);
+
+          TInt entryCount = resultArrayTemp.Count();
+
+          //    Change five random elements' flags
+          err = (entryCount >= 5) ? err : KErrNoData;
+          //    Set all flags on to test flags on.
+    for (TInt i = 0; i < entryCount; i++) {
+    resultArrayTemp[i]->SetFlags(0);
+        mStorage->AddL(resultArrayTemp[i]);
+    }
+
+    //    get random entries to test on
+    TInt testIdCount(0);
+    while (testEntries.Count() < 5) {
+    TInt randomEntryInArray = Math::Random() % entryCount;
+        TBool exists(EFalse);
+        for (TInt i = 0; i < testEntries.Count(); i++) {
+            if (testEntries[i]== randomEntryInArray) {
+                exists = ETrue;
+                break;
+            }
+        }
+        if (!exists) {
+            testEntries.AppendL(randomEntryInArray);
+        }
+    }
+
+    //    test flags on with flags from KFlagsOnTable
+
+    CCaInnerQuery *innerQueryFlagsOn = CCaInnerQuery::NewLC();
+    for (TInt j = 0; j < 5; j++) {
+    //      fill database with flag
+    for (TInt i = 0; i < 5; i++) {
+            TInt x = testEntries[i];
+            resultArrayTemp[x]->SetFlags(KFlagsOnTable[j]);
+            mStorage->AddL(resultArrayTemp[x]);
+        }
+
+        //      check filled database
+        RPointerArray<CCaInnerEntry> resultArrayFlagsOn;
+        CleanupResetAndDestroyPushL(resultArrayFlagsOn);
+        innerQueryFlagsOn->SetFlagsOn(KFlagsOnTable[j]);
+        mStorage->GetEntriesL(innerQueryFlagsOn,resultArrayFlagsOn);
+        TInt count = resultArrayFlagsOn.Count();
+        err = (resultArrayFlagsOn.Count() >= 5) ? err : KErrWrongData;
+
+        //        check that the right entries were fetched
+        for (TInt i = 0; i < 5; i++) {
+            for (TInt j = 0; j < resultArrayFlagsOn.Count(); j++) {
+                if (resultArrayFlagsOn[j]->GetId() ==
+                resultArrayTemp[testEntries[i]]->GetId()) {
+                    break;
+                } else if (j == resultArrayFlagsOn.Count()-1) {
+                    err = KErrWrongData;
+                }
+            }
+        }
+
+        CleanupStack::PopAndDestroy(&resultArrayFlagsOn);
+    }
+    CleanupStack::PopAndDestroy(innerQueryFlagsOn);
+    CleanupStack::PopAndDestroy(&testEntries);
+    CleanupStack::PopAndDestroy(&resultArrayTemp);
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries with flags which are off
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlagsOff()
+{
+    __UHEAP_MARK;
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+          RPointerArray<CCaInnerEntry> resultArrayTemp;
+          CleanupResetAndDestroyPushL(resultArrayTemp);
+          RArray<TInt> testEntries;
+          CleanupClosePushL(testEntries);
+
+          mStorage->GetEntriesL(innerQuery,resultArrayTemp);
+
+          TInt entryCount = resultArrayTemp.Count();
+
+          //    Change five random elements' flags
+          err = (entryCount >= 5) ? err : KErrNoData;
+          //    Set all flags off to test flags off assuming that there are 5 flags (63 bitwise)
+    for (TInt i = 0; i < entryCount; i++) {
+    resultArrayTemp[i]->SetFlags(63);
+        mStorage->AddL(resultArrayTemp[i]);
+    }
+
+    //    get random entries to test on
+    TInt testIdCount(0);
+    while (testEntries.Count() < 5) {
+    TInt randomEntryInArray = Math::Random() % entryCount;
+        TBool exists(EFalse);
+        for (TInt i = 0; i < testEntries.Count(); i++) {
+            if (testEntries[i]== randomEntryInArray) {
+                exists = ETrue;
+                break;
+            }
+        }
+        if (!exists) {
+            testEntries.AppendL(randomEntryInArray);
+        }
+    }
+
+    //    test flags on with flags from KFlagsOffTable
+
+    CCaInnerQuery *innerQueryFlagsOff = CCaInnerQuery::NewLC();
+    for (TInt j = 0; j < 5; j++) {
+    //      fill database with flag
+    for (TInt i = 0; i < 5; i++) {
+            TInt x = testEntries[i];
+            resultArrayTemp[x]->SetFlags(KFlagsOffTable[j]);
+            mStorage->AddL(resultArrayTemp[x]);
+        }
+
+        //      check filled database
+        RPointerArray<CCaInnerEntry> resultArrayFlagsOff;
+        CleanupResetAndDestroyPushL(resultArrayFlagsOff);
+        innerQueryFlagsOff->SetFlagsOff(KFlagsOffTableMasks[j]);
+        mStorage->GetEntriesL(innerQueryFlagsOff,resultArrayFlagsOff);
+        TInt count = resultArrayFlagsOff.Count();
+        err = (resultArrayFlagsOff.Count() >= 5) ? err : KErrWrongData;
+
+        //        check that the right entries were fetched
+        for (TInt i = 0; i < 5; i++) {
+            for (TInt j = 0; j < resultArrayFlagsOff.Count(); j++) {
+                if (resultArrayFlagsOff[j]->GetId() ==
+                resultArrayTemp[testEntries[i]]->GetId()) {
+                    break;
+                } else if (j == resultArrayFlagsOff.Count()-1) {
+                    err = KErrWrongData;
+                }
+            }
+        }
+
+        CleanupStack::PopAndDestroy(&resultArrayFlagsOff);
+    }
+    CleanupStack::PopAndDestroy(innerQueryFlagsOff);
+    CleanupStack::PopAndDestroy(&testEntries);
+    CleanupStack::PopAndDestroy(&resultArrayTemp);
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+    QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries by uid.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByUid()
+{
+    __UHEAP_MARK;
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+          innerQuery->SetUid(KCalendarAppUid);
+
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+          mStorage->GetEntriesL(innerQuery,resultArray);
+
+          TInt entryCount = resultArray.Count();
+
+          err = (entryCount == 1 && resultArray[0]->GetUid() == KCalendarAppUid)
+                ? err : KErrWrongData;
+
+          CleanupStack::PopAndDestroy(&resultArray);
+          CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries by uid.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesIds()
+{
+    __UHEAP_MARK;
+
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+          RArray<TInt> idArray;
+          CleanupClosePushL(idArray);
+
+          mStorage->GetEntriesIdsL(innerQuery,idArray);
+
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+          mStorage->GetEntriesL(innerQuery,resultArray);
+
+          err = (idArray.Count() > 0) ? err : KErrNoData;
+    if (!err) {
+    err = (idArray.Count() == resultArray.Count()) ? err : KErrWrongData;
+    }
+
+    CleanupStack::PopAndDestroy(&resultArray);
+    CleanupStack::PopAndDestroy(&idArray);
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetNewEntryWithAttributes()
+{
+    __UHEAP_MARK;
+    TInt err(KErrGeneral);
+    TRAP(err,
+         // Check database entries count
+         CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+         query->SetQueryL(KSQLGetIdCountFromEntryTable);
+         query->PrepareL();
+         TInt entriesCount(0);
+         query->ExecuteL(entriesCount);
+         CleanupStack::PopAndDestroy(query);
+
+
+         // add new entry with attributes
+         CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
+         RPointerArray<CCaInnerEntry> innerEntryArray;
+         CleanupResetAndDestroyPushL(innerEntryArray);
+         innerEntryArray.AppendL(innerEntry);
+
+         innerEntry->SetTextL(KTestName);
+         innerEntry->SetEntryTypeNameL(KTypeName);
+         innerEntry->SetFlags(flag);
+         innerEntry->SetRole(CCaInnerQuery::Item);
+         innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+         innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+         innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+         innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+         mStorage->AddL(innerEntry);
+         CleanupStack::PopAndDestroy(&innerEntryArray);
+
+
+         // get new entry with attributes
+         RPointerArray<CCaInnerEntry> resultArray;
+         CleanupResetAndDestroyPushL(resultArray);
+         RArray<TInt> idArray;
+         CleanupClosePushL(idArray);
+         idArray.AppendL(entriesCount + 1);   // new entry
+
+         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+         innerQuery->SetIdsL(idArray);
+
+         mStorage->GetEntriesL(innerQuery, resultArray);
+
+         // check results
+         TInt attributesCount = resultArray[0]->GetAttributes().Count();
+
+    if (attributesCount == 3) {
+    err = KErrNone;
+} else {
+    err = KErrGeneral;
+}
+
+// clear after test
+CleanupStack::PopAndDestroy(innerQuery);
+CleanupStack::PopAndDestroy(&idArray);
+CleanupStack::PopAndDestroy(&resultArray);
+    );
+
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetNewEntryWithAttributesByUid()
+{
+    __UHEAP_MARK;
+
+    TInt err(KErrGeneral);
+
+    TRAP(err,
+         // add new entry with attributes
+         CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
+         RPointerArray<CCaInnerEntry> innerEntryArray;
+         CleanupResetAndDestroyPushL(innerEntryArray);
+         innerEntryArray.AppendL(innerEntry);
+
+         innerEntry->SetTextL(KTestName);
+         innerEntry->SetEntryTypeNameL(KTypeName2);
+         innerEntry->SetFlags(flag);
+         innerEntry->SetRole(CCaInnerQuery::Item);
+         innerEntry->SetUid(KTestAppUid);
+         innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+         innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+         innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+         innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+         mStorage->AddL(innerEntry);
+         CleanupStack::PopAndDestroy(&innerEntryArray);
+
+
+         // get new entry with attributes by uid
+         RPointerArray<CCaInnerEntry> resultArray;
+         CleanupResetAndDestroyPushL(resultArray);
+         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+         innerQuery->SetUid(KTestAppUid);
+
+         mStorage->GetEntriesL(innerQuery, resultArray);
+
+         // check results
+         TInt attributesCount = resultArray[0]->GetAttributes().Count();
+
+    if (attributesCount == 3) {
+    err = KErrNone;
+} else {
+    err = KErrGeneral;
+}
+
+// clear after test
+CleanupStack::PopAndDestroy(innerQuery);
+CleanupStack::PopAndDestroy(&resultArray);
+    );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries with limit.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesWhenLimitSetTo()
+{
+
+
+    QList<int> entryCountList;
+    entryCountList << 5 << -15 << 0 << 50;
+    __UHEAP_MARK;
+
+    int limit(0);
+    foreach(limit, entryCountList) {
+        // Check database entries count
+        TRAPD(err,
+              CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+              query->SetQueryL(KSQLGetIdCountFromEntryTable);
+              query->PrepareL();
+              TInt entriesCount(0);
+              query->ExecuteL(entriesCount);
+              CleanupStack::PopAndDestroy(query);
+
+              RPointerArray<CCaInnerEntry> resultArray;
+              CleanupResetAndDestroyPushL(resultArray);
+              CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+              innerQuery->SetCount(limit);
+
+              // limit is set to stif parser param
+              mStorage->GetEntriesL(innerQuery, resultArray);
+
+
+              // check results
+        if ((0 < limit) && (limit <= entriesCount)) {
+        if (resultArray.Count() == innerQuery->GetCount()) {
+                err = KErrNone;
+            } else {
+                err = KErrGeneral;
+            }
+        } else {
+            if (resultArray.Count() == entriesCount) {
+                err = KErrNone;
+            } else {
+                err = KErrGeneral;
+            }
+        }
+
+        // clear after test
+        CleanupStack::PopAndDestroy(innerQuery);
+        CleanupStack::PopAndDestroy(&resultArray);
+             );
+        // limit added to make easier to identify where failure occured
+        QCOMPARE(err + limit, KErrNone + limit);
+    }
+    __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by role.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByRole()
+{
+
+
+    __UHEAP_MARK;
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+          RPointerArray<CCaInnerEntry> resultArrayGroups;
+          CleanupResetAndDestroyPushL(resultArrayGroups);
+          innerQuery->SetRole(CCaInnerQuery::Group);
+          mStorage->GetEntriesL(innerQuery, resultArrayGroups);
+          TInt groupsCount = resultArrayGroups.Count();
+          CleanupStack::PopAndDestroy(&resultArrayGroups);
+
+          RPointerArray<CCaInnerEntry> resultArrayItems;
+          CleanupResetAndDestroyPushL(resultArrayItems);
+          innerQuery->SetRole(CCaInnerQuery::Item);
+          mStorage->GetEntriesL(innerQuery, resultArrayItems);
+          TInt itemsCount = resultArrayItems.Count();
+//    changes the role of two items to be groups
+
+          resultArrayItems[0]->SetRole(CCaInnerQuery::Group);
+          resultArrayItems[1]->SetRole(CCaInnerQuery::Group);
+          TInt entry1Id = resultArrayItems[0]->GetId();
+          TInt entry2Id = resultArrayItems[1]->GetId();
+          mStorage->AddL(resultArrayItems[0]);
+          mStorage->AddL(resultArrayItems[1]);
+          CleanupStack::PopAndDestroy(&resultArrayItems);
+
+          RPointerArray<CCaInnerEntry> resultArrayGroups2;
+          CleanupResetAndDestroyPushL(resultArrayGroups2);
+          innerQuery->SetRole(CCaInnerQuery::Group);
+          mStorage->GetEntriesL(innerQuery, resultArrayGroups2);
+          TInt groupsCountAfterModifyRole = resultArrayGroups2.Count();
+          err = (groupsCountAfterModifyRole == groupsCount + 2)? err : KErrWrongData;
+
+//    Check that entry 1 is now group
+    for (TInt i = 0; i < groupsCountAfterModifyRole; i++) {
+    if (resultArrayGroups2[i]->GetId() == entry1Id) {
+            break;
+        } else if (i == groupsCountAfterModifyRole - 1) {
+            err = KErrWrongData;
+        }
+    }
+
+//    Check that entry 2 is now group
+    for (TInt i = 0; i < groupsCountAfterModifyRole; i++) {
+    if (resultArrayGroups2[i]->GetId() == entry2Id) {
+            break;
+        } else if (i == groupsCountAfterModifyRole - 1) {
+            err = KErrWrongData;
+        }
+    }
+
+    CleanupStack::PopAndDestroy(&resultArrayGroups2);
+
+    RPointerArray<CCaInnerEntry> resultArrayItems2;
+    CleanupResetAndDestroyPushL(resultArrayItems2);
+    innerQuery->SetRole(CCaInnerQuery::Item);
+    mStorage->GetEntriesL(innerQuery, resultArrayItems2);
+    TInt itemsCountAfterModifyRole = resultArrayItems2.Count();
+    err = (itemsCountAfterModifyRole == itemsCount - 2)? err : KErrWrongData;
+    CleanupStack::PopAndDestroy(&resultArrayItems2);
+
+    CleanupStack::PopAndDestroy(innerQuery);
+         );
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+}
+
+void CCAStorageTest::testGetEntriesByAttributes()
+{
+    __UHEAP_MARK;
+    int uid;
+    TInt attributesCount;
+    TInt attributesCountFromQuery;
+    TRAPD(err,
+    
+        // add new entry with attributes
+        CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+        
+        innerEntry->SetTextL(KTestName);
+        innerEntry->SetEntryTypeNameL(KTypeName2);
+        innerEntry->SetFlags(flag);
+        innerEntry->SetRole(CCaInnerQuery::Item);
+        innerEntry->SetUid(KTestAppUid);
+         innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+    
+        innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+        innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+        innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+            
+        mStorage->AddL(innerEntry);
+        
+        CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+        innerQuery->AddAttributeL(KAttrName_2, KAttrValue_2);
+        innerQuery->AddAttributeL(KAttrName_3, KAttrValue_3);
+        attributesCountFromQuery = innerQuery->GetAttributes().Count();
+         
+        // get entries by attributes
+        RPointerArray<CCaInnerEntry> resultArrayItems;
+        CleanupResetAndDestroyPushL(resultArrayItems);
+        mStorage->GetEntriesL(innerQuery, resultArrayItems);
+        
+        if( resultArrayItems.Count() )
+            {
+            uid = resultArrayItems[0]->GetUid();
+            attributesCount = resultArrayItems[0]->GetAttributes().Count();
+            }
+        
+        CleanupStack::PopAndDestroy(&resultArrayItems);
+        CleanupStack::PopAndDestroy(innerQuery);    
+        CleanupStack::PopAndDestroy(innerEntry);
+    );
+    __UHEAP_MARKEND;
+    
+    QCOMPARE(uid, KTestAppUid);
+    QCOMPARE((attributesCount-1), attributesCountFromQuery);
+    QCOMPARE(err, KErrNone);
+}
+
+void CCAStorageTest::testGetEntriesByAttributes2()
+{
+    __UHEAP_MARK;
+    int getEntriesCount;
+    TRAPD(err,
+    
+        // add new entry with attributes
+        CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+        
+        innerEntry->SetTextL(KTestName);
+        innerEntry->SetEntryTypeNameL(KTypeName2);
+        innerEntry->SetFlags(flag);
+        innerEntry->SetRole(CCaInnerQuery::Item);
+        innerEntry->SetUid(KTestAppUid);
+         innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+    
+        innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+        innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+        innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+            
+        mStorage->AddL(innerEntry);
+        
+        // add new entry with attributes
+        CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
+        
+        innerEntry2->SetTextL(KTestName2);
+        innerEntry2->SetEntryTypeNameL(KTypeName2);
+        innerEntry2->SetFlags(flag);
+        innerEntry2->SetRole(CCaInnerQuery::Item);
+        innerEntry2->SetUid(KTestAppUid2);
+
+        // add new entry with attributes
+        innerEntry2->AddAttributeL(KAttrName_1, KAttrValue_1);
+        innerEntry2->AddAttributeL(KAttrName_2, KAttrValue_2);
+            
+        mStorage->AddL(innerEntry2);
+        
+        CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+        innerQuery->AddAttributeL(KAttrName_1, KAttrValue_1);
+        innerQuery->AddAttributeL(KAttrName_2, KAttrValue_2);
+         
+        // get entries by attributes
+        RPointerArray<CCaInnerEntry> resultArrayItems;
+        CleanupResetAndDestroyPushL(resultArrayItems);
+        mStorage->GetEntriesL(innerQuery, resultArrayItems);
+        
+        TInt attributesCount = resultArrayItems[0]->GetAttributes().Count();
+        getEntriesCount = resultArrayItems.Count();
+        
+        CleanupStack::PopAndDestroy(&resultArrayItems);
+        CleanupStack::PopAndDestroy(innerQuery);
+        CleanupStack::PopAndDestroy(innerEntry2);
+        CleanupStack::PopAndDestroy(innerEntry);
+    );
+    __UHEAP_MARKEND;
+    
+    QCOMPARE(getEntriesCount, 2);
+    QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by child id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByChildId()
+{
+    TInt expectedGroupEntryCount(0);
+    TInt actualGroupEntryCount(0);
+
+    __UHEAP_MARK;
+
+    TRAPD(err,
+          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+          // check before test entries count in sfecific group
+          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+          query->SetQueryL(KSQLGetEntriesCountAsParentsForSpecificEntry);
+          query->PrepareL();
+          query->BindIntL(query->iStatement.ParameterIndex(KSQLGEEntryId), 7);
+
+          query->ExecuteL(expectedGroupEntryCount);
+
+          CleanupStack::PopAndDestroy(query);
+
+          innerQuery->SetChildId(7);
+
+          // get entries from specific group
+          RPointerArray<CCaInnerEntry> resultArray;
+          CleanupResetAndDestroyPushL(resultArray);
+
+          mStorage->GetEntriesL(innerQuery, resultArray);
+
+          actualGroupEntryCount =  resultArray.Count();
+
+          CleanupStack::PopAndDestroy(&resultArray);
+          CleanupStack::PopAndDestroy(innerQuery);
+         );
+
+    __UHEAP_MARKEND;
+
+    QCOMPARE(err, KErrNone);
+    QCOMPARE(actualGroupEntryCount, expectedGroupEntryCount);
+}
+