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

**

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

/*

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

    QScopedPointer<QContactManagerDataHolder> managerDataHolder;

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

private slots:

    void initTestCase();

    void cleanupTestCase();

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

    void rangeFiltering_data();

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

    void detailStringFiltering_data();

    void detailPhoneNumberFiltering();

    void detailPhoneNumberFiltering_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()

{

}

tst_QContactManagerFiltering::~tst_QContactManagerFiltering()

{

}

void tst_QContactManagerFiltering::initTestCase()

{

    managerDataHolder.reset(new QContactManagerDataHolder());

    // 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");

#if defined(Q_OS_SYMBIAN)

    // TODO: Analyze fails on symbiansim backend. Simply disable testing of

    // symbiansim backend for now to make sure the fails do not steal attention

    // from possible fails in symbian backend.

    managerNames.removeAll("symbiansim");

#endif

    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!";

}

void tst_QContactManagerFiltering::cleanupTestCase()

{

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

    foreach (QContactManager* manager, managers) {

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

        manager->removeContacts(contactIds, 0);

    }

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

    // And restore old contacts

    managerDataHolder.reset(0);

}

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

        if (manager->detailDefinitions().value(QContactName::DefinitionName).fields().contains(QContactName::FieldMiddleName))

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

        // prefix

        if (manager->detailDefinitions().value(QContactName::DefinitionName).fields().contains(QContactName::FieldPrefix))

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

        // suffix

        if (manager->detailDefinitions().value(QContactName::DefinitionName).fields().contains(QContactName::FieldSuffix))

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

        // nickname

        if (manager->detailDefinitions().contains(QContactNickname::DefinitionName)) {

            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

        if (manager->detailDefinitions().contains(QContactEmailAddress::DefinitionName)) {

            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

        if (manager->detailDefinitions().contains(QContactPhoneNumber::DefinitionName)) {

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

            newMRow("Phone number = 5551212", manager) << manager << phonenumber << number << QVariant("5551212") << (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"; // hyphens will be ignored by the match algorithm

            newMRow("Phone number = 555, keypad collation", manager) << manager << phonenumber << number << QVariant("555") << (int) (QContactFilter::MatchKeypadCollation | QContactFilter::MatchStartsWith) << "ab";

        }

        /* 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::detailPhoneNumberFiltering_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");

    // ITU-T standard keypad collation:

    // 2 = abc, 3 = def, 4 = ghi, 5 = jkl, 6 = mno, 7 = pqrs, 8 = tuv, 9 = wxyz, 0 = space

    QString phoneDef = QContactPhoneNumber::DefinitionName;

    QString phoneField = QContactPhoneNumber::FieldNumber;

    QString nameDef = QContactName::DefinitionName;

    QString nameField = QContactName::FieldFirstName; // just test the first name.

    // purely to test phone number filtering.

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

        QContactManager *manager = managers.at(i);

        // first, keypad collation testing (ITU-T / T9 testing)

        QTest::newRow("t9 aaron") << manager << nameDef << nameField << QVariant(QString("22766")) << (int)(QContactFilter::MatchKeypadCollation) << "a";

        QTest::newRow("t9 bob") << manager << nameDef << nameField << QVariant(QString("262")) << (int)(QContactFilter::MatchKeypadCollation) << "b";

        QTest::newRow("t9 john") << manager << nameDef << nameField << QVariant(QString("5646")) << (int)(QContactFilter::MatchKeypadCollation) << "efg";

        QTest::newRow("t9 bo") << manager << nameDef << nameField << QVariant(QString("26")) << (int)(QContactFilter::MatchKeypadCollation | QContactFilter::MatchStartsWith) << "bc"; // bob, boris

        QTest::newRow("t9 zzzz") << manager << nameDef << nameField << QVariant(QString("9999")) << (int)(QContactFilter::MatchKeypadCollation) << ""; // nobody.

        if (!manager->detailDefinitions().contains(QContactPhoneNumber::DefinitionName))

            continue; // don't test phone numbers with this manager: not supported.

        // now do phone number matching - first, aaron's phone number

        QTest::newRow("a phone hyphen") << manager << phoneDef << phoneField << QVariant(QString("555-1212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone plus") << manager << phoneDef << phoneField << QVariant(QString("+5551212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone brackets") << manager << phoneDef << phoneField << QVariant(QString("(555)1212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone nospaces") << manager << phoneDef << phoneField << QVariant(QString("5551212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone single space") << manager << phoneDef << phoneField << QVariant(QString("555 1212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone random spaces") << manager << phoneDef << phoneField << QVariant(QString("55 512 12")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone every space") << manager << phoneDef << phoneField << QVariant(QString("5 5 5 1 2 1 2")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone plus hyphen") << manager << phoneDef << phoneField << QVariant(QString("+555-1212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone plus brackets") << manager << phoneDef << phoneField << QVariant(QString("+5(55)1212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone plus brackets hyphen") << manager << phoneDef << phoneField << QVariant(QString("+5(55)1-212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        QTest::newRow("a phone plus brackets hyphen spaces") << manager << phoneDef << phoneField << QVariant(QString("+5 (55) 1-212")) << (int)(QContactFilter::MatchPhoneNumber) << "a";

        // XXX TODO: should we test for character to number conversions (eg, dial 1800-PESTCONTROL) etc ?

        //QTest::newRow("a phone characters") << manager << phoneDef << phoneField << QVariant(QString("jjj1a1a")) << (int)(QContactFilter::MatchPhoneNumber) << "a"; // 5551212

        //QTest::newRow("a phone characters") << manager << phoneDef << phoneField << QVariant(QString("jkl1b1a")) << (int)(QContactFilter::MatchPhoneNumber) << "a"; // 5551212

        // then matches bob's phone number

        QTest::newRow("b phone hyphen") << manager << phoneDef << phoneField << QVariant(QString("555-3456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone plus") << manager << phoneDef << phoneField << QVariant(QString("+5553456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone brackets") << manager << phoneDef << phoneField << QVariant(QString("(555)3456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone nospaces") << manager << phoneDef << phoneField << QVariant(QString("5553456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone single space") << manager << phoneDef << phoneField << QVariant(QString("555 3456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone random spaces") << manager << phoneDef << phoneField << QVariant(QString("55 534 56")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone every space") << manager << phoneDef << phoneField << QVariant(QString("5 5 5 3 4 5 6")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone plus hyphen") << manager << phoneDef << phoneField << QVariant(QString("+555-3456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone plus brackets") << manager << phoneDef << phoneField << QVariant(QString("+5(55)3456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone plus brackets hyphen") << manager << phoneDef << phoneField << QVariant(QString("+5(55)3-456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        QTest::newRow("b phone plus brackets hyphen spaces") << manager << phoneDef << phoneField << QVariant(QString("+5 (55) 3-456")) << (int)(QContactFilter::MatchPhoneNumber) << "b";

        // then match no phone numbers (negative testing) -- 555-9999 matches nobody in our test set.

        QTest::newRow("no phone hyphen") << manager << phoneDef << phoneField << QVariant(QString("555-9999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone plus") << manager << phoneDef << phoneField << QVariant(QString("+5559999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone brackets") << manager << phoneDef << phoneField << QVariant(QString("(555)9999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone nospaces") << manager << phoneDef << phoneField << QVariant(QString("5559999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone single space") << manager << phoneDef << phoneField << QVariant(QString("555 9999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone random spaces") << manager << phoneDef << phoneField << QVariant(QString("55 599 99")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone every space") << manager << phoneDef << phoneField << QVariant(QString("5 5 5 9 9 9 9")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone plus hyphen") << manager << phoneDef << phoneField << QVariant(QString("+555-9999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone plus brackets") << manager << phoneDef << phoneField << QVariant(QString("+5(55)9999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone plus brackets hyphen") << manager << phoneDef << phoneField << QVariant(QString("+5(55)9-999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        QTest::newRow("no phone plus brackets hyphen spaces") << manager << phoneDef << phoneField << QVariant(QString("+5 (55) 9-999")) << (int)(QContactFilter::MatchPhoneNumber) << "";

        // then match both aaron and bob via starts with

        QTest::newRow("ab phone starts nospace") << manager << phoneDef << phoneField << QVariant(QString("555")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts hyphen") << manager << phoneDef << phoneField << QVariant(QString("555-")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts space") << manager << phoneDef << phoneField << QVariant(QString("55 5")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts brackets") << manager << phoneDef << phoneField << QVariant(QString("(555)")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts plus") << manager << phoneDef << phoneField << QVariant(QString("+555")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts hyphen space") << manager << phoneDef << phoneField << QVariant(QString("5 55-")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts hyphen space brackets") << manager << phoneDef << phoneField << QVariant(QString("5 (55)-")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

        QTest::newRow("ab phone starts hyphen space brackets plus") << manager << phoneDef << phoneField << QVariant(QString("+5 (55)-")) << (int)(QContactFilter::MatchPhoneNumber | QContactFilter::MatchStartsWith) << "ab";

    }

}

void tst_QContactManagerFiltering::detailPhoneNumberFiltering()

{

    QFETCH(QContactManager*, cm);

    QFETCH(QString, defname);

    QFETCH(QString, fieldname);

    QFETCH(QVariant, value);

    QFETCH(int, matchflags);

    QFETCH(QString, expected);

    // note: this test is exactly the same as string filtering, but uses different fields and specific 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);

    //QSKIP("TODO: fix default implementation of phone number matching!", SkipSingle);

    QCOMPARE_UNSORTED(output, expected);

}

void tst_QContactManagerFiltering::detailVariantFiltering_data()

{

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