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

**

** 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 test suite of the Qt Toolkit.

**

** $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 DBUS_API_SUBJECT_TO_CHANGE

#include <QtCore/QtCore>

#include <QtTest/QtTest>

#include <QtDBus/QtDBus>

#include <QtDBus/private/qdbusutil_p.h>

#include "common.h"

#include <limits>

static const char serviceName[] = "com.trolltech.autotests.qpong";

static const char objectPath[] = "/com/trolltech/qpong";

static const char *interfaceName = serviceName;

class tst_QDBusMarshall: public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void sendBasic_data();

    void sendBasic();

    void sendVariant_data();

    void sendVariant();

    void sendArrays_data();

    void sendArrays();

    void sendArrayOfArrays_data();

    void sendArrayOfArrays();

    void sendMaps_data();

    void sendMaps();

    void sendStructs_data();

    void sendStructs();

    void sendComplex_data();

    void sendComplex();

    void sendArgument_data();

    void sendArgument();

    void sendSignalErrors();

    void sendCallErrors_data();

    void sendCallErrors();

private:

    QProcess proc;

};

struct UnregisteredType { };

Q_DECLARE_METATYPE(UnregisteredType)

class WaitForQPong: public QObject

{

    Q_OBJECT

public:

    WaitForQPong();

    bool ok();

public Q_SLOTS:

    void ownerChange(const QString &name)

    {

        if (name == serviceName)

            loop.quit();

    }

private:

    QEventLoop loop;

};

WaitForQPong::WaitForQPong()

{

    QDBusConnection con = QDBusConnection::sessionBus();

    if (!ok()) {

        connect(con.interface(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),

                SLOT(ownerChange(QString)));

        QTimer::singleShot(2000, &loop, SLOT(quit()));

        loop.exec();

    }

}

bool WaitForQPong::ok()

{

    return QDBusConnection::sessionBus().isConnected() &&

        QDBusConnection::sessionBus().interface()->isServiceRegistered(serviceName);

}

void tst_QDBusMarshall::initTestCase()

{

    commonInit();

#ifdef Q_OS_WIN

    proc.start("qpong");

#else

    proc.start("./qpong/qpong");

#endif

    QVERIFY(proc.waitForStarted());

    WaitForQPong w;

    QVERIFY(w.ok());

    //QTest::qWait(2000);

}

void tst_QDBusMarshall::cleanupTestCase()

{

    proc.close();

    proc.kill();

}

void tst_QDBusMarshall::sendBasic_data()

{

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

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

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

    // basic types:

    QTest::newRow("bool") << QVariant(false) << "b" << "false";

#if 1

    QTest::newRow("bool2") << QVariant(true) << "b" << "true";

    QTest::newRow("byte") << qVariantFromValue(uchar(1)) << "y" << "1";

    QTest::newRow("int16") << qVariantFromValue(short(2)) << "n" << "2";

    QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << "q" << "3";

    QTest::newRow("int") << QVariant(1) << "i" << "1";

    QTest::newRow("uint") << QVariant(2U) << "u" << "2";

    QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << "x" << "3";

    QTest::newRow("uint64") << QVariant(Q_UINT64_C(4)) << "t" << "4";

    QTest::newRow("double") << QVariant(42.5) << "d" << "42.5";

    QTest::newRow("string") << QVariant("ping") << "s" << "\"ping\"";

    QTest::newRow("objectpath") << qVariantFromValue(QDBusObjectPath("/org/kde")) << "o" << "[ObjectPath: /org/kde]";

    QTest::newRow("signature") << qVariantFromValue(QDBusSignature("g")) << "g" << "[Signature: g]";

    QTest::newRow("emptystring") << QVariant("") << "s" << "\"\"";

    QTest::newRow("nullstring") << QVariant(QString()) << "s" << "\"\"";

#endif

}

void tst_QDBusMarshall::sendVariant_data()

{

    sendBasic_data();

    QTest::newRow("variant") << qVariantFromValue(QDBusVariant(1)) << "v" << "[Variant(int): 1]";

    QDBusVariant nested(1);

    QTest::newRow("variant-variant") << qVariantFromValue(QDBusVariant(qVariantFromValue(nested))) << "v"

                                     << "[Variant(QDBusVariant): [Variant(int): 1]]";

}

void tst_QDBusMarshall::sendArrays_data()

{

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

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

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

    // arrays

    QStringList strings;

    QTest::newRow("emptystringlist") << QVariant(strings) << "as" << "{}";

    strings << "hello" << "world";

    QTest::newRow("stringlist") << QVariant(strings) << "as" << "{\"hello\", \"world\"}";

    strings.clear();

    strings << "" << "" << "";

    QTest::newRow("list-of-emptystrings") << QVariant(strings) << "as" << "{\"\", \"\", \"\"}";

    strings.clear();

    strings << QString() << QString() << QString() << QString();

    QTest::newRow("list-of-nullstrings") << QVariant(strings) << "as" << "{\"\", \"\", \"\", \"\"}";

    QByteArray bytearray;

    QTest::newRow("nullbytearray") << QVariant(bytearray) << "ay" << "{}";

    bytearray = "";             // empty, not null

    QTest::newRow("emptybytearray") << QVariant(bytearray) << "ay" << "{}";

    bytearray = "foo";

    QTest::newRow("bytearray") << QVariant(bytearray) << "ay" << "{102, 111, 111}";

    QList<bool> bools;

    QTest::newRow("emptyboollist") << qVariantFromValue(bools) << "ab" << "[Argument: ab {}]";

    bools << false << true << false;

    QTest::newRow("boollist") << qVariantFromValue(bools) << "ab" << "[Argument: ab {false, true, false}]";

    QList<short> shorts;

    QTest::newRow("emptyshortlist") << qVariantFromValue(shorts) << "an" << "[Argument: an {}]";

    shorts << 42 << -43 << 44 << 45 << -32768 << 32767;

    QTest::newRow("shortlist") << qVariantFromValue(shorts) << "an"

                               << "[Argument: an {42, -43, 44, 45, -32768, 32767}]";

    QList<ushort> ushorts;

    QTest::newRow("emptyushortlist") << qVariantFromValue(ushorts) << "aq" << "[Argument: aq {}]";

    ushorts << 12u << 13u << 14u << 15 << 65535;

    QTest::newRow("ushortlist") << qVariantFromValue(ushorts) << "aq" << "[Argument: aq {12, 13, 14, 15, 65535}]";

    QList<int> ints;

    QTest::newRow("emptyintlist") << qVariantFromValue(ints) << "ai" << "[Argument: ai {}]";

    ints << 42 << -43 << 44 << 45 << 2147483647 << -2147483647-1;

    QTest::newRow("intlist") << qVariantFromValue(ints) << "ai" << "[Argument: ai {42, -43, 44, 45, 2147483647, -2147483648}]";

    QList<uint> uints;

    QTest::newRow("emptyuintlist") << qVariantFromValue(uints) << "au" << "[Argument: au {}]";

    uints << uint(12) << uint(13) << uint(14) << 4294967295U;

    QTest::newRow("uintlist") << qVariantFromValue(uints) << "au" << "[Argument: au {12, 13, 14, 4294967295}]";

    QList<qlonglong> llints;

    QTest::newRow("emptyllintlist") << qVariantFromValue(llints) << "ax" << "[Argument: ax {}]";

    llints << Q_INT64_C(99) << Q_INT64_C(-100)

           << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807);

    QTest::newRow("llintlist") << qVariantFromValue(llints) << "ax"

                               << "[Argument: ax {99, -100, -9223372036854775808, 9223372036854775807}]";

    QList<qulonglong> ullints;

    QTest::newRow("emptyullintlist") << qVariantFromValue(ullints) << "at" << "[Argument: at {}]";

    ullints << Q_UINT64_C(66) << Q_UINT64_C(67)

            << Q_UINT64_C(18446744073709551615);

    QTest::newRow("ullintlist") << qVariantFromValue(ullints) << "at" << "[Argument: at {66, 67, 18446744073709551615}]";

    QList<double> doubles;

    QTest::newRow("emptydoublelist") << qVariantFromValue(doubles) << "ad" << "[Argument: ad {}]";

    doubles << 1.2 << 2.2 << 4.4

            << -std::numeric_limits<double>::infinity()

            << std::numeric_limits<double>::infinity()

            << std::numeric_limits<double>::quiet_NaN();

    QTest::newRow("doublelist") << qVariantFromValue(doubles) << "ad" << "[Argument: ad {1.2, 2.2, 4.4, -inf, inf, nan}]";

    QVariantList variants;

    QTest::newRow("emptyvariantlist") << QVariant(variants) << "av" << "[Argument: av {}]";

    variants << QString("Hello") << QByteArray("World") << 42 << -43.0 << 44U << Q_INT64_C(-45)

             << Q_UINT64_C(46) << true << qVariantFromValue(short(-47))

             << qVariantFromValue(QDBusSignature("av"))

             << qVariantFromValue(QDBusVariant(qVariantFromValue(QDBusObjectPath("/"))));

    QTest::newRow("variantlist") << QVariant(variants) << "av"

        << "[Argument: av {[Variant(QString): \"Hello\"], [Variant(QByteArray): {87, 111, 114, 108, 100}], [Variant(int): 42], [Variant(double): -43], [Variant(uint): 44], [Variant(qlonglong): -45], [Variant(qulonglong): 46], [Variant(bool): true], [Variant(short): -47], [Variant: [Signature: av]], [Variant: [Variant: [ObjectPath: /]]]}]";

}

void tst_QDBusMarshall::sendArrayOfArrays_data()

{

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

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

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

    // arrays:

    QList<QStringList> strings;

    QTest::newRow("empty-list-of-stringlist") << qVariantFromValue(strings) << "aas"

            << "[Argument: aas {}]";

    strings << QStringList();

    QTest::newRow("list-of-emptystringlist") << qVariantFromValue(strings) << "aas"

            << "[Argument: aas {{}}]";

    strings << (QStringList() << "hello" << "world")

            << (QStringList() << "hi" << "there")

            << (QStringList() << QString());

    QTest::newRow("stringlist") << qVariantFromValue(strings) << "aas"

            << "[Argument: aas {{}, {\"hello\", \"world\"}, {\"hi\", \"there\"}, {\"\"}}]";

    QList<QByteArray> bytearray;

    QTest::newRow("empty-list-of-bytearray") << qVariantFromValue(bytearray) << "aay"

            << "[Argument: aay {}]";

    bytearray << QByteArray();

    QTest::newRow("list-of-emptybytearray") << qVariantFromValue(bytearray) << "aay"

            << "[Argument: aay {{}}]";

    bytearray << "foo" << "bar" << "baz" << "" << QByteArray();

    QTest::newRow("bytearray") << qVariantFromValue(bytearray) << "aay"

            << "[Argument: aay {{}, {102, 111, 111}, {98, 97, 114}, {98, 97, 122}, {}, {}}]";

    QList<QList<bool> > bools;

    QTest::newRow("empty-list-of-boollist") << qVariantFromValue(bools) << "aab"

            << "[Argument: aab {}]";

    bools << QList<bool>();

    QTest::newRow("list-of-emptyboollist") << qVariantFromValue(bools) << "aab"

            << "[Argument: aab {[Argument: ab {}]}]";

    bools << (QList<bool>() << false << true) << (QList<bool>() << false) << (QList<bool>());

    QTest::newRow("boollist") << qVariantFromValue(bools) << "aab"

            << "[Argument: aab {[Argument: ab {}], [Argument: ab {false, true}], [Argument: ab {false}], [Argument: ab {}]}]";

    QList<QList<short> > shorts;

    QTest::newRow("empty-list-of-shortlist") << qVariantFromValue(shorts) << "aan"

            << "[Argument: aan {}]";

    shorts << QList<short>();

    QTest::newRow("list-of-emptyshortlist") << qVariantFromValue(shorts) << "aan"

            << "[Argument: aan {[Argument: an {}]}]";

    shorts << (QList<short>() << 42 << -43 << 44 << 45)

           << (QList<short>() << -32768 << 32767)

           << (QList<short>());

    QTest::newRow("shortlist") << qVariantFromValue(shorts) << "aan"

            << "[Argument: aan {[Argument: an {}], [Argument: an {42, -43, 44, 45}], [Argument: an {-32768, 32767}], [Argument: an {}]}]";

    QList<QList<ushort> > ushorts;

    QTest::newRow("empty-list-of-ushortlist") << qVariantFromValue(ushorts) << "aaq"

            << "[Argument: aaq {}]";

    ushorts << QList<ushort>();

    QTest::newRow("list-of-emptyushortlist") << qVariantFromValue(ushorts) << "aaq"

            << "[Argument: aaq {[Argument: aq {}]}]";

    ushorts << (QList<ushort>() << 12u << 13u << 14u << 15)

            << (QList<ushort>() << 65535)

            << (QList<ushort>());

    QTest::newRow("ushortlist") << qVariantFromValue(ushorts) << "aaq"

            << "[Argument: aaq {[Argument: aq {}], [Argument: aq {12, 13, 14, 15}], [Argument: aq {65535}], [Argument: aq {}]}]";

    QList<QList<int> > ints;

    QTest::newRow("empty-list-of-intlist") << qVariantFromValue(ints) << "aai"

            << "[Argument: aai {}]";

    ints << QList<int>();

    QTest::newRow("list-of-emptyintlist") << qVariantFromValue(ints) << "aai"

            << "[Argument: aai {[Argument: ai {}]}]";

    ints << (QList<int>() << 42 << -43 << 44 << 45)

         << (QList<int>() << 2147483647 << -2147483647-1)

         << (QList<int>());

    QTest::newRow("intlist") << qVariantFromValue(ints) << "aai"

            << "[Argument: aai {[Argument: ai {}], [Argument: ai {42, -43, 44, 45}], [Argument: ai {2147483647, -2147483648}], [Argument: ai {}]}]";

    QList<QList<uint> > uints;

    QTest::newRow("empty-list-of-uintlist") << qVariantFromValue(uints) << "aau"

            << "[Argument: aau {}]";

    uints << QList<uint>();

    QTest::newRow("list-of-emptyuintlist") << qVariantFromValue(uints) << "aau"

            << "[Argument: aau {[Argument: au {}]}]";

    uints << (QList<uint>() << uint(12) << uint(13) << uint(14))

          << (QList<uint>() << 4294967295U)

          << (QList<uint>());

    QTest::newRow("uintlist") << qVariantFromValue(uints) << "aau"

            << "[Argument: aau {[Argument: au {}], [Argument: au {12, 13, 14}], [Argument: au {4294967295}], [Argument: au {}]}]";

    QList<QList<qlonglong> > llints;

    QTest::newRow("empty-list-of-llintlist") << qVariantFromValue(llints) << "aax"

            << "[Argument: aax {}]";

    llints << QList<qlonglong>();

    QTest::newRow("list-of-emptyllintlist") << qVariantFromValue(llints) << "aax"

            << "[Argument: aax {[Argument: ax {}]}]";

    llints << (QList<qlonglong>() << Q_INT64_C(99) << Q_INT64_C(-100))

           << (QList<qlonglong>() << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807))

           << (QList<qlonglong>());

    QTest::newRow("llintlist") << qVariantFromValue(llints) << "aax"

            << "[Argument: aax {[Argument: ax {}], [Argument: ax {99, -100}], [Argument: ax {-9223372036854775808, 9223372036854775807}], [Argument: ax {}]}]";

    QList<QList<qulonglong> > ullints;

    QTest::newRow("empty-list-of-ullintlist") << qVariantFromValue(ullints) << "aat"

            << "[Argument: aat {}]";

    ullints << QList<qulonglong>();

    QTest::newRow("list-of-emptyullintlist") << qVariantFromValue(ullints) << "aat"

            << "[Argument: aat {[Argument: at {}]}]";

    ullints << (QList<qulonglong>() << Q_UINT64_C(66) << Q_UINT64_C(67))

            << (QList<qulonglong>() << Q_UINT64_C(18446744073709551615))

            << (QList<qulonglong>());

    QTest::newRow("ullintlist") << qVariantFromValue(ullints) << "aat"

            << "[Argument: aat {[Argument: at {}], [Argument: at {66, 67}], [Argument: at {18446744073709551615}], [Argument: at {}]}]";

    QList<QList<double> > doubles;

    QTest::newRow("empty-list-ofdoublelist") << qVariantFromValue(doubles) << "aad"

            << "[Argument: aad {}]";

    doubles << QList<double>();

    QTest::newRow("list-of-emptydoublelist") << qVariantFromValue(doubles) << "aad"

            << "[Argument: aad {[Argument: ad {}]}]";

    doubles << (QList<double>() << 1.2 << 2.2 << 4.4)

            << (QList<double>() << -std::numeric_limits<double>::infinity()

                << std::numeric_limits<double>::infinity()

                << std::numeric_limits<double>::quiet_NaN())

            << (QList<double>());

    QTest::newRow("doublelist") << qVariantFromValue(doubles) << "aad"

            << "[Argument: aad {[Argument: ad {}], [Argument: ad {1.2, 2.2, 4.4}], [Argument: ad {-inf, inf, nan}], [Argument: ad {}]}]";

    QList<QVariantList> variants;

    QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav"

            << "[Argument: aav {}]";

    variants << QVariantList();

    QTest::newRow("emptyvariantlist") << qVariantFromValue(variants) << "aav"

            << "[Argument: aav {[Argument: av {}]}]";

    variants << (QVariantList() << QString("Hello") << QByteArray("World"))

             << (QVariantList() << 42 << -43.0 << 44U << Q_INT64_C(-45))

             << (QVariantList() << Q_UINT64_C(46) << true << qVariantFromValue(short(-47)));

    QTest::newRow("variantlist") << qVariantFromValue(variants) << "aav"

            << "[Argument: aav {[Argument: av {}], [Argument: av {[Variant(QString): \"Hello\"], [Variant(QByteArray): {87, 111, 114, 108, 100}]}], [Argument: av {[Variant(int): 42], [Variant(double): -43], [Variant(uint): 44], [Variant(qlonglong): -45]}], [Argument: av {[Variant(qulonglong): 46], [Variant(bool): true], [Variant(short): -47]}]}]";

}

void tst_QDBusMarshall::sendMaps_data()

{

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

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

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

    QMap<int, QString> ismap;

    QTest::newRow("empty-is-map") << qVariantFromValue(ismap) << "a{is}"

            << "[Argument: a{is} {}]";

    ismap[1] = "a";

    ismap[2000] = "b";

    ismap[-47] = "c";

    QTest::newRow("is-map") << qVariantFromValue(ismap) << "a{is}"

            << "[Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]";

    QMap<QString, QString> ssmap;

    QTest::newRow("empty-ss-map") << qVariantFromValue(ssmap) << "a{ss}"

            << "[Argument: a{ss} {}]";

    ssmap["a"] = "a";

    ssmap["c"] = "b";

    ssmap["b"] = "c";

    QTest::newRow("ss-map") << qVariantFromValue(ssmap) << "a{ss}"

            << "[Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]";

    QVariantMap svmap;

    QTest::newRow("empty-sv-map") << qVariantFromValue(svmap) << "a{sv}"

            << "[Argument: a{sv} {}]";

    svmap["a"] = 1;

    svmap["c"] = "b";

    svmap["b"] = QByteArray("c");

    svmap["d"] = 42U;

    svmap["e"] = qVariantFromValue(short(-47));

    svmap["f"] = qVariantFromValue(QDBusVariant(0));

    QTest::newRow("sv-map1") << qVariantFromValue(svmap) << "a{sv}"

            << "[Argument: a{sv} {\"a\" = [Variant(int): 1], \"b\" = [Variant(QByteArray): {99}], \"c\" = [Variant(QString): \"b\"], \"d\" = [Variant(uint): 42], \"e\" = [Variant(short): -47], \"f\" = [Variant: [Variant(int): 0]]}]";

    QMap<QDBusObjectPath, QString> osmap;

    QTest::newRow("empty-os-map") << qVariantFromValue(osmap) << "a{os}"

            << "[Argument: a{os} {}]";

    osmap[QDBusObjectPath("/")] = "root";

    osmap[QDBusObjectPath("/foo")] = "foo";

    osmap[QDBusObjectPath("/bar/baz")] = "bar and baz";

    QTest::newRow("os-map") << qVariantFromValue(osmap) << "a{os}"

            << "[Argument: a{os} {[ObjectPath: /] = \"root\", [ObjectPath: /bar/baz] = \"bar and baz\", [ObjectPath: /foo] = \"foo\"}]";

    QHash<QDBusSignature, QString> gsmap;

    QTest::newRow("empty-gs-map") << qVariantFromValue(gsmap) << "a{gs}"

            << "[Argument: a{gs} {}]";

    gsmap[QDBusSignature("i")] = "int32";

    gsmap[QDBusSignature("s")] = "string";

    gsmap[QDBusSignature("a{gs}")] = "array of dict_entry of (signature, string)";

    QTest::newRow("gs-map") << qVariantFromValue(gsmap) << "a{gs}"

            << "[Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]";

    svmap.clear();

    svmap["ismap"] = qVariantFromValue(ismap);

    svmap["ssmap"] = qVariantFromValue(ssmap);

    svmap["osmap"] = qVariantFromValue(osmap);

    svmap["gsmap"] = qVariantFromValue(gsmap);

    QTest::newRow("sv-map2") << qVariantFromValue(svmap) << "a{sv}"

            << "[Argument: a{sv} {\"gsmap\" = [Variant: [Argument: a{gs} {[Signature: a{gs}] = \"array of dict_entry of (signature, string)\", [Signature: i] = \"int32\", [Signature: s] = \"string\"}]], \"ismap\" = [Variant: [Argument: a{is} {-47 = \"c\", 1 = \"a\", 2000 = \"b\"}]], \"osmap\" = [Variant: [Argument: a{os} {[ObjectPath: /] = \"root\", [ObjectPath: /bar/baz] = \"bar and baz\", [ObjectPath: /foo] = \"foo\"}]], \"ssmap\" = [Variant: [Argument: a{ss} {\"a\" = \"a\", \"b\" = \"c\", \"c\" = \"b\"}]]}]";

}

void tst_QDBusMarshall::sendStructs_data()

{

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

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

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

    QTest::newRow("point") << QVariant(QPoint(1, 2)) << "(ii)" << "[Argument: (ii) 1, 2]";

    QTest::newRow("pointf") << QVariant(QPointF(1.5, -1.5)) << "(dd)" << "[Argument: (dd) 1.5, -1.5]";

    QTest::newRow("size") << QVariant(QSize(1, 2)) << "(ii)" << "[Argument: (ii) 1, 2]";

    QTest::newRow("sizef") << QVariant(QSizeF(1.5, 1.5)) << "(dd)" << "[Argument: (dd) 1.5, 1.5]";

    QTest::newRow("rect") << QVariant(QRect(1, 2, 3, 4)) << "(iiii)" << "[Argument: (iiii) 1, 2, 3, 4]";

    QTest::newRow("rectf") << QVariant(QRectF(0.5, 0.5, 1.5, 1.5)) << "(dddd)" << "[Argument: (dddd) 0.5, 0.5, 1.5, 1.5]";

    QTest::newRow("line") << QVariant(QLine(1, 2, 3, 4)) << "((ii)(ii))"

                          << "[Argument: ((ii)(ii)) [Argument: (ii) 1, 2], [Argument: (ii) 3, 4]]";

    QTest::newRow("linef") << QVariant(QLineF(0.5, 0.5, 1.5, 1.5)) << "((dd)(dd))"

                           << "[Argument: ((dd)(dd)) [Argument: (dd) 0.5, 0.5], [Argument: (dd) 1.5, 1.5]]";

    QDate date(2006, 6, 18);

    QTime time(12, 25, 00);     // the date I wrote this test on :-)

    QTest::newRow("date") << QVariant(date) << "(iii)" << "[Argument: (iii) 2006, 6, 18]";

    QTest::newRow("time") << QVariant(time) << "(iiii)" << "[Argument: (iiii) 12, 25, 0, 0]";

    QTest::newRow("datetime") << QVariant(QDateTime(date, time)) << "((iii)(iiii)i)"

        << "[Argument: ((iii)(iiii)i) [Argument: (iii) 2006, 6, 18], [Argument: (iiii) 12, 25, 0, 0], 0]";

    MyStruct ms = { 1, "Hello, World" };

    QTest::newRow("int-string") << qVariantFromValue(ms) << "(is)" << "[Argument: (is) 1, \"Hello, World\"]";

    MyVariantMapStruct mvms = { "Hello, World", QVariantMap() };

    QTest::newRow("string-variantmap") << qVariantFromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {}]]";

    // use only basic types, otherwise comparison will fail

    mvms.map["int"] = 42;

    mvms.map["uint"] = 42u;

    mvms.map["short"] = qVariantFromValue<short>(-47);

    mvms.map["bytearray"] = QByteArray("Hello, world");

    QTest::newRow("string-variantmap2") << qVariantFromValue(mvms) << "(sa{sv})" << "[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]";

    QList<MyVariantMapStruct> list;

    QTest::newRow("empty-list-of-string-variantmap") << qVariantFromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {}]";

    list << mvms;

    QTest::newRow("list-of-string-variantmap") << qVariantFromValue(list) << "a(sa{sv})" << "[Argument: a(sa{sv}) {[Argument: (sa{sv}) \"Hello, World\", [Argument: a{sv} {\"bytearray\" = [Variant(QByteArray): {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100}], \"int\" = [Variant(int): 42], \"short\" = [Variant(short): -47], \"uint\" = [Variant(uint): 42]}]]}]";

}

void tst_QDBusMarshall::sendComplex_data()

{

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

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

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

    QList<QDateTime> dtlist;

    QTest::newRow("empty-datetimelist") << qVariantFromValue(dtlist) << "a((iii)(iiii)i)"

            << "[Argument: a((iii)(iiii)i) {}]";