summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/libconninet/tests
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/libconninet/tests')
-rw-r--r--src/3rdparty/libconninet/tests/Makefile.am39
-rw-r--r--src/3rdparty/libconninet/tests/ut_dbusdispatcher.cpp191
-rw-r--r--src/3rdparty/libconninet/tests/ut_iapconf.cpp186
-rw-r--r--src/3rdparty/libconninet/tests/ut_iapmonitor.cpp118
-rw-r--r--src/3rdparty/libconninet/tests/ut_maemo_icd.cpp274
-rw-r--r--src/3rdparty/libconninet/tests/ut_proxyconf.cpp400
6 files changed, 1208 insertions, 0 deletions
diff --git a/src/3rdparty/libconninet/tests/Makefile.am b/src/3rdparty/libconninet/tests/Makefile.am
new file mode 100644
index 0000000..f6f41ea
--- /dev/null
+++ b/src/3rdparty/libconninet/tests/Makefile.am
@@ -0,0 +1,39 @@
+DEFS = -DDBUS_API_SUBJECT_TO_CHANGE
+INCLUDES = @GLIB_CFLAGS@ @DBUS_CFLAGS@ @CONNSETTINGS_CFLAGS@ @OSSO_IC_CFLAGS@ @ICD_DEV_CFLAGS@ \
+ @QTCORE_CFLAGS@ @QTDBUS_CFLAGS@ @QTCORE_CFLAGS@ @QTNETWORK_CFLAGS@ @QTTEST_CFLAGS@ \
+ -I$(top_srcdir) \
+ -I$(top_srcdir)/src
+
+LIBS = @GLIB_LIBS@ @DBUS_LIBS@ @CONNSETTINGS_LIBS@ @OSSO_IC_LIBS@ @ICD_DEV_LIBS@ \
+ @QTCORE_LIBS@ @QTDBUS_LIBS@ @QTCORE_LIBS@ @QTNETWORK_LIBS@ @QTTEST_LIBS@ \
+ $(top_builddir)/src/libconninet.la
+
+AM_CFLAGS = $(CONCFLAGS)
+AM_LDFLAGS = -static
+
+bin_PROGRAMS = test_dbusdispatcher test_iapconf test_maemo_icd test_iapmonitor test_proxyconf
+
+test_dbusdispatcher_SOURCES = ut_dbusdispatcher.cpp
+ut_dbusdispatcher.o: ut_dbusdispatcher.moc
+
+test_iapconf_SOURCES = ut_iapconf.cpp
+ut_iapconf.o: ut_iapconf.moc
+
+test_maemo_icd_SOURCES = ut_maemo_icd.cpp
+ut_maemo_icd.o: ut_maemo_icd.moc
+
+test_iapmonitor_SOURCES = ut_iapmonitor.cpp
+ut_iapmonitor.o: ut_iapmonitor.moc
+
+test_proxyconf_SOURCES = ut_proxyconf.cpp
+ut_proxyconf.o: ut_proxyconf.moc
+
+
+MAINTAINERCLEANFILES = Makefile.in
+
+# This rule lets GNU make create any *.moc from the equivalent *.cpp
+%.moc: %.cpp
+ moc $< -o $@
+
+# This line ensures that generated moc files are deleted when we make clean.
+CLEANFILES = *.moc
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"
generated by cgit v0.12 at 2024-08-24 02:23:26 (GMT)