Merge lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items into lp:indicator-datetime/15.10

[Charles Kerr]

Corrects notifications' title and icon to show the correct information for calendar events.

Corrects notifications' title and icon to show the correct information for calendar events.

Based on <https://code.launchpad.net/~dbarth/indicator-datetime/adjust-title-notification-icons/+merge/284911> but stacked on top of a branch that's friendly to landing in vivid+xenial and adds unit tests for the change.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:434
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/354/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/44
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/44/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:434
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/355/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/45
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/45
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/45/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items]

435. By Charles Kerr on 2016-02-03

in settings-live.cpp, use std::string instead of auto to make g++ 4.9.2 happy on vivid

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:435
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/356/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/46
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/46
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/46/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[David Barth (dbarth)]

Tested in silo 003, +1 for me

review: Approve

[lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items]

436. By Charles Kerr on 2016-02-10

in the GLib test Fixture, add helper functions to wait for arbitrary events and bus events

437. By Charles Kerr on 2016-02-10

add a DBusMock test Fixture with helper functions to wait for arbitrary bus method calls

438. By Charles Kerr on 2016-02-10

update notification tests to wait for the needed bus events instead of waiting for arbitrary time intervals

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:438
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/357/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/47
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/47/console

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

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items]

439. By Charles Kerr on 2016-02-11

in test-notifications we do need one wait() wart after all, because the Snap is building its impl proxies asynchronously and hasn't any public way of notifying when they're built

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:439
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/358/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/48
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/48
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/48/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items]

440. By Charles Kerr on 2016-02-11

resolve some test timing issues by deferring Snap object creation until it's needed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:440
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/359/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/49
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/49/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Xavi Garcia (xavi-garcia-mena)]

Looks good to me. Thanks Charles!

review: Approve

[lp:~charlesk/indicator-datetime/lp-1440111-friendlier-calendar-items]

441. By Charles Kerr on 2016-03-10

merge lp:~stgraber/indicator-datetime/fix-deps

=== modified file 'debian/changelog'
--- debian/changelog	2016-01-29 18:53:46 +0000
+++ debian/changelog	2016-03-10 16:21:24 +0000
@@ -1,3 +1,9 @@
+indicator-datetime (15.10+16.04.20160129-0ubuntu2) xenial; urgency=medium
+
+  * Don't pull systemd-shim on systems with systemd installed.
+
+ -- Stéphane Graber <[e-mail]>  Wed, 24 Feb 2016 12:40:28 -0500
+
 indicator-datetime (15.10+16.04.20160129-0ubuntu1) xenial; urgency=medium
 
   [ Charles Kerr ]

=== modified file 'debian/control'
--- debian/control	2016-03-10 16:21:24 +0000
+++ debian/control	2016-03-10 16:21:24 +0000
@@ -42,8 +42,7 @@
 Depends: ${shlibs:Depends}, 
          ${misc:Depends},
          gsettings-ubuntu-schemas,
-         systemd-services,
-         systemd-shim,
+         systemd | systemd-shim,
 Recommends: indicator-applet | indicator-renderer,
             evolution-data-server,
             geoclue-ubuntu-geoip | geoclue-provider,

=== modified file 'src/settings-live.cpp'
--- src/settings-live.cpp	2016-03-10 16:21:24 +0000
+++ src/settings-live.cpp	2016-03-10 16:21:24 +0000
@@ -73,8 +73,8 @@
         GVariantBuilder builder;
         g_variant_builder_init(&builder, G_VARIANT_TYPE("a(ss)"));
         for(const auto& app : value){
-            const auto& pkgname {app.first};
-            const auto& appname {app.second};
+            const std::string& pkgname {app.first};
+            const std::string& appname {app.second};
             g_variant_builder_add(&builder, "(ss)", pkgname.c_str(), appname.c_str());
         }
         g_settings_set_value(m_settings_cunh, SETTINGS_CUNH_BLACKLIST_S, g_variant_builder_end(&builder));

=== modified file 'src/snap.cpp'
--- src/snap.cpp	2016-03-10 16:21:24 +0000
+++ src/snap.cpp	2016-03-10 16:21:24 +0000
@@ -123,7 +123,7 @@
         const auto minutes = std::chrono::minutes(m_settings->alarm_duration.get());
         uin::Builder b;
         b.set_body (appointment.summary);
-        b.set_icon_name ("alarm-clock");
+        b.set_icon_name (appointment.is_ubuntu_alarm() ? "alarm-clock" : "reminder");
         b.add_hint (uin::Builder::HINT_NONSHAPED_ICON);
 
         const char * timefmt;
@@ -137,7 +137,11 @@
             timefmt = _("%a, %H:%M");
         }
         const auto timestr = appointment.begin.format(timefmt);
-        auto title = g_strdup_printf(_("Alarm %s"), timestr.c_str());
+
+        const auto titlefmt = appointment.is_ubuntu_alarm()
+            ? _("Alarm %s")
+            : _("Event %s");
+        auto title = g_strdup_printf(titlefmt, timestr.c_str());
         b.set_title (title);
         g_free (title);
         b.set_timeout (std::chrono::duration_cast<std::chrono::seconds>(minutes));

=== modified file 'tests/glib-fixture.h'
--- tests/glib-fixture.h	2015-09-09 16:16:41 +0000
+++ tests/glib-fixture.h	2016-03-10 16:21:24 +0000
@@ -20,7 +20,9 @@
 #ifndef INDICATOR_DATETIME_TESTS_GLIB_FIXTURE_H
 #define INDICATOR_DATETIME_TESTS_GLIB_FIXTURE_H
 
+#include <functional> // std::function
 #include <map>
+#include <memory> // std::shared_ptr
 
 #include <glib.h>
 #include <glib/gstdio.h>
@@ -109,6 +111,92 @@
       g_source_remove(id);
     }
 
+    bool wait_for(std::function<bool()> test_function, guint timeout_msec=1000)
+    {
+      auto timer = std::shared_ptr<GTimer>(g_timer_new(), [](GTimer* t){g_timer_destroy(t);});
+      const auto timeout_sec = timeout_msec / 1000.0;
+      for (;;) {
+        if (test_function())
+          return true;
+        //g_message("%f ... %f", g_timer_elapsed(timer.get(), nullptr), timeout_sec);
+        if (g_timer_elapsed(timer.get(), nullptr) >= timeout_sec)
+          return false;
+        wait_msec();
+      }
+    }
+
+    bool wait_for_name_owned(GDBusConnection* connection,
+                             const gchar* name,
+                             guint timeout_msec=1000,
+                             GBusNameWatcherFlags flags=G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
+    {
+      struct Data {
+        GMainLoop* loop = nullptr;
+        bool owned = false;
+      };
+      Data data;
+
+      auto on_name_appeared = [](GDBusConnection* /*connection*/,
+                                 const gchar* /*name_*/,
+                                 const gchar* name_owner,
+                                 gpointer gdata)
+      {
+        if (name_owner == nullptr)
+          return;
+        auto tmp = static_cast<Data*>(gdata);
+        tmp->owned = true;
+        g_main_loop_quit(tmp->loop);
+      };
+
+      const auto timeout_id = g_timeout_add(timeout_msec, wait_msec__timeout, loop);
+      data.loop = loop;
+      const auto watch_id = g_bus_watch_name_on_connection(connection,
+                                                           name,
+                                                           flags,
+                                                           on_name_appeared,
+                                                           nullptr, /* name_vanished */
+                                                           &data,
+                                                           nullptr); /* user_data_free_func */
+      g_main_loop_run(loop);
+
+      g_bus_unwatch_name(watch_id);
+      g_source_remove(timeout_id);
+
+      return data.owned;
+    }
+
+    void EXPECT_NAME_OWNED_EVENTUALLY(GDBusConnection* connection,
+                                      const gchar* name,
+                                      guint timeout_msec=1000,
+                                      GBusNameWatcherFlags flags=G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
+    {
+      EXPECT_TRUE(wait_for_name_owned(connection, name, timeout_msec, flags)) << "name: " << name;
+    }
+
+    void EXPECT_NAME_NOT_OWNED_EVENTUALLY(GDBusConnection* connection,
+                                          const gchar* name,
+                                          guint timeout_msec=1000,
+                                          GBusNameWatcherFlags flags=G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
+    {
+      EXPECT_FALSE(wait_for_name_owned(connection, name, timeout_msec, flags)) << "name: " << name;
+    }
+
+    void ASSERT_NAME_OWNED_EVENTUALLY(GDBusConnection* connection,
+                                      const gchar* name,
+                                      guint timeout_msec=1000,
+                                      GBusNameWatcherFlags flags=G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
+    {
+      ASSERT_TRUE(wait_for_name_owned(connection, name, timeout_msec, flags)) << "name: " << name;
+    }
+
+    void ASSERT_NAME_NOT_OWNED_EVENTUALLY(GDBusConnection* connection,
+                                          const gchar* name,
+                                          guint timeout_msec=1000,
+                                          GBusNameWatcherFlags flags=G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
+    {
+      ASSERT_FALSE(wait_for_name_owned(connection, name, timeout_msec, flags)) << "name: " << name;
+    }
+
     GMainLoop * loop;
 };
 

=== added file 'tests/libdbusmock-fixture.h'
--- tests/libdbusmock-fixture.h	1970-01-01 00:00:00 +0000
+++ tests/libdbusmock-fixture.h	2016-03-10 16:21:24 +0000
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2014-2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#pragma once
+
+#include "glib-fixture.h"
+
+#include <libdbustest/dbus-test.h>
+
+/***
+****
+***/
+
+class LibdbusmockFixture: public GlibFixture
+{
+private:
+
+  typedef GlibFixture super;
+
+protected:
+
+  GDBusConnection * system_bus {};
+  GDBusConnection * session_bus {};
+  DbusTestService * service {};
+
+  void SetUp() override
+  {
+
+    super::SetUp();
+
+    service = dbus_test_service_new(nullptr);
+  }
+
+  void startDbusMock()
+  {
+    // start 'em up.
+    // make the system bus work off the mock bus too, since that's
+    // where the upower and screen are on the system bus...
+
+    dbus_test_service_start_tasks(service);
+    g_setenv("DBUS_SYSTEM_BUS_ADDRESS", g_getenv("DBUS_SESSION_BUS_ADDRESS"), TRUE);
+
+    session_bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
+    ASSERT_NE(nullptr, session_bus);
+    g_dbus_connection_set_exit_on_close(session_bus, false);
+    g_object_add_weak_pointer(G_OBJECT(session_bus), (gpointer *)&session_bus);
+
+    system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, nullptr);
+    ASSERT_NE(nullptr, system_bus);
+    g_dbus_connection_set_exit_on_close(system_bus, FALSE);
+    g_object_add_weak_pointer(G_OBJECT(system_bus), (gpointer *)&system_bus);
+  }
+
+  void TearDown() override
+  {
+    g_clear_object(&service);
+    g_object_unref(session_bus);
+    g_object_unref(system_bus);
+
+    // wait a little while for the scaffolding to shut down,
+    // but don't block on it forever...
+    unsigned int cleartry = 0;
+    while (((system_bus != nullptr) || (session_bus != nullptr)) && (cleartry < 50))
+      {
+        g_usleep(100000);
+        while (g_main_pending())
+          g_main_iteration(true);
+        cleartry++;
+      }
+
+    super::TearDown();
+  }
+
+  bool wait_for_method_call(DbusTestDbusMock* mock,
+                            DbusTestDbusMockObject* obj,
+                            const gchar* method,
+                            GVariant* params=nullptr,
+                            guint timeout_msec=100)
+  {
+    if (params != nullptr)
+      g_variant_ref_sink(params);
+
+    auto test_function = [mock, obj, method, params]() {
+      GError* error {};
+      const auto called = dbus_test_dbus_mock_object_check_method_call(mock,
+                                                                       obj,
+                                                                       method,
+                                                                       params,
+                                                                       &error);
+      if (error != nullptr) {
+        g_critical("Error looking for method call '%s': %s", method, error->message);
+        g_clear_error(&error);
+      }
+
+      return called;
+    };
+
+    const auto ret = wait_for(test_function, timeout_msec);
+    g_clear_pointer(&params, g_variant_unref);
+    return ret;
+  }
+
+  void EXPECT_METHOD_CALLED_EVENTUALLY(DbusTestDbusMock* mock,
+                                       DbusTestDbusMockObject* obj,
+                                       const gchar* method,
+                                       GVariant* params=nullptr,
+                                       guint timeout_msec=1000)
+  {
+    EXPECT_TRUE(wait_for_method_call(mock, obj, method, params, timeout_msec)) << "method: " << method;
+  }
+
+  void EXPECT_METHOD_NOT_CALLED_EVENTUALLY(DbusTestDbusMock* mock,
+                                           DbusTestDbusMockObject* obj,
+                                           const gchar* method,
+                                           GVariant* params=nullptr,
+                                           guint timeout_msec=1000)
+  {
+    EXPECT_FALSE(wait_for_method_call(mock, obj, method, params, timeout_msec)) << "method: " << method;
+  }
+
+  void ASSERT_METHOD_CALLED_EVENTUALLY(DbusTestDbusMock* mock,
+                                       DbusTestDbusMockObject* obj,
+                                       const gchar* method,
+                                       GVariant* params=nullptr,
+                                       guint timeout_msec=1000)
+  {
+    ASSERT_TRUE(wait_for_method_call(mock, obj, method, params, timeout_msec)) << "method: " << method;
+  }
+
+  void ASSERT_METHOD_NOT_CALLED_EVENTUALLY(DbusTestDbusMock* mock,
+                                           DbusTestDbusMockObject* obj,
+                                           const gchar* method,
+                                           GVariant* params=nullptr,
+                                           guint timeout_msec=1000)
+  {
+    ASSERT_FALSE(wait_for_method_call(mock, obj, method, params, timeout_msec)) << "method: " << method;
+  }
+};
+

=== modified file 'tests/notification-fixture.h'
--- tests/notification-fixture.h	2016-03-10 16:21:24 +0000
+++ tests/notification-fixture.h	2016-03-10 16:21:24 +0000
@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "glib-fixture.h"
+#include "libdbusmock-fixture.h"
 
 #include <datetime/appointment.h>
 #include <datetime/dbus-shared.h>
@@ -38,24 +38,18 @@
 ****
 ***/
 
-//using namespace unity::indicator::datetime;
-
-class NotificationFixture: public GlibFixture
+class NotificationFixture: public LibdbusmockFixture
 {
 private:
 
-  typedef GlibFixture super;
+  typedef LibdbusmockFixture super;
+
+protected:
 
   static constexpr char const * NOTIFY_BUSNAME   {"org.freedesktop.Notifications"};
   static constexpr char const * NOTIFY_INTERFACE {"org.freedesktop.Notifications"};
   static constexpr char const * NOTIFY_PATH      {"/org/freedesktop/Notifications"};
 
-  //namespace uin = unity::indicator::notifications;
-
-  //using namespace unity::indicator::datetime;
-
-protected:
-
   static constexpr char const * HAPTIC_METHOD_VIBRATE_PATTERN {"VibratePattern"};
 
   static constexpr int SCREEN_COOKIE {8675309};
@@ -90,9 +84,7 @@
 
   unity::indicator::datetime::Appointment appt;
   unity::indicator::datetime::Appointment ualarm;
-  GDBusConnection * system_bus = nullptr;
-  GDBusConnection * session_bus = nullptr;
-  DbusTestService * service = nullptr;
+
   DbusTestDbusMock * as_mock = nullptr;
   DbusTestDbusMock * notify_mock = nullptr;
   DbusTestDbusMock * powerd_mock = nullptr;
@@ -131,8 +123,6 @@
     ualarm.end = tomorrow;
     ualarm.alarms.push_back(unity::indicator::datetime::Alarm{"It's Tomorrow!", "", appt.begin});
 
-    service = dbus_test_service_new(nullptr);
-
     ///
     ///  Add the AccountsService mock
     ///
@@ -308,23 +298,7 @@
     g_assert_no_error (error);
     dbus_test_service_add_task(service, DBUS_TEST_TASK(haptic_mock));
 
-
-    // start 'em up.
-    // make the system bus work off the mock bus too, since that's
-    // where the upower and screen are on the system bus...
-
-    dbus_test_service_start_tasks(service);
-    g_setenv("DBUS_SYSTEM_BUS_ADDRESS", g_getenv("DBUS_SESSION_BUS_ADDRESS"), TRUE);
-
-    session_bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
-    ASSERT_NE(nullptr, session_bus);
-    g_dbus_connection_set_exit_on_close(session_bus, false);
-    g_object_add_weak_pointer(G_OBJECT(session_bus), (gpointer *)&session_bus);
-
-    system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, nullptr);
-    ASSERT_NE(nullptr, system_bus);
-    g_dbus_connection_set_exit_on_close(system_bus, FALSE);
-    g_object_add_weak_pointer(G_OBJECT(system_bus), (gpointer *)&system_bus);
+    startDbusMock();
   }
 
   void TearDown() override
@@ -334,20 +308,6 @@
     g_clear_object(&powerd_mock);
     g_clear_object(&notify_mock);
     g_clear_object(&as_mock);
-    g_clear_object(&service);
-    g_object_unref(session_bus);
-    g_object_unref(system_bus);
-
-    // wait a little while for the scaffolding to shut down,
-    // but don't block on it forever...
-    unsigned int cleartry = 0;
-    while (((system_bus != nullptr) || (session_bus != nullptr)) && (cleartry < 50))
-      {
-        g_usleep(100000);
-        while (g_main_pending())
-          g_main_iteration(true);
-        cleartry++;
-      }
 
     super::TearDown();
   }

=== modified file 'tests/test-notification.cpp'
--- tests/test-notification.cpp	2016-03-10 16:21:24 +0000
+++ tests/test-notification.cpp	2016-03-10 16:21:24 +0000
@@ -37,7 +37,7 @@
   {
     g_main_loop_quit(static_cast<GMainLoop*>(gloop));
     return G_SOURCE_REMOVE;
-  };
+  }
 }
 
 /***
@@ -58,11 +58,13 @@
   // combinatorial factor #1: event type
   struct {
     Appointment appt;
+    const char* icon_name;
+    const char* prefix;
     bool expected_notify_called;
     bool expected_vibrate_called;
   } test_appts[] = {
-    { appt, true, true },
-    { ualarm, true, true }
+    { appt, "reminder", "Event", true, true },
+    { ualarm, "alarm-clock", "Alarm", true, true }
   };
 
   // combinatorial factor #2: indicator-datetime's haptic mode
@@ -90,11 +92,13 @@
   const std::set<std::pair<std::string,std::string>> blacklist_empty;
   struct {
     std::set<std::pair<std::string,std::string>> muted_apps; // apps that should not trigger notifications
-    bool expected_notify_called; // do we expect the notification tho show?
-    bool expected_vibrate_called; // do we expect the phone to vibrate?
+    std::set<Appointment::Type> expected_notify_called; // do we expect the notification to show?
+    std::set<Appointment::Type> expected_vibrate_called; // do we expect the phone to vibrate?
   } test_muted_apps[] = {
-    { blacklist_calendar, false, false },
-    { blacklist_empty, true, true }
+    { blacklist_empty,    std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT },
+                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT } },
+    { blacklist_calendar, std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM },
+                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM } }
   };
 
   for (const auto& test_appt : test_appts)
@@ -105,57 +109,86 @@
   {
   for (const auto& test_muted : test_muted_apps)
   {
-    auto snap = create_snap(ne, sb, settings);
-
     const bool expected_notify_called = test_appt.expected_notify_called
                                      && test_vibes.expected_notify_called
-                                     && test_muted.expected_notify_called
+                                     && (test_muted.expected_notify_called.count(test_appt.appt.type) > 0)
                                      && test_haptic.expected_notify_called;
 
     const bool expected_vibrate_called = test_appt.expected_vibrate_called
                                       && test_vibes.expected_vibrate_called
-                                      && test_muted.expected_vibrate_called
+                                      && (test_muted.expected_vibrate_called.count(test_appt.appt.type) > 0)
                                       && test_haptic.expected_vibrate_called;
 
-    // clear out any previous iterations' noise
-    GError * error = nullptr;
-    dbus_test_dbus_mock_object_clear_method_calls(haptic_mock, haptic_obj, &error);
-    g_assert_no_error(error);
-    dbus_test_dbus_mock_object_clear_method_calls(notify_mock, notify_obj, &error);
-    g_assert_no_error(error);
-
-    // set the properties to match the test case
+    // set test case properties: blacklist
     settings->muted_apps.set(test_muted.muted_apps);
+
+    // set test case properties: haptic mode
     settings->alarm_haptic.set(test_haptic.haptic_mode);
+
+    // set test case properties: other-vibrations flag
+    // (and wait for the PropertiesChanged signal so we know the dbusmock got it)
+    GError * error {};
     dbus_test_dbus_mock_object_update_property(as_mock,
                                                as_obj,
                                                PROP_OTHER_VIBRATIONS,
                                                g_variant_new_boolean(test_vibes.other_vibrations),
                                                &error);
     g_assert_no_error(error);
-    wait_msec(100);
+
+    // wait for previous iterations' bus noise to finish and reset the counters
+    wait_msec(500);
+    dbus_test_dbus_mock_object_clear_method_calls(haptic_mock, haptic_obj, &error);
+    dbus_test_dbus_mock_object_clear_method_calls(notify_mock, notify_obj, &error);
+    g_assert_no_error(error);
 
     // run the test
-    (*snap)(appt, appt.alarms.front(), func, func);
-    wait_msec(100);
-
-    // test that the notification was as expected
-    const bool notify_called = dbus_test_dbus_mock_object_check_method_call(notify_mock,
-                                                                            notify_obj,
-                                                                            METHOD_NOTIFY,
-                                                                            nullptr,
-                                                                            &error);
-    g_assert_no_error(error);
-    EXPECT_EQ(expected_notify_called, notify_called);
-
-    // test that the vibration was as expected
-    const bool vibrate_called = dbus_test_dbus_mock_object_check_method_call(haptic_mock,
-                                                                             haptic_obj,
-                                                                             HAPTIC_METHOD_VIBRATE_PATTERN,
-                                                                             nullptr,
-                                                                             &error);
-    g_assert_no_error(error);
-    EXPECT_EQ(expected_vibrate_called, vibrate_called);
+    auto snap = create_snap(ne, sb, settings);
+    (*snap)(test_appt.appt, appt.alarms.front(), func, func);
+
+    // confirm that the notification was as expected
+    if (expected_notify_called) {
+      EXPECT_METHOD_CALLED_EVENTUALLY(notify_mock, notify_obj, METHOD_NOTIFY);
+    } else {
+      EXPECT_METHOD_NOT_CALLED_EVENTUALLY(notify_mock, notify_obj, METHOD_NOTIFY);
+    }
+
+    // confirm that the vibration was as expected
+    if (expected_vibrate_called) {
+      EXPECT_METHOD_CALLED_EVENTUALLY(haptic_mock, haptic_obj, HAPTIC_METHOD_VIBRATE_PATTERN);
+    } else {
+      EXPECT_METHOD_NOT_CALLED_EVENTUALLY(haptic_mock, haptic_obj, HAPTIC_METHOD_VIBRATE_PATTERN);
+    }
+
+    // confirm that the notification was as expected
+    guint num_notify_calls = 0;
+    const auto notify_calls = dbus_test_dbus_mock_object_get_method_calls(notify_mock,
+                                                                          notify_obj,
+                                                                          METHOD_NOTIFY,
+                                                                          &num_notify_calls,
+                                                                          &error);
+    g_assert_no_error(error);
+    if (num_notify_calls > 0)
+    {
+        // test that Notify was called with the app_name
+        const gchar* app_name {nullptr};
+        g_variant_get_child(notify_calls[0].params, 0, "&s", &app_name);
+        ASSERT_STREQ(APP_NAME, app_name);
+
+        // test that Notify was called with the type-appropriate icon
+        const gchar* icon_name {nullptr};
+        g_variant_get_child(notify_calls[0].params, 2, "&s", &icon_name);
+        ASSERT_STREQ(test_appt.icon_name, icon_name);
+
+        // test that the Notification title has the correct prefix
+        const gchar* title {nullptr};
+        g_variant_get_child(notify_calls[0].params, 3, "&s", &title);
+        ASSERT_TRUE(g_str_has_prefix(title, test_appt.prefix));
+
+        // test that Notify was called with the appointment's body
+        const gchar* body {nullptr};
+        g_variant_get_child(notify_calls[0].params, 4, "&s", &body);
+        ASSERT_STREQ(test_appt.appt.summary.c_str(), body);
+    }
   }
   }
   }

=== removed file 'tests/test-snap.cpp'
--- tests/test-snap.cpp	2016-03-10 16:21:24 +0000
+++ tests/test-snap.cpp	1970-01-01 00:00:00 +0000
@@ -1,396 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * 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/>.
- */
-
-#include <datetime/appointment.h>
-#include <datetime/dbus-shared.h>
-#include <datetime/settings.h>
-#include <datetime/snap.h>
-
-#include <notifications/dbus-shared.h>
-#include <notifications/notifications.h>
-
-#include "notification-fixture.h"
-
-using namespace unity::indicator::datetime;
-
-namespace uin = unity::indicator::notifications;
-
-/***
-****
-***/
-
-namespace
-{
-  static constexpr char const * APP_NAME {"indicator-datetime-service"};
-}
-
-using namespace unity::indicator::datetime;
-
-/***
-****
-***/
-
-namespace
-{
-  gboolean quit_idle (gpointer gloop)
-  {
-    g_main_loop_quit(static_cast<GMainLoop*>(gloop));
-    return G_SOURCE_REMOVE;
-  };
-}
-
-TEST_F(NotificationFixture, InteractiveDuration)
-{
-  static constexpr int duration_minutes = 120;
-  auto settings = std::make_shared<Settings>();
-  settings->alarm_duration.set(duration_minutes);
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto snap = create_snap(ne, sb, settings);
-
-  make_interactive();
-
-  // call the Snap Decision
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-  (*snap)(appt, appt.alarms.front(), func, func);
-
-  // confirm that Notify got called once
-  guint len = 0;
-  GError * error = nullptr;
-  const auto calls = dbus_test_dbus_mock_object_get_method_calls (notify_mock,
-                                                                  notify_obj,
-                                                                  METHOD_NOTIFY,
-                                                                  &len,
-                                                                  &error);
-  g_assert_no_error(error);
-  ASSERT_EQ(1, len);
-
-  // confirm that the app_name passed to Notify was APP_NAME
-  const auto& params = calls[0].params;
-  ASSERT_EQ(8, g_variant_n_children(params));
-  const char * str = nullptr;
-  g_variant_get_child (params, 0, "&s", &str);
-  ASSERT_STREQ(APP_NAME, str);
-
-  // confirm that the icon passed to Notify was "alarm-clock"
-  g_variant_get_child (params, 2, "&s", &str);
-  ASSERT_STREQ("alarm-clock", str);
-
-  // confirm that the hints passed to Notify included a timeout matching duration_minutes
-  int32_t i32;
-  bool b;
-  auto hints = g_variant_get_child_value (params, 6);
-  b = g_variant_lookup (hints, HINT_TIMEOUT, "i", &i32);
-  EXPECT_TRUE(b);
-  const auto duration = std::chrono::minutes(duration_minutes);
-  EXPECT_EQ(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(), i32);
-  g_variant_unref(hints);
-  ne.reset();
-}
-
-/***
-****
-***/
-
-TEST_F(NotificationFixture, InhibitSleep)
-{
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto snap = create_snap(ne, sb, settings);
-
-  make_interactive();
-
-  // invoke the notification
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-  (*snap)(appt, appt.alarms.front(), func, func);
-
-  wait_msec(1000);
-
-  // confirm that sleep got inhibited
-  GError * error = nullptr;
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_REQUEST_SYS_STATE,
-                                                             g_variant_new("(si)", APP_NAME, POWERD_SYS_STATE_ACTIVE),
-                                                             &error));
-
-  // confirm that the screen got forced on
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (screen_mock,
-                                                             screen_obj,
-                                                             SCREEN_METHOD_KEEP_DISPLAY_ON,
-                                                             nullptr,
-                                                             &error));
-
-  // force-close the snap
-  wait_msec(100);
-  snap.reset();
-  wait_msec(100);
-
-  // confirm that sleep got uninhibted
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_CLEAR_SYS_STATE,
-                                                             g_variant_new("(s)", POWERD_COOKIE),
-                                                             &error));
-
-  // confirm that the screen's no longer forced on
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (screen_mock,
-                                                             screen_obj,
-                                                             SCREEN_METHOD_REMOVE_DISPLAY_ON_REQUEST,
-                                                             g_variant_new("(i)", SCREEN_COOKIE),
-                                                             &error));
-
-  g_assert_no_error (error);
-}
-
-/***
-****
-***/
-
-TEST_F(NotificationFixture, ForceScreen)
-{
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto snap = create_snap(ne, sb, settings);
-
-  make_interactive();
-
-  // invoke the notification
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-  (*snap)(appt, appt.alarms.front(), func, func);
-
-  wait_msec(1000);
-
-  // confirm that sleep got inhibited
-  GError * error = nullptr;
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_REQUEST_SYS_STATE,
-                                                             g_variant_new("(si)", APP_NAME, POWERD_SYS_STATE_ACTIVE),
-                                                             &error));
-  g_assert_no_error(error);
-
-  // force-close the snap
-  wait_msec(100);
-  snap.reset();
-  wait_msec(100);
-
-  // confirm that sleep got uninhibted
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_CLEAR_SYS_STATE,
-                                                             g_variant_new("(s)", POWERD_COOKIE),
-                                                             &error));
-  g_assert_no_error(error);
-}
-
-/***
-****
-***/
-
-/**
- * A DefaultSoundBuilder wrapper which remembers the parameters of the last sound created.
- */
-class TestSoundBuilder: public uin::SoundBuilder
-{
-public:
-    TestSoundBuilder() =default;
-    ~TestSoundBuilder() =default;
-
-    virtual std::shared_ptr<uin::Sound> create(const std::string& role, const std::string& uri, unsigned int volume, bool loop) override {
-        m_role = role;
-        m_uri = uri;
-        m_volume = volume;
-        m_loop = loop;
-        return m_impl.create(role, uri, volume, loop);
-    }
-
-    const std::string& role() { return m_role; }
-    const std::string& uri() { return m_uri; }
-    unsigned int volume() { return m_volume; }
-    bool loop() { return m_loop; }
-
-private:
-    std::string m_role;
-    std::string m_uri;
-    unsigned int m_volume;
-    bool m_loop;
-    uin::DefaultSoundBuilder m_impl;
-};
-
-std::string path_to_uri(const std::string& path)
-{
-  auto file = g_file_new_for_path(path.c_str());
-  auto uri_cstr = g_file_get_uri(file);
-  std::string uri = uri_cstr;
-  g_free(uri_cstr);
-  g_clear_pointer(&file, g_object_unref);
-  return uri;
-}
-
-TEST_F(NotificationFixture,DefaultSounds)
-{
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<TestSoundBuilder>();
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-
-  const struct {
-      Appointment appointment;
-      std::string expected_role;
-      std::string expected_uri;
-  } test_cases[] = {
-      { ualarm, "alarm", path_to_uri(ALARM_DEFAULT_SOUND) },
-      { appt,   "alert", path_to_uri(CALENDAR_DEFAULT_SOUND) }
-  };
-
-  auto snap = create_snap(ne, sb, settings);
-
-  for(const auto& test_case : test_cases)
-  {
-    (*snap)(test_case.appointment, test_case.appointment.alarms.front(), func, func);
-    wait_msec(100);
-    EXPECT_EQ(test_case.expected_uri, sb->uri());
-    EXPECT_EQ(test_case.expected_role, sb->role());
-  }
-}
-
-/***
-****
-***/
-
-TEST_F(NotificationFixture,Notification)
-{
-  // Feed different combinations of system settings,
-  // indicator-datetime settings, and event types,
-  // then see if notifications and haptic feedback behave as expected.
-
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-
-  // combinatorial factor #1: event type
-  struct {
-    Appointment appt;
-    bool expected_notify_called;
-    bool expected_vibrate_called;
-  } test_appts[] = {
-    { appt, true, true },
-    { ualarm, true, true }
-  };
-
-  // combinatorial factor #2: indicator-datetime's haptic mode
-  struct {
-    const char* haptic_mode;
-    bool expected_notify_called;
-    bool expected_vibrate_called;
-  } test_haptics[] = {
-    { "none", true, false },
-    { "pulse", true, true }
-  };
-
-  // combinatorial factor #3: system settings' "other vibrations" enabled
-  struct {
-    bool other_vibrations;
-    bool expected_notify_called;
-    bool expected_vibrate_called;
-  } test_other_vibrations[] = {
-    { true, true, true },
-    { false, true, false }
-  };
-
-  // combinatorial factor #4: system settings' notifications app blacklist
-  const std::set<std::pair<std::string,std::string>> blacklist_calendar { std::make_pair(std::string{"com.ubuntu.calendar"}, std::string{"calendar-app"}) };
-  const std::set<std::pair<std::string,std::string>> blacklist_empty;
-  struct {
-    std::set<std::pair<std::string,std::string>> muted_apps; // apps that should not trigger notifications
-    bool expected_notify_called; // do we expect the notification tho show?
-    bool expected_vibrate_called; // do we expect the phone to vibrate?
-  } test_muted_apps[] = {
-    { blacklist_calendar, false, false },
-    { blacklist_empty, true, true }
-  };
-
-  for (const auto& test_appt : test_appts)
-  {
-  for (const auto& test_haptic : test_haptics)
-  {
-  for (const auto& test_vibes : test_other_vibrations)
-  {
-  for (const auto& test_muted : test_muted_apps)
-  {
-  auto snap = create_snap(ne, sb, settings);
-
-    const bool expected_notify_called = test_appt.expected_notify_called
-                                     && test_vibes.expected_notify_called
-                                     && test_muted.expected_notify_called
-                                     && test_haptic.expected_notify_called;
-
-    const bool expected_vibrate_called = test_appt.expected_vibrate_called
-                                      && test_vibes.expected_vibrate_called
-                                      && test_muted.expected_vibrate_called
-                                      && test_haptic.expected_vibrate_called;
-
-    // clear out any previous iterations' noise
-    GError * error = nullptr;
-    dbus_test_dbus_mock_object_clear_method_calls(haptic_mock, haptic_obj, &error);
-    g_assert_no_error(error);
-    dbus_test_dbus_mock_object_clear_method_calls(notify_mock, notify_obj, &error);
-    g_assert_no_error(error);
-
-    // set the properties to match the test case
-    settings->muted_apps.set(test_muted.muted_apps);
-    settings->alarm_haptic.set(test_haptic.haptic_mode);
-    dbus_test_dbus_mock_object_update_property(as_mock,
-                                               as_obj,
-                                               PROP_OTHER_VIBRATIONS,
-                                               g_variant_new_boolean(test_vibes.other_vibrations),
-                                               &error);
-    g_assert_no_error(error);
-    wait_msec(100);
-
-    // run the test
-    (*snap)(appt, appt.alarms.front(), func, func);
-    wait_msec(100);
-
-    // test that the notification was as expected
-    const bool notify_called = dbus_test_dbus_mock_object_check_method_call(notify_mock,
-                                                                            notify_obj,
-                                                                            METHOD_NOTIFY,
-                                                                            nullptr,
-                                                                            &error);
-    g_assert_no_error(error);
-    EXPECT_EQ(expected_notify_called, notify_called);
-
-    // test that the vibration was as expected
-    const bool vibrate_called = dbus_test_dbus_mock_object_check_method_call(haptic_mock,
-                                                                             haptic_obj,
-                                                                             HAPTIC_METHOD_VIBRATE_PATTERN,
-                                                                             nullptr,
-                                                                             &error);
-    g_assert_no_error(error);
-    EXPECT_EQ(expected_vibrate_called, vibrate_called);
-  }
-  }
-  }
-  }
-}

=== modified file 'tests/test-sound.cpp'
--- tests/test-sound.cpp	2016-03-10 16:21:24 +0000
+++ tests/test-sound.cpp	2016-03-10 16:21:24 +0000
@@ -85,7 +85,7 @@
 
   // confirm that the icon passed to Notify was "alarm-clock"
   g_variant_get_child (params, 2, "&s", &str);
-  ASSERT_STREQ("alarm-clock", str);
+  ASSERT_STREQ("reminder", str);
 
   // confirm that the hints passed to Notify included a timeout matching duration_minutes
   int32_t i32;
@@ -103,104 +103,6 @@
 ****
 ***/
 
-TEST_F(NotificationFixture, InhibitSleep)
-{
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto snap = create_snap(ne, sb, settings);
-
-  make_interactive();
-
-  // invoke the notification
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-  (*snap)(appt, appt.alarms.front(), func, func);
-
-  wait_msec(1000);
-
-  // confirm that sleep got inhibited
-  GError * error = nullptr;
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_REQUEST_SYS_STATE,
-                                                             g_variant_new("(si)", APP_NAME, POWERD_SYS_STATE_ACTIVE),
-                                                             &error));
-
-  // confirm that the screen got forced on
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (screen_mock,
-                                                             screen_obj,
-                                                             SCREEN_METHOD_KEEP_DISPLAY_ON,
-                                                             nullptr,
-                                                             &error));
-
-  // force-close the snap
-  wait_msec(100);
-  snap.reset();
-  wait_msec(100);
-
-  // confirm that sleep got uninhibted
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_CLEAR_SYS_STATE,
-                                                             g_variant_new("(s)", POWERD_COOKIE),
-                                                             &error));
-
-  // confirm that the screen's no longer forced on
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (screen_mock,
-                                                             screen_obj,
-                                                             SCREEN_METHOD_REMOVE_DISPLAY_ON_REQUEST,
-                                                             g_variant_new("(i)", SCREEN_COOKIE),
-                                                             &error));
-
-  g_assert_no_error (error);
-}
-
-/***
-****
-***/
-
-TEST_F(NotificationFixture, ForceScreen)
-{
-  auto settings = std::make_shared<Settings>();
-  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
-  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
-  auto snap = create_snap(ne, sb, settings);
-
-  make_interactive();
-
-  // invoke the notification
-  auto func = [this](const Appointment&, const Alarm&){g_idle_add(quit_idle, loop);};
-  (*snap)(appt, appt.alarms.front(), func, func);
-
-  wait_msec(1000);
-
-  // confirm that sleep got inhibited
-  GError * error = nullptr;
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_REQUEST_SYS_STATE,
-                                                             g_variant_new("(si)", APP_NAME, POWERD_SYS_STATE_ACTIVE),
-                                                             &error));
-  g_assert_no_error(error);
-
-  // force-close the snap
-  wait_msec(100);
-  snap.reset();
-  wait_msec(100);
-
-  // confirm that sleep got uninhibted
-  EXPECT_TRUE (dbus_test_dbus_mock_object_check_method_call (powerd_mock,
-                                                             powerd_obj,
-                                                             POWERD_METHOD_CLEAR_SYS_STATE,
-                                                             g_variant_new("(s)", POWERD_COOKIE),
-                                                             &error));
-  g_assert_no_error(error);
-}
-
-/***
-****
-***/
-
 /**
  * A DefaultSoundBuilder wrapper which remembers the parameters of the last sound created.
  */
@@ -258,11 +160,9 @@
   };
 
   auto snap = create_snap(ne, sb, settings);
-
   for(const auto& test_case : test_cases)
   {
     (*snap)(test_case.appointment, test_case.appointment.alarms.front(), func, func);
-    wait_msec(100);
     EXPECT_EQ(test_case.expected_uri, sb->uri());
     EXPECT_EQ(test_case.expected_role, sb->role());
   }