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

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

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

#include "../../../../src/bearer/qnetworkconfigmanager.h"

#include "../../../../src/bearer/qnetworksession.h"

#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)

#include <stdio.h>

#include <iapconf.h>

#endif

QTM_USE_NAMESPACE

// Can be used to configure tests that require manual attention (such as roaming)

//#define QNETWORKSESSION_MANUAL_TESTS 1

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

    void outOfProcessSession();

    void invalidSession();

    void repeatedOpenClose_data();

    void repeatedOpenClose();

    void roamingErrorCodes();

    void sessionStop_data();

    void sessionStop();

    void sessionProperties_data();

    void sessionProperties();

    void userChoiceSession_data();

    void userChoiceSession();

    void sessionOpenCloseStop_data();

    void sessionOpenCloseStop();

private:

    QNetworkConfigurationManager manager;

    uint inProcessSessionManagementCount;

#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)

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

void updateConfigurations();

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

#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)

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

    }

#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)

    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

}

// Robustness test for calling interfaces in nonsense order / with nonsense parameters

void tst_QNetworkSession::robustnessBombing() 

{

    QNetworkConfigurationManager mgr;

    QNetworkSession testSession(mgr.defaultConfiguration());

    // Should not reset even session is not opened

    testSession.migrate();

    testSession.accept();

    testSession.ignore();

    testSession.reject();

}

void tst_QNetworkSession::invalidSession()

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

    QNetworkSession session(QNetworkConfiguration(), 0);

    QVERIFY(!session.isOpen());

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

    // 2. 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);

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

    if (definedConfig.isValid()) {

        // TODO these timer waits should be changed to waiting appropriate signals, now these wait excessively

        qDebug() << "Shutdown WLAN IAP (waiting 60 seconds): " << definedConfig.name();

        QTest::qWait(60000);

        // Shutting down WLAN should bring back to defined -state.

        QVERIFY((definedConfig.state() & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined);

        QNetworkSession definedSession(definedConfig);

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

        QNetworkSession::SessionError sessionError;

        definedSession.open();

        QVERIFY(definedConfig.isValid()); // Session remains valid

        QVERIFY(definedSession.state() == QNetworkSession::NotAvailable); // State is not available because WLAN is not in coverage

        QVERIFY(!errorSpy.isEmpty()); // Session tells with error about invalidated configuration

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

        QVERIFY(sessionError == QNetworkSession::InvalidConfigurationError);

        qDebug() << "Turn the WLAN IAP back on (waiting 60 seconds): " << definedConfig.name();

        QTest::qWait(60000);

        QVERIFY(definedConfig.state() == QNetworkConfiguration::Discovered);

    }

#endif

}

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.

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

    }

       QVERIFY(openSession(&permanentSession));

       QVERIFY(closeSession(&permanentSession));

    }

}

#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

}

void tst_QNetworkSession::sessionStop_data() {

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

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

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

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

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

}

void tst_QNetworkSession::sessionStop() 

{

#ifndef Q_OS_SYMBIAN

    QSKIP("Testcase contains mainly Symbian specific checks, because it is only platform to really support interface (IAP-level) Stop.", SkipAll);

#endif 

    QFETCH(QString, bearerType);

    QFETCH(QNetworkConfiguration::Type, configurationType);

    int configWaitdelayInMs = 2000;