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

**

** Copyright (C) 2010 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$

**

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

#include <QtTest/QtTest>

#include "qtcontacts.h"

#include <QSet>

//TESTED_CLASS=

//TESTED_FILES=

QTM_USE_NAMESPACE

class tst_QContactDetail : public QObject

{

Q_OBJECT

public:

    tst_QContactDetail();

    virtual ~tst_QContactDetail();

public slots:

    void init();

    void cleanup();

private slots:

    void classHierarchy();

    void assignment();

    void templates();

    void contexts();

    void values();

    void hash();

    void traits();

    void keys();

    void detailUris();

};

tst_QContactDetail::tst_QContactDetail()

{

}

tst_QContactDetail::~tst_QContactDetail()

{

}

void tst_QContactDetail::init()

{

}

void tst_QContactDetail::cleanup()

{

}

/* Test class that doesn't do the right thing */

class NonMacroCustomDetail : public QContactDetail

{

public:

    NonMacroCustomDetail() : QContactDetail("malicious") {}

    void doAssign(const QContactDetail& other) {assign(other, "malicious");}

    NonMacroCustomDetail(const QContactDetail& other)

        : QContactDetail(other, "malicious") {}

};

class NonMacroCustomDetail2 : public QContactDetail

{

public:

    NonMacroCustomDetail2() : QContactDetail(QString("malicious")) {}

    void doAssign(const QContactDetail& other) {assign(other, QString("malicious"));}

    NonMacroCustomDetail2(const QContactDetail& other)

        : QContactDetail(other, QString("malicious")) {}

};

void tst_QContactDetail::classHierarchy()

{

    QContactDetail f1;

    QContactDetail f2;

    QVERIFY(f1.isEmpty());

    QVERIFY(f2.isEmpty());

    QContactPhoneNumber p1;

    p1.setNumber("123456");

    QVERIFY(!p1.isEmpty());

    QVERIFY(p1.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactName m1;

    m1.setFirstName("Bob");

    QVERIFY(!m1.isEmpty());

    QVERIFY(m1.definitionName() == QContactName::DefinitionName);

    QVERIFY(p1 != m1);

    QVERIFY(f1 == f2);

    f1 = p1; // f1 is a phonenumber

    QVERIFY(f1 == p1);

    f1 = f1; // assign to itself

    QVERIFY(f1 == f1);

    QVERIFY(f1 == p1);

    QVERIFY(f1 != f2);

    QVERIFY(p1 != f2);

    p1 = p1; // assign leaf class to itself

    QVERIFY(p1 == p1);

    QVERIFY(f1 == p1);

    QVERIFY(p1 == f1);

    f2 = f1; // f2 = f1 = phonenumber

    QVERIFY(f1 == f2);

    QVERIFY(f2 == f1);

    QVERIFY(f2 == p1);

    QVERIFY(f1 == p1);

    f1 = m1; // f1 = name, f2 = phonenumber

    QVERIFY(f1 == m1);

    QVERIFY(f1 != f2);

    QVERIFY(f2 == p1);

    QContactPhoneNumber p2(f2); // p2 = f2 = phonenumber

    QVERIFY(p1 == p2);

    QVERIFY(p1 == f2);

    QCOMPARE(p2.number(), p1.number());

    QCOMPARE(p2.number(), QString("123456"));

    p2 = p1; // phone number to phone number

    QVERIFY(p1 == p2);

    QVERIFY(p1 == f2);

    QCOMPARE(p2.number(), p1.number());

    QCOMPARE(p2.number(), QString("123456"));

    p2.setNumber("5678"); // NOTE: implicitly shared, this has caused a detach so p1 != 2

    QVERIFY(p1 != p2);

    QVERIFY(p1 == f2);

    QVERIFY(p2 != f2);

    QCOMPARE(p2.number(), QString("5678"));

    QCOMPARE(p1.number(), QString("123456"));

    /* Bad assignment */

    p2 = m1; // assign a name to a phone number

    QVERIFY(p2 != m1);

    QVERIFY(p2.definitionName() == QContactPhoneNumber::DefinitionName); // should still be a phone number though

    QVERIFY(p2.isEmpty());

    /* copy ctor */

    QContactName m2(m1);

    QVERIFY(m2 == m1);

    /* another bad assignment */

    m2 = p2; // phone number to a name

    QVERIFY(m2 != m1);

    QVERIFY(m2.definitionName() == QContactName::DefinitionName);

    QVERIFY(m2.isEmpty());

    /* Check contexts are considered for equality */

    p2 = QContactPhoneNumber(); // new id / detach

    p2.setNumber(p1.number());

    p2.setContexts(QContactDetail::ContextHome);

    QVERIFY(p1 != p2);

    p2.removeValue(QContactDetail::FieldContext); // note, context is a value.

    QVERIFY(p1 == p2); // different ids but same values should be equal

    /* Copy ctor from valid type */

    QContactDetail f3(p2);

    QVERIFY(f3 == p2);

    QVERIFY(f3.definitionName() == QContactPhoneNumber::DefinitionName);

    /* Copy ctor from invalid type */

    QContactPhoneNumber p3(m1);

    QVERIFY(p3 != m1);

    QVERIFY(p3.definitionName() == QContactPhoneNumber::DefinitionName);

    QVERIFY(p3.isEmpty());

    /* Copy ctore from invalid type, through base type */

    f3 = m1;

    QContactPhoneNumber p4(f3);

    QVERIFY(p4 != f3);

    QVERIFY(p4.definitionName() == QContactPhoneNumber::DefinitionName);

    QVERIFY(p4.isEmpty());

    /* Try a reference */

    p1.setNumber("123456");

    QContactDetail& ref = p1;

    QVERIFY(p1.number() == "123456");

    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "123456");

    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "123456");

    QVERIFY(p1 == ref);

    QVERIFY(ref == p1);

    /* Try changing the original */

    p1.setNumber("56789");

    QVERIFY(p1.number() == "56789");

    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "56789");

    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "56789");

    QVERIFY(p1 == ref);

    QVERIFY(ref == p1);

    /* Try changing the reference */

    ref.setValue(QContactPhoneNumber::FieldNumber, "654321");

    QVERIFY(p1.number() == "654321");

    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "654321");

    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "654321");

    QVERIFY(p1 == ref);

    QVERIFY(ref == p1);

    /* Random other test */

    NonMacroCustomDetail md;

    QVERIFY(md.definitionName() == "malicious");

    QVERIFY(md.setValue("key", "value"));

    QVERIFY(!md.isEmpty());

    md.doAssign(md); // self assignment

    QVERIFY(!md.isEmpty());

    QVERIFY(md.value("key") == "value");

    QContactDetail mdv;

    mdv = md;

    QVERIFY(mdv.definitionName() == "malicious");

    QVERIFY(mdv.value("key") == "value");

    md = mdv;

    QVERIFY(md.definitionName() == "malicious");

    QVERIFY(md.value("key") == "value");

    NonMacroCustomDetail2 md2;

    QVERIFY(md2.setValue("key", "value"));

    QVERIFY(md2.definitionName() == "malicious");

    QVERIFY(md2.value("key") == "value");

    md2.doAssign(md);

    QVERIFY(md2 == md);

    md2 = md;

    QVERIFY(md.definitionName() == "malicious");

    QVERIFY(md.value("key") == "value");

    // Self assignment

    md2.doAssign(md2);

    QVERIFY(md2.definitionName() == "malicious");

    QVERIFY(md2.value("key") == "value");

    md.doAssign(md2);

    QVERIFY(md == md2);

    // Assigning something else

    QContactPhoneNumber pn;

    pn.setNumber("12345");

    md2.doAssign(pn);

    QVERIFY(md2.isEmpty());

    QVERIFY(md2.definitionName() == "malicious");

    NonMacroCustomDetail mdb(pn);

    QVERIFY(mdb.isEmpty());

    QVERIFY(mdb.definitionName() == "malicious");

    NonMacroCustomDetail2 md2b(pn);

    QVERIFY(md2b.isEmpty());

    QVERIFY(md2b.definitionName() == "malicious");

}

void tst_QContactDetail::assignment()

{

    QContactPhoneNumber p1, p2;

    p1.setNumber("12345");

    p2.setNumber("54321");

    QVERIFY(p1 != p2);

    p1 = p2;

    QVERIFY(p1 == p2);

    QContactEmailAddress e1;

    e1.setEmailAddress("test@nokia.com");

    QVERIFY(e1 != p1);

    e1 = p1;

    QVERIFY(e1 != p1); // assignment across types shouldn't work

    QVERIFY(e1.emailAddress() == QString()); // should reset the detail

    QCOMPARE(e1, QContactEmailAddress());

    QContactManagerEngine::setDetailAccessConstraints(&p2, QContactDetail::Irremovable);

    QVERIFY(p1 != p2);

}

void tst_QContactDetail::templates()

{

    QContact c;

    QContactPhoneNumber p1, p2;

    p1.setNumber("1234");

    p2.setNumber("5678");

    QVERIFY(c.saveDetail(&p1));

    QVERIFY(c.saveDetail(&p2));

    QList<QContactDetail> l = c.details("PhoneNumber");

    QCOMPARE(l.count(), 2);

    QCOMPARE(QContactPhoneNumber(l.at(0)), p1);

    QCOMPARE(QContactPhoneNumber(l.at(1)), p2);

    QList<QContactPhoneNumber> l2 = c.details<QContactPhoneNumber>();

    QCOMPARE(l2.count(), 2);

    QCOMPARE(l2.at(0), p1);

    QCOMPARE(l2.at(1), p2);

}

void tst_QContactDetail::contexts()

{

    QContactDetail d;

    QVERIFY(d.contexts().count() == 0);

    // test set contexts

    d.setContexts(QContactDetail::ContextWork);

    QVERIFY(d.contexts().count() == 1);

    QVERIFY(d.contexts().contains(QContactDetail::ContextWork));

    QVERIFY(!d.contexts().contains(QContactDetail::ContextOther));

    QVERIFY(!d.contexts().contains(QContactDetail::ContextHome));

    QStringList contexts;

    contexts.append(QContactDetail::ContextHome);

    contexts.append(QContactDetail::ContextOther);

    contexts.append("CustomContext"); // note: won't (necessarily) validate but will work in QCD.

    d.setContexts(contexts);

    QVERIFY(d.contexts().count() == 3);

    QVERIFY(!d.contexts().contains(QContactDetail::ContextWork));

    QVERIFY(d.contexts().contains(QContactDetail::ContextOther));

    QVERIFY(d.contexts().contains(QContactDetail::ContextHome));

    QVERIFY(d.contexts().contains("CustomContext"));

    QCOMPARE(d.contexts(), contexts);

    // test that contexts are values.

    QCOMPARE(d.value<QStringList>(QContactDetail::FieldContext), d.contexts());

}

void tst_QContactDetail::values()

{

    QContactDetail p;

    QCOMPARE(p.variantValues(), QVariantMap());

    QDateTime dt = QDateTime::currentDateTime();

    QTime t = dt.time();

    t.setHMS(t.hour(), t.minute(), t.second(), 0); // milliseconds don't round trip through ISODate

    dt.setTime(t);

    QDate d = dt.date();

    QDateTime ddt(d); // DateTime version of a Date (QTime())

    p.setValue("string", "This is a string");

    p.setValue("date", d);

    p.setValue("datetime", dt);

    p.setValue("int", (int)6);

    p.setValue("stringdate", d.toString(Qt::ISODate));

    p.setValue("stringdatetime", dt.toString(Qt::ISODate));

    // Test the setter that takes a QString

    p.setValue(QLatin1String("stringint"), "123");

    // and the setter that takes a QL1C

    p.setValue(QContactPhoneNumber::FieldNumber, "1234");

    /* Presence test (const char * version) */

    QVERIFY(p.hasValue("string"));

    QVERIFY(p.hasValue("date"));

    QVERIFY(p.hasValue("datetime"));

    QVERIFY(p.hasValue("int"));

    QVERIFY(p.hasValue("stringdate"));

    QVERIFY(p.hasValue("stringdatetime"));

    QVERIFY(p.hasValue("stringint"));

    QVERIFY(p.hasValue(QContactPhoneNumber::FieldNumber.latin1()));

    QVERIFY(!p.hasValue("non existent field"));

    /* QLatin1Constant version */

    QVERIFY(p.hasValue(QContactPhoneNumber::FieldNumber));

    QVERIFY(!p.hasValue(QContactAddress::FieldCountry));

    /* Again with QString version */

    QVERIFY(p.hasValue(QLatin1String("string")));

    QVERIFY(p.hasValue(QLatin1String("date")));

    QVERIFY(p.hasValue(QLatin1String("datetime")));

    QVERIFY(p.hasValue(QLatin1String("int")));

    QVERIFY(p.hasValue(QLatin1String("stringdate")));

    QVERIFY(p.hasValue(QLatin1String("stringdatetime")));

    QVERIFY(p.hasValue(QLatin1String("stringint")));

    QVERIFY(p.hasValue(QString(QLatin1String(QContactPhoneNumber::FieldNumber))));

    QVERIFY(!p.hasValue(QLatin1String("non existent field")));

    /* string accessors with const char* key */

    QCOMPARE(p.value("string"), QString("This is a string"));

    QCOMPARE(p.value("date"), d.toString(Qt::ISODate));

    QCOMPARE(p.value("datetime"), dt.toString(Qt::ISODate));

    QCOMPARE(p.value("int"), QString("6"));

    QCOMPARE(p.value("stringdate"), d.toString(Qt::ISODate));

    QCOMPARE(p.value("stringdatetime"), dt.toString(Qt::ISODate));

    QCOMPARE(p.value("stringint"), QString("123"));

    QCOMPARE(p.value(QContactPhoneNumber::FieldNumber.latin1()), QString("1234"));

    /* string accessor with QL1C key */

    QCOMPARE(p.value(QContactPhoneNumber::FieldNumber), QString("1234"));

    /* string accessors with QString key */

    QCOMPARE(p.value(QLatin1String("string")), QString("This is a string"));

    QCOMPARE(p.value(QLatin1String("date")), d.toString(Qt::ISODate));

    QCOMPARE(p.value(QLatin1String("datetime")), dt.toString(Qt::ISODate));

    QCOMPARE(p.value(QLatin1String("int")), QString("6"));

    QCOMPARE(p.value(QLatin1String("stringdate")), d.toString(Qt::ISODate));

    QCOMPARE(p.value(QLatin1String("stringdatetime")), dt.toString(Qt::ISODate));

    QCOMPARE(p.value(QLatin1String("stringint")), QString("123"));

    QCOMPARE(p.value(QString(QLatin1String(QContactPhoneNumber::FieldNumber))), QString("1234"));

    /* Variant accessor with const char * key */

    QCOMPARE(p.variantValue("string"), QVariant(QString("This is a string")));

    QCOMPARE(p.variantValue("date"), QVariant(d));

    QCOMPARE(p.variantValue("datetime"), QVariant(dt));

    QCOMPARE(p.variantValue("int"), QVariant((int)6));

    QCOMPARE(p.variantValue("stringdate"), QVariant(d.toString(Qt::ISODate)));

    QCOMPARE(p.variantValue("stringdatetime"), QVariant(dt.toString(Qt::ISODate)));

    QCOMPARE(p.variantValue("stringint"), QVariant(QString("123")));

    QCOMPARE(p.variantValue(QContactPhoneNumber::FieldNumber.latin1()), QVariant(QString("1234")));

    /* Variant accessor with QL1C key */

    QCOMPARE(p.variantValue(QContactPhoneNumber::FieldNumber), QVariant(QString("1234")));

    /* Variant accessor with QString key */

    QCOMPARE(p.variantValue(QLatin1String("string")), QVariant(QString("This is a string")));

    QCOMPARE(p.variantValue(QLatin1String("date")), QVariant(d));

    QCOMPARE(p.variantValue(QLatin1String("datetime")), QVariant(dt));

    QCOMPARE(p.variantValue(QLatin1String("int")), QVariant((int)6));

    QCOMPARE(p.variantValue(QLatin1String("stringdate")), QVariant(d.toString(Qt::ISODate)));

    QCOMPARE(p.variantValue(QLatin1String("stringdatetime")), QVariant(dt.toString(Qt::ISODate)));

    QCOMPARE(p.variantValue(QLatin1String("stringint")), QVariant(QString("123")));

    QCOMPARE(p.variantValue(QLatin1String(QContactPhoneNumber::FieldNumber)), QVariant(QString("1234")));

    /* Typed accessors, string first, const char* key */

    QCOMPARE(p.value<QString>("string"), QString("This is a string"));

    QCOMPARE(p.value<QString>("date"), d.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>("datetime"), dt.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>("int"), QString("6"));

    QCOMPARE(p.value<QString>("stringdate"), d.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>("stringdatetime"), dt.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>("stringint"), QString("123"));

    QCOMPARE(p.value<QString>(QContactPhoneNumber::FieldNumber.latin1()), QString("1234"));

    /* Now individual original types */

    QCOMPARE(p.value<QDate>("date"), d);

    QCOMPARE(p.value<QDateTime>("datetime"), dt);

    QCOMPARE(p.value<int>("int"), 6);

    /* now latin constant keys */

    QCOMPARE(p.value<QString>(QContactPhoneNumber::FieldNumber), QString("1234"));

    /* Typed accessors, string first, QString key */

    QCOMPARE(p.value<QString>(QLatin1String("string")), QString("This is a string"));

    QCOMPARE(p.value<QString>(QLatin1String("date")), d.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>(QLatin1String("datetime")), dt.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>(QLatin1String("int")), QString("6"));

    QCOMPARE(p.value<QString>(QLatin1String("stringdate")), d.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>(QLatin1String("stringdatetime")), dt.toString(Qt::ISODate));

    QCOMPARE(p.value<QString>(QLatin1String("stringint")), QString("123"));

    QCOMPARE(p.value<QString>(QLatin1String(QContactPhoneNumber::FieldNumber)), QString("1234"));

    QCOMPARE(p.value<QDate>(QLatin1String("date")), d);

    QCOMPARE(p.value<QDateTime>(QLatin1String("datetime")), dt);

    QCOMPARE(p.value<int>(QLatin1String("int")), 6);

    /* Now cross types that should fail */

    QDate id;

    QDateTime idt;

    QCOMPARE(p.value<QDate>("string"), id);

    QCOMPARE(p.value<QDate>("int"), id);

    QCOMPARE(p.value<QDate>("stringint"), id);

    QCOMPARE(p.value<QDateTime>("string"), idt);

    QCOMPARE(p.value<QDateTime>("int"), idt);

    QCOMPARE(p.value<QDateTime>("stringint"), idt);

    QCOMPARE(p.value<int>("date"), 0);

    QCOMPARE(p.value<int>("datetime"), 0);

    QCOMPARE(p.value<int>("string"), 0);

    QCOMPARE(p.value<int>("stringdate"), 0);

    QCOMPARE(p.value<int>("stringdatetime"), 0);

    /* Cross types that should work.. */

    QCOMPARE(p.value<int>("stringint"), 123);

    QCOMPARE(p.value<QDate>("stringdate"), d);

    QCOMPARE(p.value<QDateTime>("stringdatetime"), dt);

    QCOMPARE(p.value<QDate>("datetime"), d);

    QCOMPARE(p.value<QDate>("stringdatetime"), d);

    QCOMPARE(p.value<QDateTime>("date"), ddt);

    QCOMPARE(p.value<QDateTime>("stringdate"), ddt);

    /* Now set everything again */

    QVariantMap emptyValues;

    QVariantMap values = p.variantValues();

    QStringList keys = values.keys();

    foreach (const QString& key, keys)

        QVERIFY(p.setValue(key, QVariant()));

    QCOMPARE(p.variantValues(), emptyValues);

    QVERIFY(p.variantValues().count() == 0);