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

**

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

**

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

#include <QtTest/QtTest>

#include <QLocalServer>

#include <QLocalSocket>

#include "../../qbearertestcommon.h"

#include <qnetworkconfigmanager.h>

#include <qnetworksession.h>

#ifdef Q_WS_MAEMO_6

#include <stdio.h>

#include <iapconf.h>

#endif

QTM_USE_NAMESPACE

Q_DECLARE_METATYPE(QNetworkConfiguration)

Q_DECLARE_METATYPE(QNetworkConfiguration::Type);

Q_DECLARE_METATYPE(QNetworkSession::State);

Q_DECLARE_METATYPE(QNetworkSession::SessionError);

class tst_QNetworkSession : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void outOfProcessSession();

    void invalidSession();

    void repeatedOpenClose_data();

    void repeatedOpenClose();

    void roamingErrorCodes();

    void sessionProperties_data();

    void sessionProperties();

    void userChoiceSession_data();

    void userChoiceSession();

    void sessionOpenCloseStop_data();

    void sessionOpenCloseStop();

private:

    QNetworkConfigurationManager manager;

    uint inProcessSessionManagementCount;

#ifdef Q_WS_MAEMO_6

    Maemo::IAPConf *iapconf;

    Maemo::IAPConf *iapconf2;

    Maemo::IAPConf *gprsiap;

#define MAX_IAPS 10

    Maemo::IAPConf *iaps[MAX_IAPS];

    QProcess *icd_stub;

#endif

};

// Helper functions

bool openSession(QNetworkSession *session);

bool closeSession(QNetworkSession *session, bool lastSessionOnConfiguration = true);

QNetworkConfiguration suitableConfiguration(QString bearerType, QNetworkConfiguration::Type configType);

void tst_QNetworkSession::initTestCase()

{

    qRegisterMetaType<QNetworkSession::State>("QNetworkSession::State");

    qRegisterMetaType<QNetworkSession::SessionError>("QNetworkSession::SessionError");

    qRegisterMetaType<QNetworkConfiguration>("QNetworkConfiguration");

    qRegisterMetaType<QNetworkConfiguration::Type>("QNetworkConfiguration::Type");

#ifdef Q_WS_MAEMO_6

    iapconf = new Maemo::IAPConf("007");

    iapconf->setValue("ipv4_type", "AUTO");

    iapconf->setValue("wlan_wepkey1", "connt");

    iapconf->setValue("wlan_wepdefkey", 1);

    iapconf->setValue("wlan_ssid", QByteArray("JamesBond"));

    iapconf->setValue("name", "James Bond");

    iapconf->setValue("type", "WLAN_INFRA");

    gprsiap = new Maemo::IAPConf("This-is-GPRS-IAP");

    gprsiap->setValue("ask_password", false);

    gprsiap->setValue("gprs_accesspointname", "internet");

    gprsiap->setValue("gprs_password", "");

    gprsiap->setValue("gprs_username", "");

    gprsiap->setValue("ipv4_autodns", true);

    gprsiap->setValue("ipv4_type", "AUTO");

    gprsiap->setValue("sim_imsi", "244070123456789");

    gprsiap->setValue("name", "MI6");

    gprsiap->setValue("type", "GPRS");

    iapconf2 = new Maemo::IAPConf("osso.net");

    iapconf2->setValue("ipv4_type", "AUTO");

    iapconf2->setValue("wlan_wepkey1", "osso.net");

    iapconf2->setValue("wlan_wepdefkey", 1);

    iapconf2->setValue("wlan_ssid", QByteArray("osso.net"));

    iapconf2->setValue("name", "osso.net");

    iapconf2->setValue("type", "WLAN_INFRA");

    iapconf2->setValue("wlan_security", "WEP");

    /* Create large number of IAPs in the gconf and see what happens */

    fflush(stdout);

    printf("Creating %d IAPS: ", MAX_IAPS);

    for (int i=0; i<MAX_IAPS; i++) {

	QString num = QString().sprintf("%d", i);

	QString iap = "iap-" + num;

	iaps[i] = new Maemo::IAPConf(iap);

	iaps[i]->setValue("name", QString("test-iap-")+num);

	iaps[i]->setValue("type", "WLAN_INFRA");

	iaps[i]->setValue("wlan_ssid", QString(QString("test-ssid-")+num).toAscii());

	iaps[i]->setValue("wlan_security", "WPA_PSK");

	iaps[i]->setValue("EAP_wpa_preshared_passphrase", QString("test-passphrase-")+num);

	printf(".");

	fflush(stdout);

    }

    printf("\n");

    fflush(stdout);

    icd_stub = new QProcess(this);

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

    QTest::qWait(1000);

    // Add a known network to scan list that icd2 stub returns

    QProcess dbus_send;

    // 007 network

    dbus_send.start("dbus-send --type=method_call --system "

		    "--dest=com.nokia.icd2 /com/nokia/icd2 "

		    "com.nokia.icd2.testing.add_available_network "

		    "string:'' uint32:0 string:'' "

		    "string:WLAN_INFRA uint32:5000011 array:byte:48,48,55");

    dbus_send.waitForFinished();

    // osso.net network

    dbus_send.start("dbus-send --type=method_call --system "

		    "--dest=com.nokia.icd2 /com/nokia/icd2 "

		    "com.nokia.icd2.testing.add_available_network "

		    "string:'' uint32:0 string:'' "

		    "string:WLAN_INFRA uint32:83886097 array:byte:111,115,115,111,46,110,101,116");

    dbus_send.waitForFinished();

#endif

    inProcessSessionManagementCount = 0;

    QSignalSpy spy(&manager, SIGNAL(updateCompleted()));

    manager.updateConfigurations();

    QTRY_VERIFY(spy.count() == 1);

}

void tst_QNetworkSession::cleanupTestCase()

{

    if (!(manager.capabilities() & QNetworkConfigurationManager::SystemSessionSupport) &&

        (manager.capabilities() & QNetworkConfigurationManager::CanStartAndStopInterfaces) &&

        inProcessSessionManagementCount == 0) {

        QFAIL("No usable configurations found to complete all possible "

              "tests in inProcessSessionManagement()");

    }

#ifdef Q_WS_MAEMO_6

    iapconf->clear();

    delete iapconf;

    iapconf2->clear();

    delete iapconf2;

    gprsiap->clear();

    delete gprsiap;

    printf("Deleting %d IAPS : ", MAX_IAPS);

    for (int i=0; i<MAX_IAPS; i++) {

	iaps[i]->clear();

	delete iaps[i];

	printf(".");

	fflush(stdout);

    }

    printf("\n");

    qDebug() << "Deleted" << MAX_IAPS << "IAPs";

    icd_stub->terminate();

    icd_stub->waitForFinished();

#endif

}

void tst_QNetworkSession::invalidSession()

{

    // Verify that session created with invalid configuration remains in invalid state

    QNetworkSession session(QNetworkConfiguration(), 0);

    QVERIFY(!session.isOpen());

    QVERIFY(session.state() == QNetworkSession::Invalid);

    // Verify that opening session with invalid configuration both 1) emits invalidconfigurationerror

    // and 2) sets session's state as invalid.

    QSignalSpy errorSpy(&session, SIGNAL(error(QNetworkSession::SessionError)));

    session.open();

    session.waitForOpened(1000); // Should bail out right away

    QVERIFY(errorSpy.count() == 1); 

    QNetworkSession::SessionError error =

           qvariant_cast<QNetworkSession::SessionError> (errorSpy.first().at(0));

    QVERIFY(error == QNetworkSession::InvalidConfigurationError);

    QVERIFY(session.state() == QNetworkSession::Invalid);

    // Check same thing with a config from platform (there are subtle differences

    // because emtpy configuration does not have private pointer). Test with config 

    // in '(un)defined' state

    QList<QNetworkConfiguration> allConfigs = manager.allConfigurations();

    foreach(QNetworkConfiguration config, allConfigs) {

        if ((config.state() & QNetworkConfiguration::Discovered) != QNetworkConfiguration::Discovered) {

            QNetworkSession session2(config);

            QSignalSpy errorSpy2(&session2, SIGNAL(error(QNetworkSession::SessionError)));

            session2.open();

            session2.waitForOpened(1000); // Should bail out right away

            QVERIFY(errorSpy2.count() == 1); 

            QNetworkSession::SessionError error2 =

                       qvariant_cast<QNetworkSession::SessionError> (errorSpy2.first().at(0));

            QVERIFY(error2 == QNetworkSession::InvalidConfigurationError);

            QVERIFY(session2.state() == QNetworkSession::Invalid);

            break; // Once is enough

        }

    }

}

void tst_QNetworkSession::sessionProperties_data()

{

    QTest::addColumn<QNetworkConfiguration>("configuration");

    QTest::newRow("invalid configuration") << QNetworkConfiguration();

    foreach (const QNetworkConfiguration &config, manager.allConfigurations()) {

        const QString name = config.name().isEmpty() ? QString("<Hidden>") : config.name();

        QTest::newRow(name.toLocal8Bit().constData()) << config;

    }

}

void tst_QNetworkSession::sessionProperties()

{

    QFETCH(QNetworkConfiguration, configuration);

    QNetworkSession session(configuration);

    QVERIFY(session.configuration() == configuration);

    QStringList validBearerNames = QStringList() << QLatin1String("Unknown")

                                                 << QLatin1String("Ethernet")

                                                 << QLatin1String("WLAN")

                                                 << QLatin1String("2G")

                                                 << QLatin1String("CDMA2000")

                                                 << QLatin1String("WCDMA")

                                                 << QLatin1String("HSPA")

                                                 << QLatin1String("Bluetooth")

                                                 << QLatin1String("WiMAX");

    if (!configuration.isValid()) {

        QVERIFY(configuration.bearerName().isEmpty());

    } else {

        switch (configuration.type())

        {

            case QNetworkConfiguration::ServiceNetwork:

            case QNetworkConfiguration::UserChoice:

            default:

                QVERIFY(configuration.bearerName().isEmpty());

                break;

            case QNetworkConfiguration::InternetAccessPoint:

                QVERIFY(validBearerNames.contains(configuration.bearerName()));

                break;

        }

    }

    // QNetworkSession::interface() should return an invalid interface unless

    // session is in the connected state.

#if !(defined(Q_OS_SYMBIAN) && defined(__WINS__))

    // On Symbian emulator, the support for data bearers is limited

    QCOMPARE(session.state() == QNetworkSession::Connected, session.interface().isValid());

#endif

    if (!configuration.isValid()) {

        QVERIFY(configuration.state() == QNetworkConfiguration::Undefined &&

                session.state() == QNetworkSession::Invalid);

    } else {

        switch (configuration.state()) {

        case QNetworkConfiguration::Undefined:

            QVERIFY(session.state() == QNetworkSession::NotAvailable);

            break;

        case QNetworkConfiguration::Defined:

            QVERIFY(session.state() == QNetworkSession::NotAvailable);

            break;

        case QNetworkConfiguration::Discovered:

            QVERIFY(session.state() == QNetworkSession::Connecting ||

                    session.state() == QNetworkSession::Disconnected);

            break;

        case QNetworkConfiguration::Active:

            QVERIFY(session.state() == QNetworkSession::Connected ||

                    session.state() == QNetworkSession::Closing ||

                    session.state() == QNetworkSession::Roaming);

            break;

        default:

            QFAIL("Invalid configuration state");

        };

    }

}

void tst_QNetworkSession::repeatedOpenClose_data() {

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

    QTest::addColumn<QNetworkConfiguration::Type>("configurationType");

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

    QTest::newRow("WLAN_IAP") << "WLAN" << QNetworkConfiguration::InternetAccessPoint << 3;

    // QTest::newRow("Cellular_IAP") << "cellular" << QNetworkConfiguration::InternetAccessPoint << 3;

    // QTest::newRow("SNAP") << "bearer_type_not_relevant_with_SNAPs" << QNetworkConfiguration::ServiceNetwork << 3;

}

// Tests repeated-open close.

void tst_QNetworkSession::repeatedOpenClose() {

    QFETCH(QString, bearerType);

    QFETCH(QNetworkConfiguration::Type, configurationType);

    QFETCH(int, repeatTimes);

    // First check that opening once succeeds and determine if repeatable testing is doable

    QNetworkConfiguration config = suitableConfiguration(bearerType, configurationType);

    if (!config.isValid()) {

        QSKIP("No suitable configurations, skipping this round of repeated open-close test.", SkipSingle);

    }

    qDebug() << "Using following configuratio to repeatedly open and close: " << config.name();

    QNetworkSession permanentSession(config);

    if (!openSession(&permanentSession) || 

        !closeSession(&permanentSession)) {

        QSKIP("Unable to open/close session, skipping this round of repeated open-close test.", SkipSingle); 

    }

    for (int i = repeatTimes; i > 0; i--) { 

       QVERIFY(openSession(&permanentSession));

       QVERIFY(closeSession(&permanentSession));

    }

}

void tst_QNetworkSession::roamingErrorCodes() {

#ifndef Q_OS_SYMBIAN

    QSKIP("Roaming supported on Symbian.", SkipAll);

#else 

    QNetworkConfiguration wlanIapConfig = suitableConfiguration("WLAN", QNetworkConfiguration::InternetAccessPoint);

    if (!wlanIapConfig.isValid()) {

        QSKIP("No WLAN IAP accessible, skipping test.", SkipAll);

    }

    // Check that opening and closing two sessions on same config work gracefully:

    QNetworkSession iapSession(wlanIapConfig);

    QVERIFY(openSession(&iapSession));

    QNetworkSession adminIapSession(wlanIapConfig);

    QVERIFY(openSession(&adminIapSession));

    QVERIFY(closeSession(&iapSession, false)); // false == not a last session based on the configuration

    QVERIFY(closeSession(&adminIapSession));

    // Open configurations again, force close bearer and check that errors are emitted correctly

    // on the other session

    QVERIFY(openSession(&iapSession));

    QVERIFY(openSession(&adminIapSession));

    QSignalSpy errorSpy(&iapSession, SIGNAL(error(QNetworkSession::SessionError)));   

    adminIapSession.stop(); // requires NetworkControl capabilities

    QTRY_VERIFY(!errorSpy.isEmpty()); // wait for error signals

    QNetworkSession::SessionError error = qvariant_cast<QNetworkSession::SessionError>(errorSpy.first().at(0));

    QVERIFY(error == QNetworkSession::SessionAbortedError);

    QVERIFY(iapSession.state() == QNetworkSession::Disconnected);

    QVERIFY(adminIapSession.state() == QNetworkSession::Disconnected);

#endif // Q_OS_SYMBIAN

    /*

     // Check for roaming error. Challenging to automate, therefore commented out.

     // Case requires that you have controllable WLAN in Internet SNAP (only).

    QNetworkConfiguration snapConfig = suitableConfiguration("bearer_not_relevant_with_snaps", QNetworkConfiguration::ServiceNetwork);

    if (!snapConfig.isValid()) {

        QSKIP("No SNAP accessible, skipping test.", SkipAll);

    }

    QNetworkSession snapSession(snapConfig);

    QVERIFY(openSession(&snapSession));

    QSignalSpy errorSpySnap(&snapSession, SIGNAL(error(QNetworkSession::SessionError)));

    qDebug("Disconnect the WLAN now");

    QTRY_VERIFY(!errorSpySnap.isEmpty()); // wait for error signals

    QVERIFY(errorSpySnap.count() == 1);

    error = qvariant_cast<QNetworkSession::SessionError>(errorSpySnap.first().at(0));

    qDebug() << "Error received when turning off wlan on SNAP: " << error;

    QVERIFY(error == QNetworkSession::RoamingError);

    qDebug("Connect the WLAN now");

    QTest::qWait(60000); // Wait for WLAN to get up

    QNetworkConfiguration wlanIapConfig2 = suitableConfiguration("WLAN", QNetworkConfiguration::InternetAccessPoint);

    QNetworkSession iapSession2(wlanIapConfig2);

    QVERIFY(openSession(&iapSession2));

    QSignalSpy errorSpy2(&iapSession2, SIGNAL(error(QNetworkSession::SessionError)));

    qDebug("Disconnect the WLAN now");

    QTRY_VERIFY(!errorSpy2.isEmpty()); // wait for error signals

    QVERIFY(errorSpy2.count() == 1);

    error = qvariant_cast<QNetworkSession::SessionError>(errorSpy2.first().at(0));

    QVERIFY(error == QNetworkSession::SessionAbortedError);

    QVERIFY(iapSession2.state() == QNetworkSession::Disconnected);

    */

}

void tst_QNetworkSession::userChoiceSession_data()

{

    QTest::addColumn<QNetworkConfiguration>("configuration");

    QNetworkConfiguration config = manager.defaultConfiguration();

    if (config.type() == QNetworkConfiguration::UserChoice)

        QTest::newRow("UserChoice") << config;

    else

        QSKIP("Default configuration is not a UserChoice configuration.", SkipAll);

}

void tst_QNetworkSession::userChoiceSession()

{

    QFETCH(QNetworkConfiguration, configuration);

    QVERIFY(configuration.type() == QNetworkConfiguration::UserChoice);

    QNetworkSession session(configuration);

    // Check that configuration was really set

    QVERIFY(session.configuration() == configuration);

    QVERIFY(!session.isOpen());

    // Check that session is not active

    QVERIFY(session.sessionProperty("ActiveConfiguration").toString().isEmpty());

    // The remaining tests require the session to be not NotAvailable.

    if (session.state() == QNetworkSession::NotAvailable)

        QSKIP("Network is not available.", SkipSingle);

    QSignalSpy sessionOpenedSpy(&session, SIGNAL(opened()));

    QSignalSpy sessionClosedSpy(&session, SIGNAL(closed()));

    QSignalSpy stateChangedSpy(&session, SIGNAL(stateChanged(QNetworkSession::State)));

    QSignalSpy errorSpy(&session, SIGNAL(error(QNetworkSession::SessionError)));

    // Test opening the session.

    {

        bool expectStateChange = session.state() != QNetworkSession::Connected;

        session.open();

        session.waitForOpened();

        if (session.isOpen())

            QVERIFY(!sessionOpenedSpy.isEmpty() || !errorSpy.isEmpty());

        if (!errorSpy.isEmpty()) {

            QNetworkSession::SessionError error =

                qvariant_cast<QNetworkSession::SessionError>(errorSpy.first().at(0));

            if (error == QNetworkSession::OperationNotSupportedError) {

                // The session needed to bring up the interface,

                // but the operation is not supported.

                QSKIP("Configuration does not support open().", SkipSingle);

            } else if (error == QNetworkSession::InvalidConfigurationError) {

                // The session needed to bring up the interface, but it is not possible for the

                // specified configuration.

                if ((session.configuration().state() & QNetworkConfiguration::Discovered) ==

                    QNetworkConfiguration::Discovered) {

                    QFAIL("Failed to open session for Discovered configuration.");

                } else {

                    QSKIP("Cannot test session for non-Discovered configuration.", SkipSingle);

                }

            } else if (error == QNetworkSession::UnknownSessionError) {

                    QSKIP("Unknown session error.", SkipSingle);

            } else {

                QFAIL("Error opening session.");

            }

        } else if (!sessionOpenedSpy.isEmpty()) {

            QCOMPARE(sessionOpenedSpy.count(), 1);

            QVERIFY(sessionClosedSpy.isEmpty());

            QVERIFY(errorSpy.isEmpty());

            if (expectStateChange)

                QTRY_VERIFY(!stateChangedSpy.isEmpty());

            QVERIFY(session.state() == QNetworkSession::Connected);

#if !(defined(Q_OS_SYMBIAN) && defined(__WINS__))

            // On Symbian emulator, the support for data bearers is limited

            QVERIFY(session.interface().isValid());

#endif

            const QString userChoiceIdentifier =

                session.sessionProperty("UserChoiceConfiguration").toString();

            QVERIFY(!userChoiceIdentifier.isEmpty());

            QVERIFY(userChoiceIdentifier != configuration.identifier());

            QNetworkConfiguration userChoiceConfiguration =

                manager.configurationFromIdentifier(userChoiceIdentifier);

            QVERIFY(userChoiceConfiguration.isValid());

            QVERIFY(userChoiceConfiguration.type() != QNetworkConfiguration::UserChoice);

            const QString testIdentifier("abc");