/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#define QT_STATICPLUGIN

#include <QtTest/QtTest>

#include "qtcontacts.h"

#include "qcontactmanagerdataholder.h" //QContactManagerDataHolder

//TESTED_CLASS=

//TESTED_FILES=

QTM_USE_NAMESPACE

/*

 * This test is mostly just for testing sorting and filtering -

 * having it in tst_QContactManager makes maintenance more

 * difficult!

 */

Q_DECLARE_METATYPE(QVariant)

Q_DECLARE_METATYPE(QContactManager*)

Q_DECLARE_METATYPE(QList<QContactLocalId>)

/*

 * Global variables:

 * These are the definition and field names used by the actions for their matching.

 */

QMap<QString, QPair<QString, QString> > defAndFieldNamesForTypeForActions;

/*

 * We use this code to compare the output and expected lists of filtering

 * where no sort order is implied.

 * TODO: use this instead of QCOMPARE in the various filtering tests!

 */

#define QCOMPARE_UNSORTED(output, expected) if (output.size() != expected.size()) { \

                                                QCOMPARE(output, expected); \

                                            } else { \

                                                for (int i = 0; i < output.size(); i++) { \

                                                    if (!expected.contains(output.at(i))) { \

                                                        QCOMPARE(output, expected); \

                                                    } \

                                                } \

                                            }

class tst_QContactManagerFiltering : public QObject

{

Q_OBJECT

public:

    tst_QContactManagerFiltering();

    virtual ~tst_QContactManagerFiltering();

private:

    void dumpContactDifferences(const QContact& a, const QContact& b);

    void dumpContact(const QContact &c);

    void dumpContacts();

    bool isSuperset(const QContact& ca, const QContact& cb);

    QPair<QString, QString> definitionAndField(QContactManager *cm, QVariant::Type type, bool *nativelyFilterable);

    QList<QContactLocalId> prepareModel(QContactManager* cm); // add the standard contacts

    QString convertIds(QList<QContactLocalId> allIds, QList<QContactLocalId> ids); // convert back to "abcd"

    QContact createContact(QContactManager* cm, QString type, QString name);

    QMap<QContactManager*, QMap<QString, QPair<QString, QString> > > defAndFieldNamesForTypePerManager;

    QMultiMap<QContactManager*, QContactLocalId> contactsAddedToManagers;

    QMultiMap<QContactManager*, QString> detailDefinitionsAddedToManagers;

    QList<QContactManager*> managers;

    QContactManagerDataHolder managerDataHolder;

    QTestData& newMRow(const char *tag, QContactManager *cm);

private slots:

    void rangeFiltering(); // XXX should take all managers

    void rangeFiltering_data();

    void detailStringFiltering(); // XXX should take all managers

    void detailStringFiltering_data();

    void actionPlugins();

    void actionFiltering();

    void actionFiltering_data();

    void detailVariantFiltering();

    void detailVariantFiltering_data();

    void intersectionFiltering();

    void intersectionFiltering_data();

    void unionFiltering();

    void unionFiltering_data();

    void relationshipFiltering();

    void relationshipFiltering_data();

    void changelogFiltering();

    void changelogFiltering_data();

    void idListFiltering();

    void idListFiltering_data();

    void sorting(); // XXX should take all managers

    void sorting_data();

    void multiSorting();

    void multiSorting_data();

    void invalidFiltering_data();

    void invalidFiltering();

    void allFiltering_data();

    void allFiltering();

};

tst_QContactManagerFiltering::tst_QContactManagerFiltering()

{

    // firstly, build a list of the managers we wish to test.

    QStringList managerNames = QContactManager::availableManagers();

    /* Known one that will not pass */

    managerNames.removeAll("invalid");

    managerNames.removeAll("testdummy");

    managerNames.removeAll("teststaticdummy");

    managerNames.removeAll("maliciousplugin");

    foreach(QString mgr, managerNames) {

        QMap<QString, QString> params;

        QString mgrUri = QContactManager::buildUri(mgr, params);

        QContactManager* cm = QContactManager::fromUri(mgrUri);

        cm->setObjectName(mgr);

        managers.append(cm);

        if (mgr == "memory") {

            params.insert("id", "tst_QContactManager");

            mgrUri = QContactManager::buildUri(mgr, params);

            cm = QContactManager::fromUri(mgrUri);

            cm->setObjectName("memory[params]");

            managers.append(cm);

        }

    }

    // for each manager that we wish to test, prepare the model.

    foreach (QContactManager* cm, managers) {

        QList<QContactLocalId> addedContacts = prepareModel(cm);

        if (addedContacts != contactsAddedToManagers.values(cm)) {

            qDebug() << "prepareModel returned:" << addedContacts;

            qDebug() << "contactsAdded are:    " << contactsAddedToManagers.values(cm);

            Q_ASSERT_X(false, "prepareModel", "returned list different from saved contacts list!");

        }

    }

    qDebug() << "Finished preparing each manager for test!";

}

tst_QContactManagerFiltering::~tst_QContactManagerFiltering()

{

    // first, remove any contacts that we've added to any managers.

    foreach (QContactManager* manager, managers) {

        QList<QContactLocalId> contactIds = contactsAddedToManagers.values(manager);

        foreach (const QContactLocalId& cid, contactIds) {

            manager->removeContact(cid);

        }

    }

    contactsAddedToManagers.clear();

    // then, remove any detail definitions that we've added.

    foreach (QContactManager* manager, managers) {

        QStringList definitionNames = detailDefinitionsAddedToManagers.values(manager);

        foreach (const QString& definitionName, definitionNames) {

            manager->removeDetailDefinition(definitionName);

        }

    }

    detailDefinitionsAddedToManagers.clear();

    // finally, we can delete all of our manager instances

    qDeleteAll(managers);

    managers.clear();

    defAndFieldNamesForTypePerManager.clear();

}

QString tst_QContactManagerFiltering::convertIds(QList<QContactLocalId> allIds, QList<QContactLocalId> ids)

{

    QString ret;

    /* Expected is of the form "abcd".. it's possible that there are some extra contacts */

    for (int i = 0; i < ids.size(); i++) {

        if (allIds.indexOf(ids.at(i)) >= 0)

            ret += ('a' + allIds.indexOf(ids.at(i)));

    }

    return ret;

}

QTestData& tst_QContactManagerFiltering::newMRow(const char *tag, QContactManager *cm)

{

    // allocate a tag

    QString foo = QString("%1[%2]").arg(tag).arg(cm->objectName());

    return QTest::newRow(foo.toAscii().constData());

}

void tst_QContactManagerFiltering::detailStringFiltering_data()

{

    QTest::addColumn<QContactManager *>("cm");

    QTest::addColumn<QString>("defname");

    QTest::addColumn<QString>("fieldname");

    QTest::addColumn<QVariant>("value");

    QTest::addColumn<int>("matchflags");

    QTest::addColumn<QString>("expected");

    QVariant ev; // empty variant

    QString es; // empty string

    QString name = QContactName::DefinitionName;

    QString firstname = QContactName::FieldFirstName;

    QString lastname = QContactName::FieldLastName;

    QString middlename = QContactName::FieldMiddleName;

    QString prefixname = QContactName::FieldPrefix;

    QString suffixname = QContactName::FieldSuffix;

    QString nickname = QContactNickname::DefinitionName;

    QString nicknameField = QContactNickname::FieldNickname;

    QString emailaddr = QContactEmailAddress::DefinitionName;

    QString emailfield = QContactEmailAddress::FieldEmailAddress;

    QString phonenumber = QContactPhoneNumber::DefinitionName;

    QString number = QContactPhoneNumber::FieldNumber;

    for (int i = 0; i < managers.size(); i++) {

        QContactManager *manager = managers.at(i);

        newMRow("Name == Aaro", manager) << manager << name << firstname << QVariant("Aaro") << 0 << es;

        newMRow("Name == Aaron", manager) << manager << name << firstname << QVariant("Aaron") << 0 << "a";

        newMRow("Name == aaron", manager) << manager << name << firstname << QVariant("aaron") << 0 << "a";

        newMRow("Name == Aaron, case sensitive", manager) << manager << name << firstname << QVariant("Aaron") << (int)(Qt::MatchCaseSensitive) << "a";

        newMRow("Name == aaron, case sensitive", manager) << manager << name << firstname << QVariant("aaron") << (int)(Qt::MatchCaseSensitive) << es;

        newMRow("Name == A, begins", manager) << manager << name << firstname << QVariant("A") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Name == Aaron, begins", manager) << manager << name << firstname << QVariant("Aaron") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Name == aaron, begins", manager) << manager << name << firstname << QVariant("aaron") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Name == Aaron, begins, case sensitive", manager) << manager << name << firstname << QVariant("Aaron") << (int)(Qt::MatchStartsWith | Qt::MatchCaseSensitive) << "a";

        newMRow("Name == aaron, begins, case sensitive", manager) << manager << name << firstname << QVariant("aaron") << (int)(Qt::MatchStartsWith | Qt::MatchCaseSensitive) << es;

        newMRow("Name == Aaron1, begins", manager) << manager << name << firstname << QVariant("Aaron1") << (int)(Qt::MatchStartsWith) << es;

        newMRow("Last name == A, begins", manager) << manager << name << lastname << QVariant("A") << (int)(Qt::MatchStartsWith) << "abc";

        newMRow("Last name == Aaronson, begins", manager) << manager << name << lastname << QVariant("Aaronson") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Last Name == Aaronson1, begins", manager) << manager << name << lastname << QVariant("Aaronson1") << (int)(Qt::MatchStartsWith) << es;

        newMRow("Name == Aar, begins", manager) << manager << name << firstname << QVariant("Aar") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Name == aar, begins", manager) << manager << name << firstname << QVariant("aar") << (int)(Qt::MatchStartsWith) << "a";

        newMRow("Name == Aar, begins, case sensitive", manager) << manager << name << firstname << QVariant("Aar") << (int)(Qt::MatchStartsWith | Qt::MatchCaseSensitive) << "a";

        newMRow("Name == aar, begins, case sensitive", manager) << manager << name << firstname << QVariant("aar") << (int)(Qt::MatchStartsWith | Qt::MatchCaseSensitive) << es;

        newMRow("Name == aro, contains", manager) << manager << name << firstname << QVariant("aro") << (int)(Qt::MatchContains) << "a";

        newMRow("Name == ARO, contains", manager) << manager << name << firstname << QVariant("ARO") << (int)(Qt::MatchContains) << "a";

        newMRow("Name == aro, contains, case sensitive", manager) << manager << name << firstname << QVariant("aro") << (int)(Qt::MatchContains | Qt::MatchCaseSensitive) << "a";

        newMRow("Name == ARO, contains, case sensitive", manager) << manager << name << firstname << QVariant("ARO") << (int)(Qt::MatchContains | Qt::MatchCaseSensitive) << es;

        newMRow("Name == ron, ends", manager) << manager << name << firstname << QVariant("ron") << (int)(Qt::MatchEndsWith) << "a";

        newMRow("Name == ARON, ends", manager) << manager << name << firstname << QVariant("ARON") << (int)(Qt::MatchEndsWith) << "a";

        newMRow("Name == aron, ends, case sensitive", manager) << manager << name << firstname << QVariant("aron") << (int)(Qt::MatchEndsWith | Qt::MatchCaseSensitive) << "a";

        newMRow("Name == ARON, ends, case sensitive", manager) << manager << name << firstname << QVariant("ARON") << (int)(Qt::MatchEndsWith | Qt::MatchCaseSensitive) << es;

        newMRow("Last name == n, ends", manager) << manager << name << lastname << QVariant("n") << (int)(Qt::MatchEndsWith) << "abc";

        newMRow("Name == Aaron, fixed", manager) << manager << name << firstname << QVariant("Aaron") << (int)(Qt::MatchFixedString) << "a";

        newMRow("Name == aaron, fixed", manager) << manager << name << firstname << QVariant("aaron") << (int)(Qt::MatchFixedString) << "a";

        newMRow("Name == Aaron, fixed, case sensitive", manager) << manager << name << firstname << QVariant("Aaron") << (int)(Qt::MatchFixedString | Qt::MatchCaseSensitive) << "a";

        newMRow("Name == aaron, fixed, case sensitive", manager) << manager << name << firstname << QVariant("aaron") << (int)(Qt::MatchFixedString | Qt::MatchCaseSensitive) << es;

        // middle name

        newMRow("MName == Arne", manager) << manager << name << middlename << QVariant("Arne") << (int)(Qt::MatchContains) << "a";

		// prefix

        newMRow("Prefix == Sir", manager) << manager << name << prefixname << QVariant("Sir") << (int)(Qt::MatchContains) << "a";

		// prefix

        newMRow("Suffix == Dr.", manager) << manager << name << suffixname << QVariant("Dr.") << (int)(Qt::MatchContains) << "a";

		// nickname

        newMRow("Nickname detail exists", manager) << manager << nickname << es << QVariant() << 0 << "ab";

        newMRow("Nickname == Aaron, contains", manager) << manager << nickname << nicknameField << QVariant("Aaron") << (int)(Qt::MatchContains) << "a";

        // email

        newMRow("Email == Aaron@Aaronson.com", manager) << manager << emailaddr << emailfield << QVariant("Aaron@Aaronson.com") << 0 << "a";

        newMRow("Email == Aaron@Aaronsen.com", manager) << manager << emailaddr << emailfield << QVariant("Aaron@Aaronsen.com") << 0 << es;

        // phone number

        newMRow("Phone number detail exists", manager) << manager << phonenumber << es << QVariant("") << 0 << "ab";

        newMRow("Phone number = 555-1212", manager) << manager << phonenumber << number << QVariant("555-1212") << (int) QContactFilter::MatchExactly << "a";

        newMRow("Phone number = 34, contains", manager) << manager << phonenumber << number << QVariant("34") << (int) QContactFilter::MatchContains << "b";

        newMRow("Phone number = 555, starts with", manager) << manager << phonenumber << number << QVariant("555") <<  (int) QContactFilter::MatchStartsWith << "ab";

        newMRow("Phone number = 1212, ends with", manager) << manager << phonenumber << number << QVariant("1212") << (int) QContactFilter::MatchEndsWith << "a";

        newMRow("Phone number = 555-1212, match phone number", manager) << manager << phonenumber << number << QVariant("555-1212") << (int) QContactFilter::MatchPhoneNumber << "a";

        /* Converting other types to strings */

        QPair<QString, QString> defAndFieldNames = defAndFieldNamesForTypePerManager.value(manager).value("Integer");

        if (!defAndFieldNames.first.isEmpty() && !defAndFieldNames.second.isEmpty()) {

            QTest::newRow("integer == 20") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("20") << 0 << es;

            QTest::newRow("integer == 20, as string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("20") << (int)(Qt::MatchFixedString) << "b";

            QTest::newRow("integer == 20, begins with, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("20") << (int)(Qt::MatchFixedString | Qt::MatchStartsWith) << "b";

            QTest::newRow("integer == 2, begins with, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("2") << (int)(Qt::MatchFixedString | Qt::MatchStartsWith) << "b";

            QTest::newRow("integer == 20, ends with, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("20") << (int)(Qt::MatchFixedString | Qt::MatchEndsWith) << "bc";

            QTest::newRow("integer == 0, ends with, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("0") << (int)(Qt::MatchFixedString | Qt::MatchEndsWith) << "abc";

            QTest::newRow("integer == 20, contains, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("20") << (int)(Qt::MatchFixedString | Qt::MatchContains) << "bc";

            QTest::newRow("integer == 0, contains, string") << manager << defAndFieldNames.first << defAndFieldNames.second << QVariant("0") << (int)(Qt::MatchFixedString | Qt::MatchContains) << "abc";

        }

    }

}

void tst_QContactManagerFiltering::detailStringFiltering()

{

    QFETCH(QContactManager*, cm);

    QFETCH(QString, defname);

    QFETCH(QString, fieldname);

    QFETCH(QVariant, value);

    QFETCH(QString, expected);

    QFETCH(int, matchflags);

    QList<QContactLocalId> contacts = contactsAddedToManagers.values(cm);

    QList<QContactLocalId> ids;

    QContactDetailFilter df;

    df.setDetailDefinitionName(defname, fieldname);

    df.setValue(value);

    df.setMatchFlags(QContactFilter::MatchFlags(matchflags));

    if (cm->managerName() == "memory") {

        /* At this point, since we're using memory, assume the filter isn't really supported */

        QVERIFY(cm->isFilterSupported(df) == false);

    }

    ids = cm->contactIds(df);

    QString output = convertIds(contacts, ids);

    QEXPECT_FAIL("integer == 20", "Not sure if this should pass or fail", Continue);

    QCOMPARE_UNSORTED(output, expected);

}

void tst_QContactManagerFiltering::detailVariantFiltering_data()

{

    QTest::addColumn<QContactManager *>("cm");

    QTest::addColumn<QString>("defname");

    QTest::addColumn<QString>("fieldname");

    QTest::addColumn<bool>("setValue");

    QTest::addColumn<QVariant>("value");

    QTest::addColumn<QString>("expected");

    QVariant ev; // empty variant

    QString es; // empty string

    for (int i = 0; i < managers.size(); i++) {

        QContactManager *manager = managers.at(i);

        /* Nothings */

        newMRow("no name", manager) << manager << es << es << false << ev << es;

        newMRow("no def name", manager) << manager << es << "value" << false << ev << es;

        /* Strings (name) */

        newMRow("first name presence", manager) << manager << "Name" << QString(QLatin1String(QContactName::FieldFirstName)) << false << ev << "abcdefg";

        newMRow("first name == Aaron", manager) << manager << "Name" << QString(QLatin1String(QContactName::FieldFirstName)) << true << QVariant("Aaron") << "a";

        /*