/*
* 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);
}