Merge lp:~unity-api-team/indicator-network/connectity-api-beginnings into lp:indicator-network/15.10

[Pete Woods]

Add flight mode and wifi toggles to connectivity service interface

Add flight mode and wifi toggles to connectivity service interface

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:495
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/333/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-amd64-ci/122
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/122
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/122/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/333/rebuild

review: Approve (continuous-integration)

[Ted Gould (ted)]

On Wed, 2015-04-22 at 10:09 +0000, Pete Woods wrote:

> Add flight mode and wifi toggles to connectivity service interface

It seems odd to me that we're adding to dbus whether the value is
changing.

+ <property name="FlightMode" type="b" access="read"/>
+ <property name="FlightModeIsChanging" type="b" access="read"/>
+
+ <property name="WifiEnabled" type="b" access="read"/>
+ <property name="WifiEnabledIsChanging" type="b" access="read"/>

Why would an application care if the value is changing?

[lp:~unity-api-team/indicator-network/connectity-api-beginnings]

496. By Pete Woods on 2015-04-23

Robustify the tests

[Pete Woods (pete-woods)]

The purpose of those properties (have now merged into one property) is to allow simple data binding in a client application for when to enable / disable the wifi and flight mode toggle buttons.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:496
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/334/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-amd64-ci/123/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/123
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/123/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/334/rebuild

review: Needs Fixing (continuous-integration)

[lp:~unity-api-team/indicator-network/connectity-api-beginnings]

497. By Pete Woods on 2015-04-23

Make the unit tests resistant against the dbus connection closing (as you should expect in a test case)

498. By Pete Woods on 2015-04-23

Use built in notification daemon template, instead of custom mock

499. By Pete Woods on 2015-04-23

Test that all the signals are emitted

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:498
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/336/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-amd64-ci/125
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/125
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/125/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/336/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:499
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/338/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-amd64-ci/127
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/127
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-vivid-armhf-ci/127/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/338/rebuild

review: Approve (continuous-integration)

[Marcus Tomlinson (marcustomlinson)]

Diff is sane, still seems functionality sound, plus test coverage is looking good too. +1

Just a note on test coverage:

692 + if (!d->m_systemConnection.registerObject(NM_DBUS_PATH_SECRET_AGENT, this)) {
693 throw logic_error(

Its tricky to recreate some of these failure conditions, but we should consider coming back some time to test things like this. I.e. check that the indicator doesn't completely fall apart when these exceptions are thrown.

review: Approve

[Ted Gould (ted)]

Applications don't need to toggle the buttons, they only need to know the
state of things. The only person chaning it should be the network
indicator.

On Thursday, April 23, 2015 11:04:06 AM BST, Pete Woods wrote:
> The purpose of those properties (have now merged into one
> property) is to allow simple data binding in a client
> application for when to enable / disable the wifi and flight
> mode toggle buttons.

=== modified file 'data/com.ubuntu.connectivity1.NetworkingStatus.xml'
--- data/com.ubuntu.connectivity1.NetworkingStatus.xml	2015-03-20 15:24:02 +0000
+++ data/com.ubuntu.connectivity1.NetworkingStatus.xml	2015-04-23 13:23:11 +0000
@@ -6,6 +6,11 @@
         <property name="Limitations" type="as" access="read"/>
         <property name="Status" type="s" access="read"/>
 
+        <property name="FlightMode" type="b" access="read"/>
+        <property name="WifiEnabled" type="b" access="read"/>
+
+        <property name="UnstoppableOperationHappening" type="b" access="read"/>
+
     </interface>
 </node>
 
 
=== modified file 'data/com.ubuntu.connectivity1.Private.xml'
--- data/com.ubuntu.connectivity1.Private.xml	2015-03-23 14:46:24 +0000
+++ data/com.ubuntu.connectivity1.Private.xml	2015-04-23 13:23:11 +0000
@@ -9,6 +9,14 @@
         <method name="UnlockModem">
             <arg type="s" direction="in" name="modem"/>
         </method>
+        
+        <method name="SetFlightMode">
+            <arg type="b" direction="in" name="enabled"/>
+        </method>
+
+        <method name="SetWifiEnabled">
+            <arg type="b" direction="in" name="enabled"/>
+        </method>
 
     </interface>
 </node>
 
=== added file 'data/org.freedesktop.DBus.Properties.xml'
--- data/org.freedesktop.DBus.Properties.xml	1970-01-01 00:00:00 +0000
+++ data/org.freedesktop.DBus.Properties.xml	2015-04-23 13:23:11 +0000
@@ -0,0 +1,27 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+                      "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.freedesktop.DBus.Properties">
+    <method name="Get">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="out"/>
+    </method>
+    <method name="GetAll">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="a{sv}" name="properties" direction="out"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+    </method>
+    <method name="Set">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="in"/>
+    </method>
+    <signal name="PropertiesChanged">
+      <arg type="s" name="interface_name"/>
+      <arg type="a{sv}" name="changed_properties"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
+      <arg type="as" name="invalidated_properties"/>
+    </signal>
+  </interface>
+</node>
 
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-04-23 13:23:11 +0000
+++ src/CMakeLists.txt	2015-04-23 13:23:11 +0000
@@ -3,6 +3,8 @@
     set(COMMON_FLAGS "${COMMON_FLAGS} -Werror")
 endif()
 
+add_subdirectory(connectivity-api)
+
 add_subdirectory(indicator)
 add_subdirectory(menumodel-cpp)
 add_subdirectory(qdbus-stubs)
 
=== added directory 'src/connectivity-api'
=== added file 'src/connectivity-api/CMakeLists.txt'
--- src/connectivity-api/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/CMakeLists.txt	2015-04-23 13:23:11 +0000
@@ -0,0 +1,4 @@
+
+#add_subdirectory(connectivity-cpp)
+add_subdirectory(connectivity-qt)
+add_subdirectory(connectivity-qml)
 \ No newline at end of file
 
=== renamed directory 'src/connectivity-cpp' => 'src/connectivity-api/connectivity-cpp'
=== added directory 'src/connectivity-api/connectivity-qml'
=== added file 'src/connectivity-api/connectivity-qml/CMakeLists.txt'
=== added directory 'src/connectivity-api/connectivity-qt'
=== added file 'src/connectivity-api/connectivity-qt/CMakeLists.txt'
--- src/connectivity-api/connectivity-qt/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/connectivity-qt/CMakeLists.txt	2015-04-23 13:23:11 +0000
@@ -0,0 +1,52 @@
+
+include_directories("${CMAKE_SOURCE_DIR}/src/qdbus-stubs")
+
+set(
+    CONNECTIVITY_QT_SRC
+    connectivityqt/internal/dbus-property-cache.cpp
+    connectivityqt/connectivity.cpp
+)
+
+set_source_files_properties(
+    "${DATA_DIR}/org.freedesktop.DBus.Properties.xml"
+    "${DATA_DIR}/com.ubuntu.connectivity1.NetworkingStatus.xml"
+    "${DATA_DIR}/com.ubuntu.connectivity1.Private.xml"
+    PROPERTIES
+    NO_NAMESPACE YES
+)
+
+
+qt5_add_dbus_interface(
+    CONNECTIVITY_QT_SRC
+    "${DATA_DIR}/com.ubuntu.connectivity1.NetworkingStatus.xml"
+    NetworkingStatusInterface
+)
+
+qt5_add_dbus_interface(
+    CONNECTIVITY_QT_SRC
+    "${DATA_DIR}/com.ubuntu.connectivity1.Private.xml"
+    NetworkingStatusPrivateInterface
+)
+
+qt5_add_dbus_interface(
+    CONNECTIVITY_QT_SRC
+    "${DATA_DIR}/org.freedesktop.DBus.Properties.xml"
+    PropertiesInterface
+)
+
+add_library(
+    connectivity-qt
+    SHARED
+    ${CONNECTIVITY_QT_SRC}
+)
+
+qt5_use_modules(
+    connectivity-qt
+    Core
+    DBus
+)
+
+target_link_libraries(
+    connectivity-qt
+    qdbus-stubs
+)
 
=== added directory 'src/connectivity-api/connectivity-qt/connectivityqt'
=== added file 'src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp'
--- src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp	2015-04-23 13:23:11 +0000
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Pete Woods <[e-mail]>
+ */
+
+#include <connectivityqt/connectivity.h>
+#include <connectivityqt/internal/dbus-property-cache.h>
+#include <dbus-types.h>
+#include <NetworkingStatusInterface.h>
+#include <NetworkingStatusPrivateInterface.h>
+
+#include <QDebug>
+
+using namespace std;
+
+namespace connectivityqt
+{
+
+class Connectivity::Priv: public QObject
+{
+    Q_OBJECT
+public:
+    Priv(Connectivity& parent, const QDBusConnection& sessionConnection) :
+            p(parent), m_sessionConnection(sessionConnection)
+    {
+    }
+
+    Connectivity& p;
+
+    QDBusConnection m_sessionConnection;
+
+    shared_ptr<internal::DBusPropertyCache> m_propertyCache;
+
+    shared_ptr<ComUbuntuConnectivity1NetworkingStatusInterface> m_readInterface;
+
+    shared_ptr<ComUbuntuConnectivity1PrivateInterface> m_writeInterface;
+
+public Q_SLOTS:
+
+    void propertyChanged(const QString& name, const QVariant& value)
+    {
+        if (name == "FlightMode")
+        {
+            Q_EMIT p.flightModeUpdated(value.toBool());
+        }
+        else if (name == "WifiEnabled")
+        {
+            Q_EMIT p.wifiEnabledUpdated(value.toBool());
+        }
+        else if (name == "UnstoppableOperationHappening")
+        {
+            Q_EMIT p.unstoppableOperationHappeningUpdated(value.toBool());
+        }
+    }
+};
+
+Connectivity::Connectivity(const QDBusConnection& sessionConnection) :
+        d(new Priv(*this, sessionConnection))
+{
+    d->m_readInterface = make_shared<
+            ComUbuntuConnectivity1NetworkingStatusInterface>(
+            DBusTypes::DBUS_NAME, DBusTypes::SERVICE_PATH,
+            d->m_sessionConnection);
+
+    d->m_writeInterface = make_shared<ComUbuntuConnectivity1PrivateInterface>(
+            DBusTypes::DBUS_NAME, DBusTypes::PRIVATE_PATH,
+            d->m_sessionConnection);
+
+    d->m_propertyCache = make_shared<internal::DBusPropertyCache>(
+            DBusTypes::DBUS_NAME, DBusTypes::SERVICE_INTERFACE,
+            DBusTypes::SERVICE_PATH, sessionConnection);
+    connect(d->m_propertyCache.get(),
+            &internal::DBusPropertyCache::propertyChanged, d.get(),
+            &Priv::propertyChanged);
+    connect(d->m_propertyCache.get(),
+            &internal::DBusPropertyCache::initialized, this,
+            &Connectivity::initialized);
+}
+
+Connectivity::~Connectivity()
+{
+}
+
+bool Connectivity::flightMode() const
+{
+    return d->m_propertyCache->get("FlightMode").toBool();
+}
+
+bool Connectivity::wifiEnabled() const
+{
+    return d->m_propertyCache->get("WifiEnabled").toBool();
+}
+
+bool Connectivity::unstoppableOperationHappening() const
+{
+    return d->m_propertyCache->get("UnstoppableOperationHappening").toBool();
+}
+
+void Connectivity::setFlightMode(bool enabled)
+{
+    d->m_writeInterface->SetFlightMode(enabled);
+}
+
+void Connectivity::setwifiEnabled(bool enabled)
+{
+    d->m_writeInterface->SetWifiEnabled(enabled);
+}
+
+bool Connectivity::isInitialized() const
+{
+    return d->m_propertyCache->isInitialized();
+}
+
+}
+
+#include "connectivity.moc"
 
=== added file 'src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h'
--- src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h	2015-04-23 13:23:11 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Pete Woods <[e-mail]>
+ */
+
+#pragma once
+
+#include <QDBusConnection>
+#include <QObject>
+#include <QStringList>
+#include <memory>
+
+#include <unity/util/DefinesPtrs.h>
+
+namespace connectivityqt
+{
+
+class Q_DECL_EXPORT Connectivity: public QObject
+{
+    Q_OBJECT
+
+public:
+    UNITY_DEFINES_PTRS(Connectivity);
+
+    Connectivity(const QDBusConnection& sessionConnection = QDBusConnection::sessionBus());
+
+    ~Connectivity();
+
+    Q_PROPERTY(bool FlightMode READ flightMode WRITE setFlightMode NOTIFY flightModeUpdated)
+    bool flightMode() const;
+
+//    Q_PROPERTY(QStringList Limitations READ limitations NOTIFY limitationsUpdated)
+//    QStringList limitations() const;
+
+//    Q_PROPERTY(QString Status READ status NOTIFY statusUpdated)
+//    QString status() const;
+
+    Q_PROPERTY(bool WifiEnabled READ wifiEnabled WRITE setwifiEnabled NOTIFY wifiEnabledUpdated)
+    bool wifiEnabled() const;
+
+    Q_PROPERTY(bool UnstoppableOperationHappening READ unstoppableOperationHappening NOTIFY unstoppableOperationHappeningUpdated)
+    bool unstoppableOperationHappening() const;
+
+    Q_PROPERTY(bool Initialized READ isInitialized NOTIFY initialized)
+    bool isInitialized() const;
+
+public Q_SLOTS:
+    void setFlightMode(bool enabled);
+
+    void setwifiEnabled(bool enabled);
+
+Q_SIGNALS:
+    void flightModeUpdated(bool);
+
+//    void limitationsUpdated(const QStringList&);
+
+//    void statusUpdated(const QString&);
+
+    void wifiEnabledUpdated(bool);
+
+    void unstoppableOperationHappeningUpdated(bool);
+
+    void initialized();
+
+protected:
+    class Priv;
+    std::shared_ptr<Priv> d;
+};
+
+}
 
=== added directory 'src/connectivity-api/connectivity-qt/connectivityqt/internal'
=== added file 'src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.cpp'
--- src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.cpp	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.cpp	2015-04-23 13:23:11 +0000
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Pete Woods <[e-mail]>
+ */
+
+#include <connectivityqt/internal/dbus-property-cache.h>
+
+#include <PropertiesInterface.h>
+
+using namespace std;
+
+namespace connectivityqt
+{
+namespace internal
+{
+
+class DBusPropertyCache::Priv: public QObject
+{
+    Q_OBJECT
+
+public:
+    Priv(DBusPropertyCache& parent, const QDBusConnection& connection) :
+        p(parent), m_connection(connection)
+    {
+    }
+
+    DBusPropertyCache& p;
+
+    QDBusConnection m_connection;
+
+    QString m_service;
+
+    QString m_interface;
+
+    QString m_path;
+
+    shared_ptr<QDBusServiceWatcher> m_serviceWatcher;
+
+    shared_ptr<OrgFreedesktopDBusPropertiesInterface> m_propertiesInterface;
+
+    QVariantMap m_propertyCache;
+
+    void refreshProperties(const QStringList& names)
+    {
+        for(const QString& name: names)
+        {
+            QDBusVariant value = m_propertiesInterface->Get(m_interface, name);
+            m_propertyCache[name] = value.variant();
+            Q_EMIT p.propertyChanged(name, value.variant());
+        }
+    }
+
+public Q_SLOTS:
+    void serviceOwnerChanged(const QString &, const QString &,
+                        const QString & newOwner)
+    {
+        m_propertiesInterface.reset();
+        m_propertyCache.clear();
+
+        if (newOwner.isEmpty())
+        {
+            return;
+        }
+
+        m_propertiesInterface = make_shared<
+                OrgFreedesktopDBusPropertiesInterface>(m_service, m_path,
+                                                       m_connection);
+
+        connect(m_propertiesInterface.get(),
+                &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged, this,
+                &Priv::propertiesChanged);
+
+        m_propertyCache = m_propertiesInterface->GetAll(m_interface);
+        QMapIterator<QString, QVariant> it(m_propertyCache);
+        while (it.hasNext())
+        {
+            it.next();
+            Q_EMIT p.propertyChanged(it.key(), it.value());
+        }
+
+        Q_EMIT p.initialized();
+    }
+
+    void propertiesChanged(const QString &,
+                      const QVariantMap &changedProperties,
+                      const QStringList &invalidatedProperties)
+    {
+        QMapIterator<QString, QVariant> it(changedProperties);
+        while (it.hasNext())
+        {
+            it.next();
+            m_propertyCache[it.key()] = it.value();
+            Q_EMIT p.propertyChanged(it.key(), it.value());
+        }
+
+        refreshProperties(invalidatedProperties);
+    }
+};
+
+DBusPropertyCache::DBusPropertyCache(const QString &service,
+                                     const QString &interface,
+                                     const QString &path,
+                                     const QDBusConnection &connection) :
+        d(new Priv(*this, connection))
+{
+    d->m_service = service;
+    d->m_interface = interface;
+    d->m_path = path;
+
+    d->m_serviceWatcher = make_shared<QDBusServiceWatcher>(service,
+                                                           connection);
+
+    connect(d->m_serviceWatcher.get(), &QDBusServiceWatcher::serviceOwnerChanged,
+            d.get(), &Priv::serviceOwnerChanged);
+
+    // If the service is already registered
+    QString serviceOwner = connection.interface()->serviceOwner(service);
+    if (!serviceOwner.isEmpty())
+    {
+        d->serviceOwnerChanged(service, "", serviceOwner);
+    }
+}
+
+DBusPropertyCache::~DBusPropertyCache()
+{
+}
+
+QVariant DBusPropertyCache::get(const QString& name)
+{
+    return d->m_propertyCache[name];
+}
+
+bool DBusPropertyCache::isInitialized() const
+{
+    return !d->m_propertyCache.empty();
+}
+
+}
+}
+
+#include "dbus-property-cache.moc"
+
 
=== added file 'src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.h'
--- src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.h	1970-01-01 00:00:00 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/internal/dbus-property-cache.h	2015-04-23 13:23:11 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Pete Woods <[e-mail]>
+ */
+
+#pragma once
+
+#include <QDBusConnection>
+#include <QObject>
+#include <QString>
+#include <memory>
+
+namespace connectivityqt
+{
+namespace internal
+{
+
+class DBusPropertyCache: public QObject
+{
+    Q_OBJECT
+
+public:
+    DBusPropertyCache(const QString &service, const QString& interface,
+                      const QString &path, const QDBusConnection &connection);
+
+    ~DBusPropertyCache();
+
+    QVariant get(const QString& name);
+
+    bool isInitialized() const;
+
+Q_SIGNALS:
+    void propertyChanged(const QString& name, const QVariant& value);
+
+    void initialized();
+
+protected:
+    class Priv;
+    std::shared_ptr<Priv> d;
+};
+
+}
+}
 
=== modified file 'src/indicator/agent/SecretAgent.cpp'
--- src/indicator/agent/SecretAgent.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/agent/SecretAgent.cpp	2015-04-23 13:23:11 +0000
@@ -16,12 +16,13 @@
  * Author: Pete Woods <[e-mail]>
  */
 
-#include <menumodel-cpp/gio-helpers/util.h>
 #include <agent/SecretAgent.h>
+#include <agent/SecretRequest.h>
+#include <AgentManagerInterface.h>
+#include <NotificationsInterface.h>
 #include <SecretAgentAdaptor.h>
 
 #include <NetworkManager.h>
-
 #include <stdexcept>
 
 using namespace std;
@@ -29,53 +30,67 @@
 namespace agent
 {
 
-const QString SecretAgent::CONNECTION_SETTING_NAME("connection");
-const QString SecretAgent::WIRELESS_SECURITY_SETTING_NAME(
-        "802-11-wireless-security");
-
-const QString SecretAgent::CONNECTION_ID("id");
-
-const QString SecretAgent::WIRELESS_SECURITY_PSK("psk");
-const QString SecretAgent::WIRELESS_SECURITY_WEP_KEY0("wep-key0");
-
-const QString SecretAgent::WIRELESS_SECURITY_KEY_MGMT("key-mgmt");
-
-const QString SecretAgent::KEY_MGMT_WPA_NONE("wpa-none");
-const QString SecretAgent::KEY_MGMT_WPA_PSK("wpa-psk");
-const QString SecretAgent::KEY_MGMT_NONE("none");
+class SecretAgent::Priv : public QObject {
+	Q_OBJECT
+
+public:
+	Priv(const QDBusConnection &systemConnection,
+			const QDBusConnection &sessionConnection) :
+			m_systemConnection(systemConnection),
+			m_sessionConnection(sessionConnection),
+			m_managerWatcher(NM_DBUS_SERVICE, m_systemConnection),
+			m_agentManager(NM_DBUS_SERVICE, NM_DBUS_PATH_AGENT_MANAGER, m_systemConnection),
+			m_notifications("org.freedesktop.Notifications", "/org/freedesktop/Notifications", m_sessionConnection),
+			m_request(nullptr) {
+	}
+
+public Q_SLOTS:
+	void serviceOwnerChanged(const QString &name, const QString &oldOwner,
+			const QString &newOwner)
+	{
+		Q_UNUSED(name)
+		Q_UNUSED(oldOwner)
+		if (!newOwner.isEmpty()) {
+			m_agentManager.Register("com.canonical.indicator.SecretAgent").waitForFinished();
+		}
+	}
+
+public:
+	QDBusConnection m_systemConnection;
+
+	QDBusConnection m_sessionConnection;
+
+	QDBusServiceWatcher m_managerWatcher;
+
+	OrgFreedesktopNetworkManagerAgentManagerInterface m_agentManager;
+
+	OrgFreedesktopNotificationsInterface m_notifications;
+
+	std::shared_ptr<SecretRequest> m_request;
+};
 
 SecretAgent::SecretAgent(const QDBusConnection &systemConnection,
 		const QDBusConnection &sessionConnection, QObject *parent) :
-		QObject(parent), m_adaptor(new SecretAgentAdaptor(this)), m_systemConnection(
-				systemConnection), m_sessionConnection(sessionConnection), m_managerWatcher(
-				NM_DBUS_SERVICE, m_systemConnection), m_agentManager(NM_DBUS_SERVICE,
-				NM_DBUS_PATH_AGENT_MANAGER, m_systemConnection), m_notifications(
-				"org.freedesktop.Notifications", "/org/freedesktop/Notifications",
-				m_sessionConnection), m_request(nullptr) {
-	if (!m_systemConnection.registerObject(NM_DBUS_PATH_SECRET_AGENT, this)) {
+		QObject(parent), d(new Priv(systemConnection, sessionConnection))
+	{
+	// Memory managed by Qt
+	new SecretAgentAdaptor(this);
+
+	if (!d->m_systemConnection.registerObject(NM_DBUS_PATH_SECRET_AGENT, this)) {
 		throw logic_error(
-                "Unable to register user secret agent object on DBus");
+				"Unable to register user secret agent object on DBus");
 	}
 
 	// Watch for NM restarting (or starting after we do)
-	connect(&m_managerWatcher, SIGNAL(serviceOwnerChanged(QString, QString, QString)),
-	        this, SLOT(serviceOwnerChanged(QString, QString, QString)));
+	connect(&d->m_managerWatcher, &QDBusServiceWatcher::serviceOwnerChanged,
+			d.get(), &Priv::serviceOwnerChanged);
 
-	m_agentManager.Register("com.canonical.indicator.SecretAgent").waitForFinished();
+	d->m_agentManager.Register("com.canonical.indicator.SecretAgent").waitForFinished();
 }
 
 SecretAgent::~SecretAgent() {
-	m_agentManager.Unregister().waitForFinished();
-	m_systemConnection.unregisterObject(NM_DBUS_PATH_SECRET_AGENT);
-}
-
-void SecretAgent::serviceOwnerChanged(const QString &name,
-		const QString &oldOwner, const QString &newOwner) {
-	Q_UNUSED(name)
-	Q_UNUSED(oldOwner)
-	if (!newOwner.isEmpty()) {
-		m_agentManager.Register("com.canonical.indicator.SecretAgent").waitForFinished();
-	}
+	d->m_agentManager.Unregister().waitForFinished();
+	d->m_systemConnection.unregisterObject(NM_DBUS_PATH_SECRET_AGENT);
 }
 
 /**
@@ -123,11 +138,11 @@
 	setDelayedReply(true);
 
 	if (flags == 0) {
-		m_systemConnection.send(
+		d->m_systemConnection.send(
 				message().createErrorReply(QDBusError::InternalError,
 						"No password found for this connection."));
 	} else {
-		m_request.reset(new SecretRequest(*this, connection,
+		d->m_request.reset(new SecretRequest(*this, connection,
 						connectionPath, settingName, hints, flags, message()));
 	}
 
@@ -136,23 +151,23 @@
 
 void SecretAgent::FinishGetSecrets(SecretRequest &request, bool error) {
 	if (error) {
-		m_systemConnection.send(
+		d->m_systemConnection.send(
 				request.message().createErrorReply(QDBusError::InternalError,
 						"No password found for this connection."));
 	} else {
-		m_systemConnection.send(
+		d->m_systemConnection.send(
 				request.message().createReply(
 						QVariant::fromValue(request.connection())));
 	}
 
-	m_request.reset();
+	d->m_request.reset();
 }
 
 void SecretAgent::CancelGetSecrets(const QDBusObjectPath &connectionPath,
 		const QString &settingName) {
 	Q_UNUSED(connectionPath);
 	Q_UNUSED(settingName);
-	m_request.reset();
+	d->m_request.reset();
 }
 
 void SecretAgent::DeleteSecrets(const QVariantDictMap &connection,
@@ -168,7 +183,10 @@
 }
 
 OrgFreedesktopNotificationsInterface & SecretAgent::notifications() {
-	return m_notifications;
-}
-
-}
+	return d->m_notifications;
+}
+
+}
+
+#include "SecretAgent.moc"
+
 
=== modified file 'src/indicator/agent/SecretAgent.h'
--- src/indicator/agent/SecretAgent.h	2015-04-23 13:23:11 +0000
+++ src/indicator/agent/SecretAgent.h	2015-04-23 13:23:11 +0000
@@ -18,50 +18,52 @@
 
 #pragma once
 
+#include <dbus-types.h>
+
 #include <memory>
 
-#include <QScopedPointer>
 #include <QDBusConnection>
 #include <QDBusContext>
 #include <QMap>
 
-#include <DBusTypes.h>
-#include <agent/SecretRequest.h>
-#include <AgentManagerInterface.h>
-#include <NotificationsInterface.h>
-
+class OrgFreedesktopNotificationsInterface;
 class SecretAgentAdaptor;
 
 namespace agent
 {
 
+class SecretRequest;
+
 class SecretAgent: public QObject, protected QDBusContext {
-Q_OBJECT
+	Q_OBJECT
+
+	friend SecretAgentAdaptor;
+	friend SecretRequest;
 
 public:
-    typedef std::shared_ptr<SecretAgent> Ptr;
-    typedef std::unique_ptr<SecretAgent> UPtr;
-
-	static const QString CONNECTION_SETTING_NAME;
-	static const QString WIRELESS_SECURITY_SETTING_NAME;
-
-	static const QString CONNECTION_ID;
-
-	static const QString WIRELESS_SECURITY_PSK;
-	static const QString WIRELESS_SECURITY_WEP_KEY0;
-
-	static const QString WIRELESS_SECURITY_KEY_MGMT;
-
-	static const QString KEY_MGMT_WPA_NONE;
-	static const QString KEY_MGMT_WPA_PSK;
-	static const QString KEY_MGMT_NONE;
+	typedef std::shared_ptr<SecretAgent> Ptr;
+	typedef std::unique_ptr<SecretAgent> UPtr;
+
+	static constexpr char const* CONNECTION_SETTING_NAME = "connection";
+	static constexpr char const* WIRELESS_SECURITY_SETTING_NAME = "802-11-wireless-security";
+
+	static constexpr char const* CONNECTION_ID = "id";
+
+	static constexpr char const* WIRELESS_SECURITY_PSK = "psk";
+	static constexpr char const* WIRELESS_SECURITY_WEP_KEY0 = "wep-key0";
+
+	static constexpr char const* WIRELESS_SECURITY_KEY_MGMT = "key-mgmt";
+
+	static constexpr char const* KEY_MGMT_WPA_NONE = "wpa-none";
+	static constexpr char const* KEY_MGMT_WPA_PSK = "wpa-psk";
+	static constexpr char const* KEY_MGMT_NONE = "none";
 
 	explicit SecretAgent(const QDBusConnection &systemConnection,
 			const QDBusConnection &sessionConnection, QObject *parent = 0);
 
 	virtual ~SecretAgent();
 
-public Q_SLOTS:
+protected Q_SLOTS:
 	QVariantDictMap GetSecrets(const QVariantDictMap &connection,
 			const QDBusObjectPath &connectionPath, const QString &settingName,
 			const QStringList &hints, uint flags);
@@ -79,24 +81,9 @@
 
 	OrgFreedesktopNotificationsInterface & notifications();
 
-protected Q_SLOTS:
-    void serviceOwnerChanged(const QString &name, const QString &oldOwner,
-            const QString &newOwner);
-
 protected:
-	QScopedPointer<SecretAgentAdaptor> m_adaptor;
-
-	QDBusConnection m_systemConnection;
-
-	QDBusConnection m_sessionConnection;
-
-	QDBusServiceWatcher m_managerWatcher;
-
-	OrgFreedesktopNetworkManagerAgentManagerInterface m_agentManager;
-
-	OrgFreedesktopNotificationsInterface m_notifications;
-
-	std::shared_ptr<SecretRequest> m_request;
+	class Priv;
+	std::shared_ptr<Priv> d;
 };
 
 }
 
=== modified file 'src/indicator/agent/SecretAgentInclude.h'
--- src/indicator/agent/SecretAgentInclude.h	2015-04-23 13:23:11 +0000
+++ src/indicator/agent/SecretAgentInclude.h	2015-04-23 13:23:11 +0000
@@ -18,6 +18,6 @@
 
 #pragma once
 
-#include <DBusTypes.h>
+#include <dbus-types.h>
 #include <agent/SecretAgent.h>
 
 
=== modified file 'src/indicator/agent/SecretRequest.cpp'
--- src/indicator/agent/SecretRequest.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/agent/SecretRequest.cpp	2015-04-23 13:23:11 +0000
@@ -20,6 +20,8 @@
 #include <agent/SecretAgent.h>
 #include <util/localisation.h>
 
+#include <NotificationsInterface.h>
+
 namespace agent
 {
 
 
=== modified file 'src/indicator/agent/SecretRequest.h'
--- src/indicator/agent/SecretRequest.h	2015-04-23 13:23:11 +0000
+++ src/indicator/agent/SecretRequest.h	2015-04-23 13:23:11 +0000
@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include <DBusTypes.h>
+#include <dbus-types.h>
 #include <agent/PasswordMenu.h>
 
 #include <QDBusMessage>
 
=== modified file 'src/indicator/connectivity-service/connectivity-service.cpp'
--- src/indicator/connectivity-service/connectivity-service.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/connectivity-service/connectivity-service.cpp	2015-04-23 13:23:11 +0000
@@ -20,7 +20,7 @@
 #include <connectivity-service/connectivity-service.h>
 #include <NetworkingStatusAdaptor.h>
 #include <NetworkingStatusPrivateAdaptor.h>
-#include <DBusTypes.h>
+#include <dbus-types.h>
 
 using namespace nmofono;
 using namespace std;
@@ -69,6 +69,27 @@
     }
 
 public Q_SLOTS:
+    void flightModeUpdated()
+    {
+        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "FlightMode" });
+    }
+
+    void wifiEnabledUpdated()
+    {
+        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "WifiEnabled" });
+    }
+
+    void unstoppableOperationHappeningUpdated()
+    {
+        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "UnstoppableOperationHappening" });
+    }
+
     void updateNetworkingStatus()
     {
         QStringList changed;
@@ -125,6 +146,9 @@
 
     connect(d->m_manager.get(), &Manager::characteristicsUpdated, d.get(), &Private::updateNetworkingStatus);
     connect(d->m_manager.get(), &Manager::statusUpdated, d.get(), &Private::updateNetworkingStatus);
+    connect(d->m_manager.get(), &Manager::flightModeUpdated, d.get(), &Private::flightModeUpdated);
+    connect(d->m_manager.get(), &Manager::wifiEnabledUpdated, d.get(), &Private::wifiEnabledUpdated);
+    connect(d->m_manager.get(), &Manager::unstoppableOperationHappeningUpdated, d.get(), &Private::unstoppableOperationHappeningUpdated);
 
     d->updateNetworkingStatus();
 
@@ -160,6 +184,21 @@
     return d->m_status;
 }
 
+bool ConnectivityService::wifiEnabled() const
+{
+    return d->m_manager->wifiEnabled();
+}
+
+bool ConnectivityService::flightMode() const
+{
+    return (d->m_manager->flightMode() == Manager::FlightModeStatus::on);
+}
+
+bool ConnectivityService::unstoppableOperationHappening() const
+{
+    return d->m_manager->unstoppableOperationHappening();
+}
+
 PrivateService::PrivateService(ConnectivityService& parent) :
         p(parent)
 {
@@ -177,6 +216,16 @@
     Q_EMIT p.unlockModem(modem);
 }
 
+void PrivateService::SetFlightMode(bool enabled)
+{
+    p.d->m_manager->setFlightMode(enabled);
+}
+
+void PrivateService::SetWifiEnabled(bool enabled)
+{
+    p.d->m_manager->setWifiEnabled(enabled);
+}
+
 }
 
 #include "connectivity-service.moc"
 
=== modified file 'src/indicator/connectivity-service/connectivity-service.h'
--- src/indicator/connectivity-service/connectivity-service.h	2015-04-23 13:23:11 +0000
+++ src/indicator/connectivity-service/connectivity-service.h	2015-04-23 13:23:11 +0000
@@ -50,6 +50,15 @@
     Q_PROPERTY(QString Status READ status)
     QString status() const;
 
+    Q_PROPERTY(bool WifiEnabled READ wifiEnabled)
+    bool wifiEnabled() const;
+
+    Q_PROPERTY(bool FlightMode READ flightMode)
+    bool flightMode() const;
+
+    Q_PROPERTY(bool UnstoppableOperationHappening READ unstoppableOperationHappening)
+    bool unstoppableOperationHappening() const;
+
 Q_SIGNALS:
     void unlockAllModems();
 
@@ -76,6 +85,10 @@
 
     void UnlockModem(const QString &modem);
 
+    void SetFlightMode(bool enabled);
+
+    void SetWifiEnabled(bool enabled);
+
 protected:
     ConnectivityService& p;
 };
 
=== modified file 'src/indicator/main.cpp'
--- src/indicator/main.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/main.cpp	2015-04-23 13:23:11 +0000
@@ -19,7 +19,7 @@
 
 #include <factory.h>
 #include <util/unix-signal-handler.h>
-#include <DBusTypes.h>
+#include <dbus-types.h>
 
 #include <QCoreApplication>
 
@@ -38,6 +38,7 @@
 {
     QCoreApplication app(argc, argv);
     DBusTypes::registerMetaTypes();
+    Variant::registerMetaTypes();
 
     util::UnixSignalHandler handler([]{
         QCoreApplication::exit(0);
@@ -60,8 +61,8 @@
     {
         Factory factory;
         auto menu = factory.newMenuBuilder();
+        auto secretAgent = factory.newSecretAgent();
         auto connectivityService = factory.newConnectivityService();
-        auto secretAgent = factory.newSecretAgent();
 
         QObject::connect(connectivityService.get(), &ConnectivityService::unlockAllModems, menu.get(), &MenuBuilder::unlockAllModems);
         QObject::connect(connectivityService.get(), &ConnectivityService::unlockModem, menu.get(), &MenuBuilder::unlockModem);
 
=== modified file 'src/indicator/nmofono/kill-switch.cpp'
--- src/indicator/nmofono/kill-switch.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/nmofono/kill-switch.cpp	2015-04-23 13:23:11 +0000
@@ -20,14 +20,11 @@
 
 #include <nmofono/kill-switch.h>
 #include <backend-utils.h>
+#include <dbus-types.h>
 
 #include <URfkillInterface.h>
 #include <URfkillKillswitchInterface.h>
 
-static QString const cBusName = "org.freedesktop.URfkill";
-static QString const cURfkillPath = "/org/freedesktop/URfkill";
-static QString const cURfkillKillswitchPath = "/org/freedesktop/URfkill/WLAN";
-
 namespace nmofono
 {
 
@@ -60,12 +57,12 @@
 
 KillSwitch::KillSwitch(const QDBusConnection& systemBus)
 {
-    auto urfkill = std::make_shared<OrgFreedesktopURfkillInterface>(cBusName,
-                                                                    cURfkillPath,
+    auto urfkill = std::make_shared<OrgFreedesktopURfkillInterface>(DBusTypes::URFKILL_BUS_NAME,
+                                                                    DBusTypes::URFKILL_OBJ_PATH,
                                                                     systemBus);
 
-    auto killSwitch = std::make_shared<OrgFreedesktopURfkillKillswitchInterface>(cBusName,
-                                                                                 cURfkillKillswitchPath,
+    auto killSwitch = std::make_shared<OrgFreedesktopURfkillKillswitchInterface>(DBusTypes::URFKILL_BUS_NAME,
+                                                                                 DBusTypes::URFKILL_WIFI_OBJ_PATH,
                                                                                  systemBus);
 
     connect(urfkill.get(), SIGNAL(FlightModeChanged(bool)), this, SLOT(setFlightMode(bool)));
 
=== modified file 'src/indicator/nmofono/manager-impl.cpp'
--- src/indicator/nmofono/manager-impl.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/nmofono/manager-impl.cpp	2015-04-23 13:23:11 +0000
@@ -53,12 +53,13 @@
     shared_ptr<QOfonoManager> m_ofono;
 
     Manager::FlightModeStatus m_flightMode = FlightModeStatus::on;
+    bool m_unstoppableOperationHappening = false;
     Manager::NetworkingStatus m_status = NetworkingStatus::offline;
     uint32_t m_characteristics = 0;
 
     bool m_hasWifi = false;
     bool m_wifiEnabled = false;
-    KillSwitch::Ptr m_wifiKillSwitch;
+    KillSwitch::Ptr m_killSwitch;
 
     QSet<Link::Ptr> m_nmLinks;
     QMap<QString, wwan::Modem::Ptr> m_ofonoLinks;
@@ -71,13 +72,24 @@
     {
     }
 
+    void setUnstoppableOperationHappening(bool happening)
+    {
+        if (m_unstoppableOperationHappening == happening)
+        {
+            return;
+        }
+
+        m_unstoppableOperationHappening = happening;
+        Q_EMIT p.unstoppableOperationHappeningUpdated(m_unstoppableOperationHappening);
+    }
+
 public Q_SLOTS:
     void updateHasWifi()
     {
-        if (m_wifiKillSwitch->state() != KillSwitch::State::not_available)
+        if (m_killSwitch->state() != KillSwitch::State::not_available)
         {
             m_hasWifi = true;
-            if (m_wifiKillSwitch->state() == KillSwitch::State::unblocked)
+            if (m_killSwitch->state() == KillSwitch::State::unblocked)
             {
                 m_wifiEnabled = true;
             }
@@ -107,15 +119,15 @@
 
     void setFlightMode(bool flightMode)
     {
-        if (flightMode)
-        {
-            m_flightMode = Manager::FlightModeStatus::on;
-        }
-        else
-        {
-            m_flightMode = Manager::FlightModeStatus::off;
-        }
-
+        FlightModeStatus newStatus =
+                flightMode ? FlightModeStatus::on : FlightModeStatus::off;
+
+        if (m_flightMode == newStatus)
+        {
+            return;
+        }
+
+        m_flightMode = newStatus;
         Q_EMIT p.flightModeUpdated(m_flightMode);
     }
 
@@ -212,8 +224,8 @@
     /// @todo offload the initialization to a thread or something
     /// @todo those Id() thingies
 
-    d->m_wifiKillSwitch = make_shared<KillSwitch>(systemConnection);
-    connect(d->m_wifiKillSwitch.get(), &KillSwitch::stateChanged, d.get(), &Private::updateHasWifi);
+    d->m_killSwitch = make_shared<KillSwitch>(systemConnection);
+    connect(d->m_killSwitch.get(), &KillSwitch::stateChanged, d.get(), &Private::updateHasWifi);
 
     connect(d->nm.get(), &OrgFreedesktopNetworkManagerInterface::DeviceAdded, this, &ManagerImpl::device_added);
     QList<QDBusObjectPath> devices(d->nm->GetDevices());
@@ -225,10 +237,10 @@
     updateNetworkingStatus(d->nm->state());
     connect(d->nm.get(), &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &ManagerImpl::nm_properties_changed);
 
-    connect(d->m_wifiKillSwitch.get(), &KillSwitch::flightModeChanged, d.get(), &Private::setFlightMode);
+    connect(d->m_killSwitch.get(), &KillSwitch::flightModeChanged, d.get(), &Private::setFlightMode);
     try
     {
-        d->setFlightMode(d->m_wifiKillSwitch->isFlightMode());
+        d->setFlightMode(d->m_killSwitch->isFlightMode());
     }
     catch (exception const& e)
     {
@@ -299,7 +311,7 @@
         if (dev->deviceType() == NM_DEVICE_TYPE_WIFI) {
             link = make_shared<wifi::WifiLinkImpl>(dev,
                                                 d->nm,
-                                                d->m_wifiKillSwitch);
+                                                d->m_killSwitch);
         }
     } catch (const exception &e) {
         qDebug() << __PRETTY_FUNCTION__ << ": failed to create Device proxy for "<< path.path() << ": ";
@@ -318,27 +330,23 @@
 
 
 void
-ManagerImpl::enableFlightMode()
-{
-#ifdef INDICATOR_NETWORK_TRACE_MESSAGES
-    cout << __PRETTY_FUNCTION__ << endl;
-#endif
-    if (!d->m_wifiKillSwitch->flightMode(true))
-    {
-        qWarning() << "Failed to enable flightmode.";
-    }
-}
-
-void
-ManagerImpl::disableFlightMode()
-{
-#ifdef INDICATOR_NETWORK_TRACE_MESSAGES
-    cout << __PRETTY_FUNCTION__ << endl;
-#endif
-    if (!d->m_wifiKillSwitch->flightMode(false))
-    {
-        qWarning() << "Failed to disable flightmode";
-    }
+ManagerImpl::setFlightMode(bool enabled)
+{
+#ifdef INDICATOR_NETWORK_TRACE_MESSAGES
+    qDebug() << __PRETTY_FUNCTION__ << enabled;
+#endif
+    if (enabled == d->m_killSwitch->isFlightMode())
+    {
+        return;
+    }
+
+    d->setUnstoppableOperationHappening(true);
+
+    if (!d->m_killSwitch->flightMode(enabled))
+    {
+        qWarning() << "Failed to change flightmode.";
+    }
+    d->setUnstoppableOperationHappening(false);
 }
 
 Manager::FlightModeStatus
@@ -350,6 +358,12 @@
     return d->m_flightMode;
 }
 
+bool
+ManagerImpl::unstoppableOperationHappening() const
+{
+    return d->m_unstoppableOperationHappening;
+}
+
 QSet<Link::Ptr>
 ManagerImpl::links() const
 {
@@ -387,57 +401,47 @@
 
 
 bool
-ManagerImpl::enableWifi()
+ManagerImpl::setWifiEnabled(bool enabled)
 {
     if (!d->m_hasWifi)
     {
         return false;
     }
 
-    if (d->m_wifiEnabled)
+    if (d->m_wifiEnabled == enabled)
     {
         return false;
     }
 
+    bool success = true;
+    d->setUnstoppableOperationHappening(true);
+
     try
     {
-        if (d->m_wifiKillSwitch->state() == KillSwitch::State::soft_blocked)
-        {
-            // try to unblock. throws if fails.
-            d->m_wifiKillSwitch->unblock();
-        }
-        d->nm->setWirelessEnabled(true);
-    } catch(runtime_error &e) {
+        if (enabled)
+        {
+            if (d->m_killSwitch->state() == KillSwitch::State::soft_blocked)
+            {
+                // try to unblock. throws if fails.
+                d->m_killSwitch->unblock();
+            }
+        }
+        else
+        {
+            if (d->m_killSwitch->state() == KillSwitch::State::unblocked) {
+                // block the device. that will disable it also
+                d->m_killSwitch->block();
+            }
+        }
+        d->nm->setWirelessEnabled(enabled);
+    }
+    catch (runtime_error &e)
+    {
         qWarning() << __PRETTY_FUNCTION__ << ": " << e.what();
-        return false;
-    }
-    return true;
-}
-
-bool
-ManagerImpl::disableWifi()
-{
-    if (!d->m_hasWifi)
-    {
-        return false;
-    }
-
-    if (!d->m_wifiEnabled)
-    {
-        return false;
-    }
-
-    try {
-        if (d->m_wifiKillSwitch->state() == KillSwitch::State::unblocked) {
-            // block the device. that will disable it also
-            d->m_wifiKillSwitch->block();
-        }
-        d->nm->setWirelessEnabled(false);
-    } catch(runtime_error &e) {
-        cerr << __PRETTY_FUNCTION__ << ": " << e.what() << endl;
-        return false;
-    }
-    return true;
+        success = false;
+    }
+    d->setUnstoppableOperationHappening(false);
+    return success;
 }
 
 bool
 
=== modified file 'src/indicator/nmofono/manager-impl.h'
--- src/indicator/nmofono/manager-impl.h	2015-04-23 13:23:11 +0000
+++ src/indicator/nmofono/manager-impl.h	2015-04-23 13:23:11 +0000
@@ -42,15 +42,15 @@
     ManagerImpl(const QDBusConnection& systemBus);
 
     // Public API
-    void enableFlightMode() override;
-    void disableFlightMode() override;
+    void setFlightMode(bool) override;
     Manager::FlightModeStatus flightMode() const override;
 
+    bool unstoppableOperationHappening() const override;
+
     bool hasWifi() const override;
     bool wifiEnabled() const override;
 
-    bool enableWifi() override;
-    bool disableWifi() override;
+    bool setWifiEnabled(bool) override;
 
     bool roaming() const override;
 
 
=== modified file 'src/indicator/nmofono/manager.h'
--- src/indicator/nmofono/manager.h	2015-04-23 13:23:11 +0000
+++ src/indicator/nmofono/manager.h	2015-04-23 13:23:11 +0000
@@ -81,15 +81,12 @@
     };
 
     /// @private
-    virtual void enableFlightMode()  = 0;
-
-    /// @private
-    virtual void disableFlightMode() = 0;
-
-    /// @private
     Q_PROPERTY(Manager::FlightModeStatus flightMode READ flightMode NOTIFY flightModeUpdated)
     virtual FlightModeStatus flightMode() const = 0;
 
+    Q_PROPERTY(bool unstoppableOperationHappening READ unstoppableOperationHappening NOTIFY unstoppableOperationHappeningUpdated)
+    virtual bool unstoppableOperationHappening() const = 0;
+
     /// @private
     Q_PROPERTY(QSet<Link::Ptr> links READ links NOTIFY linksUpdated)
     virtual QSet<Link::Ptr> links() const = 0;
@@ -123,10 +120,6 @@
     Q_PROPERTY(bool wifiEnabled READ wifiEnabled NOTIFY wifiEnabledUpdated)
     virtual bool wifiEnabled() const = 0;
 
-    virtual bool enableWifi() = 0;
-
-    virtual bool disableWifi() = 0;
-
     virtual bool roaming() const = 0;
 
     virtual void unlockModem(wwan::Modem::Ptr modem) = 0;
@@ -148,6 +141,13 @@
 
     void wifiEnabledUpdated(bool);
 
+    void unstoppableOperationHappeningUpdated(bool);
+
+public Q_SLOTS:
+    virtual bool setWifiEnabled(bool) = 0;
+
+    virtual void setFlightMode(bool)  = 0;
+
 protected:
     /**
      * @brief The default constructor is protected.
 
=== modified file 'src/indicator/sections/quick-access-section.cpp'
--- src/indicator/sections/quick-access-section.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/sections/quick-access-section.cpp	2015-04-23 13:23:11 +0000
@@ -48,6 +48,18 @@
     Private(Manager::Ptr manager, SwitchItem::Ptr wifiSwitch);
 
 public Q_SLOTS:
+    void unstoppableOperationHappeningUpdated(bool happening)
+    {
+        m_flightModeSwitch->setEnabled(!happening);
+        m_wifiSwitch->setEnabled(!happening);
+
+        if (happening)
+        {
+            // Give the GActionGroup a chance to emit its Changed signal
+            runGMainloop();
+        }
+    }
+
     void flightModeUpdated(Manager::FlightModeStatus value)
     {
         switch (value) {
@@ -59,32 +71,6 @@
             break;
         }
     }
-
-    void flightModeSwitchActivated(bool state)
-    {
-        m_flightModeSwitch->setEnabled(false);
-        m_wifiSwitch->setEnabled(false);
-
-        // Give the GActionGroup a change to emit its Changed signal
-        runGMainloop();
-
-        if (state) {
-            try {
-                m_manager->enableFlightMode();
-            } catch (const std::exception &e) {
-                std::cerr << e.what() << std::endl;
-            }
-        } else {
-            try {
-                m_manager->disableFlightMode();
-            } catch (const std::exception &e) {
-                std::cerr << e.what() << std::endl;
-            }
-        }
-
-        m_flightModeSwitch->setEnabled(true);
-        m_wifiSwitch->setEnabled(true);
-    }
 };
 
 QuickAccessSection::Private::Private(Manager::Ptr manager,
@@ -97,10 +83,15 @@
     m_flightModeSwitch = std::make_shared<SwitchItem>(_("Flight Mode"), "airplane", "enabled");
     flightModeUpdated(m_manager->flightMode());
     connect(m_manager.get(), &Manager::flightModeUpdated, this, &Private::flightModeUpdated);
-    connect(m_flightModeSwitch.get(), &SwitchItem::stateUpdated, this, &Private::flightModeSwitchActivated);
+    connect(m_flightModeSwitch.get(), &SwitchItem::stateUpdated, m_manager.get(), &Manager::setFlightMode);
 
     m_actionGroupMerger->add(m_flightModeSwitch->actionGroup());
     m_menu->append(m_flightModeSwitch->menuItem());
+
+    // Connect the unstoppable operation property to the toggle enabled properties
+    // Make sure we don't also connect this signal in the wifi-section.cpp
+    connect(m_manager.get(), &Manager::unstoppableOperationHappeningUpdated,
+            this, &Private::unstoppableOperationHappeningUpdated);
 }
 
 QuickAccessSection::QuickAccessSection(Manager::Ptr manager, SwitchItem::Ptr wifiSwitch)
 
=== modified file 'src/indicator/sections/wifi-section.cpp'
--- src/indicator/sections/wifi-section.cpp	2015-04-23 13:23:11 +0000
+++ src/indicator/sections/wifi-section.cpp	2015-04-23 13:23:11 +0000
@@ -67,7 +67,7 @@
 
         m_switch->setState(m_manager->wifiEnabled());
         connect(m_manager.get(), &Manager::wifiEnabledUpdated, m_switch.get(), &SwitchItem::setState);
-        connect(m_switch.get(), &SwitchItem::stateUpdated, this, &Private::switchActivated);
+        connect(m_switch.get(), &SwitchItem::stateUpdated, m_manager.get(), &Manager::setWifiEnabled);
 
         m_openWifiSettings = std::make_shared<TextItem>(_("Wi-Fi settings…"), "wifi", "settings");
         connect(m_openWifiSettings.get(), &TextItem::activated, this, &Private::openWiFiSettings);
@@ -115,18 +115,6 @@
             break;
         }
     }
-
-    void switchActivated(bool state)
-    {
-        m_switch->setEnabled(false);
-        runGMainloop();
-        if (state) {
-            m_manager->enableWifi();
-        } else {
-            m_manager->disableWifi();
-        }
-        m_switch->setEnabled(true);
-    }
 };
 
 WifiSection::WifiSection(Manager::Ptr manager)
 
=== modified file 'src/menumodel-cpp/gio-helpers/variant.h'
--- src/menumodel-cpp/gio-helpers/variant.h	2015-04-01 08:39:34 +0000
+++ src/menumodel-cpp/gio-helpers/variant.h	2015-04-23 13:23:11 +0000
@@ -24,6 +24,7 @@
 #include <vector>
 #include <memory>
 #include <gio/gio.h>
+#include <QObject>
 
 #include <cassert>
 
@@ -31,6 +32,8 @@
 
 class Variant;
 
+Q_DECLARE_METATYPE(Variant)
+
 template<typename T>
 struct Codec
 {
@@ -41,6 +44,11 @@
 class Variant
 {
 public:
+    static void registerMetaTypes()
+    {
+        qRegisterMetaType<Variant>("Variant");
+    }
+
     static Variant fromGVariant(GVariant *variant) {
         return Variant(variant);
     }
 
=== modified file 'src/qdbus-stubs/CMakeLists.txt'
--- src/qdbus-stubs/CMakeLists.txt	2015-04-23 13:23:11 +0000
+++ src/qdbus-stubs/CMakeLists.txt	2015-04-23 13:23:11 +0000
@@ -21,8 +21,6 @@
     "${DATA_DIR}/nm-access-point.xml"
     "${DATA_DIR}/nm-active-connection.xml"
     "${DATA_DIR}/nm-agent-manager.xml"
-    "${DATA_DIR}/com.ubuntu.connectivity1.NetworkingStatus.xml"
-    "${DATA_DIR}/com.ubuntu.connectivity1.Private.xml"
     "${DATA_DIR}/org.freedesktop.URfkill.xml"
     "${DATA_DIR}/org.freedesktop.URfkill.Device.xml"
     "${DATA_DIR}/org.freedesktop.URfkill.Killswitch.xml"
@@ -36,7 +34,7 @@
     "${DATA_DIR}/org.freedesktop.Notifications.xml"
     PROPERTIES
     NO_NAMESPACE YES
-    INCLUDE "DBusTypes.h"
+    INCLUDE "dbus-types.h"
 )
 
 qt5_add_dbus_interface(
@@ -105,18 +103,6 @@
     NotificationsInterface
 )
 
-qt5_add_dbus_interface(
-    CONNECTIVITY_BACKEND_SRC
-    "${DATA_DIR}/com.ubuntu.connectivity1.NetworkingStatus.xml"
-    NetworkingStatusInterface
-)
-
-qt5_add_dbus_interface(
-    CONNECTIVITY_BACKEND_SRC
-    "${DATA_DIR}/com.ubuntu.connectivity1.Private.xml"
-    NetworkingStatusPrivateInterface
-)
-
 add_library(
     qdbus-stubs
     STATIC
 
=== renamed file 'src/qdbus-stubs/DBusTypes.h' => 'src/qdbus-stubs/dbus-types.h'
--- src/qdbus-stubs/DBusTypes.h	2015-03-23 14:46:24 +0000
+++ src/qdbus-stubs/dbus-types.h	2015-04-23 13:23:11 +0000
@@ -16,8 +16,7 @@
  * Author: Pete Woods <[e-mail]>
  */
 
-#ifndef DBUSTYPES_H_
-#define DBUSTYPES_H_
+#pragma once
 
 #include <QDBusMetaType>
 #include <QtCore>
@@ -27,10 +26,9 @@
 typedef QMap<QString, QVariantMap> QVariantDictMap;
 Q_DECLARE_METATYPE(QVariantDictMap)
 
-class DBusTypes {
-public:
-    static void
-    registerMetaTypes()
+namespace DBusTypes
+{
+    inline void registerMetaTypes()
     {
         qRegisterMetaType<QVariantDictMap>("QVariantDictMap");
 
@@ -46,6 +44,10 @@
     static constexpr char const* SERVICE_PATH = "/com/ubuntu/connectivity1/NetworkingStatus";
 
     static constexpr char const* PRIVATE_PATH = "/com/ubuntu/connectivity1/Private";
-};
-
-#endif /* DBUSTYPES_H_ */
+
+    static constexpr char const* URFKILL_BUS_NAME = "org.freedesktop.URfkill";
+
+    static constexpr char const* URFKILL_OBJ_PATH = "/org/freedesktop/URfkill";
+
+    static constexpr char const* URFKILL_WIFI_OBJ_PATH = "/org/freedesktop/URfkill/WLAN";
+}
 
=== renamed file 'tests/integration/indicator/CMakeLists.txt' => 'tests/integration/CMakeLists.txt'
--- tests/integration/indicator/CMakeLists.txt	2015-02-19 11:14:56 +0000
+++ tests/integration/CMakeLists.txt	2015-04-23 13:23:11 +0000
@@ -1,9 +1,16 @@
 
 add_definitions(-DNETWORK_SERVICE_BIN="${CMAKE_BINARY_DIR}/src/indicator/indicator-network-service")
 
+include_directories(
+    "${CMAKE_SOURCE_DIR}/src/connectivity-api/connectivity-qt"
+    "${CMAKE_SOURCE_DIR}/src/qdbus-stubs"
+)
+
 set(
     INTEGRATION_TESTS_SRC
-    TestIndicatorNetworkService.cpp
+    indicator-network-test-base.cpp
+    test-indicator.cpp
+    test-connectivity-api.cpp
 )
 
 add_executable(
@@ -22,6 +29,7 @@
     integration-tests
     test-utils
     menuharness
+    connectivity-qt
     ${QTDBUSMOCK_LDFLAGS}
     ${QTDBUSTEST_LDFLAGS}
     ${GTEST_LIBRARIES}
 
=== removed file 'tests/integration/CMakeLists.txt'
--- tests/integration/CMakeLists.txt	2015-03-31 10:39:35 +0000
+++ tests/integration/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#add_subdirectory(connectivity-cpp)
-add_subdirectory(indicator)
 
=== removed directory 'tests/integration/connectivity-cpp'
=== removed file 'tests/integration/connectivity-cpp/CMakeLists.txt'
--- tests/integration/connectivity-cpp/CMakeLists.txt	2015-02-16 18:33:09 +0000
+++ tests/integration/connectivity-cpp/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-# Copyright © 2013 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Authors:
-#     Antti Kaijanmäki <[e-mail]>
-
-
-include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
-
-if (NOT DEFINED GTEST_ROOT)
-    set(GTEST_ROOT /usr/src/gtest)
-endif()
-
-set(GTEST_SRC_DIR "${GTEST_ROOT}/src")
-set(GTEST_INCLUDE_DIR ${GTEST_ROOT})
-
-add_library(connectivity-gtest STATIC
-${GTEST_SRC_DIR}/gtest-all.cc
-${GTEST_SRC_DIR}/gtest_main.cc
-
-)
-
-set_target_properties(connectivity-gtest PROPERTIES INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR})
-target_link_libraries(connectivity-gtest ${CMAKE_THREAD_LIBS_INIT})
-
-include_directories(${GTEST_INCLUDE_DIRS})
-
-add_definitions(-DCORE_DBUS_ENABLE_GOOGLE_TEST_FIXTURE)
-
-pkg_check_modules(PROCESS_CPP process-cpp)
-
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/test_data.h.in
-    ${CMAKE_CURRENT_BINARY_DIR}/test_data.h @ONLY
-)
-include_directories(
-    ${CMAKE_CURRENT_BINARY_DIR}
-    ${CMAKE_SOURCE_DIR}/src/connectivity-cpp/include
-    ${CMAKE_SOURCE_DIR}/src/connectivity-cpp/dbus-cpp
-)
-
-add_executable (
-    test_networking_status
-    test_networking_status.cpp
-)
-
-add_executable (
-    test_flight_mode
-    test_flight_mode.cpp
-)
-
-add_executable (
-    test_wifi_link
-    test_wifi_link.cpp
-)
-
-add_executable (
-    test_wifi_link_dedup
-    test_wifi_link_dedup.cpp
-)
-
-add_executable (
-    test_wifi_connect
-    test_wifi_connect.cpp
-)
-
-add_executable (
-    test_wifi_link_enable_disable
-    test_wifi_link_enable_disable.cpp
-)
-
-target_link_libraries(
-    test_networking_status
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-target_link_libraries(
-    test_flight_mode
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-target_link_libraries(
-    test_wifi_link
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-target_link_libraries(
-    test_wifi_link_dedup
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-target_link_libraries(
-    test_wifi_connect
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-target_link_libraries(
-    test_wifi_link_enable_disable
-    connectivity-cpp
-    connectivity-gtest
-    ${PROCESS_CPP_LIBRARIES}
-)
-
-add_test(test_networking_status ${CMAKE_CURRENT_BINARY_DIR}/test_networking_status)
-add_test(test_flight_mode ${CMAKE_CURRENT_BINARY_DIR}/test_flight_mode)
-add_test(test_wifi_link ${CMAKE_CURRENT_BINARY_DIR}/test_wifi_link)
-add_test(test_wifi_link_dedup ${CMAKE_CURRENT_BINARY_DIR}/test_wifi_link_dedup)
-add_test(test_wifi_connect ${CMAKE_CURRENT_BINARY_DIR}/test_wifi_connect)
-add_test(test_wifi_link_enable_disable ${CMAKE_CURRENT_BINARY_DIR}/test_wifi_link_enable_disable)
 
=== removed directory 'tests/integration/connectivity-cpp/mocks'
=== removed file 'tests/integration/connectivity-cpp/mocks/urfkill.h'
--- tests/integration/connectivity-cpp/mocks/urfkill.h	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/mocks/urfkill.h	1970-01-01 00:00:00 +0000
@@ -1,162 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#ifndef MOCKS_URFKILL_H
-#define MOCKS_URFKILL_H
-
-#include <services/urfkill.h>
-
-class DefaultURfkillMock : public org::freedesktop::URfkill::Service::Mock
-{
-    typedef org::freedesktop::URfkill::Interface::Killswitch Killswitch;
-
-    bool inFlightMode;
-
-public:
-
-    DefaultURfkillMock() = delete;
-    DefaultURfkillMock(const core::dbus::Bus::Ptr& bus)
-        : org::freedesktop::URfkill::Service::Mock(bus),
-          inFlightMode{false},
-          bt{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::bluetooth)),
-                        Killswitch::Type::bluetooth)},
-          fm{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::fm)),
-                        Killswitch::Type::fm)},
-          gps{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::gps)),
-                         Killswitch::Type::gps)},
-          nfc{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::nfc)),
-                         Killswitch::Type::nfc)},
-          uwb{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::uwb)),
-                         Killswitch::Type::uwb)},
-          wimax{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::wimax)),
-                           Killswitch::Type::wimax)},
-          wlan{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::wlan)),
-                          Killswitch::Type::wlan)},
-          wwan{Killswitch(urfkill->service->add_object_for_path(Killswitch::path(Killswitch::Type::wwan)),
-                          Killswitch::Type::wwan)}
-    {
-        urfkill->object->install_method_handler
-            <org::freedesktop::URfkill::Interface::URfkill::Method::Block>
-                ([this, bus](const core::dbus::Message::Ptr& msg)
-        {
-            auto reader = msg->reader();
-
-            std::uint32_t type = reader.pop_uint32();
-            bool value = reader.pop_boolean();
-
-            auto reply = core::dbus::Message::make_method_return(msg);
-            reply->writer() << block(type, value);
-            bus->send(reply);
-        });
-
-        urfkill->object->install_method_handler
-            <org::freedesktop::URfkill::Interface::URfkill::Method::FlightMode>
-                ([this, bus](const core::dbus::Message::Ptr& msg)
-        {
-            auto reply = core::dbus::Message::make_method_return(msg);
-
-            auto reader = msg->reader();
-            bool value = reader.pop_boolean();
-
-            reply->writer() << true;
-            bus->send(reply);
-
-            if (inFlightMode != value) {
-                inFlightMode = value;
-                auto signal_flightmode_changed
-                        = urfkill->object->get_signal<org::freedesktop::URfkill::Interface::URfkill::Signal::FlightModeChanged>();
-                signal_flightmode_changed->emit(inFlightMode);
-
-                block(1, inFlightMode);
-            }
-        });
-
-        urfkill->object->install_method_handler
-            <org::freedesktop::URfkill::Interface::URfkill::Method::IsFlightMode>
-                ([this, bus](const core::dbus::Message::Ptr& msg)
-        {
-            auto reply = core::dbus::Message::make_method_return(msg);
-            reply->writer() << inFlightMode;
-            bus->send(reply);
-        });
-
-        bt._state->set(0);
-        fm._state->set(0);
-        gps._state->set(0);
-        nfc._state->set(0);
-        uwb._state->set(0);
-        wimax._state->set(0);
-        wlan._state->set(0);
-        wwan._state->set(0);
-    }
-
-    bool block(std::uint32_t type, bool block)
-    {
-        switch (type) {
-        case 1:
-        {
-            if (block)
-                wlan._state->set(1); // soft blocked
-            else
-                wlan._state->set(0); // unblocked
-
-            auto signal_properties_changed
-                    = wlan.object->get_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged>();
-            std::map<std::string, core::dbus::types::Variant> changed;
-            changed["state"] = core::dbus::types::TypedVariant<std::int32_t>(wlan._state->get());
-            core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType args
-                    (org::freedesktop::URfkill::Interface::Killswitch::name(),
-                     changed,
-                     {}
-                   );
-            signal_properties_changed->emit(args);
-            break;
-        }
-        case 2:
-            //Killswitch::Type::bluetooth
-        case 3:
-            //Killswitch::Type::uwb
-        case 4:
-            //Killswitch::Type::wimax
-        case 5:
-            //Killswitch::Type::wwan
-        case 6:
-            //Killswitch::Type::gps
-        case 7:
-            //Killswitch::Type::fm
-        case 8:
-            //Killswitch::Type::nfc
-            break;
-        default:
-            std::logic_error("Unknown killswitch id: " + std::to_string(type));
-        }
-
-        return true;
-    }
-
-    org::freedesktop::URfkill::Interface::Killswitch bt;
-    org::freedesktop::URfkill::Interface::Killswitch fm;
-    org::freedesktop::URfkill::Interface::Killswitch gps;
-    org::freedesktop::URfkill::Interface::Killswitch nfc;
-    org::freedesktop::URfkill::Interface::Killswitch uwb;
-    org::freedesktop::URfkill::Interface::Killswitch wimax;
-    org::freedesktop::URfkill::Interface::Killswitch wlan;
-    org::freedesktop::URfkill::Interface::Killswitch wwan;
-};
-
-#endif
 
=== removed file 'tests/integration/connectivity-cpp/sig_term_catcher.h'
--- tests/integration/connectivity-cpp/sig_term_catcher.h	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/sig_term_catcher.h	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-
-#ifndef CORE_TESTING_SIG_TERM_CATCHER_H_
-#define CORE_TESTING_SIG_TERM_CATCHER_H_
-
-#include <system_error>
-
-#include <signal.h>
-#include <unistd.h>
-#include <poll.h>
-#include <sys/signalfd.h>
-
-namespace core
-{
-namespace testing
-{
-struct SigTermCatcher
-{
-    inline SigTermCatcher()
-    {
-        sigemptyset(&signal_mask);
-
-        if (-1 == sigaddset(&signal_mask, SIGTERM))
-            throw std::system_error(errno, std::system_category());
-
-        if (-1 == sigprocmask(SIG_BLOCK, &signal_mask, NULL))
-            throw std::system_error(errno, std::system_category());
-
-        if (-1 == (signal_fd = signalfd(-1, &signal_mask, 0)))
-            throw std::system_error(errno, std::system_category());
-    }
-
-    inline ~SigTermCatcher()
-    {
-        ::close(signal_fd);
-    }
-
-    inline void wait_for_signal_for(const std::chrono::milliseconds& ms)
-    {
-        pollfd fd; fd.fd = signal_fd; fd.events = POLLIN;
-        if (poll(&fd, 1, ms.count()) > 0)
-        {
-            signalfd_siginfo siginfo;
-            if (-1 == ::read(signal_fd, &siginfo, sizeof(siginfo)))
-                throw std::system_error(errno, std::system_category());
-        } else
-        {
-            throw std::system_error(errno, std::system_category());
-        }
-    }
-
-    sigset_t signal_mask;
-    int signal_fd = -1;
-};
-}
-}
-
-#endif // CORE_TESTING_SIG_TERM_CATCHER_H_
 
=== removed file 'tests/integration/connectivity-cpp/test_data.h.in'
--- tests/integration/connectivity-cpp/test_data.h.in	2014-08-19 20:17:22 +0000
+++ tests/integration/connectivity-cpp/test_data.h.in	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-
-#ifndef TEST_DATA_H_
-#define TEST_DATA_H_
-
-namespace core
-{
-namespace testing
-{
-
-constexpr const char* session_bus_configuration_file()
-{
-    return "@CMAKE_SOURCE_DIR@/src/connectivity-cpp/data/session.conf";
-}
-
-constexpr const char* system_bus_configuration_file()
-{
-    return "@CMAKE_SOURCE_DIR@/src/connectivity-cpp/data/system.conf";
-}
-}
-}
-#endif // TEST_DATA_H_
 
=== removed file 'tests/integration/connectivity-cpp/test_flight_mode.cpp'
--- tests/integration/connectivity-cpp/test_flight_mode.cpp	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/test_flight_mode.cpp	1970-01-01 00:00:00 +0000
@@ -1,138 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include <services/nm.h>
-#include "mocks/urfkill.h"
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include <connectivity/networking/manager.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, flightMode)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            auto nm_service = NM::Service::Mock(bus);
-            auto nm_root = nm_service.nm;
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, nm_root](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                reply->writer() << std::vector<dbus::types::ObjectPath>();
-                bus->send(reply);
-            });
-
-            nm_root->state->set(0);
-
-            DefaultURfkillMock urfkill(bus);
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{2000}));
-            sc.wait_for_signal_for(std::chrono::seconds{10});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{2000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            std::vector<connectivity::networking::Manager::FlightModeStatus> statuses;
-            try {
-                EXPECT_EQ(mgr->flightMode().get(), connectivity::networking::Manager::FlightModeStatus::off);
-
-                mgr->flightMode().changed().connect([&statuses](connectivity::networking::Manager::FlightModeStatus status) {
-                    statuses.push_back(status);
-                });
-
-                mgr->enableFlightMode();
-                mgr->disableFlightMode();
-
-            } catch (const std::runtime_error &e) {
-                std::cout << "exception: " << e.what() << std::endl;
-            }
-
-            sleep(1);
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            EXPECT_EQ(statuses.size(), 2);
-            EXPECT_EQ(statuses.at(0), connectivity::networking::Manager::FlightModeStatus::on);
-            EXPECT_EQ(statuses.at(1), connectivity::networking::Manager::FlightModeStatus::off);
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
 
=== removed file 'tests/integration/connectivity-cpp/test_networking_status.cpp'
--- tests/integration/connectivity-cpp/test_networking_status.cpp	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/test_networking_status.cpp	1970-01-01 00:00:00 +0000
@@ -1,178 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include "mocks/urfkill.h"
-
-#include <services/nm.h>
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include <connectivity/networking/manager.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, networkingStatus)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-        core::testing::CrossProcessSync update_networking_status;
-
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            DefaultURfkillMock urfkill(bus);
-
-            auto nm_service = NM::Service::Mock(bus);
-            auto nm_root = nm_service.nm;
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, nm_root](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                reply->writer() << std::vector<dbus::types::ObjectPath>();
-                bus->send(reply);
-            });
-
-            nm_root->state->set(NM_STATE_UNKNOWN);
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{2000}));
-
-            NM::Interface::NetworkManager::Signal::PropertiesChanged::ArgumentType properties;
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_UNKNOWN);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_ASLEEP);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_DISCONNECTED);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTING);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTED_LOCAL);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTED_SITE);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTED_GLOBAL);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_DISCONNECTING);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_DISCONNECTED);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTING);
-            nm_root->properties_changed->emit(properties);
-
-            properties["State"] = dbus::types::Variant::encode<std::uint32_t>(NM_STATE_CONNECTED_GLOBAL);
-            nm_root->properties_changed->emit(properties);
-
-            // status change
-            update_networking_status.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            sc.wait_for_signal_for(std::chrono::seconds{10});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{2000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            EXPECT_EQ(mgr->status().get(), connectivity::networking::Manager::NetworkingStatus::offline);
-
-            std::vector<connectivity::networking::Manager::NetworkingStatus> states;
-            mgr->status().changed().connect([&states](connectivity::networking::Manager::NetworkingStatus status) {
-                states.push_back(status);
-            });
-
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            EXPECT_EQ(1, update_networking_status.wait_for_signal_ready_for(std::chrono::milliseconds{2000}));
-
-            sleep(1);
-
-            EXPECT_EQ(states.size(), 5);
-            EXPECT_EQ(states.at(0), connectivity::networking::Manager::NetworkingStatus::connecting);
-            EXPECT_EQ(states.at(1), connectivity::networking::Manager::NetworkingStatus::online);
-            EXPECT_EQ(states.at(2), connectivity::networking::Manager::NetworkingStatus::offline);
-            EXPECT_EQ(states.at(3), connectivity::networking::Manager::NetworkingStatus::connecting);
-            EXPECT_EQ(states.at(4), connectivity::networking::Manager::NetworkingStatus::online);
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
-
 
=== removed file 'tests/integration/connectivity-cpp/test_service.h'
--- tests/integration/connectivity-cpp/test_service.h	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/test_service.h	1970-01-01 00:00:00 +0000
@@ -1,124 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-
-#ifndef TEST_SERVICE_H_
-#define TEST_SERVICE_H_
-
-namespace test
-{
-struct Service
-{
-    struct Method
-    {
-        typedef Service Interface;
-
-        inline static const std::string& name()
-        {
-            static const std::string s
-            {
-                "Method"
-            };
-            return s;
-        }
-
-        inline static const std::chrono::milliseconds default_timeout()
-        {
-            return std::chrono::seconds{1};
-        }
-    };
-
-    struct Signals
-    {
-        struct Dummy
-        {
-            inline static std::string name()
-            {
-                return "Dummy";
-            };
-            typedef Service Interface;
-            typedef int64_t ArgumentType;
-        };
-    };
-
-    struct Properties
-    {
-        struct Dummy
-        {
-            inline static std::string name()
-            {
-                return "Dummy";
-            };
-            typedef Service Interface;
-            typedef double ValueType;
-            static const bool readable = true;
-            static const bool writable = true;
-        };
-    };
-
-    struct Interfaces
-    {
-        struct Foo
-        {
-            static const std::string& name()
-            {
-                static const std::string s{"this.is.unlikely.to.exist.Service.Foo"};
-                return s;
-            }
-
-            struct Signals
-            {
-                struct Dummy
-                {
-                    inline static std::string name()
-                    {
-                        return "Dummy";
-                    }
-                    typedef Foo Interface;
-                    typedef int64_t ArgumentType;
-                };
-            };
-        };
-    };
-};
-}
-
-#include <core/dbus/traits/service.h>
-
-namespace core
-{
-namespace dbus
-{
-namespace traits
-{
-template<>
-struct Service<test::Service>
-{
-    inline static const std::string& interface_name()
-    {
-        static const std::string s
-        {
-            "this.is.unlikely.to.exist.Service"
-        };
-        return s;
-    }
-};
-}
-}
-}
-
-#endif // TEST_SERVICE_H_
 
=== removed file 'tests/integration/connectivity-cpp/test_wifi_connect.cpp'
--- tests/integration/connectivity-cpp/test_wifi_connect.cpp	2014-08-23 18:11:18 +0000
+++ tests/integration/connectivity-cpp/test_wifi_connect.cpp	1970-01-01 00:00:00 +0000
@@ -1,278 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include <services/nm.h>
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include "mocks/urfkill.h"
-
-#include <connectivity/networking/manager.h>
-#include <connectivity/networking/wifi/link.h>
-#include <connectivity/networking/wifi/access-point.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, wifiLink)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-        core::testing::CrossProcessSync stage1;
-        core::testing::CrossProcessSync stage2;
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            auto service = NM::Service::Mock(bus);
-            auto nm_root = service.nm;
-
-            auto wifi_dev = NM::Interface::Device(nm_root->service,
-                                                  nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Devices/0")));
-            auto ap1 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/1")));
-            auto ap2 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/2")));
-
-            auto wrong_settings = NM::Interface::Connection(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Settings/1")));
-            auto correct_settings = NM::Interface::Connection(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Settings/2")));
-
-            wrong_settings.object->install_method_handler<NM::Interface::Connection::Method::GetSettings>([&](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::map<std::string, std::map<std::string, core::dbus::types::Variant>> conf;
-                std::map<std::string, dbus::types::Variant> wireless_conf;
-                wireless_conf["ssid"] = dbus::types::Variant::encode<std::vector<std::int8_t>>({0x64, 0x65, 0x66}); // def
-                conf["802-11-wireless"] = wireless_conf;
-                reply->writer() << conf;
-                bus->send(reply);
-            });
-
-            correct_settings.object->install_method_handler<NM::Interface::Connection::Method::GetSettings>([&](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::map<std::string, std::map<std::string, core::dbus::types::Variant>> conf;
-                std::map<std::string, dbus::types::Variant> wireless_conf;
-                wireless_conf["ssid"] = dbus::types::Variant::encode<std::vector<std::int8_t>>({static_cast<std::int8_t>(0xC3),
-                                                                                                static_cast<std::int8_t>(0xA4),
-                                                                                                static_cast<std::int8_t>(0x62),
-                                                                                                static_cast<std::int8_t>(0x63)}); // äbc
-                conf["802-11-wireless"] = wireless_conf;
-                reply->writer() << conf;
-                bus->send(reply);
-            });
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, &wifi_dev](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::vector<dbus::types::ObjectPath> devices;
-                devices.push_back(wifi_dev.object->path());
-                reply->writer() << devices;
-                bus->send(reply);
-            });
-
-            NM::Interface::Device::Property::AvailableConnections::ValueType available_connections;
-            available_connections.push_back(wrong_settings.object->path());
-            available_connections.push_back(correct_settings.object->path());
-            wifi_dev.available_connections->set(available_connections);
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::ActivateConnection>([&](const dbus::Message::Ptr& msg)
-            {
-                std::cout << "Server: Active Connection" << std::endl;
-                auto reader = msg->reader();
-
-                dbus::types::ObjectPath connection = reader.pop_object_path();
-                dbus::types::ObjectPath device = reader.pop_object_path();
-                dbus::types::ObjectPath specific_object = reader.pop_object_path();
-
-                EXPECT_EQ(connection, correct_settings.object->path());
-                EXPECT_EQ(device, wifi_dev.object->path());
-                EXPECT_EQ(specific_object, ap1.object->path());
-
-                auto reply = dbus::Message::make_method_return(msg);
-                reply->writer() << dbus::types::ObjectPath("/"); /// @todo return an actual ActiveConnection at some point.
-                bus->send(reply);
-            });
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::AddAndActivateConnection>([&](const dbus::Message::Ptr& msg)
-            {
-                std::cout << "Server: Add and Active Connection" << std::endl;
-                auto reader = msg->reader();
-
-                std::map<std::string, std::map<std::string, core::dbus::types::Variant>> connection;
-                reader >> connection;
-                dbus::types::ObjectPath device = reader.pop_object_path();
-                dbus::types::ObjectPath specific_object = reader.pop_object_path();
-
-                EXPECT_TRUE(connection.find("802-11-wireless") != connection.end());
-                auto wificonf = connection["802-11-wireless"];
-                EXPECT_TRUE(wificonf.find("ssid") != wificonf.end());
-                EXPECT_EQ(wificonf["ssid"].as<std::vector<std::int8_t>>(), ap2.ssid->get());
-                EXPECT_EQ(device, wifi_dev.object->path());
-                EXPECT_EQ(specific_object, ap2.object->path());
-
-                auto reply = dbus::Message::make_method_return(msg);
-                auto ret = std::make_tuple(dbus::types::ObjectPath("/"), dbus::types::ObjectPath("/"));
-                reply->writer() << ret; /// @todo return actual Settings and ActiveConnection at some point.
-                bus->send(reply);
-            });
-
-
-            nm_root->state->set(NM_STATE_DISCONNECTED);
-            wifi_dev.device_type->set(NM_DEVICE_TYPE_WIFI);
-
-            std::vector<dbus::types::ObjectPath> aps;
-            wifi_dev.object->install_method_handler<NM::Interface::Device::Wireless::Method::GetAccessPoints>([bus, &aps](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                reply->writer() << aps;
-                bus->send(reply);
-            });
-
-            auto ap_added = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointAdded>();
-            auto ap_removed = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointRemoved>();
-
-            ap1.flags->set(NM_802_11_AP_FLAGS_PRIVACY);
-            ap1.mode->set(NM_802_11_MODE_INFRA);
-            // SSID name is äbc to test that utf-8 in names works.
-            // The casts are because the underlying datatype is
-            // signed char (should be unsigned) and 0x63 > 127.
-            ap1.ssid->set({static_cast<std::int8_t>(0xC3),
-                           static_cast<std::int8_t>(0xA4),
-                           static_cast<std::int8_t>(0x62),
-                           static_cast<std::int8_t>(0x63)});
-            ap1.strength->set(90);
-
-            auto ap1_pc = ap1.properties_changed;
-
-            ap2.flags->set(NM_802_11_AP_FLAGS_NONE);
-            ap2.mode->set(NM_802_11_MODE_ADHOC);
-            ap2.ssid->set({0x31, 0x32, 0x33}); // 123
-            ap2.strength->set(60);
-            auto ap2_pc = ap2.properties_changed;
-
-            DefaultURfkillMock urfkill(bus);
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            aps.push_back(ap1.object->path());
-            aps.push_back(ap2.object->path());
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{5000});
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-
-            stage1.try_signal_ready_for(std::chrono::milliseconds{5000});
-
-            sleep(1);
-
-            stage2.try_signal_ready_for(std::chrono::milliseconds{5000});
-
-            sc.wait_for_signal_for(std::chrono::seconds{60});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            auto links = mgr->links();
-            EXPECT_EQ(links->size(), 1);
-
-            EXPECT_EQ((*links->begin())->type(), connectivity::networking::Link::Type::wifi);
-            auto wifilink = std::dynamic_pointer_cast<connectivity::networking::wifi::Link>(*links->begin());
-            EXPECT_TRUE(wifilink.get() != nullptr);
-
-            auto aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 2);
-
-            std::shared_ptr<connectivity::networking::wifi::AccessPoint> ap_abc;
-            std::shared_ptr<connectivity::networking::wifi::AccessPoint> ap_123;
-            for (auto ap : aps) {
-                if (ap->ssid() == "äbc")
-                    ap_abc = ap;
-                if (ap->ssid() == "123")
-                    ap_123 = ap;
-            }
-
-            EXPECT_TRUE(ap_abc.get() != nullptr);
-            EXPECT_TRUE(ap_123.get() != nullptr);
-
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            wifilink->connect_to(ap_abc);
-
-            sleep(1);
-
-            EXPECT_EQ(1, stage1.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-            wifilink->connect_to(ap_123);
-
-            sleep(1);
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
-
 
=== removed file 'tests/integration/connectivity-cpp/test_wifi_link.cpp'
--- tests/integration/connectivity-cpp/test_wifi_link.cpp	2014-08-20 19:18:40 +0000
+++ tests/integration/connectivity-cpp/test_wifi_link.cpp	1970-01-01 00:00:00 +0000
@@ -1,362 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include <services/nm.h>
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include "mocks/urfkill.h"
-
-#include <connectivity/networking/manager.h>
-#include <connectivity/networking/wifi/link.h>
-#include <connectivity/networking/wifi/access-point.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, wifiLink)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-        core::testing::CrossProcessSync stage1;
-        core::testing::CrossProcessSync stage2;
-        core::testing::CrossProcessSync stage3;
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            auto service = NM::Service::Mock(bus);
-            auto nm_root = service.nm;
-
-            auto wifi_dev = NM::Interface::Device(nm_root->service,
-                                                  nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Devices/0")));
-            auto ap1 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/1")));
-            auto ap2 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/2")));
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, &wifi_dev](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::vector<dbus::types::ObjectPath> devices;
-                devices.push_back(wifi_dev.object->path());
-                reply->writer() << devices;
-                bus->send(reply);
-            });
-
-            nm_root->state->set(NM_STATE_CONNECTED_GLOBAL);
-
-            wifi_dev.device_type->set(NM_DEVICE_TYPE_WIFI);
-
-            std::vector<dbus::types::ObjectPath> aps;
-            wifi_dev.object->install_method_handler<NM::Interface::Device::Wireless::Method::GetAccessPoints>([bus, &aps](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);                
-                reply->writer() << aps;
-                bus->send(reply);
-            });
-
-            auto ap_added = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointAdded>();
-            auto ap_removed = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointRemoved>();
-
-            ap1.flags->set(NM_802_11_AP_FLAGS_PRIVACY);
-            ap1.mode->set(NM_802_11_MODE_INFRA);
-            ap1.ssid->set({0x61, 0x62, 0x63}); // abc
-            ap1.strength->set(90);
-
-            auto ap1_pc = ap1.properties_changed;
-
-            ap2.flags->set(NM_802_11_AP_FLAGS_NONE);
-            ap2.mode->set(NM_802_11_MODE_ADHOC);
-            ap2.ssid->set({0x31, 0x32, 0x33}); // 123
-            ap2.strength->set(60);
-            auto ap2_pc = ap2.properties_changed;
-
-            DefaultURfkillMock urfkill(bus);
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            // add just one AP initially
-            aps.push_back(ap1.object->path());
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{5000});
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-            NM::Interface::AccessPoint::Signal::PropertiesChanged::ArgumentType properties;
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(0);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(1);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(2);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(3);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(4);
-            ap1_pc->emit(properties);
-
-            stage1.try_signal_ready_for(std::chrono::milliseconds{5000});
-
-            // add second ap
-            aps.push_back(ap2.object->path());
-            ap_added->emit(ap2.object->path());
-
-            sleep(5);
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(5);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(6);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(7);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(8);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(9);
-            ap1_pc->emit(properties);
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(100);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(99);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(98);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(97);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(96);
-            ap2_pc->emit(properties);
-            ap2_pc->emit(properties);
-
-            stage2.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            // remove the first ap
-            aps.clear();
-            aps.push_back(ap2.object->path());
-            ap_removed->emit(ap1.object->path());
-
-            sleep(5);
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(95);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(94);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(93);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(92);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(91);
-            ap2_pc->emit(properties);
-
-            stage3.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            // add the first ap back
-            aps.push_back(ap1.object->path());
-            ap_added->emit(ap1.object->path());
-
-            sleep(5);
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(10);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(11);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(12);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(13);
-            ap1_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(14);
-            ap1_pc->emit(properties);
-
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(90);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(89);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(88);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(87);
-            ap2_pc->emit(properties);
-            properties["Strength"] = dbus::types::Variant::encode<std::int8_t>(86);
-            ap2_pc->emit(properties);
-
-            sc.wait_for_signal_for(std::chrono::seconds{60});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            auto links = mgr->links();
-            EXPECT_EQ(links->size(), 1);
-
-            EXPECT_EQ((*links->begin())->type(), connectivity::networking::Link::Type::wifi);
-            auto wifilink = std::dynamic_pointer_cast<connectivity::networking::wifi::Link>(*links->begin());
-            EXPECT_TRUE(wifilink.get() != nullptr);
-
-            std::vector<double> values_abc;
-            std::vector<double> values_123;
-            std::map<std::shared_ptr<connectivity::networking::wifi::AccessPoint>, core::ScopedConnection> connections;
-            auto ap_connect = [&](std::shared_ptr<connectivity::networking::wifi::AccessPoint> ap) {
-                if (ap->ssid() == "abc") {
-                    EXPECT_TRUE(ap->secured());
-                    EXPECT_FALSE(ap->adhoc());
-                    auto con = ap->strength().changed().connect([&values_abc](double value){
-                        values_abc.push_back(value);
-                    });
-                    connections.insert(std::make_pair(ap, core::ScopedConnection(con)));
-                } else if (ap->ssid() == "123") {
-                    EXPECT_FALSE(ap->secured());
-                    EXPECT_TRUE(ap->adhoc());
-                    auto con = ap->strength().changed().connect([&values_123](double value){
-                        values_123.push_back(value);
-                    });
-                    connections.insert(std::make_pair(ap, core::ScopedConnection(con)));
-                }
-            };
-            auto aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 1);
-            for (auto ap : aps) {
-                ap_connect(ap);
-            }
-            aps.clear();
-            wifilink->accessPoints().changed().connect([&](std::set<std::shared_ptr<connectivity::networking::wifi::AccessPoint>> aps) {
-                connections.clear();
-                for (auto ap: aps)
-                    ap_connect(ap);
-            });
-
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            sleep(5);
-
-            EXPECT_EQ(values_abc.size(), 5);
-            EXPECT_EQ(values_123.size(), 0);
-
-            EXPECT_FLOAT_EQ(values_abc[0], 0);
-            EXPECT_FLOAT_EQ(values_abc[1], 1);
-            EXPECT_FLOAT_EQ(values_abc[2], 2);
-            EXPECT_FLOAT_EQ(values_abc[3], 3);
-            EXPECT_FLOAT_EQ(values_abc[4], 4);
-
-            values_abc.clear();
-            values_123.clear();
-            EXPECT_EQ(1, stage1.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            sleep(5);
-
-            EXPECT_EQ(values_abc.size(), 5);
-            EXPECT_EQ(values_123.size(), 5);
-
-            EXPECT_FLOAT_EQ(values_abc[0], 5);
-            EXPECT_FLOAT_EQ(values_abc[1], 6);
-            EXPECT_FLOAT_EQ(values_abc[2], 7);
-            EXPECT_FLOAT_EQ(values_abc[3], 8);
-            EXPECT_FLOAT_EQ(values_abc[4], 9);
-
-            EXPECT_FLOAT_EQ(values_123[0], 100);
-            EXPECT_FLOAT_EQ(values_123[1], 99);
-            EXPECT_FLOAT_EQ(values_123[2], 98);
-            EXPECT_FLOAT_EQ(values_123[3], 97);
-            EXPECT_FLOAT_EQ(values_123[4], 96);
-
-            values_abc.clear();
-            values_123.clear();
-            EXPECT_EQ(1, stage2.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            sleep(5);
-
-            EXPECT_EQ(values_abc.size(), 0);
-            EXPECT_EQ(values_123.size(), 5);
-
-            EXPECT_FLOAT_EQ(values_123[0], 95);
-            EXPECT_FLOAT_EQ(values_123[1], 94);
-            EXPECT_FLOAT_EQ(values_123[2], 93);
-            EXPECT_FLOAT_EQ(values_123[3], 92);
-            EXPECT_FLOAT_EQ(values_123[4], 91);
-
-            values_abc.clear();
-            values_123.clear();
-            EXPECT_EQ(1, stage3.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            sleep(5);
-
-            EXPECT_EQ(values_abc.size(), 5);
-            EXPECT_EQ(values_123.size(), 5);
-
-            EXPECT_FLOAT_EQ(values_abc[0], 10);
-            EXPECT_FLOAT_EQ(values_abc[1], 11);
-            EXPECT_FLOAT_EQ(values_abc[2], 12);
-            EXPECT_FLOAT_EQ(values_abc[3], 13);
-            EXPECT_FLOAT_EQ(values_abc[4], 14);
-
-            EXPECT_FLOAT_EQ(values_123[0], 90);
-            EXPECT_FLOAT_EQ(values_123[1], 89);
-            EXPECT_FLOAT_EQ(values_123[2], 88);
-            EXPECT_FLOAT_EQ(values_123[3], 87);
-            EXPECT_FLOAT_EQ(values_123[4], 86);
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
-
 
=== removed file 'tests/integration/connectivity-cpp/test_wifi_link_dedup.cpp'
--- tests/integration/connectivity-cpp/test_wifi_link_dedup.cpp	2014-08-20 20:16:32 +0000
+++ tests/integration/connectivity-cpp/test_wifi_link_dedup.cpp	1970-01-01 00:00:00 +0000
@@ -1,240 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include <services/nm.h>
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include "mocks/urfkill.h"
-
-#include <connectivity/networking/manager.h>
-#include <connectivity/networking/wifi/link.h>
-#include <connectivity/networking/wifi/access-point.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, wifiLink)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-        core::testing::CrossProcessSync stage1;
-        core::testing::CrossProcessSync stage2;
-        core::testing::CrossProcessSync stage3;
-        core::testing::CrossProcessSync stage4;
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            auto service = NM::Service::Mock(bus);
-            auto nm_root = service.nm;
-
-            auto wifi_dev = NM::Interface::Device(nm_root->service,
-                                                  nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Devices/0")));
-            auto ap1 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/1")));
-            auto ap2 = NM::Interface::AccessPoint(nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/AccessPoint/2")));
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, &wifi_dev](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::vector<dbus::types::ObjectPath> devices;
-                devices.push_back(wifi_dev.object->path());
-                reply->writer() << devices;
-                bus->send(reply);
-            });
-
-            nm_root->state->set(NM_STATE_CONNECTED_GLOBAL);
-
-            wifi_dev.device_type->set(NM_DEVICE_TYPE_WIFI);
-
-            std::vector<dbus::types::ObjectPath> aps;
-            wifi_dev.object->install_method_handler<NM::Interface::Device::Wireless::Method::GetAccessPoints>([bus, &aps](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);                
-                reply->writer() << aps;
-                bus->send(reply);
-            });
-
-            auto ap_added = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointAdded>();
-            auto ap_removed = wifi_dev.object->get_signal<NM::Interface::Device::Wireless::Signal::AccessPointRemoved>();
-
-            ap1.flags->set(NM_802_11_AP_FLAGS_PRIVACY);
-            ap1.mode->set(NM_802_11_MODE_INFRA);
-            ap1.ssid->set({0x61, 0x62, 0x63}); // abc
-            ap1.strength->set(60);
-
-            auto ap1_pc = ap1.properties_changed;
-
-            ap2.flags->set(NM_802_11_AP_FLAGS_PRIVACY);
-            ap2.mode->set(NM_802_11_MODE_INFRA);
-            ap2.ssid->set({0x61, 0x62, 0x63}); // abc
-            ap2.strength->set(90);
-            auto ap2_pc = ap2.properties_changed;
-
-            DefaultURfkillMock urfkill(bus);
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            // add just one AP initially
-            aps.push_back(ap1.object->path());
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{10000});
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            NM::Interface::AccessPoint::Signal::PropertiesChanged::ArgumentType properties;
-
-            stage1.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            // add second ap
-            aps.push_back(ap2.object->path());
-            ap_added->emit(ap2.object->path());
-
-            sleep(5);
-
-            stage2.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            // remove second ap
-            aps.clear();
-            aps.push_back(ap1.object->path());
-            ap_removed->emit(ap2.object->path());
-
-            sleep(5);
-
-            stage3.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            aps.clear();
-            ap_removed->emit(ap1.object->path());
-
-            sleep(5);
-
-            stage4.try_signal_ready_for(std::chrono::milliseconds{10000});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            auto links = mgr->links();
-            EXPECT_EQ(links->size(), 1);
-
-            EXPECT_EQ((*links->begin())->type(), connectivity::networking::Link::Type::wifi);
-            auto wifilink = std::dynamic_pointer_cast<connectivity::networking::wifi::Link>(*links->begin());
-            EXPECT_TRUE(wifilink.get() != nullptr);
-
-            std::vector<double> values_abc;
-            std::vector<double> values_123;
-            std::map<std::shared_ptr<connectivity::networking::wifi::AccessPoint>, core::ScopedConnection> connections;
-            auto ap_connect = [&](std::shared_ptr<connectivity::networking::wifi::AccessPoint> ap) {
-                EXPECT_EQ(ap->ssid(), "abc");
-                EXPECT_TRUE(ap->secured());
-                EXPECT_FALSE(ap->adhoc());
-                //connections.insert(std::make_pair(ap, core::ScopedConnection(con)));
-            };
-
-            wifilink->accessPoints().changed().connect([&](std::set<std::shared_ptr<connectivity::networking::wifi::AccessPoint>> aps) {
-                connections.clear();
-                for (auto ap: aps)
-                    ap_connect(ap);
-            });
-
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            auto aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 1);
-            EXPECT_EQ((*aps.begin())->strength().get(), 60);
-            sleep(5);
-
-            EXPECT_EQ(1, stage1.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 1);
-            EXPECT_EQ((*aps.begin())->strength().get(), 90);
-
-
-            EXPECT_EQ(1, stage2.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            sleep(5);
-
-            aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 1);
-            EXPECT_EQ((*aps.begin())->strength().get(), 60);
-
-            EXPECT_EQ(1, stage3.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            sleep(5);
-
-            aps = wifilink->accessPoints().get();
-            EXPECT_EQ(aps.size(), 0);
-
-            EXPECT_EQ(1, stage4.wait_for_signal_ready_for(std::chrono::milliseconds{10000}));
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
-
 
=== removed file 'tests/integration/connectivity-cpp/test_wifi_link_enable_disable.cpp'
--- tests/integration/connectivity-cpp/test_wifi_link_enable_disable.cpp	2014-08-19 19:55:15 +0000
+++ tests/integration/connectivity-cpp/test_wifi_link_enable_disable.cpp	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Antti Kaijanmäki <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include "sig_term_catcher.h"
-#include "test_data.h"
-#include "test_service.h"
-
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
-#include <gtest/gtest.h>
-
-#include <system_error>
-#include <thread>
-
-#include <services/nm.h>
-namespace fdo = org::freedesktop;
-namespace NM = fdo::NetworkManager;
-
-#include "mocks/urfkill.h"
-
-#include <connectivity/networking/manager.h>
-#include <connectivity/networking/wifi/link.h>
-#include <connectivity/networking/wifi/access-point.h>
-
-namespace dbus = core::dbus;
-
-namespace
-{
-struct Service : public core::dbus::testing::Fixture {};
-
-auto session_bus_config_file =
-        core::dbus::testing::Fixture::default_session_bus_config_file() =
-        core::testing::session_bus_configuration_file();
-
-auto system_bus_config_file =
-        core::dbus::testing::Fixture::default_system_bus_config_file() =
-        core::testing::system_bus_configuration_file();
-
-}
-
-TEST_F(Service, wifiLink)
-{
-        core::testing::CrossProcessSync services_ready;
-        core::testing::CrossProcessSync client_ready;
-        core::testing::CrossProcessSync stage1;
-        core::testing::CrossProcessSync stage2;
-
-        auto service = [&, this]()
-        {
-            core::testing::SigTermCatcher sc;
-
-            auto bus = system_bus();
-            bus->install_executor(core::dbus::asio::make_executor(bus));
-
-            auto service = NM::Service::Mock(bus);
-            auto nm_root = service.nm;
-
-            auto wifi_dev = NM::Interface::Device(nm_root->service,
-                                                  nm_root->service->add_object_for_path(dbus::types::ObjectPath("/org/freedesktop/NetworkManager/Devices/0")));
-
-            nm_root->object->install_method_handler<NM::Interface::NetworkManager::Method::GetDevices>([bus, &wifi_dev](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                std::vector<dbus::types::ObjectPath> devices;
-                devices.push_back(wifi_dev.object->path());
-                reply->writer() << devices;
-                bus->send(reply);
-            });
-
-            nm_root->state->set(NM_STATE_CONNECTED_GLOBAL);
-            wifi_dev.device_type->set(NM_DEVICE_TYPE_WIFI);
-            wifi_dev.state->set(NM_DEVICE_STATE_ACTIVATED);
-
-            wifi_dev.object->install_method_handler<NM::Interface::Device::Wireless::Method::GetAccessPoints>([&](const dbus::Message::Ptr& msg)
-            {
-                auto reply = dbus::Message::make_method_return(msg);
-                reply->writer() << std::vector<dbus::types::ObjectPath>();
-                bus->send(reply);
-            });
-
-            DefaultURfkillMock urfkill(bus);
-            urfkill.wlan.state.changed().connect([&](fdo::URfkill::Interface::Killswitch::State value) {
-                typedef fdo::URfkill::Interface::Killswitch Killswitch;
-                switch (value) {
-                case Killswitch::State::not_available:
-                case Killswitch::State::unblocked:
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_UNAVAILABLE, NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_PREPARE, NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_PREPARE, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_PREPARE, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_PREPARE, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_IP_CONFIG, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_SECONDARIES, NM_DEVICE_STATE_IP_CONFIG, NM_DEVICE_STATE_REASON_NONE));
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_ACTIVATED, NM_DEVICE_STATE_SECONDARIES, NM_DEVICE_STATE_REASON_NONE));
-                    break;
-                case Killswitch::State::soft_blocked:
-                case Killswitch::State::hard_blocked:
-                    wifi_dev.state_changed->emit(std::make_tuple(NM_DEVICE_STATE_UNAVAILABLE, NM_DEVICE_STATE_ACTIVATED, NM_DEVICE_STATE_REASON_NONE));
-                }
-            });
-
-            std::thread t{[bus](){ bus->run(); }};
-
-            services_ready.try_signal_ready_for(std::chrono::milliseconds{5000});
-            EXPECT_EQ(1, client_ready.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-
-            stage1.try_signal_ready_for(std::chrono::milliseconds{5000});
-            sleep(1);
-
-            stage2.try_signal_ready_for(std::chrono::milliseconds{5000});
-            sleep(1);
-
-            sc.wait_for_signal_for(std::chrono::seconds{60});
-
-            bus->stop();
-
-            if (t.joinable())
-                t.join();
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        auto client = [&, this]()
-        {
-            EXPECT_EQ(1, services_ready.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-            std::unique_ptr<connectivity::networking::Manager> mgr;
-            mgr = connectivity::networking::Manager::createInstance();
-
-            auto links = mgr->links();
-            EXPECT_EQ(links->size(), 1);
-
-            EXPECT_EQ((*links->begin())->type(), connectivity::networking::Link::Type::wifi);
-            auto wifilink = std::dynamic_pointer_cast<connectivity::networking::wifi::Link>(*links->begin());
-            EXPECT_TRUE(wifilink.get() != nullptr);
-
-            client_ready.try_signal_ready_for(std::chrono::milliseconds{2000});
-
-            wifilink->disable();
-            sleep(1);
-
-            EXPECT_EQ(1, stage1.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-            EXPECT_EQ(wifilink->status().get(), connectivity::networking::Link::Status::disabled);
-
-            wifilink->enable();
-
-            sleep(1);
-            EXPECT_EQ(1, stage2.wait_for_signal_ready_for(std::chrono::milliseconds{5000}));
-
-            EXPECT_EQ(wifilink->status().get(), connectivity::networking::Link::Status::online);
-
-            return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-        };
-
-        EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(service, client));
-}
-
 
=== removed directory 'tests/integration/indicator'
=== added file 'tests/integration/indicator-network-test-base.cpp'
--- tests/integration/indicator-network-test-base.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration/indicator-network-test-base.cpp	2015-04-23 13:23:11 +0000
@@ -0,0 +1,338 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ */
+
+#include <indicator-network-test-base.h>
+#include <dbus-types.h>
+
+using namespace QtDBusTest;
+using namespace QtDBusMock;
+using namespace std;
+using namespace testing;
+namespace mh = menuharness;
+
+IndicatorNetworkTestBase::IndicatorNetworkTestBase() :
+    dbusMock(dbusTestRunner)
+{
+}
+
+IndicatorNetworkTestBase::~IndicatorNetworkTestBase()
+{
+}
+
+void IndicatorNetworkTestBase::SetUp()
+{
+    if (qEnvironmentVariableIsSet("TEST_WITH_BUSTLE"))
+    {
+        const TestInfo* const test_info =
+                UnitTest::GetInstance()->current_test_info();
+
+        QDir::temp().mkpath("indicator-network-tests");
+        QDir testDir(QDir::temp().filePath("indicator-network-tests"));
+
+        dbusTestRunner.registerService(
+                DBusServicePtr(
+                        new QProcessDBusService(
+                                "", QDBusConnection::SessionBus,
+                                "/usr/bin/bustle-pcap",
+                                QStringList{"-e", testDir.filePath(QString("%1-%2").arg(test_info->name(), "session.log"))})));
+        dbusTestRunner.registerService(
+                DBusServicePtr(
+                        new QProcessDBusService(
+                                "", QDBusConnection::SystemBus,
+                                "/usr/bin/bustle-pcap",
+                                QStringList{"-y", testDir.filePath(QString("%1-%2").arg(test_info->name(), "system.log"))})));
+    }
+
+    dbusMock.registerNetworkManager();
+    dbusMock.registerNotificationDaemon();
+    // By default the ofono mock starts with one modem
+    dbusMock.registerOfono();
+    dbusMock.registerURfkill();
+
+    dbusTestRunner.startServices();
+
+    // Identify the test when looking at Bustle logs
+    QDBusConnection systemConnection = dbusTestRunner.systemConnection();
+    systemConnection.registerService("org.TestIndicatorNetworkService");
+    QDBusConnection sessionConnection = dbusTestRunner.sessionConnection();
+    sessionConnection.registerService("org.TestIndicatorNetworkService");
+}
+
+mh::MenuMatcher::Parameters IndicatorNetworkTestBase::phoneParameters()
+{
+    return mh::MenuMatcher::Parameters(
+            "com.canonical.indicator.network",
+            { { "indicator", "/com/canonical/indicator/network" } },
+            "/com/canonical/indicator/network/phone");
+}
+
+mh::MenuMatcher::Parameters IndicatorNetworkTestBase::unlockSimParameters(std::string const& busName, int exportId)
+{
+    return mh::MenuMatcher::Parameters(
+            busName,
+            { { "notifications", "/com/canonical/indicator/network/unlocksim" + to_string(exportId) } },
+            "/com/canonical/indicator/network/unlocksim" + to_string(exportId));
+}
+
+void IndicatorNetworkTestBase::startIndicator()
+{
+    try
+    {
+        indicator.reset(
+                new QProcessDBusService(DBusTypes::DBUS_NAME,
+                                        QDBusConnection::SessionBus,
+                                        NETWORK_SERVICE_BIN,
+                                        QStringList()));
+        indicator->start(dbusTestRunner.sessionConnection());
+    }
+    catch (exception const& e)
+    {
+        cout << "startIndicator(): " << e.what() << endl;
+        throw;
+    }
+}
+
+QString IndicatorNetworkTestBase::createWiFiDevice(int state, const QString& id)
+{
+    auto& networkManager(dbusMock.networkManagerInterface());
+    auto reply = networkManager.AddWiFiDevice(id, "eth1", state);
+    reply.waitForFinished();
+    return reply;
+}
+
+QString IndicatorNetworkTestBase::randomMac()
+{
+    int high = 254;
+    int low = 1;
+    QString hardwareAddress;
+    bool first = true;
+
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+        if (!first)
+        {
+            hardwareAddress.append(":");
+        }
+        int r = qrand() % ((high + 1) - low) + low;
+        hardwareAddress.append(QString("%1").arg(r, 2, 16, QChar('0')));
+        first = false;
+    }
+
+    return hardwareAddress;
+}
+
+void IndicatorNetworkTestBase::enableWiFi()
+{
+    auto& urfkillInterface = dbusMock.urfkillInterface();
+    urfkillInterface.Block(1, false).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::disableWiFi()
+{
+    auto& urfkillInterface = dbusMock.urfkillInterface();
+    urfkillInterface.Block(1, true).waitForFinished();
+}
+
+QString IndicatorNetworkTestBase::createAccessPoint(const QString& id, const QString& ssid, const QString& device, int strength,
+                          Secure secure, ApMode apMode)
+{
+
+    auto& networkManager(dbusMock.networkManagerInterface());
+    auto reply = networkManager.AddAccessPoint(
+                        device, id, ssid,
+                        randomMac(),
+                        apMode == ApMode::adhoc ? NM_802_11_MODE_ADHOC : NM_802_11_MODE_INFRA,
+                        0, 0, strength,
+                        secure == Secure::secure ? NM_802_11_AP_SEC_KEY_MGMT_PSK : NM_802_11_AP_SEC_NONE);
+    reply.waitForFinished();
+    return reply;
+}
+
+void IndicatorNetworkTestBase::removeAccessPoint(const QString& device, const QString& ap)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    nm.RemoveAccessPoint(device, ap).waitForFinished();
+}
+
+QString IndicatorNetworkTestBase::createAccessPointConnection(const QString& id, const QString& ssid, const QString& device)
+{
+    auto& networkManager(dbusMock.networkManagerInterface());
+    auto reply = networkManager.AddWiFiConnection(device, id, ssid,
+                                                  "");
+    reply.waitForFinished();
+    return reply;
+}
+
+void IndicatorNetworkTestBase::removeWifiConnection(const QString& device, const QString& connection)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    nm.RemoveWifiConnection(device, connection).waitForFinished();
+}
+
+QString IndicatorNetworkTestBase::createActiveConnection(const QString& id, const QString& device, const QString& connection, const QString& ap)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    auto reply = nm.AddActiveConnection(QStringList() << device,
+                           connection,
+                           ap,
+                           id,
+                           NM_ACTIVE_CONNECTION_STATE_ACTIVATED);
+    reply.waitForFinished();
+    return reply;
+}
+
+void IndicatorNetworkTestBase::removeActiveConnection(const QString& device, const QString& active_connection)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    nm.RemoveActiveConnection(device, active_connection).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::setGlobalConnectedState(int state)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    nm.SetGlobalConnectionState(state).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::setNmProperty(const QString& path, const QString& iface, const QString& name, const QVariant& value)
+{
+    auto& nm = dbusMock.networkManagerInterface();
+    nm.SetProperty(path, iface, name, QDBusVariant(value)).waitForFinished();
+}
+
+QString IndicatorNetworkTestBase::createModem(const QString& id)
+{
+    auto& ofono(dbusMock.ofonoInterface());
+    QVariantMap modemProperties {{ "Powered", false } };
+    return ofono.AddModem(id, modemProperties);
+}
+
+void IndicatorNetworkTestBase::setModemProperty(const QString& path, const QString& propertyName, const QVariant& value)
+{
+    auto& ofono(dbusMock.ofonoModemInterface(path));
+    ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::setSimManagerProperty(const QString& path, const QString& propertyName, const QVariant& value)
+{
+    auto& ofono(dbusMock.ofonoSimManagerInterface(path));
+    ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::setConnectionManagerProperty(const QString& path, const QString& propertyName, const QVariant& value)
+{
+    auto& ofono(dbusMock.ofonoConnectionManagerInterface(path));
+    ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
+}
+
+void IndicatorNetworkTestBase::setNetworkRegistrationProperty(const QString& path, const QString& propertyName, const QVariant& value)
+{
+    auto& ofono(dbusMock.ofonoNetworkRegistrationInterface(path));
+    ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
+}
+
+OrgFreedesktopDBusMockInterface& IndicatorNetworkTestBase::notificationsMockInterface()
+{
+    return dbusMock.mockInterface("org.freedesktop.Notifications",
+                                   "/org/freedesktop/Notifications",
+                                   "org.freedesktop.Notifications",
+                                   QDBusConnection::SessionBus);
+}
+
+OrgFreedesktopDBusMockInterface& IndicatorNetworkTestBase::modemMockInterface(const QString& path)
+{
+    return dbusMock.mockInterface("org.ofono",
+                                   path,
+                                   "",
+                                   QDBusConnection::SystemBus);
+}
+
+bool IndicatorNetworkTestBase::qDBusArgumentToMap(QVariant const& variant, QVariantMap& map)
+{
+    if (variant.canConvert<QDBusArgument>())
+    {
+        QDBusArgument value(variant.value<QDBusArgument>());
+        if (value.currentType() == QDBusArgument::MapType)
+        {
+            value >> map;
+            return true;
+        }
+    }
+    return false;
+}
+
+QString IndicatorNetworkTestBase::firstModem()
+{
+    return "/ril_0";
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::flightModeSwitch(bool toggled)
+{
+    return mh::MenuItemMatcher::checkbox()
+        .label("Flight Mode")
+        .action("indicator.airplane.enabled")
+        .toggled(toggled);
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::accessPoint(const string& ssid, Secure secure,
+            ApMode apMode, ConnectionStatus connectionStatus, int strength)
+{
+    return mh::MenuItemMatcher::checkbox()
+        .label(ssid)
+        .widget("unity.widgets.systemsettings.tablet.accesspoint")
+        .toggled(connectionStatus == ConnectionStatus::connected)
+        .pass_through_attribute(
+            "x-canonical-wifi-ap-strength-action",
+            shared_ptr<GVariant>(g_variant_new_byte(strength), &mh::gvariant_deleter))
+        .boolean_attribute("x-canonical-wifi-ap-is-secure", secure == Secure::secure)
+        .boolean_attribute("x-canonical-wifi-ap-is-adhoc", apMode == ApMode::adhoc);
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::wifiEnableSwitch(bool toggled)
+{
+    return mh::MenuItemMatcher::checkbox()
+        .label("Wi-Fi")
+        .action("indicator.wifi.enable") // This action is accessed by system-settings-ui, do not change it
+        .toggled(toggled);
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::wifiSettings()
+{
+    return mh::MenuItemMatcher()
+        .label("Wi-Fi settings…")
+        .action("indicator.wifi.settings");
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::modemInfo(const string& simIdentifier, const string& label, const string& statusIcon, bool locked)
+{
+    return mh::MenuItemMatcher()
+        .widget("com.canonical.indicator.network.modeminfoitem")
+        .pass_through_string_attribute("x-canonical-modem-sim-identifier-label-action", simIdentifier)
+        .pass_through_string_attribute("x-canonical-modem-connectivity-icon-action", "")
+        .pass_through_string_attribute("x-canonical-modem-status-label-action", label)
+        .pass_through_string_attribute("x-canonical-modem-status-icon-action", statusIcon)
+        .pass_through_boolean_attribute("x-canonical-modem-roaming-action", false)
+        .pass_through_boolean_attribute("x-canonical-modem-locked-action", locked);
+}
+
+mh::MenuItemMatcher IndicatorNetworkTestBase::cellularSettings()
+{
+    return mh::MenuItemMatcher()
+        .label("Cellular settings…")
+        .action("indicator.cellular.settings");
+}
+
 
=== added file 'tests/integration/indicator-network-test-base.h'
--- tests/integration/indicator-network-test-base.h	1970-01-01 00:00:00 +0000
+++ tests/integration/indicator-network-test-base.h	2015-04-23 13:23:11 +0000
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ */
+
+#pragma once
+
+#include <libqtdbustest/DBusTestRunner.h>
+#include <libqtdbustest/QProcessDBusService.h>
+#include <libqtdbusmock/DBusMock.h>
+
+#include <menuharness/MatchUtils.h>
+#include <menuharness/MenuMatcher.h>
+
+#include <NetworkManager.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+inline void PrintTo(const QVariant& variant, std::ostream* os) {
+        *os << "QVariant(" << variant.toString().toStdString() << ")";
+}
+
+#define WAIT_FOR_SIGNALS(signalSpy, signalsExpected)\
+{\
+    while (signalSpy.size() < signalsExpected)\
+    {\
+        ASSERT_TRUE(signalSpy.wait());\
+    }\
+    ASSERT_EQ(signalsExpected, signalSpy.size());\
+}
+
+#define CHECK_METHOD_CALL(signalSpy, signalIndex, methodName, ...)\
+{\
+    QVariantList const& call(signalSpy.at(signalIndex));\
+    EXPECT_EQ(methodName, call.at(0));\
+    auto arguments = vector<pair<int, QVariant>>{__VA_ARGS__};\
+    if (!arguments.empty())\
+    {\
+        QVariantList const& args(call.at(1).toList());\
+        ASSERT_LE(arguments.back().first + 1, args.size());\
+        for (auto const& argument : arguments)\
+        {\
+            EXPECT_EQ(argument.second, args.at(argument.first));\
+        }\
+    }\
+}
+
+class IndicatorNetworkTestBase: public testing::Test
+{
+public:
+    enum class Secure
+    {
+        secure,
+        insecure
+    };
+
+    enum class ApMode
+    {
+        infra,
+        adhoc
+    };
+
+    enum class ConnectionStatus
+    {
+        connected,
+        disconnected
+    };
+
+    IndicatorNetworkTestBase();
+
+    ~IndicatorNetworkTestBase();
+
+protected:
+    void SetUp() override;
+
+    static menuharness::MenuMatcher::Parameters phoneParameters();
+
+    static menuharness::MenuMatcher::Parameters unlockSimParameters(std::string const& busName, int exportId);
+
+    void startIndicator();
+
+    QString createWiFiDevice(int state, const QString& id = "0");
+
+    static QString randomMac();
+
+    void enableWiFi();
+
+    void disableWiFi();
+
+    QString createAccessPoint(const QString& id, const QString& ssid, const QString& device, int strength = 100,
+                              Secure secure = Secure::secure, ApMode apMode = ApMode::infra);
+
+    void removeAccessPoint(const QString& device, const QString& ap);
+
+    QString createAccessPointConnection(const QString& id, const QString& ssid, const QString& device);
+
+    void removeWifiConnection(const QString& device, const QString& connection);
+
+    QString createActiveConnection(const QString& id, const QString& device, const QString& connection, const QString& ap);
+
+    void removeActiveConnection(const QString& device, const QString& active_connection);
+
+    void setGlobalConnectedState(int state);
+
+    void setNmProperty(const QString& path, const QString& iface, const QString& name, const QVariant& value);
+
+    QString createModem(const QString& id);
+
+    void setModemProperty(const QString& path, const QString& propertyName, const QVariant& value);
+
+    void setSimManagerProperty(const QString& path, const QString& propertyName, const QVariant& value);
+
+    void setConnectionManagerProperty(const QString& path, const QString& propertyName, const QVariant& value);
+
+    void setNetworkRegistrationProperty(const QString& path, const QString& propertyName, const QVariant& value);
+
+    OrgFreedesktopDBusMockInterface& notificationsMockInterface();
+
+    OrgFreedesktopDBusMockInterface& modemMockInterface(const QString& path);
+
+    static bool qDBusArgumentToMap(QVariant const& variant, QVariantMap& map);
+
+    static QString firstModem();
+
+    static menuharness::MenuItemMatcher flightModeSwitch(bool toggled = false);
+
+    static menuharness::MenuItemMatcher accessPoint(const std::string& ssid, Secure secure,
+                ApMode apMode, ConnectionStatus connectionStatus, int strength = 100);
+
+    static menuharness::MenuItemMatcher wifiEnableSwitch(bool toggled = true);
+
+    static menuharness::MenuItemMatcher wifiSettings();
+
+    static menuharness::MenuItemMatcher modemInfo(const std::string& simIdentifier, const std::string& label, const std::string& statusIcon, bool locked = false);
+
+    static menuharness::MenuItemMatcher cellularSettings();
+
+    QtDBusTest::DBusTestRunner dbusTestRunner;
+
+    QtDBusMock::DBusMock dbusMock;
+
+    QtDBusTest::DBusServicePtr indicator;
+};
 
=== added file 'tests/integration/test-connectivity-api.cpp'
--- tests/integration/test-connectivity-api.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration/test-connectivity-api.cpp	2015-04-23 13:23:11 +0000
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ */
+
+#include <indicator-network-test-base.h>
+#include <connectivityqt/connectivity.h>
+#include <dbus-types.h>
+
+#include <QDebug>
+#include <QTestEventLoop>
+#include <QSignalSpy>
+
+using namespace std;
+using namespace testing;
+using namespace connectivityqt;
+
+namespace
+{
+
+class TestConnectivityApi: public IndicatorNetworkTestBase
+{
+protected:
+    Connectivity::UPtr newConnectivity()
+    {
+        auto connectivity = make_unique<Connectivity>(dbusTestRunner.sessionConnection());
+
+        if (!connectivity->isInitialized())
+        {
+            QSignalSpy initSpy(connectivity.get(), SIGNAL(initialized()));
+            initSpy.wait();
+        }
+
+        return connectivity;
+    }
+};
+
+TEST_F(TestConnectivityApi, FollowsFlightMode)
+{
+    // Set up disconnected with flight mode on
+    setGlobalConnectedState(NM_STATE_DISCONNECTED);
+    ASSERT_TRUE(dbusMock.urfkillInterface().FlightMode(true));
+
+    // Start the indicator
+    ASSERT_NO_THROW(startIndicator());
+
+    // Connect to the service
+    auto connectivity(newConnectivity());
+
+    // Check flight mode is enabled
+    EXPECT_TRUE(connectivity->flightMode());
+
+    // Now disable flight mode
+    ASSERT_TRUE(dbusMock.urfkillInterface().FlightMode(false));
+
+    // Check that flight mode gets updated
+    {
+        QSignalSpy spy(connectivity.get(), SIGNAL(flightModeUpdated(bool)));
+        ASSERT_TRUE(spy.wait());
+        ASSERT_EQ(1, spy.size());
+    }
+    // Check that flight mode is disabled
+    EXPECT_FALSE(connectivity->flightMode());
+}
+
+TEST_F(TestConnectivityApi, FlightModeTalksToURfkill)
+{
+    // Start the indicator
+    ASSERT_NO_THROW(startIndicator());
+
+    // Connect to the UrfKill mock
+    auto& urfkillInterface = dbusMock.urfkillInterface();
+    QSignalSpy urfkillSpy(&urfkillInterface, SIGNAL(FlightModeChanged(bool)));
+
+    // Connect the the service
+    auto connectivity(newConnectivity());
+
+    // Follow the flightMode property
+    QSignalSpy flightModeSpy(connectivity.get(), SIGNAL(flightModeUpdated(bool)));
+
+    // Follow the unstoppableOperationHappening property
+    QSignalSpy operationSpy(connectivity.get(), SIGNAL(unstoppableOperationHappeningUpdated(bool)));
+
+    // Check that nothing is happening yet
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+
+    // Enable flight mode
+    connectivity->setFlightMode(true);
+
+    // We should first get the unstoppable operation change
+    ASSERT_TRUE(operationSpy.wait());
+    ASSERT_EQ(1, operationSpy.size());
+    EXPECT_EQ(operationSpy.first(), QVariantList() << QVariant(true));
+
+    // Wait to be notified that flight mode was enabled
+    if (urfkillSpy.size() != 1)
+    {
+        ASSERT_TRUE(urfkillSpy.wait());
+    }
+    ASSERT_EQ(1, urfkillSpy.size());
+    EXPECT_EQ(urfkillSpy.first(), QVariantList() << QVariant(true));
+
+    // The unstoppable operation should complete
+    if (operationSpy.size() != 2)
+    {
+        ASSERT_TRUE(operationSpy.wait());
+    }
+    ASSERT_EQ(2, operationSpy.size());
+    EXPECT_EQ(operationSpy.last(), QVariantList() << QVariant(false));
+
+    // Wait for flight mode property change
+    if (flightModeSpy.size() != 1)
+    {
+        ASSERT_TRUE(flightModeSpy.wait());
+    }
+    ASSERT_EQ(1, flightModeSpy.size());
+    EXPECT_EQ(flightModeSpy.first(), QVariantList() << QVariant(true));
+
+    // Check that nothing is happening again
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+
+    // The icing on the cake
+    EXPECT_TRUE(connectivity->flightMode());
+
+    // Start again
+    urfkillSpy.clear();
+    operationSpy.clear();
+    flightModeSpy.clear();
+
+    // Disable flight mode
+    connectivity->setFlightMode(false);
+
+    // We should first get the unstoppable operation change
+    ASSERT_TRUE(operationSpy.wait());
+    ASSERT_EQ(1, operationSpy.size());
+    EXPECT_EQ(operationSpy.first(), QVariantList() << QVariant(true));
+
+    // Wait to be notified that flight mode was disabled
+    if (urfkillSpy.size() != 1)
+    {
+        ASSERT_TRUE(urfkillSpy.wait());
+    }
+    ASSERT_EQ(1, urfkillSpy.size());
+    EXPECT_EQ(urfkillSpy.first(), QVariantList() << QVariant(false));
+
+    // The unstoppable operation should complete
+    if (operationSpy.size() != 2)
+    {
+        ASSERT_TRUE(operationSpy.wait());
+    }
+    ASSERT_EQ(2, operationSpy.size());
+    EXPECT_EQ(operationSpy.last(), QVariantList() << QVariant(false));
+
+    // Wait for flight mode property change
+    if (flightModeSpy.size() != 1)
+    {
+        ASSERT_TRUE(flightModeSpy.wait());
+    }
+    ASSERT_EQ(1, flightModeSpy.size());
+    EXPECT_EQ(flightModeSpy.first(), QVariantList() << QVariant(false));
+
+    // Check that nothing is happening again
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+
+    // The icing on the cake
+    EXPECT_FALSE(connectivity->flightMode());
+}
+
+TEST_F(TestConnectivityApi, WifiToggleTalksToUrfkill)
+{
+    // Start the indicator
+    ASSERT_NO_THROW(startIndicator());
+
+    // Connect to the UrfKill mock
+    OrgFreedesktopURfkillKillswitchInterface wifiKillswitchInterface(
+            DBusTypes::URFKILL_BUS_NAME, DBusTypes::URFKILL_WIFI_OBJ_PATH,
+            dbusTestRunner.systemConnection());
+    QSignalSpy urfkillSpy(&wifiKillswitchInterface, SIGNAL(StateChanged()));
+
+    // Connect the the service
+    auto connectivity(newConnectivity());
+
+    // Follow the wifiEnabled property
+    QSignalSpy wifiEnabledSpy(connectivity.get(), SIGNAL(wifiEnabledUpdated(bool)));
+
+    // Follow the unstoppableOperationHappening property
+    QSignalSpy operationSpy(connectivity.get(), SIGNAL(unstoppableOperationHappeningUpdated(bool)));
+
+    // Check that nothing is happening yet
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+    EXPECT_TRUE(connectivity->wifiEnabled());
+    EXPECT_EQ(0, wifiKillswitchInterface.state());
+
+    // Disable WiFi
+    connectivity->setwifiEnabled(false);
+
+    // We should first get the unstoppable operation change
+    ASSERT_TRUE(operationSpy.wait());
+    ASSERT_EQ(1, operationSpy.size());
+    EXPECT_EQ(operationSpy.first(), QVariantList() << QVariant(true));
+
+    // Wait to be notified that wifi was toggled
+    if (urfkillSpy.size() != 1)
+    {
+        ASSERT_TRUE(urfkillSpy.wait());
+    }
+    ASSERT_EQ(1, urfkillSpy.size());
+
+    // The unstoppable operation should complete
+    if (operationSpy.size() != 2)
+    {
+        ASSERT_TRUE(operationSpy.wait());
+    }
+    ASSERT_EQ(2, operationSpy.size());
+    EXPECT_EQ(operationSpy.last(), QVariantList() << QVariant(false));
+
+    // Wait for wifi enabled property change
+    if (wifiEnabledSpy.size() != 1)
+    {
+        ASSERT_TRUE(wifiEnabledSpy.wait());
+    }
+    ASSERT_EQ(1, wifiEnabledSpy.size());
+    EXPECT_EQ(wifiEnabledSpy.first(), QVariantList() << QVariant(false));
+
+    // Check that nothing is happening again
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+
+    // The icing on the cake
+    EXPECT_FALSE(connectivity->wifiEnabled());
+    EXPECT_EQ(1, wifiKillswitchInterface.state());
+
+    // Start again
+    urfkillSpy.clear();
+    operationSpy.clear();
+    wifiEnabledSpy.clear();
+
+    // Disable flight mode
+    connectivity->setwifiEnabled(true);
+
+    // We should first get the unstoppable operation change
+    ASSERT_TRUE(operationSpy.wait());
+    ASSERT_EQ(1, operationSpy.size());
+    EXPECT_EQ(operationSpy.first(), QVariantList() << QVariant(true));
+
+    // Wait to be notified that wifi was toggled
+    if (urfkillSpy.size() != 1)
+    {
+        ASSERT_TRUE(urfkillSpy.wait());
+    }
+    ASSERT_EQ(1, urfkillSpy.size());
+
+    // The unstoppable operation should complete
+    if (operationSpy.size() != 2)
+    {
+        ASSERT_TRUE(operationSpy.wait());
+    }
+    ASSERT_EQ(2, operationSpy.size());
+    EXPECT_EQ(operationSpy.last(), QVariantList() << QVariant(false));
+
+    // Wait for wifi enabled property change
+    if (wifiEnabledSpy.size() != 1)
+    {
+        ASSERT_TRUE(wifiEnabledSpy.wait());
+    }
+    ASSERT_EQ(1, wifiEnabledSpy.size());
+    EXPECT_EQ(wifiEnabledSpy.first(), QVariantList() << QVariant(true));
+
+    // Check that nothing is happening again
+    EXPECT_FALSE(connectivity->unstoppableOperationHappening());
+
+    // The icing on the cake
+    EXPECT_TRUE(connectivity->wifiEnabled());
+    EXPECT_EQ(0, wifiKillswitchInterface.state());
+}
+
+}
 
=== renamed file 'tests/integration/indicator/TestIndicatorNetworkService.cpp' => 'tests/integration/test-indicator.cpp'
--- tests/integration/indicator/TestIndicatorNetworkService.cpp	2015-03-27 08:34:44 +0000
+++ tests/integration/test-indicator.cpp	2015-04-23 13:23:11 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2015 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -16,397 +16,24 @@
  * Author: Pete Woods <[e-mail]>
  */
 
-#include <libqtdbustest/DBusTestRunner.h>
-#include <libqtdbustest/QProcessDBusService.h>
-#include <libqtdbusmock/DBusMock.h>
-
-#include <menuharness/MatchUtils.h>
-#include <menuharness/MenuMatcher.h>
-
-#include <NetworkManager.h>
+#include <indicator-network-test-base.h>
 
 #include <QDebug>
 #include <QTestEventLoop>
 #include <QSignalSpy>
 
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-void PrintTo(const QVariant& variant, std::ostream* os) {
-        *os << "QVariant(" << variant.toString().toStdString() << ")";
-}
-
-
-#define WAIT_FOR_SIGNALS(signalSpy, signalsExpected)\
-{\
-    while (signalSpy.size() < signalsExpected)\
-    {\
-        ASSERT_TRUE(signalSpy.wait());\
-    }\
-    ASSERT_EQ(signalsExpected, signalSpy.size());\
-}
-
-#define CHECK_METHOD_CALL(signalSpy, signalIndex, methodName, ...)\
-{\
-    QVariantList const& call(signalSpy.at(signalIndex));\
-    EXPECT_EQ(methodName, call.at(0));\
-    auto arguments = vector<pair<int, QVariant>>{__VA_ARGS__};\
-    if (!arguments.empty())\
-    {\
-        QVariantList const& args(call.at(1).toList());\
-        ASSERT_LE(arguments.back().first + 1, args.size());\
-        for (auto const& argument : arguments)\
-        {\
-            EXPECT_EQ(argument.second, args.at(argument.first));\
-        }\
-    }\
-}
-
 using namespace std;
 using namespace testing;
-using namespace QtDBusTest;
-using namespace QtDBusMock;
-
 namespace mh = menuharness;
 
 namespace
 {
-enum class Secure
-{
-    secure,
-    insecure
-};
-
-enum class ApMode
-{
-    infra,
-    adhoc
-};
-
-enum class ConnectionStatus
-{
-    connected,
-    disconnected
-};
-
-class TestIndicatorNetworkService : public Test
-{
-protected:
-    TestIndicatorNetworkService() :
-            dbusMock(dbusTestRunner)
-    {
-    }
-
-    void SetUp() override
-    {
-        if (qEnvironmentVariableIsSet("TEST_WITH_BUSTLE"))
-        {
-            const TestInfo* const test_info =
-                    UnitTest::GetInstance()->current_test_info();
-
-            QDir::temp().mkpath("indicator-network-tests");
-            QDir testDir(QDir::temp().filePath("indicator-network-tests"));
-
-            dbusTestRunner.registerService(
-                    DBusServicePtr(
-                            new QProcessDBusService(
-                                    "", QDBusConnection::SessionBus,
-                                    "/usr/bin/bustle-pcap",
-                                    QStringList{"-e", testDir.filePath(QString("%1-%2").arg(test_info->name(), "session.log"))})));
-            dbusTestRunner.registerService(
-                    DBusServicePtr(
-                            new QProcessDBusService(
-                                    "", QDBusConnection::SystemBus,
-                                    "/usr/bin/bustle-pcap",
-                                    QStringList{"-y", testDir.filePath(QString("%1-%2").arg(test_info->name(), "system.log"))})));
-        }
-
-        dbusMock.registerNetworkManager();
-        dbusMock.registerNotificationDaemon();
-        // By default the ofono mock starts with one modem
-        dbusMock.registerOfono();
-        dbusMock.registerURfkill();
-
-        dbusTestRunner.startServices();
-
-        // Identify the test when looking at Bustle logs
-        QDBusConnection systemConnection = dbusTestRunner.systemConnection();
-        systemConnection.registerService("org.TestIndicatorNetworkService");
-        QDBusConnection sessionConnection = dbusTestRunner.sessionConnection();
-        sessionConnection.registerService("org.TestIndicatorNetworkService");
-    }
-
-    static mh::MenuMatcher::Parameters phoneParameters()
-    {
-        return mh::MenuMatcher::Parameters(
-                "com.canonical.indicator.network",
-                { { "indicator", "/com/canonical/indicator/network" } },
-                "/com/canonical/indicator/network/phone");
-    }
-
-    mh::MenuMatcher::Parameters unlockSimParameters(std::string const& busName, int exportId)
-    {
-        return mh::MenuMatcher::Parameters(
-                busName,
-                { { "notifications", "/com/canonical/indicator/network/unlocksim" + to_string(exportId) } },
-                "/com/canonical/indicator/network/unlocksim" + to_string(exportId));
-    }
-
-    void startIndicator()
-    {
-        try
-        {
-            indicator.reset(
-                    new QProcessDBusService("com.canonical.indicator.network",
-                                            QDBusConnection::SessionBus,
-                                            NETWORK_SERVICE_BIN,
-                                            QStringList()));
-            indicator->start(dbusTestRunner.sessionConnection());
-        }
-        catch (exception const& e)
-        {
-            cout << "startIndicator(): " << e.what() << endl;
-            throw;
-        }
-    }
-
-    QString createWiFiDevice(int state, const QString& id = "0")
-    {
-        auto& networkManager(dbusMock.networkManagerInterface());
-        auto reply = networkManager.AddWiFiDevice(id, "eth1", state);
-        reply.waitForFinished();
-        return reply;
-    }
-
-    static QString randomMac()
-    {
-        int high = 254;
-        int low = 1;
-        QString hardwareAddress;
-        bool first = true;
-
-        for (unsigned int i = 0; i < 6; ++i)
-        {
-            if (!first)
-            {
-                hardwareAddress.append(":");
-            }
-            int r = qrand() % ((high + 1) - low) + low;
-            hardwareAddress.append(QString("%1").arg(r, 2, 16, QChar('0')));
-            first = false;
-        }
-
-        return hardwareAddress;
-    }
-
-    void enableWiFi()
-    {
-        auto& urfkillInterface = dbusMock.urfkillInterface();
-        urfkillInterface.Block(1, false).waitForFinished();
-    }
-
-    void disableWiFi()
-    {
-        auto& urfkillInterface = dbusMock.urfkillInterface();
-        urfkillInterface.Block(1, true).waitForFinished();
-    }
-
-    QString createAccessPoint(const QString& id, const QString& ssid, const QString& device, int strength = 100,
-                              Secure secure = Secure::secure, ApMode apMode = ApMode::infra)
-    {
-
-        auto& networkManager(dbusMock.networkManagerInterface());
-        auto reply = networkManager.AddAccessPoint(
-                            device, id, ssid,
-                            randomMac(),
-                            apMode == ApMode::adhoc ? NM_802_11_MODE_ADHOC : NM_802_11_MODE_INFRA,
-                            0, 0, strength,
-                            secure == Secure::secure ? NM_802_11_AP_SEC_KEY_MGMT_PSK : NM_802_11_AP_SEC_NONE);
-        reply.waitForFinished();
-        return reply;
-    }
-
-    void removeAccessPoint(const QString& device, const QString& ap)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        nm.RemoveAccessPoint(device, ap).waitForFinished();
-    }
-
-    QString createAccessPointConnection(const QString& id, const QString& ssid, const QString& device)
-    {
-        auto& networkManager(dbusMock.networkManagerInterface());
-        auto reply = networkManager.AddWiFiConnection(device, id, ssid,
-                                                      "");
-        reply.waitForFinished();
-        return reply;
-    }
-
-    void removeWifiConnection(const QString& device, const QString& connection)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        nm.RemoveWifiConnection(device, connection).waitForFinished();
-    }
-
-    QString createActiveConnection(const QString& id, const QString& device, const QString& connection, const QString& ap)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        auto reply = nm.AddActiveConnection(QStringList() << device,
-                               connection,
-                               ap,
-                               id,
-                               NM_ACTIVE_CONNECTION_STATE_ACTIVATED);
-        reply.waitForFinished();
-        return reply;
-    }
-
-    void removeActiveConnection(const QString& device, const QString& active_connection)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        nm.RemoveActiveConnection(device, active_connection).waitForFinished();
-    }
-
-    void setGlobalConnectedState(int state)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        nm.SetGlobalConnectionState(state).waitForFinished();
-    }
-
-    void setNmProperty(const QString& path, const QString& iface, const QString& name, const QVariant& value)
-    {
-        auto& nm = dbusMock.networkManagerInterface();
-        nm.SetProperty(path, iface, name, QDBusVariant(value)).waitForFinished();
-    }
-
-    QString createModem(const QString& id)
-    {
-        auto& ofono(dbusMock.ofonoInterface());
-        QVariantMap modemProperties {{ "Powered", false } };
-        return ofono.AddModem(id, modemProperties);
-    }
-
-    void setModemProperty(const QString& path, const QString& propertyName, const QVariant& value)
-    {
-        auto& ofono(dbusMock.ofonoModemInterface(path));
-        ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
-    }
-
-    void setSimManagerProperty(const QString& path, const QString& propertyName, const QVariant& value)
-    {
-        auto& ofono(dbusMock.ofonoSimManagerInterface(path));
-        ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
-    }
-
-    void setConnectionManagerProperty(const QString& path, const QString& propertyName, const QVariant& value)
-    {
-        auto& ofono(dbusMock.ofonoConnectionManagerInterface(path));
-        ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
-    }
-
-    void setNetworkRegistrationProperty(const QString& path, const QString& propertyName, const QVariant& value)
-    {
-        auto& ofono(dbusMock.ofonoNetworkRegistrationInterface(path));
-        ofono.SetProperty(propertyName, QDBusVariant(value)).waitForFinished();
-    }
-
-    OrgFreedesktopDBusMockInterface* notificationsMockInterface()
-    {
-        return &dbusMock.mockInterface("org.freedesktop.Notifications",
-                                       "/org/freedesktop/Notifications",
-                                       "org.freedesktop.Notifications",
-                                       QDBusConnection::SessionBus);
-    }
-
-    OrgFreedesktopDBusMockInterface* modemMockInterface(const QString& path)
-    {
-        return &dbusMock.mockInterface("org.ofono",
-                                       path,
-                                       "",
-                                       QDBusConnection::SystemBus);
-    }
-
-    bool qDBusArgumentToMap(QVariant const& variant, QVariantMap& map)
-    {
-        if (variant.canConvert<QDBusArgument>())
-        {
-            QDBusArgument value(variant.value<QDBusArgument>());
-            if (value.currentType() == QDBusArgument::MapType)
-            {
-                value >> map;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    QString firstModem()
-    {
-        return "/ril_0";
-    }
-
-    static mh::MenuItemMatcher flightModeSwitch(bool toggled = false)
-    {
-        return mh::MenuItemMatcher::checkbox()
-            .label("Flight Mode")
-            .action("indicator.airplane.enabled")
-            .toggled(toggled);
-    }
-
-    static mh::MenuItemMatcher accessPoint(const string& ssid, Secure secure,
-                ApMode apMode, ConnectionStatus connectionStatus, int strength = 100)
-    {
-        return mh::MenuItemMatcher::checkbox()
-            .label(ssid)
-            .widget("unity.widgets.systemsettings.tablet.accesspoint")
-            .toggled(connectionStatus == ConnectionStatus::connected)
-            .pass_through_attribute(
-                "x-canonical-wifi-ap-strength-action",
-                shared_ptr<GVariant>(g_variant_new_byte(strength), &mh::gvariant_deleter))
-            .boolean_attribute("x-canonical-wifi-ap-is-secure", secure == Secure::secure)
-            .boolean_attribute("x-canonical-wifi-ap-is-adhoc", apMode == ApMode::adhoc);
-    }
-
-    static mh::MenuItemMatcher wifiEnableSwitch(bool toggled = true)
-    {
-        return mh::MenuItemMatcher::checkbox()
-            .label("Wi-Fi")
-            .action("indicator.wifi.enable") // This action is accessed by system-settings-ui, do not change it
-            .toggled(toggled);
-    }
-
-    static mh::MenuItemMatcher wifiSettings()
-    {
-        return mh::MenuItemMatcher()
-            .label("Wi-Fi settings…")
-            .action("indicator.wifi.settings");
-    }
-
-    static mh::MenuItemMatcher modemInfo(const string& simIdentifier, const string& label, const string& statusIcon, bool locked = false)
-    {
-        return mh::MenuItemMatcher()
-            .widget("com.canonical.indicator.network.modeminfoitem")
-            .pass_through_string_attribute("x-canonical-modem-sim-identifier-label-action", simIdentifier)
-            .pass_through_string_attribute("x-canonical-modem-connectivity-icon-action", "")
-            .pass_through_string_attribute("x-canonical-modem-status-label-action", label)
-            .pass_through_string_attribute("x-canonical-modem-status-icon-action", statusIcon)
-            .pass_through_boolean_attribute("x-canonical-modem-roaming-action", false)
-            .pass_through_boolean_attribute("x-canonical-modem-locked-action", locked);
-    }
-
-    static mh::MenuItemMatcher cellularSettings()
-    {
-        return mh::MenuItemMatcher()
-            .label("Cellular settings…")
-            .action("indicator.cellular.settings");
-    }
-
-    DBusTestRunner dbusTestRunner;
-
-    DBusMock dbusMock;
-
-    DBusServicePtr indicator;
-};
-
-TEST_F(TestIndicatorNetworkService, BasicMenuContents)
+
+class TestIndicator: public IndicatorNetworkTestBase
+{
+};
+
+TEST_F(TestIndicator, BasicMenuContents)
 {
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
     ASSERT_NO_THROW(startIndicator());
@@ -428,7 +55,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, OneDisconnectedAccessPointAtStartup)
+TEST_F(TestIndicator, OneDisconnectedAccessPointAtStartup)
 {
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
     auto device = createWiFiDevice(NM_DEVICE_STATE_DISCONNECTED);
@@ -456,7 +83,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, OneConnectedAccessPointAtStartup)
+TEST_F(TestIndicator, OneConnectedAccessPointAtStartup)
 {
     setGlobalConnectedState(NM_STATE_CONNECTED_GLOBAL);
     auto device = createWiFiDevice(NM_DEVICE_STATE_ACTIVATED);
@@ -485,7 +112,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, AddOneDisconnectedAccessPointAfterStartup)
+TEST_F(TestIndicator, AddOneDisconnectedAccessPointAfterStartup)
 {
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
     auto device = createWiFiDevice(NM_DEVICE_STATE_DISCONNECTED);
@@ -512,7 +139,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, AddOneConnectedAccessPointAfterStartup)
+TEST_F(TestIndicator, AddOneConnectedAccessPointAfterStartup)
 {
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
     auto device = createWiFiDevice(NM_DEVICE_STATE_DISCONNECTED);
@@ -542,7 +169,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SecondModem)
+TEST_F(TestIndicator, SecondModem)
 {
     createModem("ril_1"); // ril_0 already exists
     ASSERT_NO_THROW(startIndicator());
@@ -562,7 +189,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, FlightModeTalksToURfkill)
+TEST_F(TestIndicator, FlightModeTalksToURfkill)
 {
     ASSERT_NO_THROW(startIndicator());
 
@@ -583,7 +210,7 @@
     EXPECT_EQ(urfkillSpy.first(), QVariantList() << QVariant(true));
 }
 
-TEST_F(TestIndicatorNetworkService, IndicatorListensToURfkill)
+TEST_F(TestIndicator, IndicatorListensToURfkill)
 {
     setGlobalConnectedState(NM_STATE_CONNECTED_GLOBAL);
     auto device = createWiFiDevice(NM_DEVICE_STATE_ACTIVATED);
@@ -621,7 +248,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_NoSIM)
+TEST_F(TestIndicator, SimStates_NoSIM)
 {
     // set flight mode off, wifi off, and cell data off
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -646,7 +273,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_NoSIM2)
+TEST_F(TestIndicator, SimStates_NoSIM2)
 {
     // set flight mode off, wifi off, and cell data off
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -673,7 +300,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_LockedSIM)
+TEST_F(TestIndicator, SimStates_LockedSIM)
 {
     // set flight mode off, wifi off, and cell data off, and sim in
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -717,7 +344,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_LockedSIM2)
+TEST_F(TestIndicator, SimStates_LockedSIM2)
 {
     // set flight mode off, wifi off, and cell data off, and sim in
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -762,7 +389,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_UnlockedSIM)
+TEST_F(TestIndicator, SimStates_UnlockedSIM)
 {
     // set flight mode off, wifi off, cell data off, sim in, and sim unlocked
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -886,7 +513,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, SimStates_UnlockedSIM2)
+TEST_F(TestIndicator, SimStates_UnlockedSIM2)
 {
     // set flight mode off, wifi off, cell data off, sim in, and sim unlocked
     setGlobalConnectedState(NM_STATE_DISCONNECTED);
@@ -1018,7 +645,7 @@
         ).match());
 }
 
-TEST_F(TestIndicatorNetworkService, FlightMode_NoSIM)
+TEST_F(TestIndicator, FlightMode_NoSIM)
 {