Add version 0.42 of libconninet.

Minor update. Fixes infinite loops.

5 files changed, 1169 insertions, 0 deletions

diff --git a/src/3rdparty/libconninet/tests/ut_dbusdispatcher.cpp b/src/3rdparty/libconninet/tests/ut_dbusdispatcher.cpp
new file mode 100644
index 0000000..70deb3f
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/ut_dbusdispatcher.cpp
@@ -0,0 +1,191 @@
+/* * 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"
diff --git a/src/3rdparty/libconninet/tests/ut_iapconf.cpp b/src/3rdparty/libconninet/tests/ut_iapconf.cpp
new file mode 100644
index 0000000..6a91d61
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/ut_iapconf.cpp
@@ -0,0 +1,186 @@
+/*
+  libconninet - Internet Connectivity support library
+
+  Copyright (C) 2009 Nokia Corporation. All rights reserved.
+
+  Contact: Aapo Makela <aapo.makela@nokia.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public License
+  version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+  02110-1301 USA
+*/
+
+
+#include <QtTest/QtTest>
+#include <QDebug>
+
+#include <iapconf.h>
+
+class Ut_IAPConf : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void init();
+    void cleanup();
+    void initTestCase();
+    void cleanupTestCase();
+
+    void setupIAP();
+    void setupIAPContainingDot();
+    void unsetIAPValueIsNotValid();
+    void verifyAllIAPs();
+    void allForEmptyConfReturnsEmptyList();
+    void settingInvalidValueUnsetsKey();
+
+private:
+    Maemo::IAPConf *mSubject;
+};
+
+void Ut_IAPConf::init()
+{
+    mSubject = new Maemo::IAPConf("test_iap");
+}
+
+void Ut_IAPConf::cleanup()
+{
+    // Clear made settings
+    mSubject->clear();
+
+    delete mSubject;
+    mSubject = 0;
+}
+
+void Ut_IAPConf::initTestCase()
+{
+} 
+
+void Ut_IAPConf::cleanupTestCase()
+{
+}
+
+void Ut_IAPConf::setupIAP()
+{
+    // Set bunch of values
+    mSubject->set("ipv4_type", "AUTO",
+                  "wlan_wepkey1", "connt",
+                  "wlan_wepdefkey", 1,
+                  "wlan_ssid", QByteArray("CONNTEST-1"));
+
+    // Set one value
+    mSubject->setValue("type", "WLAN_INFRA");
+
+    // Check all values that they were set correctly
+    QVERIFY(mSubject->value("ipv4_type").toString() == "AUTO");
+    QVERIFY(mSubject->value("wlan_wepkey1").toString() == "connt");
+    QVERIFY(mSubject->value("wlan_wepdefkey").toInt() == 1);
+    QVERIFY(mSubject->value("wlan_ssid").toByteArray() == QByteArray("CONNTEST-1"));
+    QVERIFY(mSubject->value("type").toString() == "WLAN_INFRA");
+}
+
+void Ut_IAPConf::setupIAPContainingDot()
+{
+    delete mSubject;
+    mSubject = new Maemo::IAPConf("test.iap");
+
+    // Set and check one value
+    mSubject->setValue("type", "DUMMY");
+    QVERIFY(mSubject->value("type").toString() == "DUMMY");
+}
+
+void Ut_IAPConf::unsetIAPValueIsNotValid()
+{
+    QVariant invalidValue = mSubject->value("this_value_does_not_exist");
+    QVERIFY(invalidValue.isValid() == false);
+}
+
+void Ut_IAPConf::verifyAllIAPs()
+{
+    int count = 0, extras = 0;
+    QRegExp regexp("iap[1-3]");
+    Maemo::IAPConf iap1("iap1");
+    Maemo::IAPConf iap2("iap2");
+    Maemo::IAPConf iap3("iap3");
+
+    iap1.clear();
+    iap2.clear();
+    iap3.clear();
+
+    iap1.setValue("name", "iap1");
+    iap2.setValue("name", "iap2");
+    iap3.setValue("name", "iap3");
+
+    count = extras = 0;
+    QList<QString> iaps;
+    Maemo::IAPConf::getAll(iaps, true);
+    foreach (QString iap_path, iaps) {
+        QString iap_id = iap_path.section('/', 5);  /* This is the IAP id */
+	if (!iap_id.contains(regexp)) {
+	    extras++;
+	    continue;
+	}
+	Maemo::IAPConf iap(iap_id);
+	QString name = iap.value("name").toString();
+	QVERIFY(name == iap_id);
+	count++;
+    }
+    QCOMPARE(count, iaps.size()-extras);
+
+    iap1.clear();
+    iap2.clear();
+    iap3.clear();
+
+    iap1.setValue("name", "iap1");
+    iap2.setValue("name", "iap2");
+    iap3.setValue("name", "iap3");
+
+    count = extras = 0;
+    Maemo::IAPConf::getAll(iaps);
+    foreach (QString iap_id, iaps) {
+        if (!iap_id.contains(regexp)) {
+	    extras++;
+	    continue;
+	}
+	Maemo::IAPConf iap(iap_id);
+	QString name = iap.value("name").toString();
+	QVERIFY(name == iap_id);
+	count++;
+    }
+    QCOMPARE(count, iaps.size()-extras);
+}
+
+void Ut_IAPConf::allForEmptyConfReturnsEmptyList()
+{
+    // Clear everything in configuration
+    mSubject->clearAll();
+
+    // Get all for a list and check that it is empty
+    QStringList iaps;
+    mSubject->getAll(iaps);
+    QVERIFY(iaps.isEmpty());
+}
+
+void Ut_IAPConf::settingInvalidValueUnsetsKey()
+{
+    // Setup some IAP
+    setupIAP();
+
+    // Set invalid value to unset "wlan_wepdefkey" key and verify that the
+    // value is unset
+    mSubject->setValue("wlan_wepdefkey", QVariant());
+    QVERIFY(!mSubject->value("wlan_wepdefkey").isValid());
+}
+
+QTEST_MAIN(Ut_IAPConf)
+
+#include "ut_iapconf.moc"
diff --git a/src/3rdparty/libconninet/tests/ut_iapmonitor.cpp b/src/3rdparty/libconninet/tests/ut_iapmonitor.cpp
new file mode 100644
index 0000000..f14f623
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/ut_iapmonitor.cpp
@@ -0,0 +1,118 @@
+/*
+  libconninet - Internet Connectivity support library
+
+  Copyright (C) 2009-2010 Nokia Corporation. All rights reserved.
+
+  Contact: Jukka Rissanen <jukka.rissanen@nokia.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public License
+  version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+  02110-1301 USA
+*/
+
+
+#include <QtTest/QtTest>
+#include <QDebug>
+
+#include <iapmonitor.h>
+#include <iapconf.h>
+
+static const char *iap_id = "test_monitor_1";
+
+class TestIAPMonitor : public Maemo::IAPMonitor
+{
+public:
+    QString addedIap;
+    QString removedIap;
+    
+protected:
+    virtual void iapAdded(const QString &id)
+    {
+        addedIap = id;
+    }
+
+    virtual void iapRemoved(const QString &id)
+    {
+        removedIap = id;
+    }
+};
+
+class Ut_IAPMonitor : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void init();
+    void cleanup();
+    void initTestCase();
+    void cleanupTestCase();
+
+    void check();
+
+private:
+    TestIAPMonitor *mon;
+    Maemo::IAPConf *iap;
+};
+
+void Ut_IAPMonitor::init()
+{
+    mon = new TestIAPMonitor;
+}
+
+void Ut_IAPMonitor::cleanup()
+{
+    delete mon;
+    mon = 0;
+}
+
+void Ut_IAPMonitor::initTestCase()
+{
+} 
+
+void Ut_IAPMonitor::cleanupTestCase()
+{
+}
+
+void Ut_IAPMonitor::check()
+{
+    QVERIFY(mon->addedIap.isEmpty());
+
+    iap = new Maemo::IAPConf(iap_id);
+    iap->set("ipv4_type", "AUTO",
+	    "wlan_wepkey1", "connt",
+	    "wlan_wepdefkey", 1,
+	    "wlan_ssid", QByteArray(iap_id));
+    
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+    QVERIFY(mon->addedIap == iap_id);
+    mon->addedIap.clear();
+
+    QVERIFY(mon->removedIap.isEmpty());
+
+    // Unset only one value and verify that IAP is not removed
+    iap->set("ipv4_type", QVariant());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+    QVERIFY(mon->removedIap.isEmpty());
+
+    // Clear the whole IAP and check that it is removed
+    iap->clear();
+    delete iap;
+
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QVERIFY(mon->removedIap == iap_id);
+}
+
+QTEST_MAIN(Ut_IAPMonitor)
+
+#include "ut_iapmonitor.moc"
diff --git a/src/3rdparty/libconninet/tests/ut_maemo_icd.cpp b/src/3rdparty/libconninet/tests/ut_maemo_icd.cpp
new file mode 100644
index 0000000..494829d
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/ut_maemo_icd.cpp
@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ *
+ * Contact: Jukka Rissanen <jukka.rissanen@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+
+// !!!!
+// !!!! NOTE: THESE TEST DO NOT REALLY WORK YET BECAUSE OF MISSING
+// !!!!       FUNCTIONALITY IN ICD2 STUB. YOU HAVE BEEN WARNED.
+// !!!!
+
+
+#include <QtTest/QtTest>
+#include <QCoreApplication>
+#include <QEventLoop>
+#include <QDebug>
+#include <icd/dbus_api.h>
+
+#include "maemo_icd.h"
+
+class Ut_MaemoIcd : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void init();
+    void cleanup();
+    void initTestCase();
+    void cleanupTestCase();
+
+    void scan_req();
+    void scan_cancel_req();
+    void connect_req_default();
+    void state_req_all();
+    void state_req();
+    void statistics_req_all();
+    void statistics_req();
+    void addrinfo_req_all();
+    void addrinfo_req();
+
+private:
+    void disconnect_req_default(); // this is currently not run
+    void connect_req_specific();   // this is currently not run
+    QProcess *icd_stub;
+    bool connect_iap(Maemo::IcdConnectResult &connect_result,
+		     QString &result,
+		     QString &error,
+		     QString iap=QString());
+};
+
+
+QString create_error_str(Maemo::Icd &icd)
+{
+    return icd.error();
+}
+
+
+void Ut_MaemoIcd::init()
+{
+    icd_stub = new QProcess(this);
+    icd_stub->setStandardOutputFile("/tmp/ut_maemo_icd.log");
+    icd_stub->start("/usr/bin/icd2_stub.py");
+    QTest::qWait(1000);
+
+    // Set the statistics
+    QProcess dbus_send;
+    dbus_send.start("dbus-send --type=method_call --system "
+		    "--dest=com.nokia.icd2 /com/nokia/icd2 "
+		    "com.nokia.icd2.testing.set_statistics "
+		    "uint32:1024 uint32:256");
+    dbus_send.waitForFinished();
+
+}
+
+void Ut_MaemoIcd::cleanup()
+{
+    icd_stub->terminate();
+    icd_stub->waitForFinished();
+}
+
+void Ut_MaemoIcd::initTestCase()
+{
+} 
+
+void Ut_MaemoIcd::cleanupTestCase()
+{
+}
+
+void Ut_MaemoIcd::scan_req()
+{    
+    QList<Maemo::IcdScanResult> scanned;
+    QStringList scannedNetworkTypes;
+    QStringList networkTypesToScan;
+    QString error;
+    Maemo::Icd icd(ICD_SHORT_SCAN_TIMEOUT);
+
+    scannedNetworkTypes = icd.scan(ICD_SCAN_REQUEST_ACTIVE,
+				   networkTypesToScan,
+				   scanned,
+				   error);
+    QVERIFY(error.isEmpty());
+    QCOMPARE(scanned.size(), 3);
+    QVERIFY(scannedNetworkTypes[0] == "WLAN_INFRA");
+    QVERIFY(scannedNetworkTypes[1] == "DUN_GSM_PS");
+}
+
+void Ut_MaemoIcd::scan_cancel_req()
+{
+    Maemo::Icd icd;
+    icd.scanCancel();
+    // Not much to verify here
+}
+
+bool Ut_MaemoIcd::connect_iap(Maemo::IcdConnectResult &connect_result,
+			      QString &result,
+			      QString &error,
+			      QString iap)
+{
+    icd_connection_flags flags = ICD_CONNECTION_FLAG_USER_EVENT;
+    bool st;
+    Maemo::Icd icd(ICD_SHORT_CONNECT_TIMEOUT);
+
+    if (iap.isEmpty()) {
+      qDebug() << "connecting to default IAP";
+      st = icd.connect(flags, connect_result);
+    } else {
+      qDebug() << "connecting to" << iap;
+      st = icd.connect(flags, iap, result);
+    }
+
+    error = create_error_str(icd);
+    return st;
+}
+
+void Ut_MaemoIcd::connect_req_default()
+{
+    Maemo::IcdConnectResult connect_result;
+    QString result, error;
+    bool st;
+    st = connect_iap(connect_result, result, error);
+    QVERIFY2(st, error.toAscii().data());
+    result = connect_result.connect.network_id.data();
+    qDebug() << result;
+}
+
+
+void Ut_MaemoIcd::disconnect_req_default()
+{
+    icd_connection_flags flags = ICD_CONNECTION_FLAG_USER_EVENT;
+    bool st;
+    Maemo::Icd icd(ICD_SHORT_CONNECT_TIMEOUT);
+    icd.disconnect(flags);
+}
+
+
+void Ut_MaemoIcd::connect_req_specific()
+{
+    Maemo::IcdConnectResult connect_result;
+    QString result;
+    QString error;
+    bool st;
+    st = connect_iap(connect_result, result, error, "wpa2gx2.osso.net");
+    QVERIFY2(st, error.toAscii().data());
+    qDebug() << result;
+}
+
+
+void Ut_MaemoIcd::state_req_all()
+{
+    QList<Maemo::IcdStateResult> state_results;
+    Maemo::Icd icd;
+    int sig;
+    sig = icd.state(state_results);
+    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
+}
+
+
+void Ut_MaemoIcd::state_req()
+{
+    Maemo::IcdStateResult state_result;
+    Maemo::Icd icd;
+    int sig;
+    QString service_type, service_id;
+    QString network_type("WLAN_INFRA");
+    QByteArray network_id("wpa2gx2.osso.net");
+    sig = icd.state(service_type, 0, service_id,
+		    network_type, (uint)0x17a1, network_id,
+		    state_result);
+    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
+}
+
+
+void Ut_MaemoIcd::statistics_req_all()
+{
+    QList<Maemo::IcdStatisticsResult> stats_results;
+    Maemo::Icd icd;
+    int sig;
+    QString err;
+    sig = icd.statistics(stats_results);
+    err = create_error_str(icd);
+    if (!err.isEmpty())
+      QVERIFY2(sig==1, err.toAscii().data());
+    else
+      QCOMPARE(sig, 1);
+
+    for(int i=0; i<sig; i++) {
+        QVERIFY(stats_results[i].bytes_received == 1024);
+        QVERIFY(stats_results[i].bytes_sent == 256);
+    }
+}
+
+
+// Can be uncommented when needed function is enabled in Icd class
+void Ut_MaemoIcd::statistics_req()
+{
+    Maemo::IcdStatisticsResult stats_result;
+    Maemo::Icd icd;
+    int sig;
+    QString service_type, service_id;
+    QString network_type("WLAN_INFRA");
+    QByteArray network_id("wpa2gx2.osso.net");
+    sig = icd.statistics(service_type, 0, service_id,
+			 network_type, (uint)0x17a1, network_id,
+			 stats_result);
+    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
+    QVERIFY(stats_result.bytes_received == 1024);
+    QVERIFY(stats_result.bytes_sent == 256);
+}
+
+
+void Ut_MaemoIcd::addrinfo_req_all()
+{
+    QList<Maemo::IcdAddressInfoResult> addr_results;
+    Maemo::Icd icd;
+    int sig;
+    sig = icd.addrinfo(addr_results);
+    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
+}
+
+
+void Ut_MaemoIcd::addrinfo_req()
+{
+    Maemo::IcdAddressInfoResult addr_result;
+    Maemo::Icd icd;
+    int sig;
+    QString service_type, service_id;
+    QString network_type("WLAN_INFRA");
+    QByteArray network_id("wpa2gx2.osso.net");
+    sig = icd.addrinfo(service_type, 0, service_id,
+			 network_type, (uint)0x17a1, network_id,
+			 addr_result);
+    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
+}
+
+
+QTEST_MAIN(Ut_MaemoIcd)
+
+#include "ut_maemo_icd.moc"
diff --git a/src/3rdparty/libconninet/tests/ut_proxyconf.cpp b/src/3rdparty/libconninet/tests/ut_proxyconf.cpp
new file mode 100644
index 0000000..1f407f0
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/ut_proxyconf.cpp
@@ -0,0 +1,400 @@
+/*
+  libconninet - Internet Connectivity support library
+
+  Copyright (C) 2010 Nokia Corporation. All rights reserved.
+
+  Contact: Jukka Rissanen <jukka.rissanen@nokia.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public License
+  version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+  02110-1301 USA
+*/
+
+
+#include <QtTest/QtTest>
+#include <QDebug>
+#include <QNetworkProxy>
+#include <conn_settings.h>
+
+#include "../src/proxyconf.h"
+
+class Ut_ProxyConf : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void init();
+    void cleanup();
+    void initTestCase();
+    void cleanupTestCase();
+
+    // tests without the factory
+    void proxy_ftp_no_factory_ok_auto();
+    void proxy_ftp_no_factory_ok_manual();
+    void proxy_http_no_factory_ok_manual();
+    void proxy_https_no_factory_ok_manual();
+    void proxy_socks_no_factory_ok_manual();
+    void proxy_default_no_factory_ok_manual();
+
+    // tests using the factory
+    void proxy_ftp_factory_ok_auto();
+    void proxy_ftp_factory_ok_manual();
+    void proxy_http_factory_ok_manual();
+    void proxy_https_factory_ok_manual();
+    void proxy_socks_factory_ok_manual();
+    void proxy_http_factory_ok_manual_clear();
+    void proxy_default_factory_ok_manual();
+    void proxy_http_factory_ok_manual_ignore_list();
+    void proxy_default_factory_ok_manual_system();
+
+private:
+    Maemo::ProxyConf *pc;
+};
+
+
+void put(QString var, QString type, QString value)
+{
+    QProcess gconf;
+    if (value.isEmpty())
+        gconf.start(QString("gconftool-2 -u /system/proxy/"+var));
+    else
+        gconf.start(QString("gconftool-2 -s /system/proxy/"+var+" -t "+type+" "+value));
+    gconf.waitForFinished();
+}
+
+void put_http(QString var, QString type, QString value)
+{
+    QProcess gconf;
+    if (value.isEmpty())
+        gconf.start(QString("gconftool-2 -u /system/http_proxy/"+var));
+    else
+        gconf.start(QString("gconftool-2 -s /system/http_proxy/"+var+" -t "+type+" "+value));
+    gconf.waitForFinished();
+}
+
+void put_list(QString var, QString type, QList<QString> value)
+{
+    QProcess gconf;
+    QString values = "[";
+    foreach (QString str, value)
+        values = values + str + ",";
+    values.chop(1);
+    values = values + "]";
+
+    gconf.start(QString("gconftool-2 -s /system/http_proxy/"+var+" -t list --list-type="+type+" "+values));
+    gconf.waitForFinished();
+}
+
+
+void Ut_ProxyConf::init()
+{
+    put_http("host", "string", "my.proxy.com");
+    put_http("port", "int", "8080");
+
+    QList<QString> list;
+    list.append("foo.bar.com");
+    list.append("192.168.19.69");
+    list.append("192.168.20.0/24");
+    list.append("bar.foo.com");
+    put_list("ignore_hosts", "string", list);
+    put_http("use_http_host", "boolean", "true");
+
+    put("mode", "string", "auto");
+    put("autoconfig_url", "string", "http://foo.bar.com/autoconf");
+    put("secure_host", "string", "secure_host.com");
+    put("secure_port", "int", "112");
+
+    put("ftp_host", "string", "ftp.nuukia.com");
+    put("ftp_port", "int", "2000");
+    put("socks_host", "string", "socks.host.com");
+    put("socks_port", "int", "10080");
+    put("rtsp_host", "string", "rtsp.voice.com");
+    put("rtsp_port", "int", "1554");
+
+    pc = new Maemo::ProxyConf();
+}
+
+void Ut_ProxyConf::cleanup()
+{
+    delete pc;
+    pc = 0;
+}
+
+void Ut_ProxyConf::initTestCase()
+{
+} 
+
+void Ut_ProxyConf::cleanupTestCase()
+{
+}
+
+
+void Ut_ProxyConf::proxy_ftp_no_factory_ok_auto()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("ftp://maps.google.com/"));
+
+    nplist = pc->flush(query);
+    QVERIFY(nplist.length()==0);
+}
+
+
+void Ut_ProxyConf::proxy_ftp_no_factory_ok_manual()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("ftp://maps.google.com/"));
+
+    put("mode", "string", "manual");
+
+    nplist = pc->flush(query);
+    foreach (QNetworkProxy proxy, nplist) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(nplist.length()==3);
+    QVERIFY(nplist.first().type() == QNetworkProxy::FtpCachingProxy);
+}
+
+
+void Ut_ProxyConf::proxy_http_no_factory_ok_manual()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+
+    put("mode", "string", "manual");
+
+    nplist = pc->flush(query);
+    foreach (QNetworkProxy proxy, nplist) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(nplist.length()==3);
+    QVERIFY(nplist.first().type() == QNetworkProxy::HttpProxy);
+}
+
+
+void Ut_ProxyConf::proxy_https_no_factory_ok_manual()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("https://maps.google.com/"));
+
+    put("mode", "string", "manual");
+
+    nplist = pc->flush(query);
+    foreach (QNetworkProxy proxy, nplist) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(nplist.length()==2);
+    QVERIFY(nplist.first().type() == QNetworkProxy::HttpProxy);
+}
+
+
+void Ut_ProxyConf::proxy_socks_no_factory_ok_manual()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+
+    put("mode", "string", "manual");
+    put_http("host", "string", "");
+
+    nplist = pc->flush(query);
+    foreach (QNetworkProxy proxy, nplist) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(nplist.length()==2);
+    QVERIFY(nplist.first().type() == QNetworkProxy::Socks5Proxy);
+}
+
+
+void Ut_ProxyConf::proxy_default_no_factory_ok_manual()
+{
+    QList<QNetworkProxy> nplist;
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("foobar://maps.google.com/"));
+
+    put("mode", "string", "manual");
+    put("socks_host", "string", "");
+    put("secure_host", "string", "");
+
+    nplist = pc->flush(query);
+    foreach (QNetworkProxy proxy, nplist) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(nplist.length()==0);
+}
+
+
+void Ut_ProxyConf::proxy_ftp_factory_ok_auto()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("ftp://maps.google.com/"));
+    Maemo::ProxyConf::update();
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+    QVERIFY(listOfProxies.length()==1);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::NoProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_ftp_factory_ok_manual()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("ftp://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==3);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::FtpCachingProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_http_factory_ok_manual()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==3);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::HttpProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_https_factory_ok_manual()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("https://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==2);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::HttpProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_socks_factory_ok_manual()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+    put_http("host", "string", "");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==2);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::Socks5Proxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_http_factory_ok_manual_clear()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+    put_http("host", "string", "192.168.1.1");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==3);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::HttpProxy);
+
+    Maemo::ProxyConf::clear();
+    listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+    QVERIFY(listOfProxies.length()==1);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::NoProxy);
+}
+
+
+void Ut_ProxyConf::proxy_default_factory_ok_manual()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("foobar://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+    put("socks_host", "string", "");
+    put("secure_host", "string", "");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    QVERIFY(listOfProxies.length()==1);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::NoProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_http_factory_ok_manual_ignore_list()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://192.168.19.70/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+
+    foreach (QNetworkProxy proxy, listOfProxies) {
+      qDebug() << "proxy: " << proxy.hostName() << "port" << proxy.port();
+    }
+    QVERIFY(listOfProxies.length()==3);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::HttpProxy);
+
+    query = QNetworkProxyQuery(QUrl("http://192.168.20.10/"));
+    listOfProxies = QNetworkProxyFactory::proxyForQuery(query);
+    QVERIFY(listOfProxies.length()==1);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::NoProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+void Ut_ProxyConf::proxy_default_factory_ok_manual_system()
+{
+    QNetworkProxyQuery query = QNetworkProxyQuery(QUrl("http://maps.google.com/"));
+    Maemo::ProxyConf::update();
+
+    put("mode", "string", "manual");
+
+    QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::systemProxyForQuery(query);
+
+    QVERIFY(listOfProxies.length()==1);
+    QVERIFY(listOfProxies.first().type() == QNetworkProxy::NoProxy);
+    Maemo::ProxyConf::clear();
+}
+
+
+
+
+QTEST_MAIN(Ut_ProxyConf)
+
+#include "ut_proxyconf.moc"