/*

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