Indicator Date and Time

Merge lp:~charlesk/indicator-datetime/lp-1588526-remember-system-bus into lp:indicator-datetime

lp-1588526-remember-system-bus
Merge into trunk.16.10

Proposed by Charles Kerr on 2016-10-06

Status:

Merged

Approved by:

Charles Kerr on 2016-11-04

Approved revision:

467

Merged at revision:

467

Proposed branch:

lp:~charlesk/indicator-datetime/lp-1588526-remember-system-bus

Merge into:

lp:indicator-datetime

Diff against target:

582 lines (+201/-180)

11 files modified

include/datetime/snap.h (+4/-1)
include/notifications/awake.h (+3/-1)
src/awake.cpp (+23/-54)
src/main.cpp (+1/-1)
src/snap.cpp (+20/-13)
tests/CMakeLists.txt (+1/-0)
tests/libdbusmock-fixture.h (+1/-8)
tests/manual-test-snap.cpp (+3/-1)
tests/notification-fixture.h (+1/-1)
tests/test-notification-response.cpp (+144/-0)
tests/test-notification.cpp (+0/-100)

To merge this branch:

bzr merge lp:~charlesk/indicator-datetime/lp-1588526-remember-system-bus

Undecided

Invalid

Link a bug report

Reviewer	Review Type	Date Requested	Status
unity-api-1-bot	continuous-integration		Approve on 2016-11-04
dobey (community)		2016-10-06	Approve on 2016-10-06
Review via email: mp+307871@code.launchpad.net

Commit message

Remember the system bus instead of fetching it asynchronously

Description of the change

In the Awake class, take the system_bus as a constructor argument instead of fetching it asynchronously.

The goal of this branch is to reduce the time between when indicator-datetime receives a Wakeup signal and when it calls repowerd to keep the phone awake while showing an alarm. This may ameliorate https://launchpad.net/bugs/1588526 if the problem is the phone going back to sleep too soon after a wakeup.

NB: this branch is not a silver bullet, it only makes datetime behave better. It's also worth looking at repowerd wrt ensuring the phone stays awake long enough for clients to respond to Wakeups.

Revision history for this message

dobey (dobey) wrote on 2016-10-06:

Looks ok to me.

review: Approve

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-10-06:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-indicator-datetime-ci/4/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-10-21:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-indicator-datetime-ci/6/rebuild

review: Needs Fixing (continuous-integration)

lp:~charlesk/indicator-datetime/lp-1588526-remember-system-bus updated on 2016-11-04

466. By Charles Kerr on 2016-11-04: break test-notification into two separate test units
467. By Charles Kerr on 2016-11-04: remove unnecessary test in Awake::Impl::~Impl()

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-11-04:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-indicator-datetime-ci/7/rebuild

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Charles Kerr

Indicator Applet Developers

 === modified file 'include/datetime/snap.h'
 --- include/datetime/snap.h	2016-05-14 17:18:45 +0000
 +++ include/datetime/snap.h	2016-11-04 16:02:06 +0000
@@ -26,6 +26,8 @@
  #include <notifications/notifications.h>
  #include <notifications/sound.h>
++#include <gio/gio.h> // GDBusConnection
++
  #include <functional>
  #include <memory>
@@ -41,7 +43,8 @@
  public:
      Snap(const std::shared_ptr<unity::indicator::notifications::Engine>& engine,
           const std::shared_ptr<unity::indicator::notifications::SoundBuilder>& sound_builder,
--         const std::shared_ptr<const Settings>& settings);
++         const std::shared_ptr<const Settings>& settings,
++         GDBusConnection* system_bus);
      virtual ~Snap();
      enum class Response { None, Snooze, ShowApp };
 === modified file 'include/notifications/awake.h'
 --- include/notifications/awake.h	2015-03-31 18:54:26 +0000
 +++ include/notifications/awake.h	2016-11-04 16:02:06 +0000
@@ -22,6 +22,8 @@
  #include <memory>
++#include <gio/gio.h>
++
  namespace unity {
  namespace indicator {
  namespace notifications {
@@ -36,7 +38,7 @@
  class Awake
+ {
  public:
--    explicit Awake(const std::string& app_name);
++    explicit Awake(GDBusConnection* system_bus, const std::string& app_name);
      ~Awake();
  private:
 === modified file 'src/awake.cpp'
 --- src/awake.cpp	2016-07-05 19:42:21 +0000
 +++ src/awake.cpp	2016-11-04 16:02:06 +0000
@@ -36,68 +36,38 @@
+ {
  public:
--    Impl(const std::string& app_name):
++    Impl(GDBusConnection* bus, const std::string& app_name):
          m_app_name(app_name),
--        m_cancellable(g_cancellable_new())
++        m_cancellable(g_cancellable_new()),
++        m_system_bus{G_DBUS_CONNECTION(g_object_ref(bus))}
+     {
--        g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this);
++        // ask repowerd to keep the system awake
++        static constexpr int32_t POWERD_SYS_STATE_ACTIVE = 1;
++        g_dbus_connection_call (m_system_bus,
++                                BUS_POWERD_NAME,
++                                BUS_POWERD_PATH,
++                                BUS_POWERD_INTERFACE,
++                                "requestSysState",
++                                g_variant_new("(si)", m_app_name.c_str(), POWERD_SYS_STATE_ACTIVE),
++                                G_VARIANT_TYPE("(s)"),
++                                G_DBUS_CALL_FLAGS_NONE,
++                                -1,
++                                m_cancellable,
++                                on_force_awake_response,
++                                this);
++
+     }
      ~Impl()
+     {
          g_cancellable_cancel (m_cancellable);
          g_object_unref (m_cancellable);
--
--        if (m_system_bus != nullptr)
--        {
--            unforce_awake ();
--            g_object_unref (m_system_bus);
--        }
++        unforce_awake ();
++        g_clear_object (&m_system_bus);
+     }
  private:
--    static void on_system_bus_ready (GObject *,
--                                     GAsyncResult *res,
--                                     gpointer gself)
--    {
--        GError * error;
--        GDBusConnection * system_bus;
--
--        error = nullptr;
--        system_bus = g_bus_get_finish (res, &error);
--        if (error != nullptr)
--        {
--            if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
--                g_warning ("Unable to get bus: %s", error->message);
--
--            g_error_free (error);
--        }
--        else if (system_bus != nullptr)
--        {
--            auto self = static_cast<Impl*>(gself);
--
--            self->m_system_bus = G_DBUS_CONNECTION (g_object_ref (system_bus));
--
--            // ask powerd to keep the system awake
--            static constexpr int32_t POWERD_SYS_STATE_ACTIVE = 1;
--            g_dbus_connection_call (system_bus,
--                                    BUS_POWERD_NAME,
--                                    BUS_POWERD_PATH,
--                                    BUS_POWERD_INTERFACE,
--                                    "requestSysState",
--                                    g_variant_new("(si)", self->m_app_name.c_str(), POWERD_SYS_STATE_ACTIVE),
--                                    G_VARIANT_TYPE("(s)"),
--                                    G_DBUS_CALL_FLAGS_NONE,
--                                    -1,
--                                    self->m_cancellable,
--                                    on_force_awake_response,
--                                    self);
--
--            g_object_unref (system_bus);
--        }
--    }
--
      static void on_force_awake_response (GObject      * connection,
                                           GAsyncResult * res,
                                           gpointer       gself)
@@ -125,7 +95,6 @@
              g_clear_pointer (&self->m_awake_cookie, g_free);
              g_variant_get (args, "(s)", &self->m_awake_cookie);
--            g_debug ("m_awake_cookie is now '%s'", self->m_awake_cookie);
              g_variant_unref (args);
+         }
@@ -146,7 +115,7 @@
                                      nullptr,
                                      G_DBUS_CALL_FLAGS_NONE,
                                      -1,
--                                    nullptr,
++                                    m_cancellable,
                                      nullptr,
                                      nullptr);
@@ -164,8 +133,8 @@
  ****
  ***/
--Awake::Awake(const std::string& app_name):
--    impl(new Impl(app_name))
++Awake::Awake(GDBusConnection* system_bus, const std::string& app_name):
++    impl{new Impl{system_bus, app_name}}
+ {
+ }
 === modified file 'src/main.cpp'
 --- src/main.cpp	2016-05-14 17:18:45 +0000
 +++ src/main.cpp	2016-11-04 16:02:06 +0000
@@ -147,7 +147,7 @@
      auto snooze_planner = std::make_shared<SnoozePlanner>(state->settings, state->clock);
      auto notification_engine = std::make_shared<uin::Engine>("indicator-datetime-service");
      auto sound_builder = std::make_shared<uin::DefaultSoundBuilder>();
--    std::unique_ptr<Snap> snap (new Snap(notification_engine, sound_builder, state->settings));
++    std::unique_ptr<Snap> snap (new Snap(notification_engine, sound_builder, state->settings, system_bus));
      auto alarm_queue = create_simple_alarm_queue(state->clock, snooze_planner, engine, timezone_);
      auto on_response = [snooze_planner, actions](const Appointment& appointment, const Alarm& alarm, const Snap::Response& response) {
          switch(response) {
 === modified file 'src/snap.cpp'
 --- src/snap.cpp	2016-07-04 23:44:47 +0000
 +++ src/snap.cpp	2016-11-04 16:02:06 +0000
@@ -53,20 +53,24 @@
      Impl(const std::shared_ptr<unity::indicator::notifications::Engine>& engine,
           const std::shared_ptr<unity::indicator::notifications::SoundBuilder>& sound_builder,
--         const std::shared_ptr<const Settings>& settings):
++         const std::shared_ptr<const Settings>& settings,
++         GDBusConnection* system_bus):
        m_engine(engine),
        m_sound_builder(sound_builder),
        m_settings(settings),
--      m_cancellable(g_cancellable_new())
++      m_cancellable(g_cancellable_new()),
++      m_system_bus{G_DBUS_CONNECTION(g_object_ref(system_bus))}
+     {
          auto object_path = g_strdup_printf("/org/freedesktop/Accounts/User%lu", (gulong)getuid());
--        accounts_service_sound_proxy_new_for_bus(G_BUS_TYPE_SYSTEM,
--                                                 G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
--                                                 "org.freedesktop.Accounts",
--                                                 object_path,
--                                                 m_cancellable,
--                                                 on_sound_proxy_ready,
--                                                 this);
++
++
++        accounts_service_sound_proxy_new(m_system_bus,
++                                         G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
++                                         "org.freedesktop.Accounts",
++                                         object_path,
++                                         m_cancellable,
++                                         on_sound_proxy_ready,
++                                         this);
          g_free(object_path);
+     }
@@ -75,6 +79,7 @@
          g_cancellable_cancel(m_cancellable);
          g_clear_object(&m_cancellable);
          g_clear_object(&m_accounts_service_sound_proxy);
++        g_clear_object(&m_system_bus);
          for (const auto& key : m_notifications)
              m_engine->close (key);
@@ -99,7 +104,7 @@
          // force the system to stay awake
          std::shared_ptr<uin::Awake> awake;
          if (appointment.is_ubuntu_alarm() || calendar_bubbles_enabled() || calendar_list_enabled()) {
--            awake = std::make_shared<uin::Awake>(m_engine->app_name());
++            awake = std::make_shared<uin::Awake>(m_system_bus, m_engine->app_name());
+         }
          // calendar events are muted in silent mode; alarm clocks never are
@@ -229,7 +234,7 @@
          GError * error;
          error = nullptr;
--        auto proxy = accounts_service_sound_proxy_new_for_bus_finish (res, &error);
++        auto proxy = accounts_service_sound_proxy_new_finish (res, &error);
          if (error != nullptr)
+         {
              if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
@@ -296,6 +301,7 @@
      std::set<int> m_notifications;
      GCancellable * m_cancellable {nullptr};
      AccountsServiceSound * m_accounts_service_sound_proxy {nullptr};
++    GDBusConnection * m_system_bus {nullptr};
      static constexpr char const * ACTION_NONE {"none"};
      static constexpr char const * ACTION_SNOOZE {"snooze"};
@@ -308,8 +314,9 @@
  Snap::Snap(const std::shared_ptr<unity::indicator::notifications::Engine>& engine,
             const std::shared_ptr<unity::indicator::notifications::SoundBuilder>& sound_builder,
--           const std::shared_ptr<const Settings>& settings):
--  impl(new Impl(engine, sound_builder, settings))
++           const std::shared_ptr<const Settings>& settings,
++           GDBusConnection* system_bus):
++  impl(new Impl(engine, sound_builder, settings, system_bus))
+ {
+ }
 === modified file 'tests/CMakeLists.txt'
 --- tests/CMakeLists.txt	2016-06-28 13:26:17 +0000
 +++ tests/CMakeLists.txt	2016-11-04 16:02:06 +0000
@@ -49,6 +49,7 @@
  add_test_by_name(test-datetime)
  add_test_by_name(test-sound)
  add_test_by_name(test-notification)
++add_test_by_name(test-notification-response)
  add_test_by_name(test-actions)
  add_test_by_name(test-alarm-queue)
  add_test(NAME dear-reader-the-next-test-takes-60-seconds COMMAND true)
 === modified file 'tests/libdbusmock-fixture.h'
 --- tests/libdbusmock-fixture.h	2016-02-10 20:48:24 +0000
 +++ tests/libdbusmock-fixture.h	2016-11-04 16:02:06 +0000
@@ -75,14 +75,7 @@
      // 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++;
--      }
++    wait_for([this](){return system_bus==nullptr && session_bus==nullptr;}, 5000);
      super::TearDown();
+   }
 === modified file 'tests/manual-test-snap.cpp'
 --- tests/manual-test-snap.cpp	2016-05-14 17:20:00 +0000
 +++ tests/manual-test-snap.cpp	2016-11-04 16:02:06 +0000
@@ -95,10 +95,12 @@
      auto notification_engine = std::make_shared<uin::Engine>("indicator-datetime-service");
      auto sound_builder = std::make_shared<uin::DefaultSoundBuilder>();
--    Snap snap (notification_engine, sound_builder, settings);
++    auto system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, nullptr);
++    Snap snap (notification_engine, sound_builder, settings, system_bus);
      snap(a, a.alarms.front(), on_response);
      g_main_loop_run(loop);
      g_main_loop_unref(loop);
++    g_clear_object(&system_bus);
      return 0;
+ }
 === modified file 'tests/notification-fixture.h'
 --- tests/notification-fixture.h	2016-05-14 02:07:10 +0000
 +++ tests/notification-fixture.h	2016-11-04 16:02:06 +0000
@@ -334,7 +334,7 @@
                const std::shared_ptr<unity::indicator::notifications::SoundBuilder>& sb,
                const std::shared_ptr<unity::indicator::datetime::Settings>& settings)
+   {
--    auto snap = std::make_shared<unity::indicator::datetime::Snap>(ne, sb, settings);
++    auto snap = std::make_shared<unity::indicator::datetime::Snap>(ne, sb, settings, system_bus);
      wait_msec(100); // wait a moment for the Snap to finish its async dbus bootstrapping
      return snap;
+   }
 === added file 'tests/test-notification-response.cpp'
 --- tests/test-notification-response.cpp	1970-01-01 00:00:00 +0000
 +++ tests/test-notification-response.cpp	2016-11-04 16:02:06 +0000
@@ -0,0 +1,144 @@
++/*
++ * 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 <charles.kerr@canonical.com>
++ */
++
++#include <datetime/appointment.h>
++#include <datetime/settings.h>
++#include <datetime/snap.h>
++
++#include "notification-fixture.h"
++
++/***
++****
++***/
++
++using namespace unity::indicator::datetime;
++
++namespace
++{
++  static constexpr char const * APP_NAME {"indicator-datetime-service"};
++
++  gboolean quit_idle (gpointer gloop)
++  {
++    g_main_loop_quit(static_cast<GMainLoop*>(gloop));
++    return G_SOURCE_REMOVE;
++  }
++}
++
++/***
++****
++***/
++
++TEST_F(NotificationFixture,Response)
++{
++  // create the world
++  make_interactive();
++  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
++  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
++  auto settings = std::make_shared<Settings>();
++  int next_notification_id {FIRST_NOTIFY_ID};
++
++  // set a response callback that remembers what response we got
++  bool on_response_called {};
++  Snap::Response response {};
++  auto on_response = [this, &on_response_called, &response]
++                     (const Appointment&, const Alarm&, const Snap::Response& r){
++    on_response_called = true;
++    response = r;
++    g_idle_add(quit_idle, loop);
++  };
++
++  // our tests!
++  const struct {
++    Appointment appt;
++    std::vector<std::string> expected_actions;
++    std::string action;
++    Snap::Response expected_response;
++  } tests[] = {
++    { appt,   {"show-app"},       "show-app", Snap::Response::ShowApp },
++    { ualarm, {"none", "snooze"}, "snooze",   Snap::Response::Snooze  },
++    { ualarm, {"none", "snooze"}, "none",     Snap::Response::None    }
++  };
++
++
++  settings->cal_notification_enabled.set(true);
++  settings->cal_notification_sounds.set(true);
++  settings->cal_notification_vibrations.set(true);
++  settings->cal_notification_bubbles.set(true);
++  settings->cal_notification_list.set(true);
++
++  // walk through the tests
++  for (const auto& test : tests)
++  {
++    // wait for previous iterations' bus noise to finish and reset the counters
++    GError* error {};
++    wait_msec(500);
++    dbus_test_dbus_mock_object_clear_method_calls(notify_mock, notify_obj, &error);
++    g_assert_no_error(error);
++    on_response_called = false;
++
++    // create a snap decision
++    auto snap = create_snap(ne, sb, settings);
++    (*snap)(test.appt, test.appt.alarms.front(), on_response);
++
++    // wait for the notification to show up
++    EXPECT_METHOD_CALLED_EVENTUALLY(notify_mock, notify_obj, METHOD_NOTIFY);
++
++    // test that Notify was called the right number of times
++    static constexpr int expected_num_notify_calls {1};
++    guint num_notify_calls {};
++    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);
++    EXPECT_EQ(expected_num_notify_calls, num_notify_calls);
++
++    // test that Notify was called with the correct list of actions
++    if (num_notify_calls > 0) {
++      std::vector<std::string> actions;
++      const gchar** as {nullptr};
++      g_variant_get_child(notify_calls[0].params, 5, "^a&s", &as);
++      for (int i=0; as && as[i]; i+=2) // actions are in pairs of (name, i18n), skip the i18n
++        actions.push_back(as[i]);
++      EXPECT_EQ(test.expected_actions, actions);
++    }
++
++    // make the notification mock tell the world that the user invoked an action
++    const auto notification_id = next_notification_id++;
++    idle_add([this, notification_id, test](){
++      GError* err {};
++      dbus_test_dbus_mock_object_emit_signal(notify_mock, notify_obj, "ActionInvoked",
++        G_VARIANT_TYPE("(us)"),
++        g_variant_new("(us)", guint(notification_id), test.action.c_str()),
++        &err);
++      dbus_test_dbus_mock_object_emit_signal(notify_mock, notify_obj, "NotificationClosed",
++        G_VARIANT_TYPE("(uu)"),
++        g_variant_new("(uu)", guint(notification_id), guint(NOTIFICATION_CLOSED_DISMISSED)),
++        &err);
++      g_assert_no_error(err);
++      return G_SOURCE_REMOVE;
++    });
++
++    // confirm that the response callback got the right response
++    EXPECT_TRUE(wait_for([&on_response_called](){return on_response_called;}));
++    EXPECT_EQ(int(test.expected_response), int(response)) << "notification_id " << notification_id;
++  }
++}
 === modified file 'tests/test-notification.cpp'
 --- tests/test-notification.cpp	2016-06-24 12:26:06 +0000
 +++ tests/test-notification.cpp	2016-11-04 16:02:06 +0000
@@ -196,103 +196,3 @@
+   }
+   }
+ }
--
--
--TEST_F(NotificationFixture,Response)
--{
--  // create the world
--  make_interactive();
--  auto ne = std::make_shared<unity::indicator::notifications::Engine>(APP_NAME);
--  auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
--  auto settings = std::make_shared<Settings>();
--  int next_notification_id {FIRST_NOTIFY_ID};
--
--  // set a response callback that remembers what response we got
--  bool on_response_called {};
--  Snap::Response response {};
--  auto on_response = [this, &on_response_called, &response]
--                     (const Appointment&, const Alarm&, const Snap::Response& r){
--    on_response_called = true;
--    response = r;
--    g_idle_add(quit_idle, loop);
--  };
--
--  // our tests!
--  const struct {
--    Appointment appt;
--    std::vector<std::string> expected_actions;
--    std::string action;
--    Snap::Response expected_response;
--  } tests[] = {
--    { appt,   {"show-app"},       "show-app", Snap::Response::ShowApp },
--    { ualarm, {"none", "snooze"}, "snooze",   Snap::Response::Snooze  },
--    { ualarm, {"none", "snooze"}, "none",     Snap::Response::None    }
--  };
--
--
--  settings->cal_notification_enabled.set(true);
--  settings->cal_notification_sounds.set(true);
--  settings->cal_notification_vibrations.set(true);
--  settings->cal_notification_bubbles.set(true);
--  settings->cal_notification_list.set(true);
--
--  // walk through the tests
--  for (const auto& test : tests)
--  {
--    // wait for previous iterations' bus noise to finish and reset the counters
--    GError* error {};
--    wait_msec(500);
--    dbus_test_dbus_mock_object_clear_method_calls(notify_mock, notify_obj, &error);
--    g_assert_no_error(error);
--    on_response_called = false;
--
--    // create a snap decision
--    auto snap = create_snap(ne, sb, settings);
--    (*snap)(test.appt, test.appt.alarms.front(), on_response);
--
--    // wait for the notification to show up
--    EXPECT_METHOD_CALLED_EVENTUALLY(notify_mock, notify_obj, METHOD_NOTIFY);
--
--    // test that Notify was called the right number of times
--    static constexpr int expected_num_notify_calls {1};
--    guint num_notify_calls {};
--    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);
--    EXPECT_EQ(expected_num_notify_calls, num_notify_calls);
--
--    // test that Notify was called with the correct list of actions
--    if (num_notify_calls > 0) {
--      std::vector<std::string> actions;
--      const gchar** as {nullptr};
--      g_variant_get_child(notify_calls[0].params, 5, "^a&s", &as);
--      for (int i=0; as && as[i]; i+=2) // actions are in pairs of (name, i18n), skip the i18n
--        actions.push_back(as[i]);
--      EXPECT_EQ(test.expected_actions, actions);
--    }
--
--    // make the notification mock tell the world that the user invoked an action
--    const auto notification_id = next_notification_id++;
--    idle_add([this, notification_id, test](){
--      GError* err {};
--      dbus_test_dbus_mock_object_emit_signal(notify_mock, notify_obj, "ActionInvoked",
--        G_VARIANT_TYPE("(us)"),
--        g_variant_new("(us)", guint(notification_id), test.action.c_str()),
--        &err);
--      dbus_test_dbus_mock_object_emit_signal(notify_mock, notify_obj, "NotificationClosed",
--        G_VARIANT_TYPE("(uu)"),
--        g_variant_new("(uu)", guint(notification_id), guint(NOTIFICATION_CLOSED_DISMISSED)),
--        &err);
--      g_assert_no_error(err);
--      return G_SOURCE_REMOVE;
--    });
--
--    // confirm that the response callback got the right response
--    EXPECT_TRUE(wait_for([&on_response_called](){return on_response_called;}));
--    EXPECT_EQ(int(test.expected_response), int(response)) << "notification_id " << notification_id;
--  }
--}