/* * This file is part of conn-dui-settings-inet *

 *

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

 * All rights reserved.

 *

 * Contact: Aapo Makela <aapo.makela@nokia.com>

 *

 * This software, including documentation, is protected by copyright

 * controlled by Nokia Corporation. All rights are reserved. Copying,

 * including reproducing, storing, adapting or translating, any or all of

 * this material requires the prior written consent of Nokia Corporation.

 * This material also contains confidential information which may not be

 * disclosed to others without the prior written consent of Nokia.

 */

#include <QtTest/QtTest>

#include <QCoreApplication>

#include <QEventLoop>

#include <QDebug>

#include <icd/dbus_api.h>

#include <dbusdispatcher.h>

class Ut_DBusDispatcher : public QObject

{

    Q_OBJECT

private Q_SLOTS:

    void init();

    void cleanup();

    void initTestCase();

    void cleanupTestCase();

    void simpleSignalReceived(const QString& interface, 

                              const QString& signal,

                              const QList<QVariant>& args);

    void simpleCallReply(const QString& method, 

                         const QList<QVariant>& args,

                         const QString& error);

    void simpleCall();

    void complexCallReply(const QString& method, 

                          const QList<QVariant>& args,

                          const QString& error);

    void complexCall();

private:

    Maemo::DBusDispatcher *mSubject;

    QProcess *icd_stub;

    QString mMethod;

    QString mInterface;

    QString mSignal;

    QList<QVariant> mArgs;

};

void Ut_DBusDispatcher::init()

{

    mSubject = new Maemo::DBusDispatcher("com.nokia.icd2", "/com/nokia/icd2",

					 "com.nokia.icd2");

    // Start icd2 stub

    icd_stub = new QProcess(this);

    icd_stub->start("/usr/bin/icd2_stub.py");

    QTest::qWait(1000);

}

void Ut_DBusDispatcher::cleanup()

{

    // Terminate icd2 stub

    icd_stub->terminate();

    icd_stub->waitForFinished();

    delete mSubject;

    mSubject = 0;

}

void Ut_DBusDispatcher::initTestCase()

{

} 

void Ut_DBusDispatcher::cleanupTestCase()

{

}

void Ut_DBusDispatcher::simpleSignalReceived(const QString& interface, 

                                             const QString& signal,

                                             const QList<QVariant>& args)

{

    // Signal handler, which simply records what has been signalled

    mInterface = interface;

    mSignal = signal;

    mArgs = args;

}

void Ut_DBusDispatcher::simpleCallReply(const QString& method, 

                                        const QList<QVariant>& args,

                                        const QString& error)

{

    mMethod = method;

    // Check that method matches and at least WLAN_INFRA is returned

    QVERIFY(error.isEmpty());

    QVERIFY(args[0].toStringList().contains("WLAN_INFRA"));

}

void Ut_DBusDispatcher::simpleCall()

{

    uint flags = 0;

    QList<QVariant> reply;

    int idx = 0;

    QTimer timer;

    // Connect signals

    connect(mSubject, SIGNAL(signalReceived(const QString&, 

                                            const QString&,

                                            const QList<QVariant>&)),

            this, SLOT(simpleSignalReceived(const QString&, 

                                      const QString&,

                                      const QList<QVariant>&)));

    connect(mSubject, SIGNAL(callReply(const QString&,

                                       const QList<QVariant>&,

                                       const QString&)),

            this, SLOT(simpleCallReply(const QString&,

                                 const QList<QVariant>&,

                                 const QString&)));

    // Request scan and verify the call starts succesfully

    QVERIFY(mSubject->callAsynchronous("scan_req", flags));

    // Wait 1st scan signal for 10 secs

    timer.setSingleShot(true);

    timer.start(10000);

    while (timer.isActive() && mInterface.isEmpty()) {

        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);

        idx++;

    }

    timer.stop();

    // Sanity checks for the scan result

    QVERIFY(mInterface == "com.nokia.icd2");    // interface is icd2

    QVERIFY(mMethod == "scan_req");             // method is scan_req

    QVERIFY(mSignal == "scan_result_sig");      // signal is scan result

    QVERIFY(mArgs[0] == QVariant(0) ||

	    mArgs[0] == QVariant(4));           // First argument is status

                                                // (0 == NEW, 4 == COMPLETED)

    //QVERIFY(mArgs.contains(QVariant("WLAN_INFRA"))); // WLAN scan result

}

void Ut_DBusDispatcher::complexCallReply(const QString& method, 

                                         const QList<QVariant>& args,

                                         const QString& error)

{

    mMethod = method;

    // Check that method has not return arguments and error is not set

    QVERIFY(error.isEmpty());

    QVERIFY(args.isEmpty());

}

void Ut_DBusDispatcher::complexCall()

{    

    uint flags = ICD_CONNECTION_FLAG_UI_EVENT;

    QList<QVariant> reply;

    QVariantList networks;

    QVariantList network1;

    network1 << "" << (uint)0 << "" << "WLAN_INFRA" << (uint)0x05000011 << QByteArray("osso@46@net");

    networks << QVariant(network1);

    // Connect signal

    connect(mSubject, SIGNAL(callReply(const QString&,

                                       const QList<QVariant>&,

                                       const QString&)),

            this, SLOT(complexCallReply(const QString&,

                                        const QList<QVariant>&,

                                        const QString&)));

    // Request connect and verify the call starts succesfully

    QVERIFY(mSubject->callAsynchronous("connect_req", flags, networks));

    QTest::qWait(1000);

    // Sanity checks for the scan result

    QVERIFY(mInterface == "com.nokia.icd2");    // interface is icd2

    QVERIFY(mMethod == "connect_req");          // method connect_req

}

QTEST_MAIN(Ut_DBusDispatcher)

#include "ut_dbusdispatcher.moc"