test version for gmenuharness

35 files changed, 3307 insertions, 110 deletions

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
new file mode 100644
index 0000000..9d74e15
--- /dev/null
+++ b/include/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(unity)
diff --git a/include/unity/CMakeLists.txt b/include/unity/CMakeLists.txt
new file mode 100644
index 0000000..ef57b9e
--- /dev/null
+++ b/include/unity/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(gmenuharness)
diff --git a/include/unity/gmenuharness/MatchResult.h b/include/unity/gmenuharness/MatchResult.h
new file mode 100644
index 0000000..8503a98
--- /dev/null
+++ b/include/unity/gmenuharness/MatchResult.h
@@ -0,0 +1,66 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <string>
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+class MatchResult
+{
+public:
+    MatchResult();
+
+    MatchResult(MatchResult&& other);
+
+    MatchResult(const MatchResult& other);
+
+    MatchResult& operator=(const MatchResult& other);
+
+    MatchResult& operator=(MatchResult&& other);
+
+    ~MatchResult() = default;
+
+    MatchResult createChild() const;
+
+    void failure(const std::vector<unsigned int>& location, const std::string& message);
+
+    void merge(const MatchResult& other);
+
+    bool success() const;
+
+    bool hasTimedOut() const;
+
+    std::string concat_failures() const;
+
+protected:
+    struct Priv;
+
+    std::shared_ptr<Priv> p;
+};
+
+}   // namespace gmenuharness
+
+}   // namespace unity
diff --git a/include/unity/gmenuharness/MatchUtils.h b/include/unity/gmenuharness/MatchUtils.h
new file mode 100644
index 0000000..899e506
--- /dev/null
+++ b/include/unity/gmenuharness/MatchUtils.h
@@ -0,0 +1,42 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <gio/gio.h>
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+void waitForCore(GObject* obj, const std::string& signalName, unsigned int timeout = 10);
+
+void menuWaitForItems(const std::shared_ptr<GMenuModel>& menu, unsigned int timeout = 10);
+
+void g_object_deleter(gpointer object);
+
+void gvariant_deleter(GVariant* varptr);
+
+}  //namespace gmenuharness
+
+}  // namespace unity
diff --git a/include/unity/gmenuharness/MenuItemMatcher.h b/include/unity/gmenuharness/MenuItemMatcher.h
new file mode 100644
index 0000000..dc1d6f3
--- /dev/null
+++ b/include/unity/gmenuharness/MenuItemMatcher.h
@@ -0,0 +1,133 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include <gio/gio.h>
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+class MatchResult;
+
+class MenuItemMatcher
+{
+public:
+    enum class Mode
+    {
+        all,
+        starts_with,
+        ends_with
+    };
+
+    enum class Type
+    {
+        plain,
+        checkbox,
+        radio
+    };
+
+    static MenuItemMatcher checkbox();
+
+    static MenuItemMatcher radio();
+
+    MenuItemMatcher();
+
+    ~MenuItemMatcher();
+
+    MenuItemMatcher(const MenuItemMatcher& other);
+
+    MenuItemMatcher(MenuItemMatcher&& other);
+
+    MenuItemMatcher& operator=(const MenuItemMatcher& other);
+
+    MenuItemMatcher& operator=(MenuItemMatcher&& other);
+
+    MenuItemMatcher& type(Type type);
+
+    MenuItemMatcher& label(const std::string& label);
+
+    MenuItemMatcher& action(const std::string& action);
+
+    MenuItemMatcher& state_icons(const std::vector<std::string>& state);
+
+    MenuItemMatcher& icon(const std::string& icon);
+
+    MenuItemMatcher& widget(const std::string& widget);
+
+    MenuItemMatcher& pass_through_attribute(const std::string& actionName, const std::shared_ptr<GVariant>& value);
+
+    MenuItemMatcher& pass_through_boolean_attribute(const std::string& actionName, bool value);
+
+    MenuItemMatcher& pass_through_string_attribute(const std::string& actionName, const std::string& value);
+
+    MenuItemMatcher& pass_through_double_attribute(const std::string& actionName, double value);
+
+    MenuItemMatcher& round_doubles(double maxDifference);
+
+    MenuItemMatcher& attribute(const std::string& name, const std::shared_ptr<GVariant>& value);
+
+    MenuItemMatcher& boolean_attribute(const std::string& name, bool value);
+
+    MenuItemMatcher& string_attribute(const std::string& name, const std::string& value);
+
+    MenuItemMatcher& toggled(bool toggled);
+
+    MenuItemMatcher& mode(Mode mode);
+
+    MenuItemMatcher& submenu();
+
+    MenuItemMatcher& section();
+
+    MenuItemMatcher& is_empty();
+
+    MenuItemMatcher& has_exactly(std::size_t children);
+
+    MenuItemMatcher& item(const MenuItemMatcher& item);
+
+    MenuItemMatcher& item(MenuItemMatcher&& item);
+
+    MenuItemMatcher& pass_through_activate(const std::string& action, const std::shared_ptr<GVariant>& parameter = nullptr);
+
+    MenuItemMatcher& activate(const std::shared_ptr<GVariant>& parameter = nullptr);
+
+    MenuItemMatcher& set_pass_through_action_state(const std::string& action, const std::shared_ptr<GVariant>& state);
+
+    MenuItemMatcher& set_action_state(const std::shared_ptr<GVariant>& state);
+
+    void match(MatchResult& matchResult, const std::vector<unsigned int>& location,
+          const std::shared_ptr<GMenuModel>& menu,
+          std::map<std::string, std::shared_ptr<GActionGroup>>& actions,
+          int index) const;
+
+protected:
+    struct Priv;
+
+    std::shared_ptr<Priv> p;
+};
+
+}   // namespace gmenuharness
+
+}   // namespace unity
diff --git a/include/unity/gmenuharness/MenuMatcher.h b/include/unity/gmenuharness/MenuMatcher.h
new file mode 100644
index 0000000..c2eb65e
--- /dev/null
+++ b/include/unity/gmenuharness/MenuMatcher.h
@@ -0,0 +1,95 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#pragma once
+
+#define EXPECT_MATCHRESULT(statement) \
+do {\
+    auto result = (statement);\
+    GTEST_TEST_BOOLEAN_(result.success(), #statement, false, true, \
+                      GTEST_NONFATAL_FAILURE_) << result.concat_failures().c_str(); \
+} while (0)
+
+#include <unity/gmenuharness/MatchResult.h>
+#include <unity/gmenuharness/MenuItemMatcher.h>
+
+#include <memory>
+#include <vector>
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+class MenuMatcher
+{
+public:
+    class Parameters
+    {
+    public:
+        Parameters(
+                const std::string& busName,
+                const std::vector<std::pair<std::string, std::string>>& actions,
+                const std::string& menuObjectPath);
+
+        ~Parameters();
+
+        Parameters(const Parameters& other);
+
+        Parameters(Parameters&& other);
+
+        Parameters& operator=(const Parameters& other);
+
+        Parameters& operator=(Parameters&& other);
+
+    protected:
+        friend MenuMatcher;
+
+        struct Priv;
+
+        std::shared_ptr<Priv> p;
+    };
+
+    MenuMatcher(const Parameters& parameters);
+
+    ~MenuMatcher();
+
+    MenuMatcher(const MenuMatcher& other) = delete;
+
+    MenuMatcher(MenuMatcher&& other) = delete;
+
+    MenuMatcher& operator=(const MenuMatcher& other) = delete;
+
+    MenuMatcher& operator=(MenuMatcher&& other) = delete;
+
+    MenuMatcher& item(const MenuItemMatcher& item);
+
+    MatchResult match() const;
+
+    void match(MatchResult& matchResult) const;
+
+protected:
+    struct Priv;
+
+    std::shared_ptr<Priv> p;
+};
+
+}   // gmenuharness
+
+}   // unity
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 194dfc9..4a25deb 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -8,12 +8,12 @@ set(SYMBOLS_PATH "${CMAKE_CURRENT_BINARY_DIR}/indicator-sound-service.def")
 set(VAPI_PATH "${CMAKE_CURRENT_BINARY_DIR}/indicator-sound-service.vapi")
 
 vapi_gen(accounts-service
-	LIBRARY
-		accounts-service
-	PACKAGES
-		gio-2.0
-	INPUT
-		/usr/share/gir-1.0/AccountsService-1.0.gir
+    LIBRARY
+        accounts-service
+    PACKAGES
+        gio-2.0
+    INPUT
+        /usr/share/gir-1.0/AccountsService-1.0.gir
 )
 
 vala_init(indicator-sound-service
@@ -70,7 +70,7 @@ vala_add(indicator-sound-service
   media-player-user.vala
   DEPENDS
     media-player
-	accounts-service-sound-settings
+    accounts-service-sound-settings
     greeter-broadcast
 )
 vala_add(indicator-sound-service
@@ -164,8 +164,8 @@ add_definitions(
 )
 
 add_library(
-	indicator-sound-service-lib STATIC
-	${INDICATOR_SOUND_SOURCES}
+    indicator-sound-service-lib STATIC
+    ${INDICATOR_SOUND_SOURCES}
 )
 
 target_link_libraries(
@@ -206,3 +206,4 @@ install(
   RUNTIME DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/indicator-sound/
 )
 
+add_subdirectory(gmenuharness)
diff --git a/src/gmenuharness/CMakeLists.txt b/src/gmenuharness/CMakeLists.txt
new file mode 100644
index 0000000..c9e613a
--- /dev/null
+++ b/src/gmenuharness/CMakeLists.txt
@@ -0,0 +1,17 @@
+pkg_check_modules(UNITY_API libunity-api>=0.1.3 REQUIRED)
+include_directories(${UNITY_API_INCLUDE_DIRS})
+
+include_directories("${CMAKE_SOURCE_DIR}/include")
+
+add_library(
+    gmenuharness-shared SHARED
+    MatchResult.cpp
+    MatchUtils.cpp
+    MenuItemMatcher.cpp
+    MenuMatcher.cpp
+)
+
+target_link_libraries(
+    gmenuharness-shared
+    ${GLIB_LDFLAGS}
+)
diff --git a/src/gmenuharness/MatchResult.cpp b/src/gmenuharness/MatchResult.cpp
new file mode 100644
index 0000000..40629aa
--- /dev/null
+++ b/src/gmenuharness/MatchResult.cpp
@@ -0,0 +1,187 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#include <unity/gmenuharness/MatchResult.h>
+
+#include <chrono>
+#include <map>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+namespace
+{
+
+
+static void printLocation(ostream& ss, const vector<unsigned int>& location, bool first)
+{
+    for (int i : location)
+    {
+        ss << " ";
+        if (first)
+        {
+            ss << i;
+        }
+        else
+        {
+            ss << " ";
+        }
+    }
+    ss << " ";
+}
+
+struct compare_vector
+{
+    bool operator()(const vector<unsigned int>& a,
+               const vector<unsigned int>& b) const
+    {
+        auto p1 = a.begin();
+        auto p2 = b.begin();
+
+        while (p1 != a.end())
+        {
+            if (p2 == b.end())
+            {
+                return false;
+            }
+            if (*p2 > *p1)
+            {
+                return true;
+            }
+            if (*p1 > *p2)
+            {
+                return false;
+            }
+
+            ++p1;
+            ++p2;
+        }
+
+        if (p2 != b.end())
+        {
+            return true;
+        }
+
+        return false;
+    }
+};
+}
+
+struct MatchResult::Priv
+{
+    bool m_success = true;
+
+    map<vector<unsigned int>, vector<string>, compare_vector> m_failures;
+
+    chrono::time_point<chrono::system_clock> m_timeout = chrono::system_clock::now() + chrono::seconds(10);
+};
+
+MatchResult::MatchResult() :
+        p(new Priv)
+{
+}
+
+MatchResult::MatchResult(MatchResult&& other)
+{
+    *this = move(other);
+}
+
+MatchResult::MatchResult(const MatchResult& other) :
+        p(new Priv)
+{
+    *this = other;
+}
+
+MatchResult& MatchResult::operator=(const MatchResult& other)
+{
+    p->m_success = other.p->m_success;
+    p->m_failures= other.p->m_failures;
+    return *this;
+}
+
+MatchResult& MatchResult::operator=(MatchResult&& other)
+{
+    p = move(other.p);
+    return *this;
+}
+
+MatchResult MatchResult::createChild() const
+{
+    MatchResult child;
+    child.p->m_timeout = p->m_timeout;
+    return child;
+}
+
+void MatchResult::failure(const vector<unsigned int>& location, const string& message)
+{
+    p->m_success = false;
+    auto it = p->m_failures.find(location);
+    if (it == p->m_failures.end())
+    {
+        it = p->m_failures.insert(make_pair(location, vector<string>())).first;
+    }
+    it->second.emplace_back(message);
+}
+
+void MatchResult::merge(const MatchResult& other)
+{
+    p->m_success &= other.p->m_success;
+    for (const auto& e : other.p->m_failures)
+    {
+        p->m_failures.insert(make_pair(e.first, e.second));
+    }
+}
+
+bool MatchResult::success() const
+{
+    return p->m_success;
+}
+
+bool MatchResult::hasTimedOut() const
+{
+    auto now = chrono::system_clock::now();
+    return (now >= p->m_timeout);
+}
+
+string MatchResult::concat_failures() const
+{
+    stringstream ss;
+    ss << "Failed expectations:" << endl;
+    for (const auto& failure : p->m_failures)
+    {
+        bool first = true;
+        for (const string& s: failure.second)
+        {
+            printLocation(ss, failure.first, first);
+            first = false;
+            ss << s << endl;
+        }
+    }
+    return ss.str();
+}
+
+}   // namespace gmenuharness
+
+}   // namespace unity
diff --git a/src/gmenuharness/MatchUtils.cpp b/src/gmenuharness/MatchUtils.cpp
new file mode 100644
index 0000000..7b87a25
--- /dev/null
+++ b/src/gmenuharness/MatchUtils.cpp
@@ -0,0 +1,77 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#include <unity/gmenuharness/MatchUtils.h>
+
+#include <unity/util/ResourcePtr.h>
+
+using namespace std;
+namespace util = unity::util;
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+void waitForCore (GObject * obj, const string& signalName, unsigned int timeout) {
+    shared_ptr<GMainLoop> loop(g_main_loop_new(nullptr, false), &g_main_loop_unref);
+
+    /* Our two exit criteria */
+    util::ResourcePtr<gulong, function<void(gulong)>> signal(
+            g_signal_connect_swapped(obj, signalName.c_str(),
+                                     G_CALLBACK(g_main_loop_quit), loop.get()),
+            [obj](gulong s)
+            {
+                g_signal_handler_disconnect(obj, s);
+            });
+
+    util::ResourcePtr<guint, function<void(guint)>> timer(g_timeout_add(timeout,
+            [](gpointer user_data) -> gboolean
+            {
+                g_main_loop_quit((GMainLoop *)user_data);
+                return G_SOURCE_CONTINUE;
+            },
+            loop.get()),
+            &g_source_remove);
+
+    /* Wait for sync */
+    g_main_loop_run(loop.get());
+}
+
+void menuWaitForItems(const shared_ptr<GMenuModel>& menu, unsigned int timeout)
+{
+    waitForCore(G_OBJECT(menu.get()), "items-changed", timeout);
+}
+
+void g_object_deleter(gpointer object)
+{
+    g_clear_object(&object);
+}
+
+void gvariant_deleter(GVariant* varptr)
+{
+    if (varptr != nullptr)
+    {
+        g_variant_unref(varptr);
+    }
+}
+
+}   // namespace gmenuharness
+
+}   // namespace unity
diff --git a/src/gmenuharness/MenuItemMatcher.cpp b/src/gmenuharness/MenuItemMatcher.cpp
new file mode 100644
index 0000000..2280ef5
--- /dev/null
+++ b/src/gmenuharness/MenuItemMatcher.cpp
@@ -0,0 +1,902 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#include <unity/gmenuharness/MatchResult.h>
+#include <unity/gmenuharness/MatchUtils.h>
+#include <unity/gmenuharness/MenuItemMatcher.h>
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+namespace
+{
+
+enum class LinkType
+{
+    any,
+    section,
+    submenu
+};
+
+static string bool_to_string(bool value)
+{
+    return value? "true" : "false";
+}
+
+static shared_ptr<GVariant> get_action_group_attribute(const shared_ptr<GActionGroup>& actionGroup, const gchar* attribute)
+{
+    shared_ptr<GVariant> value(
+            g_action_group_get_action_state(actionGroup.get(), attribute),
+            &gvariant_deleter);
+    return value;
+}
+
+static shared_ptr<GVariant> get_attribute(const shared_ptr<GMenuItem> menuItem, const gchar* attribute)
+{
+    shared_ptr<GVariant> value(
+            g_menu_item_get_attribute_value(menuItem.get(), attribute, nullptr),
+            &gvariant_deleter);
+    return value;
+}
+
+static string get_string_attribute(const shared_ptr<GMenuItem> menuItem, const gchar* attribute)
+{
+    string result;
+    char* temp = nullptr;
+    if (g_menu_item_get_attribute(menuItem.get(), attribute, "s", &temp))
+    {
+        result = temp;
+        g_free(temp);
+    }
+    return result;
+}
+
+static pair<string, string> split_action(const string& action)
+{
+    auto index = action.find('.');
+
+    if (index == string::npos)
+    {
+        return make_pair(string(), action);
+    }
+
+    return make_pair(action.substr(0, index), action.substr(index + 1, action.size()));
+}
+
+static string type_to_string(MenuItemMatcher::Type type)
+{
+    switch(type)
+    {
+        case MenuItemMatcher::Type::plain:
+            return "plain";
+        case MenuItemMatcher::Type::checkbox:
+            return "checkbox";
+        case MenuItemMatcher::Type::radio:
+            return "radio";
+    }
+
+    return string();
+}
+}
+
+struct MenuItemMatcher::Priv
+{
+    void all(MatchResult& matchResult, const vector<unsigned int>& location,
+        const shared_ptr<GMenuModel>& menu,
+        map<string, shared_ptr<GActionGroup>>& actions)
+    {
+        int count = g_menu_model_get_n_items(menu.get());
+
+        if (m_items.size() != (unsigned int) count)
+        {
+            matchResult.failure(
+                    location,
+                    "Expected " + to_string(m_items.size())
+                            + " children, but found " + to_string(count));
+            return;
+        }
+
+        for (size_t i = 0; i < m_items.size(); ++i)
+        {
+            const auto& matcher = m_items.at(i);
+            matcher.match(matchResult, location, menu, actions, i);
+        }
+    }
+
+    void startsWith(MatchResult& matchResult, const vector<unsigned int>& location,
+               const shared_ptr<GMenuModel>& menu,
+               map<string, shared_ptr<GActionGroup>>& actions)
+    {
+        int count = g_menu_model_get_n_items(menu.get());
+        if (m_items.size() > (unsigned int) count)
+        {
+            matchResult.failure(
+                    location,
+                    "Expected at least " + to_string(m_items.size())
+                            + " children, but found " + to_string(count));
+            return;
+        }
+
+        for (size_t i = 0; i < m_items.size(); ++i)
+        {
+            const auto& matcher = m_items.at(i);
+            matcher.match(matchResult, location, menu, actions, i);
+        }
+    }
+
+    void endsWith(MatchResult& matchResult, const vector<unsigned int>& location,
+               const shared_ptr<GMenuModel>& menu,
+               map<string, shared_ptr<GActionGroup>>& actions)
+    {
+        int count = g_menu_model_get_n_items(menu.get());
+        if (m_items.size() > (unsigned int) count)
+        {
+            matchResult.failure(
+                    location,
+                    "Expected at least " + to_string(m_items.size())
+                            + " children, but found " + to_string(count));
+            return;
+        }
+
+        // match the last N items
+        size_t j;
+        for (size_t i = count - m_items.size(), j = 0; i < count && j < m_items.size(); ++i, ++j)
+        {
+            const auto& matcher = m_items.at(j);
+            matcher.match(matchResult, location, menu, actions, i);
+        }
+    }
+
+    Type m_type = Type::plain;
+
+    Mode m_mode = Mode::all;
+
+    LinkType m_linkType = LinkType::any;
+
+    shared_ptr<size_t> m_expectedSize;
+
+    shared_ptr<string> m_label;
+
+    shared_ptr<string> m_icon;
+
+    shared_ptr<string> m_action;
+
+    vector<std::string> m_state_icons;
+
+    vector<pair<string, shared_ptr<GVariant>>> m_attributes;
+
+    vector<pair<string, shared_ptr<GVariant>>> m_pass_through_attributes;
+
+    shared_ptr<bool> m_isToggled;
+
+    vector<MenuItemMatcher> m_items;
+
+    vector<pair<string, shared_ptr<GVariant>>> m_activations;
+
+    vector<pair<string, shared_ptr<GVariant>>> m_setActionStates;
+
+    double m_maxDifference = 0.0;
+};
+
+MenuItemMatcher MenuItemMatcher::checkbox()
+{
+    MenuItemMatcher matcher;
+    matcher.type(Type::checkbox);
+    return matcher;
+}
+
+MenuItemMatcher MenuItemMatcher::radio()
+{
+    MenuItemMatcher matcher;
+    matcher.type(Type::radio);
+    return matcher;
+}
+
+MenuItemMatcher::MenuItemMatcher() :
+        p(new Priv)
+{
+}
+
+MenuItemMatcher::~MenuItemMatcher()
+{
+}
+
+MenuItemMatcher::MenuItemMatcher(const MenuItemMatcher& other) :
+        p(new Priv)
+{
+    *this = other;
+}
+
+MenuItemMatcher::MenuItemMatcher(MenuItemMatcher&& other)
+{
+    *this = move(other);
+}
+
+MenuItemMatcher& MenuItemMatcher::operator=(const MenuItemMatcher& other)
+{
+    p->m_type = other.p->m_type;
+    p->m_mode = other.p->m_mode;
+    p->m_expectedSize = other.p->m_expectedSize;
+    p->m_label = other.p->m_label;
+    p->m_icon = other.p->m_icon;
+    p->m_action = other.p->m_action;
+    p->m_state_icons = other.p->m_state_icons;
+    p->m_attributes = other.p->m_attributes;
+    p->m_pass_through_attributes = other.p->m_pass_through_attributes;
+    p->m_isToggled = other.p->m_isToggled;
+    p->m_linkType = other.p->m_linkType;
+    p->m_items = other.p->m_items;
+    p->m_activations = other.p->m_activations;
+    p->m_setActionStates = other.p->m_setActionStates;
+    p->m_maxDifference = other.p->m_maxDifference;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::operator=(MenuItemMatcher&& other)
+{
+    p = move(other.p);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::type(Type type)
+{
+    p->m_type = type;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::label(const string& label)
+{
+    p->m_label = make_shared<string>(label);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::action(const string& action)
+{
+    p->m_action = make_shared<string>(action);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::state_icons(const std::vector<std::string>& state_icons)
+{
+    p->m_state_icons = state_icons;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::icon(const string& icon)
+{
+    p->m_icon = make_shared<string>(icon);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::widget(const string& widget)
+{
+    return string_attribute("x-canonical-type", widget);
+}
+
+MenuItemMatcher& MenuItemMatcher::pass_through_attribute(const string& actionName, const shared_ptr<GVariant>& value)
+{
+    p->m_pass_through_attributes.emplace_back(actionName, value);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::pass_through_boolean_attribute(const string& actionName, bool value)
+{
+    return pass_through_attribute(
+            actionName,
+            shared_ptr<GVariant>(g_variant_new_boolean(value),
+                                 &gvariant_deleter));
+}
+
+MenuItemMatcher& MenuItemMatcher::pass_through_string_attribute(const string& actionName, const string& value)
+{
+    return pass_through_attribute(
+            actionName,
+            shared_ptr<GVariant>(g_variant_new_string(value.c_str()),
+                                 &gvariant_deleter));
+}
+
+MenuItemMatcher& MenuItemMatcher::pass_through_double_attribute(const std::string& actionName, double value)
+{
+    return pass_through_attribute(
+                actionName,
+                shared_ptr<GVariant>(g_variant_new_double(value),
+                                     &gvariant_deleter));
+}
+
+MenuItemMatcher& MenuItemMatcher::round_doubles(double maxDifference)
+{
+    p->m_maxDifference = maxDifference;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::attribute(const string& name, const shared_ptr<GVariant>& value)
+{
+    p->m_attributes.emplace_back(name, value);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::boolean_attribute(const string& name, bool value)
+{
+    return attribute(
+            name,
+            shared_ptr<GVariant>(g_variant_new_boolean(value),
+                                 &gvariant_deleter));
+}
+
+MenuItemMatcher& MenuItemMatcher::string_attribute(const string& name, const string& value)
+{
+    return attribute(
+            name,
+            shared_ptr<GVariant>(g_variant_new_string(value.c_str()),
+                                 &gvariant_deleter));
+}
+
+MenuItemMatcher& MenuItemMatcher::toggled(bool isToggled)
+{
+    p->m_isToggled = make_shared<bool>(isToggled);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::mode(Mode mode)
+{
+    p->m_mode = mode;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::submenu()
+{
+    p->m_linkType = LinkType::submenu;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::section()
+{
+    p->m_linkType = LinkType::section;
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::is_empty()
+{
+    return has_exactly(0);
+}
+
+MenuItemMatcher& MenuItemMatcher::has_exactly(size_t children)
+{
+    p->m_expectedSize = make_shared<size_t>(children);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::item(const MenuItemMatcher& item)
+{
+    p->m_items.emplace_back(item);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::item(MenuItemMatcher&& item)
+{
+    p->m_items.emplace_back(item);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::pass_through_activate(std::string const& action, const shared_ptr<GVariant>& parameter)
+{
+    p->m_activations.emplace_back(action, parameter);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::activate(const shared_ptr<GVariant>& parameter)
+{
+    p->m_activations.emplace_back(string(), parameter);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::set_pass_through_action_state(const std::string& action, const std::shared_ptr<GVariant>& state)
+{
+    p->m_setActionStates.emplace_back(action, state);
+    return *this;
+}
+
+MenuItemMatcher& MenuItemMatcher::set_action_state(const std::shared_ptr<GVariant>& state)
+{
+    p->m_setActionStates.emplace_back("", state);
+    return *this;
+}
+
+void MenuItemMatcher::match(
+        MatchResult& matchResult,
+       const vector<unsigned int>& parentLocation,
+       const shared_ptr<GMenuModel>& menu,
+       map<string, shared_ptr<GActionGroup>>& actions,
+       int index) const
+{
+    shared_ptr<GMenuItem> menuItem(g_menu_item_new_from_model(menu.get(), index), &g_object_deleter);
+
+    vector<unsigned int> location(parentLocation);
+    location.emplace_back(index);
+
+    string action = get_string_attribute(menuItem, G_MENU_ATTRIBUTE_ACTION);
+
+    bool isCheckbox = false;
+    bool isRadio = false;
+    bool isToggled = false;
+
+    pair<string, string> idPair;
+    shared_ptr<GActionGroup> actionGroup;
+    shared_ptr<GVariant> state;
+
+    if (!action.empty())
+    {
+        idPair = split_action(action);
+        actionGroup = actions[idPair.first];
+        state = shared_ptr<GVariant>(g_action_group_get_action_state(actionGroup.get(),
+                                     idPair.second.c_str()),
+                                     &gvariant_deleter);
+        auto attributeTarget = get_attribute(menuItem, G_MENU_ATTRIBUTE_TARGET);
+
+        if (attributeTarget && state)
+        {
+            isToggled = g_variant_equal(state.get(), attributeTarget.get());
+            isRadio = true;
+        }
+        else if (state
+                && g_variant_is_of_type(state.get(), G_VARIANT_TYPE_BOOLEAN))
+        {
+            isToggled = g_variant_get_boolean(state.get());
+            isCheckbox = true;
+        }
+    }
+
+    Type actualType = Type::plain;
+    if (isCheckbox)
+    {
+        actualType = Type::checkbox;
+    }
+    else if (isRadio)
+    {
+        actualType = Type::radio;
+    }
+
+    if (actualType != p->m_type)
+    {
+        matchResult.failure(
+                location,
+                "Expected " + type_to_string(p->m_type) + ", found "
+                        + type_to_string(actualType));
+    }
+
+    string label = get_string_attribute(menuItem, G_MENU_ATTRIBUTE_LABEL);
+    if (p->m_label && (*p->m_label) != label)
+    {
+        matchResult.failure(
+                location,
+                "Expected label '" + *p->m_label + "', but found '" + label
+                        + "'");
+    }
+
+    string icon = get_string_attribute(menuItem, G_MENU_ATTRIBUTE_ICON);
+    if (p->m_icon && (*p->m_icon) != icon)
+    {
+        matchResult.failure(
+                location,
+                "Expected icon '" + *p->m_icon + "', but found '" + icon + "'");
+    }
+
+    if (p->m_action && (*p->m_action) != action)
+    {
+        matchResult.failure(
+                location,
+                "Expected action '" + *p->m_action + "', but found '" + action
+                        + "'");
+    }
+
+    if (!p->m_state_icons.empty() && !state)
+    {
+        matchResult.failure(
+                location,
+                "Expected state icons but no state was found");
+    }
+    else if (!p->m_state_icons.empty() && state &&
+             !g_variant_is_of_type(state.get(), G_VARIANT_TYPE_VARDICT))
+    {
+        matchResult.failure(
+                location,
+                "Expected state icons vardict, found "
+                        + type_to_string(actualType));
+    }
+    else if (!p->m_state_icons.empty() && state &&
+             g_variant_is_of_type(state.get(), G_VARIANT_TYPE_VARDICT))
+    {
+        std::vector<std::string> actual_state_icons;
+        GVariantIter it;
+        gchar* key;
+        GVariant* value;
+
+        g_variant_iter_init(&it, state.get());
+        while (g_variant_iter_loop(&it, "{sv}", &key, &value))
+        {
+            if (std::string(key) == "icon") {
+                auto gicon = g_icon_deserialize(value);
+                if (gicon && G_IS_THEMED_ICON(gicon))
+                {
+                    auto iconNames = g_themed_icon_get_names(G_THEMED_ICON(gicon));
+                    // Just take the first icon in the list (there is only ever one)
+                    actual_state_icons.push_back(iconNames[0]);
+                    g_object_unref(gicon);
+                }
+            }
+            else if (std::string(key) == "icons" && g_variant_is_of_type(value, G_VARIANT_TYPE("av")))
+            {
+                // If we find "icons" in the map, clear any icons we may have found in "icon",
+                // then break from the loop as we have found all icons now.
+                actual_state_icons.clear();
+                GVariantIter icon_it;
+                GVariant* icon_value;
+
+                g_variant_iter_init(&icon_it, value);
+                while (g_variant_iter_loop(&icon_it, "v", &icon_value))
+                {
+                    auto gicon = g_icon_deserialize(icon_value);
+                    if (gicon && G_IS_THEMED_ICON(gicon))
+                    {
+                        auto iconNames = g_themed_icon_get_names(G_THEMED_ICON(gicon));
+                        // Just take the first icon in the list (there is only ever one)
+                        actual_state_icons.push_back(iconNames[0]);
+                        g_object_unref(gicon);
+                    }
+                }
+                // We're breaking out of g_variant_iter_loop here so clean up
+                g_variant_unref(value);
+                g_free(key);
+                break;
+            }
+        }
+
+        if (p->m_state_icons != actual_state_icons)
+        {
+            std::string expected_icons;
+            for (unsigned int i = 0; i < p->m_state_icons.size(); ++i)
+            {
+                expected_icons += i == 0 ? p->m_state_icons[i] : ", " + p->m_state_icons[i];
+            }
+            std::string actual_icons;
+            for (unsigned int i = 0; i < actual_state_icons.size(); ++i)
+            {
+                actual_icons += i == 0 ? actual_state_icons[i] : ", " + actual_state_icons[i];
+            }
+            matchResult.failure(
+                    location,
+                    "Expected state_icons == {" + expected_icons
+                        + "} but found {" + actual_icons + "}");
+        }
+    }
+
+    for (const auto& e: p->m_pass_through_attributes)
+    {
+        string actionName = get_string_attribute(menuItem, e.first.c_str());
+        if (actionName.empty())
+        {
+            matchResult.failure(
+                    location,
+                    "Could not find action name '" + e.first + "'");
+        }
+        else
+        {
+            auto passThroughIdPair = split_action(actionName);
+            auto actionGroup = actions[passThroughIdPair.first];
+            if (actionGroup)
+            {
+                auto value = get_action_group_attribute(
+                        actionGroup, passThroughIdPair.second.c_str());
+                if (!value)
+                {
+                    matchResult.failure(
+                            location,
+                            "Expected pass-through attribute '" + e.first
+                                    + "' was not present");
+                }
+                else if (!g_variant_is_of_type(e.second.get(), g_variant_get_type(value.get())))
+                {
+                    std::string expectedType = g_variant_get_type_string(e.second.get());
+                    std::string actualType = g_variant_get_type_string(value.get());
+                    matchResult.failure(
+                            location,
+                            "Expected pass-through attribute type '" + expectedType
+                                    + "' but found '" + actualType + "'");
+                }
+                else if (g_variant_compare(e.second.get(), value.get()))
+                {
+                    bool reportMismatch = true;
+                    if (g_strcmp0(g_variant_get_type_string(value.get()),"d") == 0 && p->m_maxDifference)
+                    {
+                        auto actualDouble = g_variant_get_double(value.get());
+                        auto expectedDouble = g_variant_get_double(e.second.get());
+                        auto difference = actualDouble-expectedDouble;
+                        if (difference < 0) difference = difference * -1.0;
+                        if (difference <= p->m_maxDifference)
+                        {
+                            reportMismatch = false;
+                        }
+                    }
+                    if (reportMismatch)
+                    {
+                        gchar* expectedString = g_variant_print(e.second.get(), true);
+                        gchar* actualString = g_variant_print(value.get(), true);
+                        matchResult.failure(
+                                location,
+                                "Expected pass-through attribute '" + e.first
+                                    + "' == " + expectedString + " but found "
+                                    + actualString);
+
+                        g_free(expectedString);
+                        g_free(actualString);
+                    }
+                }
+            }
+            else
+            {
+                matchResult.failure(location, "Could not find action group for ID '" + passThroughIdPair.first + "'");
+            }
+        }
+    }
+
+    for (const auto& e: p->m_attributes)
+    {
+        auto value = get_attribute(menuItem, e.first.c_str());
+        if (!value)
+        {
+            matchResult.failure(location,
+                    "Expected attribute '" + e.first
+                            + "' could not be found");
+        }
+        else if (!g_variant_is_of_type(e.second.get(), g_variant_get_type(value.get())))
+        {
+            std::string expectedType = g_variant_get_type_string(e.second.get());
+            std::string actualType = g_variant_get_type_string(value.get());
+            matchResult.failure(
+                    location,
+                    "Expected attribute type '" + expectedType
+                            + "' but found '" + actualType + "'");
+        }
+        else if (g_variant_compare(e.second.get(), value.get()))
+        {
+            gchar* expectedString = g_variant_print(e.second.get(), true);
+            gchar* actualString = g_variant_print(value.get(), true);
+            matchResult.failure(
+                    location,
+                    "Expected attribute '" + e.first + "' == " + expectedString
+                            + ", but found " + actualString);
+            g_free(expectedString);
+            g_free(actualString);
+        }
+    }
+
+    if (p->m_isToggled && (*p->m_isToggled) != isToggled)
+    {
+        matchResult.failure(
+                location,
+                "Expected toggled = " + bool_to_string(*p->m_isToggled)
+                        + ", but found " + bool_to_string(isToggled));
+    }
+
+    if (!matchResult.success())
+    {
+        return;
+    }
+
+    if (!p->m_items.empty() || p->m_expectedSize)
+    {
+        shared_ptr<GMenuModel> link;
+
+        switch (p->m_linkType)
+        {
+            case LinkType::any:
+            {
+                link.reset(g_menu_model_get_item_link(menu.get(), (int) index, G_MENU_LINK_SUBMENU), &g_object_deleter);
+                if (!link)
+                {
+                    link.reset(g_menu_model_get_item_link(menu.get(), (int) index, G_MENU_LINK_SECTION), &g_object_deleter);
+                }
+                break;
+            }
+            case LinkType::submenu:
+            {
+                link.reset(g_menu_model_get_item_link(menu.get(), (int) index, G_MENU_LINK_SUBMENU), &g_object_deleter);
+                break;
+            }
+            case LinkType::section:
+            {
+                link.reset(g_menu_model_get_item_link(menu.get(), (int) index, G_MENU_LINK_SECTION), &g_object_deleter);
+                break;
+            }
+        }
+
+
+        if (!link)
+        {
+            if (p->m_expectedSize)
+            {
+                matchResult.failure(
+                        location,
+                        "Expected " + to_string(*p->m_expectedSize)
+                                + " children, but found none");
+            }
+            else
+            {
+                matchResult.failure(
+                        location,
+                        "Expected " + to_string(p->m_items.size())
+                                + " children, but found none");
+            }
+            return;
+        }
+        else
+        {
+            while (true)
+            {
+                MatchResult childMatchResult(matchResult.createChild());
+
+                if (p->m_expectedSize
+                        && *p->m_expectedSize
+                                != (unsigned int) g_menu_model_get_n_items(
+                                        link.get()))
+                {
+                    childMatchResult.failure(
+                            location,
+                            "Expected " + to_string(*p->m_expectedSize)
+                                    + " child items, but found "
+                                    + to_string(
+                                            g_menu_model_get_n_items(
+                                                    link.get())));
+                }
+                else if (!p->m_items.empty())
+                {
+                    switch (p->m_mode)
+                    {
+                        case Mode::all:
+                            p->all(childMatchResult, location, link, actions);
+                            break;
+                        case Mode::starts_with:
+                            p->startsWith(childMatchResult, location, link, actions);
+                            break;
+                        case Mode::ends_with:
+                            p->endsWith(childMatchResult, location, link, actions);
+                            break;
+                    }
+                }
+
+                if (childMatchResult.success())
+                {
+                    matchResult.merge(childMatchResult);
+                    break;
+                }
+                else
+                {
+                    if (matchResult.hasTimedOut())
+                    {
+                        matchResult.merge(childMatchResult);
+                        break;
+                    }
+                    menuWaitForItems(link);
+                }
+            }
+        }
+    }
+
+
+    for (const auto& a: p->m_setActionStates)
+    {
+        auto stateAction = action;
+        auto stateIdPair = idPair;
+        auto stateActionGroup = actionGroup;
+        if (!a.first.empty())
+        {
+            stateAction = get_string_attribute(menuItem, a.first.c_str());;
+            stateIdPair = split_action(stateAction);
+            stateActionGroup = actions[stateIdPair.first];
+        }
+
+        if (stateAction.empty())
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to set action state, but no action was found");
+        }
+        else if(!stateActionGroup)
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to set action state for action group '" + stateIdPair.first
+                            + "', but action group wasn't found");
+        }
+        else if (!g_action_group_has_action(stateActionGroup.get(), stateIdPair.second.c_str()))
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to set action state for action '" + stateAction
+                            + "', but action was not found");
+        }
+        else
+        {
+            g_action_group_change_action_state(stateActionGroup.get(), stateIdPair.second.c_str(),
+                                               g_variant_ref(a.second.get()));
+        }
+
+        // FIXME this is a dodgy way to ensure the action state change gets dispatched
+        menuWaitForItems(menu, 100);
+    }
+
+    for (const auto& a: p->m_activations)
+    {
+        string tmpAction = action;
+        auto tmpIdPair = idPair;
+        auto tmpActionGroup = actionGroup;
+        if (!a.first.empty())
+        {
+            tmpAction = get_string_attribute(menuItem, a.first.c_str());
+            tmpIdPair = split_action(tmpAction);
+            tmpActionGroup = actions[tmpIdPair.first];
+        }
+
+        if (tmpAction.empty())
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to activate action, but no action was found");
+        }
+        else if(!tmpActionGroup)
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to activate action group '" + tmpIdPair.first
+                            + "', but action group wasn't found");
+        }
+        else if (!g_action_group_has_action(tmpActionGroup.get(), tmpIdPair.second.c_str()))
+        {
+            matchResult.failure(
+                    location,
+                    "Tried to activate action '" + tmpAction + "', but action was not found");
+        }
+        else
+        {
+            if (a.second)
+            {
+                g_action_group_activate_action(tmpActionGroup.get(), tmpIdPair.second.c_str(),
+                                               g_variant_ref(a.second.get()));
+            }
+            else
+            {
+                g_action_group_activate_action(tmpActionGroup.get(), tmpIdPair.second.c_str(), nullptr);
+            }
+
+            // FIXME this is a dodgy way to ensure the activation gets dispatched
+            menuWaitForItems(menu, 100);
+        }
+    }
+}
+
+}   // namepsace gmenuharness
+
+}   // namespace unity
diff --git a/src/gmenuharness/MenuMatcher.cpp b/src/gmenuharness/MenuMatcher.cpp
new file mode 100644
index 0000000..5bb4fbd
--- /dev/null
+++ b/src/gmenuharness/MenuMatcher.cpp
@@ -0,0 +1,208 @@
+/*
+ * 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: Pete Woods <pete.woods@canonical.com>
+ */
+
+#include <unity/gmenuharness/MenuMatcher.h>
+#include <unity/gmenuharness/MatchUtils.h>
+
+#include <iostream>
+
+#include <gio/gio.h>
+
+using namespace std;
+
+namespace unity
+{
+
+namespace gmenuharness
+{
+
+namespace
+{
+
+static void gdbus_connection_deleter(GDBusConnection* connection)
+{
+//    if (!g_dbus_connection_is_closed(connection))
+//    {
+//        g_dbus_connection_close_sync(connection, nullptr, nullptr);
+//    }
+    g_clear_object(&connection);
+}
+}
+
+struct MenuMatcher::Parameters::Priv
+{
+    string m_busName;
+
+    vector<pair<string, string>> m_actions;
+
+    string m_menuObjectPath;
+};
+
+MenuMatcher::Parameters::Parameters(const string& busName,
+                                    const vector<pair<string, string>>& actions,
+                                    const string& menuObjectPath) :
+        p(new Priv)
+{
+    p->m_busName = busName;
+    p->m_actions = actions;
+    p->m_menuObjectPath = menuObjectPath;
+}
+
+MenuMatcher::Parameters::~Parameters()
+{
+}
+
+MenuMatcher::Parameters::Parameters(const Parameters& other) :
+        p(new Priv)
+{
+    *this = other;
+}
+
+MenuMatcher::Parameters::Parameters(Parameters&& other)
+{
+    *this = move(other);
+}
+
+MenuMatcher::Parameters& MenuMatcher::Parameters::operator=(const Parameters& other)
+{
+    p->m_busName = other.p->m_busName;
+    p->m_actions = other.p->m_actions;
+    p->m_menuObjectPath = other.p->m_menuObjectPath;
+    return *this;
+}
+
+MenuMatcher::Parameters& MenuMatcher::Parameters::operator=(Parameters&& other)
+{
+    p = move(other.p);
+    return *this;
+}
+
+struct MenuMatcher::Priv
+{
+    Priv(const Parameters& parameters) :
+        m_parameters(parameters)
+    {
+    }
+
+    Parameters m_parameters;
+
+    vector<MenuItemMatcher> m_items;
+
+    shared_ptr<GDBusConnection> m_system;
+
+    shared_ptr<GDBusConnection> m_session;
+
+    shared_ptr<GMenuModel>  m_menu;
+
+    map<string, shared_ptr<GActionGroup>> m_actions;
+};
+
+MenuMatcher::MenuMatcher(const Parameters& parameters) :
+        p(new Priv(parameters))
+{
+    p->m_system.reset(g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, nullptr),
+                      &gdbus_connection_deleter);
+    g_dbus_connection_set_exit_on_close(p->m_system.get(), false);
+
+    p->m_session.reset(g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr),
+                       &gdbus_connection_deleter);
+    g_dbus_connection_set_exit_on_close(p->m_session.get(), false);
+
+    p->m_menu.reset(
+            G_MENU_MODEL(
+                    g_dbus_menu_model_get(
+                            p->m_session.get(),
+                            p->m_parameters.p->m_busName.c_str(),
+                            p->m_parameters.p->m_menuObjectPath.c_str())),
+            &g_object_deleter);
+
+    for (const auto& action : p->m_parameters.p->m_actions)
+    {
+        shared_ptr<GActionGroup> actionGroup(
+                G_ACTION_GROUP(
+                        g_dbus_action_group_get(
+                                p->m_session.get(),
+                                p->m_parameters.p->m_busName.c_str(),
+                                action.second.c_str())),
+                &g_object_deleter);
+        p->m_actions[action.first] = actionGroup;
+    }
+}
+
+MenuMatcher::~MenuMatcher()
+{
+}
+
+MenuMatcher& MenuMatcher::item(const MenuItemMatcher& item)
+{
+    p->m_items.emplace_back(item);
+    return *this;
+}
+
+void MenuMatcher::match(MatchResult& matchResult) const
+{
+    vector<unsigned int> location;
+
+    while (true)
+    {
+        MatchResult childMatchResult(matchResult.createChild());
+
+        int menuSize = g_menu_model_get_n_items(p->m_menu.get());
+        if (p->m_items.size() > (unsigned int) menuSize)
+        {
+            childMatchResult.failure(
+                    location,
+                    "Row count mismatch, expected " + to_string(p->m_items.size())
+                            + " but found " + to_string(menuSize));
+        }
+        else
+        {
+            for (size_t i = 0; i < p->m_items.size(); ++i)
+            {
+                const auto& matcher = p->m_items.at(i);
+                matcher.match(childMatchResult, location, p->m_menu, p->m_actions, i);
+            }
+        }
+
+        if (childMatchResult.success())
+        {
+            matchResult.merge(childMatchResult);
+            break;
+        }
+        else
+        {
+            if (matchResult.hasTimedOut())
+            {
+                matchResult.merge(childMatchResult);
+                break;
+            }
+            menuWaitForItems(p->m_menu);
+        }
+    }
+}
+
+MatchResult MenuMatcher::match() const
+{
+    MatchResult matchResult;
+    match(matchResult);
+    return matchResult;
+}
+
+}   // namespace gmenuharness
+
+}   // namespace unity
diff --git a/src/volume-control-pulse.vala b/src/volume-control-pulse.vala
index 87af258..b60d97e 100644
--- a/src/volume-control-pulse.vala
+++ b/src/volume-control-pulse.vala
@@ -275,7 +275,7 @@ public class VolumeControlPulse : VolumeControl
 				}
 
 				/* We only care about signals if our internal count is zero */
-				if (sig_count == 0) {
+				//if (sig_count == 0) {
 					/* Extract volume and make sure it's not a side effect of us setting it */
 					Variant body = message.get_body ();
 					Variant varray = body.get_child_value (0);
@@ -293,7 +293,7 @@ public class VolumeControlPulse : VolumeControl
 						vol.reason = VolumeControl.VolumeReasons.PULSE_CHANGE;
 						this.volume = vol;
 					}
-				}
+				//}
 			}
 		}
 
@@ -478,7 +478,9 @@ public class VolumeControlPulse : VolumeControl
 		this.context = new PulseAudio.Context (loop.get_api(), null, props);
 		this.context.set_state_callback (context_state_callback);
 
-		if (context.connect(null, Context.Flags.NOFAIL, null) < 0)
+		var server_string = Environment.get_variable("PULSE_SERVER");
+		warning("XGM: PULSE_SERVER=%s", server_string);
+		if (context.connect(server_string, Context.Flags.NOFAIL, null) < 0)
 			warning( "pa_context_connect() failed: %s\n", PulseAudio.strerror(context.errno()));
 	}
 
@@ -627,7 +629,7 @@ public class VolumeControlPulse : VolumeControl
 		}
 		set {
 			var volume_changed = (value.volume != _volume.volume);
-			debug("Setting volume to %f for profile %d because %d", value.volume, _active_sink_input, value.reason);
+			warning("Setting volume to %f for profile %d because %d", value.volume, _active_sink_input, value.reason);
 
 			_volume = value;
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 2bbd8c5..4c28cdf 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -5,10 +5,10 @@
 
 include_directories(${GTEST_INCLUDE_DIR})
 
-add_library (gtest STATIC
+add_library (gtest-static STATIC
              ${GTEST_SOURCE_DIR}/gtest-all.cc
              ${GTEST_SOURCE_DIR}/gtest_main.cc)
-target_link_libraries(gtest ${GTEST_LIBS})
+target_link_libraries(gtest-static ${GTEST_LIBS})
 
 ###########################
 # GSettings Schema
@@ -41,74 +41,74 @@ set(VALA_MOCKS_HEADER_PATH "${CMAKE_CURRENT_BINARY_DIR}/vala-mocks.h")
 set(VALA_MOCKS_SYMBOLS_PATH "${CMAKE_CURRENT_BINARY_DIR}/vala-mocks.def")
 
 vala_init(vala-mocks
-	DEPENDS
-		indicator-sound-service-lib
-	PACKAGES
-		config
-		gio-2.0
-		gio-unix-2.0
-		libxml-2.0
-		libpulse
-		libpulse-mainloop-glib
-		libnotify
-		accounts-service
-		indicator-sound-service
-	OPTIONS
-		--ccode
-		--thread
-		--vapidir=${CMAKE_BINARY_DIR}/src/
-		--vapidir=${CMAKE_SOURCE_DIR}/vapi/
-		--vapidir=.
+    DEPENDS
+        indicator-sound-service-lib
+    PACKAGES
+        config
+        gio-2.0
+        gio-unix-2.0
+        libxml-2.0
+        libpulse
+        libpulse-mainloop-glib
+        libnotify
+        accounts-service
+        indicator-sound-service
+    OPTIONS
+        --ccode
+        --thread
+        --vapidir=${CMAKE_BINARY_DIR}/src/
+        --vapidir=${CMAKE_SOURCE_DIR}/vapi/
+        --vapidir=.
 )
 
 vala_add(vala-mocks
-	media-player-mock.vala
+    media-player-mock.vala
 )
 
 vala_add(vala-mocks
-	media-player-list-mock.vala
+    media-player-list-mock.vala
 )
 
 vala_add(vala-mocks
-	volume-control-mock.vala
+    volume-control-mock.vala
 )
 
 vala_finish(vala-mocks
-	SOURCES
-		vala_mocks_VALA_SOURCES
-	OUTPUTS
-		vala_mocks_VALA_C
-	GENERATE_HEADER
-		${VALA_MOCKS_HEADER_PATH}
-	GENERATE_SYMBOLS
-		${VALA_MOCKS_SYMBOLS_PATH}
+    SOURCES
+        vala_mocks_VALA_SOURCES
+    OUTPUTS
+        vala_mocks_VALA_C
+    GENERATE_HEADER
+        ${VALA_MOCKS_HEADER_PATH}
+    GENERATE_SYMBOLS
+        ${VALA_MOCKS_SYMBOLS_PATH}
 )
 
 set_source_files_properties(
-	${vala_mocks_VALA_SOURCES}
-	PROPERTIES
-	HEADER_FILE_ONLY TRUE
+    ${vala_mocks_VALA_SOURCES}
+    PROPERTIES
+    HEADER_FILE_ONLY TRUE
 )
 
 set(
-	VALA_MOCKS_SOURCES
-	${vala_mocks_VALA_SOURCES}
-	${vala_mocks_VALA_C}
-	${VALA_MOCKS_SYMBOLS_PATH}
+    VALA_MOCKS_SOURCES
+    ${vala_mocks_VALA_SOURCES}
+    ${vala_mocks_VALA_C}
+    ${VALA_MOCKS_SYMBOLS_PATH}
 )
 
 add_definitions(
-	-Wno-unused-but-set-variable
+    -Wno-unused-but-set-variable
 )
 
 add_library(
-	vala-mocks-lib STATIC
-	${VALA_MOCKS_SOURCES}
+    vala-mocks-lib STATIC
+    ${VALA_MOCKS_SOURCES}
 )
 
 target_link_libraries(
-	vala-mocks-lib
-	indicator-sound-service-lib
+    vala-mocks-lib
+    indicator-sound-service-lib
 )
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
@@ -118,9 +118,9 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 ###########################
 
 add_library(
-	pulse-mock
-	SHARED
-	pa-mock.cpp
+    pulse-mock
+    SHARED
+    pa-mock.cpp
 )
 
 target_link_libraries (pulse-mock ${PULSEAUDIO_LIBRARIES})
@@ -131,7 +131,7 @@ target_link_libraries (pulse-mock ${PULSEAUDIO_LIBRARIES})
 
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (name-watch-test name-watch-test.cc ${CMAKE_SOURCE_DIR}/src/bus-watch-namespace.c)
-target_link_libraries (name-watch-test gtest ${SOUNDSERVICE_LIBRARIES})
+target_link_libraries (name-watch-test gtest-static ${SOUNDSERVICE_LIBRARIES})
 add_test(name-watch-test name-watch-test)
 
 ###########################
@@ -141,21 +141,21 @@ add_test(name-watch-test name-watch-test)
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (accounts-service-user-test accounts-service-user.cc)
 target_link_libraries (
-	accounts-service-user-test
-	indicator-sound-service-lib
-	vala-mocks-lib
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    accounts-service-user-test
+    indicator-sound-service-lib
+    vala-mocks-lib
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 # Split tests to work around libaccountservice sucking
 add_test(accounts-service-user-test-basic
-	accounts-service-user-test  --gtest_filter=AccountsServiceUserTest.BasicObject
+    accounts-service-user-test  --gtest_filter=AccountsServiceUserTest.BasicObject
 )
 
 add_test(accounts-service-user-test-player
-	accounts-service-user-test  --gtest_filter=AccountsServiceUserTest.SetMediaPlayer
+    accounts-service-user-test  --gtest_filter=AccountsServiceUserTest.SetMediaPlayer
 )
 
 ###########################
@@ -165,11 +165,11 @@ add_test(accounts-service-user-test-player
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (volume-control-test volume-control-test.cc gschemas.compiled)
 target_link_libraries (
-	volume-control-test
-	indicator-sound-service-lib
-	pulse-mock
-	gtest
-	${TEST_LIBRARIES}
+    volume-control-test
+    indicator-sound-service-lib
+    pulse-mock
+    gtest-static
+    ${TEST_LIBRARIES}
 )
 
 add_test(volume-control-test volume-control-test)
@@ -181,12 +181,12 @@ add_test(volume-control-test volume-control-test)
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (sound-menu-test sound-menu.cc)
 target_link_libraries (
-	sound-menu-test
-	indicator-sound-service-lib
-	vala-mocks-lib
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    sound-menu-test
+    indicator-sound-service-lib
+    vala-mocks-lib
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 add_test(sound-menu-test sound-menu-test)
@@ -198,13 +198,13 @@ add_test(sound-menu-test sound-menu-test)
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (notifications-test notifications-test.cc)
 target_link_libraries (
-	notifications-test
-	indicator-sound-service-lib
-	vala-mocks-lib
-	pulse-mock
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    notifications-test
+    indicator-sound-service-lib
+    vala-mocks-lib
+    pulse-mock
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 add_test(notifications-test notifications-test)
@@ -216,23 +216,23 @@ add_test(notifications-test notifications-test)
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (media-player-user-test media-player-user.cc)
 target_link_libraries (
-	media-player-user-test
-	indicator-sound-service-lib
-	vala-mocks-lib
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    media-player-user-test
+    indicator-sound-service-lib
+    vala-mocks-lib
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 # Split tests to work around libaccountservice sucking
 add_test(media-player-user-test-basic
-	media-player-user-test  --gtest_filter=MediaPlayerUserTest.BasicObject
+    media-player-user-test  --gtest_filter=MediaPlayerUserTest.BasicObject
 )
 add_test(media-player-user-test-dataset
-	media-player-user-test  --gtest_filter=MediaPlayerUserTest.DataSet
+    media-player-user-test  --gtest_filter=MediaPlayerUserTest.DataSet
 )
 add_test(media-player-user-test-timeout
-	media-player-user-test  --gtest_filter=MediaPlayerUserTest.TimeoutTest
+    media-player-user-test  --gtest_filter=MediaPlayerUserTest.TimeoutTest
 )
 
 ###########################
@@ -242,20 +242,20 @@ add_test(media-player-user-test-timeout
 include_directories(${CMAKE_SOURCE_DIR}/src)
 add_executable (greeter-list-test greeter-list.cc)
 target_link_libraries (
-	greeter-list-test
-	indicator-sound-service-lib
-	vala-mocks-lib
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    greeter-list-test
+    indicator-sound-service-lib
+    vala-mocks-lib
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 # Split tests to work around libaccountservice sucking
 add_test(greeter-list-test-basic
-	greeter-list-test  --gtest_filter=GreeterListTest.BasicObject
+    greeter-list-test  --gtest_filter=GreeterListTest.BasicObject
 )
 add_test(greeter-list-test-iterator
-	greeter-list-test  --gtest_filter=GreeterListTest.BasicIterator
+    greeter-list-test  --gtest_filter=GreeterListTest.BasicIterator
 )
 
 ###########################
@@ -263,18 +263,21 @@ add_test(greeter-list-test-iterator
 ###########################
 
 add_definitions(
-	-DINDICATOR_SOUND_SERVICE_BINARY="${CMAKE_BINARY_DIR}/src/indicator-sound-service"
-	-DPA_MOCK_LIB="${CMAKE_CURRENT_BINARY_DIR}/libpulse-mock.so"
+    -DINDICATOR_SOUND_SERVICE_BINARY="${CMAKE_BINARY_DIR}/src/indicator-sound-service"
+    -DPA_MOCK_LIB="${CMAKE_CURRENT_BINARY_DIR}/libpulse-mock.so"
 )
 add_executable (indicator-test indicator-test.cc gschemas.compiled)
 target_link_libraries (
-	indicator-test
-	gtest
-	${SOUNDSERVICE_LIBRARIES}
-	${TEST_LIBRARIES}
+    indicator-test
+    gtest-static
+    ${SOUNDSERVICE_LIBRARIES}
+    ${TEST_LIBRARIES}
 )
 
 # Split tests to work around libaccountservice sucking
 add_test(indcator-test
-	indicator-test
+    indicator-test
 )
+
+add_subdirectory(integration)
+add_subdirectory(dbus-types)
\ No newline at end of file
diff --git a/tests/dbus-types/CMakeLists.txt b/tests/dbus-types/CMakeLists.txt
new file mode 100644
index 0000000..6346e25
--- /dev/null
+++ b/tests/dbus-types/CMakeLists.txt
@@ -0,0 +1,48 @@
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+find_package(Qt5DBus REQUIRED)
+include_directories(${Qt5DBus_INCLUDE_DIRS})
+
+add_definitions(-DQT_NO_KEYWORDS=1)
+
+set(dbusinterface_streamrestore_xml "org.PulseAudio.Ext.StreamRestore1.xml")
+set_source_files_properties(${dbusinterface_streamrestore_xml} PROPERTIES
+  CLASSNAME StreamRestoreInterface)
+
+set(dbusinterface_accounts_xml "org.freedesktop.Accounts.xml")
+set_source_files_properties(${dbusinterface_accounts_xml} PROPERTIES
+  CLASSNAME AccountsInterface)
+
+set(dbusinterface_accountssound_xml "com.ubuntu.AccountsService.Sound.xml")
+set_source_files_properties(${dbusinterface_accountssound_xml} PROPERTIES
+  CLASSNAME AccountsSoundInterface)
+
+set(dbusinterface_properties_xml "org.freedesktop.DBus.Properties.xml")
+set_source_files_properties(${dbusinterface_properties_xml} PROPERTIES
+  CLASSNAME DBusPropertiesInterface
+  NO_NAMESPACE YES
+  INCLUDE "dbus-types.h")
+
+set(dbusinterface_menus_xml "org.gtk.Menus.xml")
+set_source_files_properties(${dbusinterface_menus_xml} PROPERTIES
+  CLASSNAME MenusInterface)
+
+qt5_add_dbus_interface(interface_files ${dbusinterface_streamrestore_xml} stream_restore_interface)
+qt5_add_dbus_interface(interface_files ${dbusinterface_properties_xml} dbus_properties_interface)
+qt5_add_dbus_interface(interface_files ${dbusinterface_accounts_xml} dbus_accounts_interface)
+qt5_add_dbus_interface(interface_files ${dbusinterface_accountssound_xml} dbus_accountssound_interface)
+qt5_add_dbus_interface(interface_files ${dbusinterface_menus_xml} dbus_menus_interface)
+
+add_library(
+  sound-indicator-dbus-interfaces
+  STATIC
+  ${interface_files}
+  pulseaudio-volume.cpp
+)
+
+qt5_use_modules(
+    sound-indicator-dbus-interfaces
+    Core
+    DBus
+)
diff --git a/tests/dbus-types/com.ubuntu.AccountsService.Sound.xml b/tests/dbus-types/com.ubuntu.AccountsService.Sound.xml
new file mode 100644
index 0000000..27c915a
--- /dev/null
+++ b/tests/dbus-types/com.ubuntu.AccountsService.Sound.xml
@@ -0,0 +1,9 @@
+<node>
+  <interface name="com.ubuntu.AccountsService.Sound">
+    <method name="Set">
+      <arg direction="in" type="s" name="interface" />
+      <arg direction="in" type="s" name="property" />
+      <arg direction="out" type="o" name="path" />
+    </method>
+  </interface>
+</node>
diff --git a/tests/dbus-types/dbus-types.h b/tests/dbus-types/dbus-types.h
new file mode 100644
index 0000000..f747458
--- /dev/null
+++ b/tests/dbus-types/dbus-types.h
@@ -0,0 +1,40 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+#pragma once
+
+#include <QDBusMetaType>
+#include "pulseaudio-volume.h"
+
+namespace DBusTypes
+{
+    inline void registerMetaTypes()
+    {
+        PulseaudioVolume::registerMetaType();
+        PulseaudioVolumeArray::registerMetaType();
+    }
+
+    static constexpr char const* DBUS_NAME = "com.canonical.indicator.sound";
+
+    static constexpr char const* DBUS_PULSE = "org.PulseAudio1";
+
+    static constexpr char const* STREAM_RESTORE_NAME = "org.PulseAudio.Ext.StreamRestore1";
+
+    static constexpr char const* STREAM_RESTORE_PATH = "/org/pulseaudio/stream_restore1";
+
+    static constexpr char const* STREAM_RESTORE_ENTRY_NAME = "org.PulseAudio.Ext.StreamRestore1.RestoreEntry";
+}
diff --git a/tests/dbus-types/org.PulseAudio.Ext.StreamRestore1.xml b/tests/dbus-types/org.PulseAudio.Ext.StreamRestore1.xml
new file mode 100644
index 0000000..bf9af76
--- /dev/null
+++ b/tests/dbus-types/org.PulseAudio.Ext.StreamRestore1.xml
@@ -0,0 +1,7 @@
+<node>
+  <interface name="org.PulseAudio.Ext.StreamRestore1">
+    <method name="GetEntryByName">
+      <arg direction="in" type="s" name="entry" />
+      <arg direction="out" type="o" name="value" />
+  </interface>
+</node>
diff --git a/tests/dbus-types/org.freedesktop.Accounts.xml b/tests/dbus-types/org.freedesktop.Accounts.xml
new file mode 100644
index 0000000..d9c6b2a
--- /dev/null
+++ b/tests/dbus-types/org.freedesktop.Accounts.xml
@@ -0,0 +1,8 @@
+<node>
+  <interface name="org.freedesktop.Accounts">
+    <method name="FindUserByName">
+      <arg direction="in" type="s" name="user" />
+      <arg direction="out" type="o" name="path" />
+    </method>
+  </interface>
+</node>
diff --git a/tests/dbus-types/org.freedesktop.DBus.Properties.xml b/tests/dbus-types/org.freedesktop.DBus.Properties.xml
new file mode 100644
index 0000000..19a1b90
--- /dev/null
+++ b/tests/dbus-types/org.freedesktop.DBus.Properties.xml
@@ -0,0 +1,21 @@
+<node>
+  <interface name="org.freedesktop.DBus.Properties">
+    <method name="Set">
+      <arg direction="in" type="s" name="entry" />
+      <arg direction="in" type="s" name="property" />
+      <arg direction="in" type="v" name="value" />
+    </method>
+    <method name="Get">
+      <arg direction="in" type="s" name="entry" />
+      <arg direction="in" type="s" name="property" />
+      <arg direction="out" type="v" name="value" />
+    </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>
diff --git a/tests/dbus-types/org.gtk.Menus.xml b/tests/dbus-types/org.gtk.Menus.xml
new file mode 100644
index 0000000..a0d6a83
--- /dev/null
+++ b/tests/dbus-types/org.gtk.Menus.xml
@@ -0,0 +1,6 @@
+<node>
+  <interface name="org.gtk.Menus">
+    <signal name="Changed">
+    </signal>
+  </interface>
+</node>
diff --git a/tests/dbus-types/pulseaudio-volume.cpp b/tests/dbus-types/pulseaudio-volume.cpp
new file mode 100644
index 0000000..8ee305f
--- /dev/null
+++ b/tests/dbus-types/pulseaudio-volume.cpp
@@ -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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+#include "dbus-types.h"
+
+PulseaudioVolume::PulseaudioVolume() :
+        type_(0),
+        volume_(10)
+{
+}
+
+PulseaudioVolume::PulseaudioVolume(unsigned int type, unsigned int volume) :
+          type_(type)
+        , volume_(volume)
+{
+}
+
+PulseaudioVolume::PulseaudioVolume(const PulseaudioVolume &other) :
+        type_(other.type_),
+        volume_(other.volume_)
+{
+}
+
+PulseaudioVolume& PulseaudioVolume::operator=(const PulseaudioVolume &other)
+{
+    type_ = other.type_;
+    volume_ = other.volume_;
+
+    return *this;
+}
+
+PulseaudioVolume::~PulseaudioVolume()
+{
+}
+
+unsigned int PulseaudioVolume::getType() const
+{
+    return type_;
+}
+
+unsigned int PulseaudioVolume::getVolume() const
+{
+    return volume_;
+}
+
+void PulseaudioVolume::registerMetaType()
+{
+    qRegisterMetaType<PulseaudioVolume>("PulseaudioVolume");
+
+    qDBusRegisterMetaType<PulseaudioVolume>();
+}
+
+QDBusArgument &operator<<(QDBusArgument &argument, const PulseaudioVolume& volume)
+{
+    argument.beginStructure();
+    argument << volume.type_;
+    argument << volume.volume_;
+    argument.endStructure();
+
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, PulseaudioVolume &volume)
+{
+    argument.beginStructure();
+    argument >> volume.type_;
+    argument >> volume.volume_;
+    argument.endStructure();
+
+    return argument;
+}
+
+PulseaudioVolumeArray::PulseaudioVolumeArray()
+{
+}
+
+PulseaudioVolumeArray::PulseaudioVolumeArray(const PulseaudioVolumeArray &other) :
+          volume_array_(other.volume_array_)
+{
+}
+
+PulseaudioVolumeArray& PulseaudioVolumeArray::operator=(const PulseaudioVolumeArray &other)
+{
+    volume_array_ = other.volume_array_;
+
+    return *this;
+}
+
+PulseaudioVolumeArray::~PulseaudioVolumeArray()
+{
+}
+
+int PulseaudioVolumeArray::getNumItems() const
+{
+    return volume_array_.size();
+}
+
+PulseaudioVolume PulseaudioVolumeArray::getItem(int i) const
+{
+    if (i < volume_array_.size())
+    {
+        return volume_array_[i];
+    }
+    return PulseaudioVolume();
+}
+
+void PulseaudioVolumeArray::addItem(PulseaudioVolume const &item)
+{
+    volume_array_.push_back(item);
+}
+
+void PulseaudioVolumeArray::registerMetaType()
+{
+    qRegisterMetaType<PulseaudioVolumeArray>("PulseaudioVolumeArray");
+
+    qDBusRegisterMetaType<PulseaudioVolumeArray>();
+}
+
+QDBusArgument &operator<<(QDBusArgument &argument, const PulseaudioVolumeArray& volume)
+{
+    argument.beginArray( qMetaTypeId<PulseaudioVolume>() );
+    for (int i = 0; i < volume.volume_array_.size(); ++ i)
+    {
+        PulseaudioVolume item = volume.getItem(i);
+        argument << item;
+    }
+    argument.endArray();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, PulseaudioVolumeArray &volume)
+{
+    argument.beginArray();
+    while ( !argument.atEnd() ) {
+        PulseaudioVolume item;
+        argument >> item;
+        volume.volume_array_.push_back(item);
+    }
+    argument.endArray();
+
+    return argument;
+}
diff --git a/tests/dbus-types/pulseaudio-volume.h b/tests/dbus-types/pulseaudio-volume.h
new file mode 100644
index 0000000..e9fe73d
--- /dev/null
+++ b/tests/dbus-types/pulseaudio-volume.h
@@ -0,0 +1,71 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+#pragma once
+
+#include <QtDBus>
+
+class PulseaudioVolume
+{
+public:
+    PulseaudioVolume();
+    PulseaudioVolume(unsigned int type, unsigned int volume);
+    PulseaudioVolume(const PulseaudioVolume &other);
+    PulseaudioVolume& operator=(const PulseaudioVolume &other);
+    ~PulseaudioVolume();
+
+    friend QDBusArgument &operator<<(QDBusArgument &argument, PulseaudioVolume const & volume);
+    friend const QDBusArgument &operator>>(QDBusArgument const & argument, PulseaudioVolume &volume);
+
+    unsigned int getType() const;
+    unsigned int getVolume() const;
+
+    //register Message with the Qt type system
+    static void registerMetaType();
+
+private:
+    unsigned int type_;
+    unsigned int volume_;
+};
+
+Q_DECLARE_METATYPE(PulseaudioVolume)
+
+
+class PulseaudioVolumeArray
+{
+public:
+    PulseaudioVolumeArray();
+    PulseaudioVolumeArray(QString const &interface, QString const &property, QDBusVariant const& value);
+    PulseaudioVolumeArray(const PulseaudioVolumeArray &other);
+    PulseaudioVolumeArray& operator=(const PulseaudioVolumeArray &other);
+    ~PulseaudioVolumeArray();
+
+    friend QDBusArgument &operator<<(QDBusArgument &argument, PulseaudioVolumeArray const & volume);
+    friend const QDBusArgument &operator>>(QDBusArgument const & argument, PulseaudioVolumeArray &volume);
+
+    int getNumItems() const;
+    PulseaudioVolume getItem(int i) const;
+    void addItem(PulseaudioVolume const &item);
+
+    //register Message with the Qt type system
+    static void registerMetaType();
+
+private:
+    QVector<PulseaudioVolume> volume_array_;
+};
+
+Q_DECLARE_METATYPE(PulseaudioVolumeArray)
diff --git a/tests/integration/CMakeLists.txt b/tests/integration/CMakeLists.txt
new file mode 100644
index 0000000..2e4004a
--- /dev/null
+++ b/tests/integration/CMakeLists.txt
@@ -0,0 +1,128 @@
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+include(FindGMock)
+
+#pkg_check_modules(GMENUHARNESS REQUIRED libgmenuharness REQUIRED)
+#include_directories(${GMENUHARNESS_INCLUDE_DIRS})
+include_directories("${CMAKE_SOURCE_DIR}/include")
+
+pkg_check_modules(QTDBUSTEST REQUIRED libqtdbustest-1 REQUIRED)
+include_directories(${QTDBUSTEST_INCLUDE_DIRS})
+
+pkg_check_modules(QTDBUSMOCK REQUIRED libqtdbusmock-1 REQUIRED)
+include_directories(${QTDBUSMOCK_INCLUDE_DIRS})
+
+find_package(Qt5Test REQUIRED)
+include_directories(${Qt5Test_INCLUDE_DIRS})
+
+find_package(Qt5DBus REQUIRED)
+include_directories(${Qt5DBus_INCLUDE_DIRS})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${GMOCK_INCLUDE_DIRS})
+include_directories(${GTEST_INCLUDE_DIRS})
+
+include_directories("${CMAKE_SOURCE_DIR}/tests/dbus-types")
+include_directories("${CMAKE_BINARY_DIR}/tests/dbus-types")
+
+add_definitions(-DSOUND_SERVICE_BIN="${CMAKE_BINARY_DIR}/src/indicator-sound-service"
+                -DSTREAM_RESTORE_TABLE="${CMAKE_SOURCE_DIR}/tests/integration/touch-stream-restore.table"
+                -DVOLUME_SET_BIN="${CMAKE_BINARY_DIR}/tests/integration/set-volume"
+                -DTEST_SOUND="${CMAKE_SOURCE_DIR}/tests/integration/test-sound.wav"
+                -DQT_NO_KEYWORDS=1
+)
+
+set(GLIB_REQUIRED_VERSION 2.26)
+
+pkg_check_modules(
+  GLIB REQUIRED
+  glib-2.0>=${GLIB_REQUIRED_VERSION}
+  gio-2.0>=${GLIB_REQUIRED_VERSION}
+)
+include_directories(${GLIB_INCLUDE_DIRS})
+
+set(
+    INTEGRATION_TESTS_SRC
+    indicator-sound-test-base.cpp
+    test-indicator.cpp
+    utils/dbus-pulse-volume.cpp
+    main.cpp
+)
+
+add_executable(
+    integration-tests
+    ${INTEGRATION_TESTS_SRC}
+)
+
+qt5_use_modules(
+    integration-tests
+    Core
+    DBus
+    Test
+)
+
+target_link_libraries(
+    integration-tests
+    sound-indicator-dbus-interfaces
+    ${QTDBUSMOCK_LDFLAGS}
+    ${QTDBUSTEST_LDFLAGS}
+    ${GTEST_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+#    ${GMENUHARNESS_LDFLAGS}
+    ${GLIB_LDFLAGS}
+    gmenuharness-shared
+)
+
+add_test(
+    integration-tests
+    integration-tests
+)
+
+set(
+    SET-VOLUME-SRC
+    utils/dbus-pulse-volume.cpp
+    utils/set-volume.cpp
+)
+
+set(
+    GET-VOLUME-SRC
+    utils/dbus-pulse-volume.cpp
+    utils/get-volume.cpp
+)
+
+add_executable(
+    set-volume
+    ${SET-VOLUME-SRC}
+)
+
+add_executable(
+    get-volume
+    ${GET-VOLUME-SRC}
+)
+
+qt5_use_modules(
+    set-volume
+    Core
+    DBus
+    Test
+)
+
+qt5_use_modules(
+    get-volume
+    Core
+    DBus
+    Test
+)
+
+target_link_libraries(
+    get-volume
+    sound-indicator-dbus-interfaces
+)
+
+target_link_libraries(
+    set-volume
+    sound-indicator-dbus-interfaces
+)
+
+#add_subdirectory(utils)
\ No newline at end of file
diff --git a/tests/integration/Copy of test-sound.wav b/tests/integration/Copy of test-sound.wav
new file mode 100644
index 0000000..709c6eb
--- /dev/null
+++ b/tests/integration/Copy of test-sound.wav
diff --git a/tests/integration/indicator-sound-test-base.cpp b/tests/integration/indicator-sound-test-base.cpp
new file mode 100644
index 0000000..6e05efe
--- /dev/null
+++ b/tests/integration/indicator-sound-test-base.cpp
@@ -0,0 +1,263 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#include "indicator-sound-test-base.h"
+
+#include "dbus_menus_interface.h"
+#include "dbus_properties_interface.h"
+#include "dbus_accounts_interface.h"
+#include "dbus_accountssound_interface.h"
+#include "dbus-types.h"
+
+#include <gio/gio.h>
+
+#include <QSignalSpy>
+#include "utils/dbus-pulse-volume.h"
+
+using namespace QtDBusTest;
+using namespace QtDBusMock;
+using namespace std;
+using namespace testing;
+namespace mh = unity::gmenuharness;
+
+IndicatorSoundTestBase::IndicatorSoundTestBase() :
+    dbusMock(dbusTestRunner)
+{
+}
+
+IndicatorSoundTestBase::~IndicatorSoundTestBase()
+{
+
+}
+
+bool IndicatorSoundTestBase::setVolume(QString const &role, double volume)
+{
+    QProcess setVolume;
+    setVolume.start(VOLUME_SET_BIN, QStringList()
+                                        << role
+                                        << QString("%1").arg(volume));
+    if (!setVolume.waitForStarted())
+        return false;
+
+    if (!setVolume.waitForFinished())
+        return false;
+
+    return setVolume.exitCode() == 0;
+}
+
+bool IndicatorSoundTestBase::startTestSound(QString const &role)
+{
+    testSoundProcess.terminate();
+    testSoundProcess.start("paplay", QStringList()
+                                << "-s"
+                                << "127.0.0.1"
+                                << TEST_SOUND
+                                << QString("--property=media.role=%1").arg(role));
+
+    if (!testSoundProcess.waitForStarted())
+        return false;
+
+//    sleep(1);
+    return true;
+}
+
+void IndicatorSoundTestBase::stopTestSound()
+{
+    testSoundProcess.terminate();
+}
+
+void IndicatorSoundTestBase::startPulse()
+{
+    try
+    {
+        pulseaudio.reset(
+                new QProcessDBusService(DBusTypes::DBUS_PULSE,
+                                        QDBusConnection::SessionBus,
+                                        "pulseaudio",
+                                        QStringList() << "--start"
+                                                      << "-vvvv"
+                                                      << "--disable-shm=true"
+                                                      << "--daemonize=false"
+                                                      << "--use-pid-file=false"
+                                                      << "--system=false"
+                                                      << "--exit-idle-time=-1"
+                                                      << "-n"
+                                                      << "--load=module-null-sink"
+                                                      << "--log-target=file:/tmp/pulse-daemon.log"
+                                                      << QString("--load=module-stream-restore restore_device=false restore_muted=false fallback_table=%1").arg(STREAM_RESTORE_TABLE)
+                                                      << "--load=module-dbus-protocol"
+                                                      << "--load=module-native-protocol-tcp auth-ip-acl=127.0.0.1"
+                ));
+        pulseaudio->start(dbusTestRunner.sessionConnection());
+    }
+    catch (exception const& e)
+    {
+        cout << "pulseaudio(): " << e.what() << endl;
+        throw;
+    }
+}
+
+void IndicatorSoundTestBase::startIndicator()
+{
+    try
+    {
+        setenv("PULSE_SERVER", "127.0.0.1", true);
+        setenv("DBUS_SYSTEM_BUS_ADDRESS", dbusTestRunner.systemBus().toStdString().c_str(), true);
+        indicator.reset(
+                new QProcessDBusService(DBusTypes::DBUS_NAME,
+                                        QDBusConnection::SessionBus,
+                                        SOUND_SERVICE_BIN,
+                                        QStringList()));
+        indicator->start(dbusTestRunner.sessionConnection());
+    }
+    catch (exception const& e)
+    {
+        cout << "startIndicator(): " << e.what() << endl;
+        throw;
+    }
+}
+
+// /usr/bin/pulseaudio --start -vvvv --disable-shm=true --daemonize=false --use-pid-file=false --system=false --exit-idle-time=-1 -n  "--load=module-null-sink sink_name=multimedia" --load=module-stream-restore
+
+mh::MenuMatcher::Parameters IndicatorSoundTestBase::desktopParameters()
+{
+    return mh::MenuMatcher::Parameters(
+            "com.canonical.indicator.sound",
+            { { "indicator", "/com/canonical/indicator/sound" } },
+            "/com/canonical/indicator/sound/desktop");
+}
+
+void IndicatorSoundTestBase::SetUp()
+{
+    initializeAccountsInterface();
+}
+
+void IndicatorSoundTestBase::TearDown()
+{
+    unsetenv("PULSE_SERVER");
+}
+
+void gvariant_deleter(GVariant* varptr)
+{
+    if (varptr != nullptr)
+    {
+        g_variant_unref(varptr);
+    }
+}
+
+std::shared_ptr<GVariant> IndicatorSoundTestBase::volume_variant(double volume)
+{
+    GVariantBuilder builder;
+
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
+    g_variant_builder_add(&builder,
+                          "{sv}",
+                          "title",
+                          g_variant_new_string("_Sound"));
+
+    g_variant_builder_add(&builder,
+                          "{sv}",
+                          "accessible-desc",
+                          g_variant_new_string("_Sound"));
+
+    auto icon = g_themed_icon_new("icon");
+    g_variant_builder_add(&builder,
+                          "{sv}",
+                          "icon",
+                          g_icon_serialize(icon));
+
+    g_variant_builder_add(&builder,
+                          "{sv}",
+                          "visible",
+                          g_variant_new_boolean(true));
+    return shared_ptr<GVariant>(g_variant_builder_end(&builder), &gvariant_deleter);
+}
+
+unity::gmenuharness::MenuItemMatcher IndicatorSoundTestBase::volumeSlider(double volume)
+{
+    return mh::MenuItemMatcher().radio()
+            .label("Volume")
+            .round_doubles(0.1)
+            .pass_through_double_attribute("action", volume);
+}
+
+bool IndicatorSoundTestBase::waitMenuChange()
+{
+    if (!menu_interface_)
+    {
+        menu_interface_.reset(new MenusInterface("com.canonical.indicator.sound",
+                                                 "/com/canonical/indicator/sound/desktop",
+                                                QDBusConnection::sessionBus(), 0));
+    }
+    if (menu_interface_)
+    {
+        qDebug() << "Waiting for signal";
+        QSignalSpy spy(menu_interface_.get(), &MenusInterface::Changed);
+        qDebug() << "Signal count " << spy.count();
+        return spy.wait();
+    }
+    return false;
+}
+
+bool IndicatorSoundTestBase::waitVolumeChangedInIndicator()
+{
+    qDebug() << "IndicatorSoundTestBase::waitVolumeChangedInIndicator() signal " << (void *)signal_spy_volume_changed_.get();
+    if (signal_spy_volume_changed_)
+    {
+        return signal_spy_volume_changed_->wait();
+    }
+    return false;
+}
+
+void IndicatorSoundTestBase::initializeAccountsInterface()
+{
+    auto username = qgetenv("USER");
+    if (username != "")
+    {
+        qDebug() << "Setting Accounts interface for user: " << username;
+        std::unique_ptr<AccountsInterface> setInterface(new AccountsInterface("org.freedesktop.Accounts",
+                                                        "/org/freedesktop/Accounts",
+                                                        QDBusConnection::systemBus(), 0));
+        qDebug() << "Interface: " << setInterface.get();
+
+        QDBusReply<QDBusObjectPath> userResp = setInterface->call(QLatin1String("FindUserByName"),
+                                                                  QLatin1String(username));
+
+        if (!userResp.isValid())
+        {
+            qWarning() << "SetVolume::initializeAccountsInterface(): D-Bus error: " << userResp.error().message();
+        }
+        auto userPath = userResp.value().path();
+        if (userPath != "")
+        {
+            std::unique_ptr<AccountsSoundInterface> soundInterface(new AccountsSoundInterface("org.freedesktop.Accounts",
+                                                                    userPath,
+                                                                    QDBusConnection::systemBus(), 0));
+
+            accounts_interface_.reset(new DBusPropertiesInterface("org.freedesktop.Accounts",
+                                                                userPath,
+                                                                soundInterface->connection(), 0));
+            qDebug() << "Interface for setting volume: " << accounts_interface_.get();
+            if (!accounts_interface_->isValid())
+            {
+                qWarning() << "SetVolume::initializeAccountsInterface(): D-Bus error: " << accounts_interface_->lastError().message();
+            }
+            signal_spy_volume_changed_.reset(new QSignalSpy(accounts_interface_.get(),&DBusPropertiesInterface::PropertiesChanged));
+        }
+    }
+}
diff --git a/tests/integration/indicator-sound-test-base.h b/tests/integration/indicator-sound-test-base.h
new file mode 100644
index 0000000..81d8204
--- /dev/null
+++ b/tests/integration/indicator-sound-test-base.h
@@ -0,0 +1,83 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#pragma once
+
+#include <libqtdbustest/DBusTestRunner.h>
+#include <libqtdbustest/QProcessDBusService.h>
+#include <libqtdbusmock/DBusMock.h>
+
+#include <unity/gmenuharness/MatchUtils.h>
+#include <unity/gmenuharness/MenuMatcher.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+class MenusInterface;
+class DBusPulseVolume;
+class DBusPropertiesInterface;
+class QSignalSpy;
+
+class IndicatorSoundTestBase: public testing::Test
+{
+public:
+    IndicatorSoundTestBase();
+
+    ~IndicatorSoundTestBase();
+
+protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    void startIndicator();
+    void startPulse();
+
+    bool setVolume(QString const &role, double volume);
+
+    bool startTestSound(QString const &role);
+
+    void stopTestSound();
+
+    static std::shared_ptr<GVariant> volume_variant(double volume);
+
+    static unity::gmenuharness::MenuMatcher::Parameters desktopParameters();
+
+    static unity::gmenuharness::MenuItemMatcher volumeSlider(double volume);
+
+    bool waitMenuChange();
+
+    bool waitVolumeChangedInIndicator();
+
+    void initializeAccountsInterface();
+
+    QtDBusTest::DBusTestRunner dbusTestRunner;
+
+    QtDBusMock::DBusMock dbusMock;
+
+    QtDBusTest::DBusServicePtr indicator;
+
+    QtDBusTest::DBusServicePtr pulseaudio;
+
+    QProcess testSoundProcess;
+
+    std::unique_ptr<MenusInterface> menu_interface_;
+
+    std::unique_ptr<DBusPropertiesInterface> accounts_interface_;
+
+    std::unique_ptr<QSignalSpy> signal_spy_volume_changed_;
+};
diff --git a/tests/integration/main.cpp b/tests/integration/main.cpp
new file mode 100644
index 0000000..a29b3b6
--- /dev/null
+++ b/tests/integration/main.cpp
@@ -0,0 +1,58 @@
+/*
+ * 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/>.
+ *
+ * Authors:
+ *     Pete Woods <pete.woods@canonical.com>
+ */
+
+//#include <config.h>
+
+#include <QCoreApplication>
+#include <QTimer>
+#include <gtest/gtest.h>
+
+#include <libqtdbusmock/DBusMock.h>
+
+#include "dbus-types.h"
+
+using namespace QtDBusMock;
+
+class Runner: public QObject
+{
+    Q_OBJECT
+public Q_SLOTS:
+    void run()
+    {
+        QCoreApplication::exit(RUN_ALL_TESTS());
+    }
+};
+
+int main(int argc, char **argv)
+{
+    qputenv("LANG", "C.UTF-8");
+    unsetenv("LC_ALL");
+
+    QCoreApplication application(argc, argv);
+    DBusMock::registerMetaTypes();
+    DBusTypes::registerMetaTypes();
+    ::testing::InitGoogleTest(&argc, argv);
+
+    Runner runner;
+    QTimer::singleShot(0, &runner, SLOT(run()));
+
+    return application.exec();
+}
+
+#include "main.moc"
diff --git a/tests/integration/test-indicator.cpp b/tests/integration/test-indicator.cpp
new file mode 100644
index 0000000..8803f91
--- /dev/null
+++ b/tests/integration/test-indicator.cpp
@@ -0,0 +1,182 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#include <indicator-sound-test-base.h>
+
+#include <QDebug>
+#include <QTestEventLoop>
+#include <QSignalSpy>
+
+using namespace std;
+using namespace testing;
+namespace mh = unity::gmenuharness;
+namespace
+{
+
+class TestIndicator: public IndicatorSoundTestBase
+{
+};
+
+TEST_F(TestIndicator, ChangeRoleVolume)
+{
+    double INITIAL_VOLUME = 0.0;
+
+    ASSERT_NO_THROW(startPulse());
+
+    // initialize volumes in pulseaudio
+    EXPECT_TRUE(setVolume("mutimedia", INITIAL_VOLUME));
+    EXPECT_TRUE(setVolume("alert", INITIAL_VOLUME));
+
+    // start now the indicator, so it picks the new volumes
+    ASSERT_NO_THROW(startIndicator());
+
+    // Generate a random volume
+    QTime now = QTime::currentTime();
+    qsrand(now.msec());
+    int randInt = qrand() % 100;
+    double randomVolume = randInt / 100.0;
+
+    // set an initial volume to the alert role
+    setVolume("alert", 1.0);
+    EXPECT_TRUE(waitVolumeChangedInIndicator());
+
+    // play a test sound, it should change the role in the indicator
+    EXPECT_TRUE(startTestSound("multimedia"));
+    EXPECT_TRUE(waitVolumeChangedInIndicator());
+
+    // set the random volume to the multimedia role
+    EXPECT_TRUE(setVolume("multimedia", randomVolume));
+    if (randomVolume != INITIAL_VOLUME)
+    {
+        EXPECT_TRUE(waitVolumeChangedInIndicator());
+    }
+
+    // check the indicator
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::starts_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .section()
+                .item(mh::MenuItemMatcher().checkbox()
+                    .label("Mute")
+                )
+                .item(volumeSlider(randomVolume))
+            )
+        ).match());
+
+    // check that the last item is Sound Settings
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::ends_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .label("Sound Settings…")
+            )
+        ).match());
+
+    // stop the test sound, the role should change again to alert
+    stopTestSound();
+    if (randomVolume != 1.0)
+    {
+        // we only wait if the volume in the alert and the
+        // one set in the multimedia roles differ
+        EXPECT_TRUE(waitVolumeChangedInIndicator());
+    }
+
+    // check the initial volume for the alert role
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::starts_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .section()
+                .item(mh::MenuItemMatcher().checkbox()
+                    .label("Mute")
+                )
+                .item(volumeSlider(1.0))
+            )
+        ).match());
+
+    // check that the last item is Sound Settings
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::ends_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .label("Sound Settings…")
+            )
+        ).match());
+}
+
+TEST_F(TestIndicator, BasicInitialVolume)
+{
+    double INITIAL_VOLUME = 0.0;
+
+    ASSERT_NO_THROW(startPulse());
+
+    // initialize volumes in pulseaudio
+    EXPECT_TRUE(setVolume("alert", INITIAL_VOLUME));
+
+    // start now the indicator, so it picks the new volumes
+    ASSERT_NO_THROW(startIndicator());
+
+    // check the initial volume for the alert role
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::starts_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .section()
+                .item(mh::MenuItemMatcher().checkbox()
+                    .label("Mute")
+                )
+                .item(volumeSlider(INITIAL_VOLUME))
+            )
+        ).match());
+
+    // check that the last item is Sound Settings
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::ends_with)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .label("Sound Settings…")
+            )
+        ).match());
+}
+
+} // namespace
diff --git a/tests/integration/test-sound.wav b/tests/integration/test-sound.wav
new file mode 100644
index 0000000..f696657
--- /dev/null
+++ b/tests/integration/test-sound.wav
diff --git a/tests/integration/touch-stream-restore.table b/tests/integration/touch-stream-restore.table
new file mode 100755
index 0000000..146b02e
--- /dev/null
+++ b/tests/integration/touch-stream-restore.table
@@ -0,0 +1,4 @@
+sink-input-by-media-role:multimedia -8
+sink-input-by-media-role:alert -8
+sink-input-by-media-role:alarm -8
+sink-input-by-media-role:phone -15
diff --git a/tests/integration/utils/dbus-pulse-volume.cpp b/tests/integration/utils/dbus-pulse-volume.cpp
new file mode 100644
index 0000000..6989754
--- /dev/null
+++ b/tests/integration/utils/dbus-pulse-volume.cpp
@@ -0,0 +1,252 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#include "dbus_properties_interface.h"
+#include "dbus_accounts_interface.h"
+#include "dbus_accountssound_interface.h"
+#include "stream_restore_interface.h"
+
+#include <pulse/volume.h>
+#include "dbus-pulse-volume.h"
+
+#include <QSignalSpy>
+
+unsigned int volumeDoubleToUint(double volume)
+{
+    double tmp = (double)(PA_VOLUME_NORM - PA_VOLUME_MUTED) * volume;
+    return (unsigned int)tmp + PA_VOLUME_MUTED;
+}
+
+double volumeUIntToDoulbe(uint volume)
+{
+    double tmp = (double)(volume - PA_VOLUME_MUTED);
+    return tmp / (double)(PA_VOLUME_NORM - PA_VOLUME_MUTED);
+}
+
+DBusPulseVolume::DBusPulseVolume() :
+    QObject()
+{
+    std::unique_ptr<DBusPropertiesInterface> basicConnectionInterface(new DBusPropertiesInterface("org.PulseAudio1",
+                                                            "/org/pulseaudio/server_lookup1",
+                                                            QDBusConnection::sessionBus(), 0));
+
+    QDBusReply<QVariant> connection_string = basicConnectionInterface->call(QLatin1String("Get"),
+                    QLatin1String("org.PulseAudio.ServerLookup1"),
+                    QLatin1String("Address"));
+
+    if (!connection_string.isValid())
+    {
+        qWarning() << "DBusPulseVolume::DBusPulseVolume(): D-Bus error: " << connection_string.error().message();
+    }
+
+    qDebug() << "********************************Connetion: " << connection_string.value().toString();
+
+//    connection_.reset(new QDBusConnection(QDBusConnection::connectToPeer(connection_string.value().toString(), "set-volume")));
+
+    connection_.reset(new QDBusConnection(QDBusConnection::connectToPeer("unix:path=/run/user/1000/pulse/dbus-socket", "set-volume")));
+    qDebug() << "Is connected " << connection_->isConnected();
+
+    if (connection_->isConnected())
+    {
+        interface_paths_.reset(new StreamRestoreInterface("org.PulseAudio.Ext.StreamRestore1",
+                                                    "/org/pulseaudio/stream_restore1",
+                                                    *(connection_.get()), 0));
+        qDebug() << "Interface " << (void *)interface_paths_.get();
+
+        if (interface_paths_)
+        {
+            // get the role paths
+            fillRolePath("multimedia");
+            fillRolePath("alert");
+            fillRolePath("alarm");
+            fillRolePath("phone");
+        }
+
+        initializeAccountsInterface();
+    }
+    else
+    {
+        qWarning() << "DBusPulseVolume::DBusPulseVolume(): Error connecting: " << connection_->lastError().message();
+    }
+}
+
+DBusPulseVolume::~DBusPulseVolume()
+{
+    connection_->disconnectFromPeer("unix:path=/run/user/1000/pulse/dbus-socket");
+}
+
+QString DBusPulseVolume::fillRolePath(QString const &role)
+{
+    QString role_complete_name = QString("sink-input-by-media-role:") + role;
+    // get the role paths
+    QDBusReply<QDBusObjectPath> objectPath = interface_paths_->call(QLatin1String("GetEntryByName"), role_complete_name);
+    if (!objectPath.isValid())
+    {
+        qWarning() << "SetVolume::fillRolePath(): D-Bus error: " << objectPath.error().message();
+        return "";
+    }
+    qDebug() << "XGM: path for role " << role << "=" << objectPath.value().path();
+    auto role_info = std::make_shared<RoleInformation>();
+    role_info->interface_.reset(new DBusPropertiesInterface("org.PulseAudio.Ext.StreamRestore1.RestoreEntry",
+                                                objectPath.value().path(),
+                                                *(connection_.get()), 0));
+    if (!role_info->interface_)
+    {
+        qWarning() << "SetVolume::fillRolePath() - Error obtaining properties interface";
+        return "";
+    }
+    role_info->path_ = objectPath.value().path();
+    roles_map_[role] = role_info;
+    return role_info->path_;
+}
+
+bool DBusPulseVolume::setVolume(QString const & role, double volume)
+{
+    if (!interface_paths_)
+    {
+        qWarning() << "SetVolume::setVolume(): error: Volume interfaces are not initialized";
+        return false;
+    }
+    RolesMap::const_iterator iter = roles_map_.find(role);
+    if (iter != roles_map_.end())
+    {
+        QDBusReply<QVariant> prev_vol = (*iter).second->interface_->call(QLatin1String("Get"),
+                QLatin1String("org.PulseAudio.Ext.StreamRestore1.RestoreEntry"),
+                QLatin1String("Volume"));
+
+        if (!prev_vol.isValid())
+        {
+            qWarning() << "SetVolume::setVolume(): D-Bus error: " << prev_vol.error().message();
+            return false;
+        }
+        QDBusArgument arg = prev_vol.value().value<QDBusArgument>();
+        PulseaudioVolumeArray element;
+        arg >> element;
+
+        PulseaudioVolume signal_vol(0, 4000);
+        PulseaudioVolumeArray vol_array;
+        vol_array.addItem(signal_vol);
+
+        QVariant var;
+        PulseaudioVolumeArray t;
+        PulseaudioVolume vv(0, volumeDoubleToUint(volume));
+        t.addItem(vv);
+        var.setValue(t);
+        QDBusVariant dbusVar(var);
+        QDBusReply<void> set_vol = (*iter).second->interface_->call(QLatin1String("Set"),
+                            QVariant::fromValue(QString("org.PulseAudio.Ext.StreamRestore1.RestoreEntry")),
+                            QVariant::fromValue(QString("Volume")),
+                            QVariant::fromValue(dbusVar));
+
+        if (!set_vol.isValid())
+        {
+            qWarning() << "SetVolume::setVolume(): D-Bus error: " << set_vol.error().message();
+            return false;
+        }
+
+        if (accounts_interface_)
+        {
+            QDBusVariant dbusVar(QVariant::fromValue(volume));
+            QDBusReply<void> set_vol = accounts_interface_->call(QLatin1String("Set"),
+                                            QVariant::fromValue(QString("com.ubuntu.AccountsService.Sound")),
+                                            QVariant::fromValue(QString("Volume")),
+                                            QVariant::fromValue(dbusVar));
+            if (!set_vol.isValid())
+            {
+                qWarning() << "SetVolume::setVolume(): D-Bus error: " << set_vol.error().message();
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+double DBusPulseVolume::getVolume(QString const & role)
+{
+    if (interface_paths_)
+    {
+        RolesMap::const_iterator iter = roles_map_.find(role);
+        if (iter != roles_map_.end())
+        {
+            QDBusReply<QVariant> prev_vol = (*iter).second->interface_->call(QLatin1String("Get"),
+                                QLatin1String("org.PulseAudio.Ext.StreamRestore1.RestoreEntry"),
+                                QLatin1String("Volume"));
+
+            if (!prev_vol.isValid())
+            {
+                qWarning() << "SetVolume::setVolume(): D-Bus error: " << prev_vol.error().message();
+            }
+            QDBusArgument arg = prev_vol.value().value<QDBusArgument>();
+            PulseaudioVolumeArray element;
+            arg >> element;
+            return volumeUIntToDoulbe(element.getItem(0).getVolume());
+        }
+    }
+    return -1.0;
+}
+
+void DBusPulseVolume::initializeAccountsInterface()
+{
+    auto username = qgetenv("USER");
+    if (username != "")
+    {
+        qDebug() << "Setting Accounts interface for user: " << username;
+        std::unique_ptr<AccountsInterface> setInterface(new AccountsInterface("org.freedesktop.Accounts",
+                                                        "/org/freedesktop/Accounts",
+                                                        QDBusConnection::systemBus(), 0));
+        qDebug() << "Interface: " << setInterface.get();
+
+        QDBusReply<QDBusObjectPath> userResp = setInterface->call(QLatin1String("FindUserByName"),
+                                                                  QLatin1String(username));
+
+        if (!userResp.isValid())
+        {
+            qWarning() << "SetVolume::initializeAccountsInterface(): D-Bus error: " << userResp.error().message();
+        }
+        auto userPath = userResp.value().path();
+        if (userPath != "")
+        {
+            std::unique_ptr<AccountsSoundInterface> soundInterface(new AccountsSoundInterface("org.freedesktop.Accounts",
+                                                                    userPath,
+                                                                    QDBusConnection::systemBus(), 0));
+
+            accounts_interface_.reset(new DBusPropertiesInterface("org.freedesktop.Accounts",
+                                                                userPath,
+                                                                soundInterface->connection(), 0));
+            qDebug() << "Interface for setting volume: " << accounts_interface_.get();
+            if (!accounts_interface_->isValid())
+            {
+                qWarning() << "SetVolume::initializeAccountsInterface(): D-Bus error: " << accounts_interface_->lastError().message();
+            }
+            signal_spy_volume_changed_.reset(new QSignalSpy(accounts_interface_.get(),&DBusPropertiesInterface::PropertiesChanged));
+        }
+    }
+}
+
+bool DBusPulseVolume::waitForVolumeChangedInAccountsService()
+{
+    if (signal_spy_volume_changed_)
+    {
+        return signal_spy_volume_changed_->wait();
+    }
+    else
+    {
+        qWarning() << "DBusPulseVolume::waitForVolumeChangedInAccountsService(): signal was not instantiated";
+    }
+    return false;
+}
diff --git a/tests/integration/utils/dbus-pulse-volume.h b/tests/integration/utils/dbus-pulse-volume.h
new file mode 100644
index 0000000..2d55e89
--- /dev/null
+++ b/tests/integration/utils/dbus-pulse-volume.h
@@ -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/>.
+ *
+ * Author: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+#pragma once
+
+#include <QObject>
+#include <QDBusConnection>
+
+#include <map>
+#include <memory>
+
+class StreamRestoreInterface;
+class DBusPropertiesInterface;
+class AccountsInterface;
+class AccountsSoundInterface;
+class QSignalSpy;
+
+struct RoleInformation
+{
+    std::unique_ptr<DBusPropertiesInterface> interface_;
+    QString path_;
+};
+
+class DBusPulseVolume : public QObject
+{
+public:
+    DBusPulseVolume();
+    ~DBusPulseVolume();
+
+    bool setVolume(QString const & role, double volume);
+    double getVolume(QString const & role);
+    bool waitForVolumeChangedInAccountsService();
+
+protected:
+    QString fillRolePath(QString const &role);
+    void initializeAccountsInterface();
+    std::unique_ptr<QDBusConnection> connection_;
+    std::unique_ptr<StreamRestoreInterface> interface_paths_;
+    typedef std::map<QString, std::shared_ptr<RoleInformation>> RolesMap;
+    RolesMap roles_map_;
+    std::unique_ptr<DBusPropertiesInterface> accounts_interface_;
+    std::unique_ptr<QSignalSpy> signal_spy_volume_changed_;
+};
diff --git a/tests/integration/utils/get-volume.cpp b/tests/integration/utils/get-volume.cpp
new file mode 100644
index 0000000..309da36
--- /dev/null
+++ b/tests/integration/utils/get-volume.cpp
@@ -0,0 +1,33 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#include "dbus-types.h"
+
+#include <string>
+#include "dbus-pulse-volume.h"
+
+int main(int argc, char **argv)
+{
+    DBusTypes::registerMetaTypes();
+    if (argc == 2)
+    {
+        DBusPulseVolume volume;
+        volume.getVolume(argv[1]);
+    }
+    return 0;
+}
diff --git a/tests/integration/utils/set-volume.cpp b/tests/integration/utils/set-volume.cpp
new file mode 100644
index 0000000..d29e5ef
--- /dev/null
+++ b/tests/integration/utils/set-volume.cpp
@@ -0,0 +1,36 @@
+/*
+ * 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: Xavi Garcia <xavi.garcia.mena@canonical.com>
+ */
+
+#include "dbus-types.h"
+
+#include <string>
+#include "dbus-pulse-volume.h"
+
+int main(int argc, char **argv)
+{
+    DBusTypes::registerMetaTypes();
+    if (argc == 3)
+    {
+        DBusPulseVolume volume;
+        if(!volume.setVolume(argv[1], std::stod(argv[2])))
+        {
+            return 1;
+        }
+    }
+    return 0;
+}