aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/CMakeLists.txt26
-rw-r--r--tests/gtest-gvariant.h110
-rw-r--r--tests/indicator-test.cc6
-rw-r--r--tests/media-player-list-mock.vala25
-rw-r--r--tests/notifications-mock.h155
-rw-r--r--tests/notifications-test.cc349
-rw-r--r--tests/volume-control-mock.vala47
-rw-r--r--tests/volume-control-test.cc4
8 files changed, 720 insertions, 2 deletions
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 38a76ae..6e30bf5 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -65,6 +65,14 @@ vala_add(vala-mocks
media-player-mock.vala
)
+vala_add(vala-mocks
+ media-player-list-mock.vala
+)
+
+vala_add(vala-mocks
+ volume-control-mock.vala
+)
+
vala_finish(vala-mocks
SOURCES
vala_mocks_VALA_SOURCES
@@ -184,6 +192,24 @@ target_link_libraries (
add_test(sound-menu-test sound-menu-test)
###########################
+# Notification 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}
+)
+
+add_test(notifications-test notifications-test)
+
+###########################
# Accounts Service User
###########################
diff --git a/tests/gtest-gvariant.h b/tests/gtest-gvariant.h
new file mode 100644
index 0000000..38fde0f
--- /dev/null
+++ b/tests/gtest-gvariant.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright © 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Ted Gould <ted@canonical.com>
+ */
+
+#include <gtest/gtest.h>
+#include <gio/gio.h>
+
+namespace GTestGVariant {
+
+testing::AssertionResult expectVariantEqual (const gchar * expectStr, const gchar * haveStr, GVariant * expect, GVariant * have)
+{
+ if (expect == nullptr && have == nullptr) {
+ auto result = testing::AssertionSuccess();
+ return result;
+ }
+
+ if (expect == nullptr || have == nullptr) {
+ gchar * havePrint;
+ if (have == nullptr) {
+ havePrint = g_strdup("(nullptr)");
+ } else {
+ havePrint = g_variant_print(have, TRUE);
+ }
+
+ auto result = testing::AssertionFailure();
+ result <<
+ " Result: " << haveStr << std::endl <<
+ " Value: " << havePrint << std::endl <<
+ " Expected: " << expectStr << std::endl;
+
+ g_free(havePrint);
+ return result;
+ }
+
+ if (g_variant_equal(expect, have)) {
+ auto result = testing::AssertionSuccess();
+ return result;
+ } else {
+ gchar * havePrint = g_variant_print(have, TRUE);
+ gchar * expectPrint = g_variant_print(expect, TRUE);
+
+ auto result = testing::AssertionFailure();
+ result <<
+ " Result: " << haveStr << std::endl <<
+ " Value: " << havePrint << std::endl <<
+ " Expected: " << expectStr << std::endl <<
+ " Expected: " << expectPrint << std::endl;
+
+ g_free(havePrint);
+ g_free(expectPrint);
+
+ return result;
+ }
+}
+
+testing::AssertionResult expectVariantEqual (const gchar * expectStr, const gchar * haveStr, std::shared_ptr<GVariant> expect, std::shared_ptr<GVariant> have)
+{
+ return expectVariantEqual(expectStr, haveStr, expect.get(), have.get());
+}
+
+testing::AssertionResult expectVariantEqual (const gchar * expectStr, const gchar * haveStr, const char * expect, std::shared_ptr<GVariant> have)
+{
+ auto expectv = std::shared_ptr<GVariant>([expect] {
+ auto variant = g_variant_parse(nullptr, expect, nullptr, nullptr, nullptr);
+ if (variant != nullptr)
+ g_variant_ref_sink(variant);
+ return variant;
+ }(),
+ [](GVariant * variant) {
+ if (variant != nullptr)
+ g_variant_unref(variant);
+ });
+
+ return expectVariantEqual(expectStr, haveStr, expectv, have);
+}
+
+testing::AssertionResult expectVariantEqual (const gchar * expectStr, const gchar * haveStr, const char * expect, GVariant * have)
+{
+ auto havep = std::shared_ptr<GVariant>([have] {
+ if (have != nullptr)
+ g_variant_ref_sink(have);
+ return have;
+ }(),
+ [](GVariant * variant) {
+ if (variant != nullptr)
+ g_variant_unref(variant);
+ });
+
+ return expectVariantEqual(expectStr, haveStr, expect, havep);
+}
+
+}; // ns GTestGVariant
+
+#define EXPECT_GVARIANT_EQ(expect, have) \
+ EXPECT_PRED_FORMAT2(GTestGVariant::expectVariantEqual, expect, have)
diff --git a/tests/indicator-test.cc b/tests/indicator-test.cc
index f7d0b2b..b41a1ab 100644
--- a/tests/indicator-test.cc
+++ b/tests/indicator-test.cc
@@ -22,6 +22,7 @@
#include "indicator-fixture.h"
#include "accounts-service-mock.h"
+#include "notifications-mock.h"
class IndicatorTest : public IndicatorFixture
{
@@ -32,6 +33,7 @@ protected:
}
std::shared_ptr<AccountsServiceMock> as;
+ std::shared_ptr<NotificationsMock> notification;
virtual void SetUp() override
{
@@ -45,12 +47,16 @@ protected:
as = std::make_shared<AccountsServiceMock>();
addMock(*as);
+ notification = std::make_shared<NotificationsMock>();
+ addMock(*notification);
+
IndicatorFixture::SetUp();
}
virtual void TearDown() override
{
as.reset();
+ notification.reset();
IndicatorFixture::TearDown();
}
diff --git a/tests/media-player-list-mock.vala b/tests/media-player-list-mock.vala
new file mode 100644
index 0000000..44a6ae6
--- /dev/null
+++ b/tests/media-player-list-mock.vala
@@ -0,0 +1,25 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Ted Gould <ted@canonical.com>
+ */
+
+public class MediaPlayerListMock : MediaPlayerList {
+ public override MediaPlayerList.Iterator iterator () { return new MediaPlayerList.Iterator(); }
+
+ public override void sync (string[] ids) { return; }
+}
+
diff --git a/tests/notifications-mock.h b/tests/notifications-mock.h
new file mode 100644
index 0000000..b0f3b74
--- /dev/null
+++ b/tests/notifications-mock.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright © 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Ted Gould <ted@canonical.com>
+ */
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <type_traits>
+
+#include <libdbustest/dbus-test.h>
+
+class NotificationsMock
+{
+ DbusTestDbusMock * mock = nullptr;
+ DbusTestDbusMockObject * baseobj = nullptr;
+
+ public:
+ NotificationsMock (std::vector<std::string> capabilities = {"body", "body-markup", "icon-static", "image/svg+xml", "x-canonical-private-synchronous", "x-canonical-append", "x-canonical-private-icon-only", "x-canonical-truncation", "private-synchronous", "append", "private-icon-only", "truncation"}) {
+ mock = dbus_test_dbus_mock_new("org.freedesktop.Notifications");
+ dbus_test_task_set_bus(DBUS_TEST_TASK(mock), DBUS_TEST_SERVICE_BUS_SESSION);
+ dbus_test_task_set_name(DBUS_TEST_TASK(mock), "Notify");
+
+ baseobj =dbus_test_dbus_mock_get_object(mock, "/org/freedesktop/Notifications", "org.freedesktop.Notifications", nullptr);
+
+ std::string capspython("ret = ");
+ capspython += vector2py(capabilities);
+ dbus_test_dbus_mock_object_add_method(mock, baseobj,
+ "GetCapabilities", nullptr, G_VARIANT_TYPE("as"),
+ capspython.c_str(), nullptr);
+
+ dbus_test_dbus_mock_object_add_method(mock, baseobj,
+ "GetServerInformation", nullptr, G_VARIANT_TYPE("(ssss)"),
+ "ret = ['notification-mock', 'Testing harness', '1.0', '1.1']", nullptr);
+
+ dbus_test_dbus_mock_object_add_method(mock, baseobj,
+ "Notify", G_VARIANT_TYPE("(susssasa{sv}i)"), G_VARIANT_TYPE("u"),
+ "ret = 10", nullptr);
+
+ dbus_test_dbus_mock_object_add_method(mock, baseobj,
+ "CloseNotification", G_VARIANT_TYPE("u"), nullptr,
+ "", nullptr);
+ }
+
+ ~NotificationsMock () {
+ g_debug("Destroying the Notifications Mock");
+ g_clear_object(&mock);
+ }
+
+ std::string vector2py (std::vector<std::string> vect) {
+ std::string retval("[ ");
+
+ std::for_each(vect.begin(), vect.end() - 1, [&retval](std::string entry) {
+ retval += "'";
+ retval += entry;
+ retval += "', ";
+ });
+
+ retval += "'";
+ retval += *(vect.end() - 1);
+ retval += "']";
+
+ return retval;
+ }
+
+ operator std::shared_ptr<DbusTestTask> () {
+ std::shared_ptr<DbusTestTask> retval(DBUS_TEST_TASK(g_object_ref(mock)), [](DbusTestTask * task) { g_clear_object(&task); });
+ return retval;
+ }
+
+ operator DbusTestTask* () {
+ return DBUS_TEST_TASK(mock);
+ }
+
+ operator DbusTestDbusMock* () {
+ return mock;
+ }
+
+ struct Notification {
+ std::string app_name;
+ unsigned int replace_id;
+ std::string app_icon;
+ std::string summary;
+ std::string body;
+ std::vector<std::string> actions;
+ std::map<std::string, std::shared_ptr<GVariant>> hints;
+ int timeout;
+ };
+
+ std::shared_ptr<GVariant> childGet (GVariant * tuple, gsize index) {
+ return std::shared_ptr<GVariant>(g_variant_get_child_value(tuple, index),
+ [](GVariant * v){ if (v != nullptr) g_variant_unref(v); });
+ }
+
+ std::vector<Notification> getNotifications (void) {
+ std::vector<Notification> notifications;
+
+ unsigned int cnt, i;
+ auto calls = dbus_test_dbus_mock_object_get_method_calls(mock, baseobj, "Notify", &cnt, nullptr);
+
+ for (i = 0; i < cnt; i++) {
+ auto call = calls[i];
+ Notification notification;
+
+ notification.app_name = g_variant_get_string(childGet(call.params, 0).get(), nullptr);
+ notification.replace_id = g_variant_get_uint32(childGet(call.params, 1).get());
+ notification.app_icon = g_variant_get_string(childGet(call.params, 2).get(), nullptr);
+ notification.summary = g_variant_get_string(childGet(call.params, 3).get(), nullptr);
+ notification.body = g_variant_get_string(childGet(call.params, 4).get(), nullptr);
+ notification.timeout = g_variant_get_int32(childGet(call.params, 7).get());
+
+ auto vactions = childGet(call.params, 5);
+ GVariantIter iactions = {0};
+ g_variant_iter_init(&iactions, vactions.get());
+ const gchar * action = nullptr;
+ while (g_variant_iter_loop(&iactions, "&s", &action)) {
+ std::string saction(action);
+ notification.actions.push_back(saction);
+ }
+
+ auto vhints = childGet(call.params, 6);
+ GVariantIter ihints = {0};
+ g_variant_iter_init(&ihints, vhints.get());
+ const gchar * hint_key = nullptr;
+ GVariant * hint_value = nullptr;
+ while (g_variant_iter_loop(&ihints, "{&sv}", &hint_key, &hint_value)) {
+ std::string key(hint_key);
+ std::shared_ptr<GVariant> value(g_variant_ref(hint_value), [](GVariant * v){ if (v != nullptr) g_variant_unref(v); });
+ notification.hints[key] = value;
+ }
+
+ notifications.push_back(notification);
+ }
+
+ return notifications;
+ }
+
+ bool clearNotifications (void) {
+ return dbus_test_dbus_mock_object_clear_method_calls(mock, baseobj, nullptr);
+ }
+};
diff --git a/tests/notifications-test.cc b/tests/notifications-test.cc
new file mode 100644
index 0000000..79b6e8e
--- /dev/null
+++ b/tests/notifications-test.cc
@@ -0,0 +1,349 @@
+/*
+ * Copyright © 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Ted Gould <ted@canonical.com>
+ */
+
+#include <memory>
+
+#include <gtest/gtest.h>
+#include <gio/gio.h>
+#include <libdbustest/dbus-test.h>
+#include <libnotify/notify.h>
+
+#include "notifications-mock.h"
+#include "gtest-gvariant.h"
+
+extern "C" {
+#include "indicator-sound-service.h"
+#include "vala-mocks.h"
+}
+
+class NotificationsTest : public ::testing::Test
+{
+ protected:
+ DbusTestService * service = NULL;
+
+ GDBusConnection * session = NULL;
+ std::shared_ptr<NotificationsMock> notifications;
+
+ virtual void SetUp() {
+ g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
+ g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
+
+ service = dbus_test_service_new(NULL);
+ dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SESSION);
+
+ /* Useful for debugging test failures, not needed all the time (until it fails) */
+ #if 0
+ auto bustle = std::shared_ptr<DbusTestTask>([]() {
+ DbusTestTask * bustle = DBUS_TEST_TASK(dbus_test_bustle_new("notifications-test.bustle"));
+ dbus_test_task_set_name(bustle, "Bustle");
+ dbus_test_task_set_bus(bustle, DBUS_TEST_SERVICE_BUS_SESSION);
+ return bustle;
+ }(), [](DbusTestTask * bustle) {
+ g_clear_object(&bustle);
+ });
+ dbus_test_service_add_task(service, bustle.get());
+ #endif
+
+ notifications = std::make_shared<NotificationsMock>();
+
+ dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+ dbus_test_service_start_tasks(service);
+
+ session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+ ASSERT_NE(nullptr, session);
+ g_dbus_connection_set_exit_on_close(session, FALSE);
+ g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
+
+ /* This is done in main.c */
+ notify_init("indicator-sound");
+ }
+
+ virtual void TearDown() {
+ if (notify_is_initted())
+ notify_uninit();
+
+ notifications.reset();
+ g_clear_object(&service);
+
+ g_object_unref(session);
+
+ unsigned int cleartry = 0;
+ while (session != NULL && cleartry < 100) {
+ loop(100);
+ cleartry++;
+ }
+
+ ASSERT_EQ(nullptr, session);
+ }
+
+ static gboolean timeout_cb (gpointer user_data) {
+ GMainLoop * loop = static_cast<GMainLoop *>(user_data);
+ g_main_loop_quit(loop);
+ return G_SOURCE_REMOVE;
+ }
+
+ void loop (unsigned int ms) {
+ GMainLoop * loop = g_main_loop_new(NULL, FALSE);
+ g_timeout_add(ms, timeout_cb, loop);
+ g_main_loop_run(loop);
+ g_main_loop_unref(loop);
+ }
+
+ static int unref_idle (gpointer user_data) {
+ g_variant_unref(static_cast<GVariant *>(user_data));
+ return G_SOURCE_REMOVE;
+ }
+
+ std::shared_ptr<MediaPlayerList> playerListMock () {
+ auto playerList = std::shared_ptr<MediaPlayerList>(
+ MEDIA_PLAYER_LIST(media_player_list_mock_new()),
+ [](MediaPlayerList * list) {
+ g_clear_object(&list);
+ });
+ return playerList;
+ }
+
+ std::shared_ptr<VolumeControl> volumeControlMock () {
+ auto volumeControl = std::shared_ptr<VolumeControl>(
+ VOLUME_CONTROL(volume_control_mock_new()),
+ [](VolumeControl * control){
+ g_clear_object(&control);
+ });
+ return volumeControl;
+ }
+
+ std::shared_ptr<IndicatorSoundService> standardService (std::shared_ptr<VolumeControl> volumeControl, std::shared_ptr<MediaPlayerList> playerList) {
+ auto soundService = std::shared_ptr<IndicatorSoundService>(
+ indicator_sound_service_new(playerList.get(), volumeControl.get(), nullptr),
+ [](IndicatorSoundService * service){
+ g_clear_object(&service);
+ });
+
+ return soundService;
+ }
+};
+
+TEST_F(NotificationsTest, BasicObject) {
+ auto soundService = standardService(volumeControlMock(), playerListMock());
+
+ /* Give some time settle */
+ loop(50);
+
+ /* Auto free */
+}
+
+TEST_F(NotificationsTest, VolumeChanges) {
+ auto volumeControl = volumeControlMock();
+ auto soundService = standardService(volumeControl, playerListMock());
+
+ /* Set a volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.50);
+ loop(50);
+ auto notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+ EXPECT_EQ("indicator-sound", notev[0].app_name);
+ EXPECT_EQ("Volume", notev[0].summary);
+ EXPECT_EQ(0, notev[0].actions.size());
+ EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
+ EXPECT_GVARIANT_EQ("@i 50", notev[0].hints["value"]);
+
+ /* Set a different volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.60);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+ EXPECT_GVARIANT_EQ("@i 60", notev[0].hints["value"]);
+
+ /* Set the same volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.60);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(0, notev.size());
+
+ /* Change just a little */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.60001);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(0, notev.size());
+}
+
+TEST_F(NotificationsTest, StreamChanges) {
+ auto volumeControl = volumeControlMock();
+ auto soundService = standardService(volumeControl, playerListMock());
+
+ /* Set a volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.5);
+ loop(50);
+ auto notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+
+ /* Change Streams, no volume change */
+ notifications->clearNotifications();
+ volume_control_mock_set_mock_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), "alarm");
+ volume_control_set_volume(volumeControl.get(), 0.5);
+ loop(50);
+ notev = notifications->getNotifications();
+ EXPECT_EQ(0, notev.size());
+
+ /* Change Streams, volume change */
+ notifications->clearNotifications();
+ volume_control_mock_set_mock_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), "alert");
+ volume_control_set_volume(volumeControl.get(), 0.60);
+ loop(50);
+ notev = notifications->getNotifications();
+ EXPECT_EQ(0, notev.size());
+
+ /* Change Streams, no volume change, volume up */
+ notifications->clearNotifications();
+ volume_control_mock_set_mock_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), "multimedia");
+ volume_control_set_volume(volumeControl.get(), 0.60);
+ loop(50);
+ volume_control_set_volume(volumeControl.get(), 0.65);
+ notev = notifications->getNotifications();
+ EXPECT_EQ(1, notev.size());
+ EXPECT_GVARIANT_EQ("@i 65", notev[0].hints["value"]);
+}
+
+TEST_F(NotificationsTest, IconTesting) {
+ auto volumeControl = volumeControlMock();
+ auto soundService = standardService(volumeControl, playerListMock());
+
+ /* Set an initial volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.5);
+ loop(50);
+ auto notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+
+ /* Generate a set of notifications */
+ notifications->clearNotifications();
+ for (float i = 0.0; i < 1.01; i += 0.1) {
+ volume_control_set_volume(volumeControl.get(), i);
+ }
+
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(11, notev.size());
+
+ EXPECT_EQ("audio-volume-muted", notev[0].app_icon);
+ EXPECT_EQ("audio-volume-low", notev[1].app_icon);
+ EXPECT_EQ("audio-volume-low", notev[2].app_icon);
+ EXPECT_EQ("audio-volume-medium", notev[3].app_icon);
+ EXPECT_EQ("audio-volume-medium", notev[4].app_icon);
+ EXPECT_EQ("audio-volume-medium", notev[5].app_icon);
+ EXPECT_EQ("audio-volume-medium", notev[6].app_icon);
+ EXPECT_EQ("audio-volume-high", notev[7].app_icon);
+ EXPECT_EQ("audio-volume-high", notev[8].app_icon);
+ EXPECT_EQ("audio-volume-high", notev[9].app_icon);
+ EXPECT_EQ("audio-volume-high", notev[10].app_icon);
+}
+
+TEST_F(NotificationsTest, ServerRestart) {
+ auto volumeControl = volumeControlMock();
+ auto soundService = standardService(volumeControl, playerListMock());
+
+ /* Set a volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.50);
+ loop(50);
+ auto notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+
+ /* Restart server without sync notifications */
+ notifications->clearNotifications();
+ dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
+ notifications.reset();
+
+ loop(50);
+
+ notifications = std::make_shared<NotificationsMock>(std::vector<std::string>({"body", "body-markup", "icon-static"}));
+ dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+ dbus_test_task_run((DbusTestTask*)*notifications);
+
+ /* Change the volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.60);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(0, notev.size());
+
+ /* Put a good server back */
+ dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
+ notifications.reset();
+
+ loop(50);
+
+ notifications = std::make_shared<NotificationsMock>();
+ dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+ dbus_test_task_run((DbusTestTask*)*notifications);
+
+ /* Change the volume again */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.70);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+}
+
+TEST_F(NotificationsTest, HighVolume) {
+ auto volumeControl = volumeControlMock();
+ auto soundService = standardService(volumeControl, playerListMock());
+
+ /* Set a volume */
+ notifications->clearNotifications();
+ volume_control_set_volume(volumeControl.get(), 0.50);
+ loop(50);
+ auto notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+ EXPECT_EQ("Volume", notev[0].summary);
+ EXPECT_EQ("", notev[0].body);
+ EXPECT_GVARIANT_EQ("@s 'false'", notev[0].hints["x-canonical-value-bar-tint"]);
+
+ /* Set high volume with volume change */
+ notifications->clearNotifications();
+ volume_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), TRUE);
+ volume_control_set_volume(volumeControl.get(), 0.90);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_LT(0, notev.size()); /* This passes with one or two since it would just be an update to the first if a second was sent */
+ EXPECT_EQ("Volume", notev[0].summary);
+ EXPECT_EQ("High volume", notev[0].body);
+ EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
+
+ /* Move it back */
+ volume_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), FALSE);
+ volume_control_set_volume(volumeControl.get(), 0.50);
+ loop(50);
+
+ /* Set high volume without level change */
+ /* NOTE: This can happen if headphones are plugged in */
+ notifications->clearNotifications();
+ volume_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), TRUE);
+ loop(50);
+ notev = notifications->getNotifications();
+ ASSERT_EQ(1, notev.size());
+ EXPECT_EQ("Volume", notev[0].summary);
+ EXPECT_EQ("High volume", notev[0].body);
+ EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
+}
diff --git a/tests/volume-control-mock.vala b/tests/volume-control-mock.vala
new file mode 100644
index 0000000..4b846bf
--- /dev/null
+++ b/tests/volume-control-mock.vala
@@ -0,0 +1,47 @@
+/*
+ * -*- Mode:Vala; indent-tabs-mode:t; tab-width:4; encoding:utf8 -*-
+ * Copyright © 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ * Ted Gould <ted@canonical.com>
+ */
+
+public class VolumeControlMock : VolumeControl
+{
+ public string mock_stream { get; set; default = "multimedia"; }
+ public override string stream { get { return mock_stream; } }
+ public override bool ready { get; set; }
+ public override bool active_mic { get; set; }
+ public bool mock_high_volume { get; set; }
+ public override bool high_volume { get { return mock_high_volume; } }
+ public bool mock_mute { get; set; }
+ public override bool mute { get { return mock_mute; } }
+ public bool mock_is_playing { get; set; }
+ public override bool is_playing { get { return mock_is_playing; } }
+ public override double volume { get; set; }
+ public override double mic_volume { get; set; }
+
+ public override void set_mute (bool mute) {
+
+ }
+
+ public VolumeControlMock() {
+ ready = true;
+ this.notify["mock-stream"].connect(() => this.notify_property("stream"));
+ this.notify["mock-high-volume"].connect(() => this.notify_property("high-volume"));
+ this.notify["mock-mute"].connect(() => this.notify_property("mute"));
+ this.notify["mock-is-playing"].connect(() => this.notify_property("is-playing"));
+ }
+}
diff --git a/tests/volume-control-test.cc b/tests/volume-control-test.cc
index 9970241..41e1886 100644
--- a/tests/volume-control-test.cc
+++ b/tests/volume-control-test.cc
@@ -71,13 +71,13 @@ class VolumeControlTest : public ::testing::Test
};
TEST_F(VolumeControlTest, BasicObject) {
- VolumeControl * control = volume_control_new();
+ VolumeControlPulse * control = volume_control_pulse_new();
/* Setup the PA backend */
loop(100);
/* Ready */
- EXPECT_TRUE(volume_control_get_ready(control));
+ EXPECT_TRUE(volume_control_get_ready(VOLUME_CONTROL(control)));
g_clear_object(&control);
}