Merge lp:~aacid/unity/do_not_reuse_menus_on_order_change into lp:unity

[Albert Astals Cid]

Do not reuse the menu entries if their order changes

Since the indicators api only have "add" and "remove" signals, if we reuse an entry that is not in the correct order it will case the menus or whatever this indicator represents to be in the wrong order

Do not reuse the menu entries if their order changes

Since the indicators api only have "add" and "remove" signals, if we reuse an entry that is not in the correct order it will case the menus or whatever this indicator represents to be in the wrong order

[Albert Astals Cid (aacid)]

Working in a unittest

[Albert Astals Cid (aacid)]

Unit test added

[Marco Trevisan (Treviño) (3v1n0)]

112 + DBusIndicators(const std::string &dbus_name = "com.canonical.Unity.Panel.Service");

In unity we prefer to use this syntax instead:
  std::string const& dbus_name

8 -const std::string SERVICE_NAME("com.canonical.Unity.Panel.Service");

However, probably instead of adding an optional parameter, I would add another one (better if protected, so that you'll make accessible only in a test mock class) that takes the service name parameter.

91 + : connected(false), pimpl(new Impl(dbus_name, this))

Better two lines here.

115 + nux::Property<bool> connected;

Don't use a property here, for two reasons: a non-RO property like is this one, is meant to be editable, while you only use to store a value; also you don't really need that... Just add an IsConnected() (protected as well?) method that proxies gproxy_.IsConnected().

On the testing side, yes... That's what I meant: good! :)

However, on code side you can be more clean by using the TestDBusIndicators class: so, add in the constructor (or in a SetUp() function) the calls you're duplicating in the tests to initialize them, and the cleanup calls in a TearDown() method.

Also instead of using g_timeout, you can use glib::Timeout, since probably you won't able to use utils::WaitUntil

+ session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);

I guess that using a glib::DbusProxy would be better here.

182 === added file 'tests/test_dbusindicators.cpp'

I'd prefer it to be named test_dbus_indicators.cpp

PS: also cleanup the commented code in test.

review: Needs Fixing

[Albert Astals Cid (aacid)]

ok, all suggestions should be implemented if i did not miss something

[Marco Trevisan (Treviño) (3v1n0)]

331 + DBusIndicatorsTest* dbus_indicators;

Would be nice to have DBusIndicators::Ptr instead, so you don't need to worry about destruction (unless it must be done before unreffing the loop)

336 +TEST_F(TestDBusIndicators, TestConstruction)
337 +{
338 + SetUp();

357 + TearDown();
358 +}

No need to do this... GTest will do this automatically, so forget about setting-up and tearing-down once you've defined these testing::Test functions.

341 + auto timeout_check = [&] () -> bool
342 + {
343 + nChecks++;
344 + bool quit_loop = dbus_indicators->IsConnected() || nChecks > 99;
345 + if (quit_loop)
346 + g_main_loop_quit(loop_);
347 + return !quit_loop;
348 + };
349
350 + nChecks = 0;
351 + timeout.reset(new glib::Timeout(100, timeout_check));
352 +
353 + g_main_loop_run(loop_);

No need to repeat this for every test...

Just do it in the SetUp function, and probably instead of quitting the loop is enough to add an ASSERT there.

[Marco Trevisan (Treviño) (3v1n0)]

108 + GVariant *CallSync(string const& method_name,
109 + GVariant* parameters,

Ah, please also add the * near to the typename (i.e. GVariant*) and, fix the parameters indentation.

[Albert Astals Cid (aacid)]

Second round of updates hope i did not miss anything :-)

[Marco Trevisan (Treviño) (3v1n0)]

Thanks a lot for your changes (and patience), it looks very nice now! ;)

review: Approve

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/1502/console reported an error when processing this lp:~aacid/unity/do_not_reuse_menus_on_order_change branch.
Not merging it.

=== modified file 'UnityCore/DBusIndicators.cpp'
--- UnityCore/DBusIndicators.cpp	2012-06-18 02:57:23 +0000
+++ UnityCore/DBusIndicators.cpp	2012-10-08 14:36:19 +0000
@@ -48,7 +48,7 @@
 class DBusIndicators::Impl
 {
 public:
-  Impl(DBusIndicators* owner);
+  Impl(std::string const& dbus_name, DBusIndicators* owner);
 
   void CheckLocalService();
   void RequestSyncAll();
@@ -84,9 +84,9 @@
 
 
 // Public Methods
-DBusIndicators::Impl::Impl(DBusIndicators* owner)
+DBusIndicators::Impl::Impl(std::string const& dbus_name, DBusIndicators* owner)
   : owner_(owner)
-  , gproxy_(SERVICE_NAME, SERVICE_PATH, SERVICE_IFACE,
+  , gproxy_(dbus_name, SERVICE_PATH, SERVICE_IFACE,
             G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES)
 {
   gproxy_.Connect("ReSync", sigc::mem_fun(this, &DBusIndicators::Impl::OnReSync));
@@ -276,6 +276,8 @@
     return;
 
   std::map<Indicator::Ptr, Indicator::Entries> indicators;
+  int wantedIndex = 0;
+  bool anyIndexDifferent = false;
 
   g_variant_get(args, "(a(ssssbbusbbi))", &iter);
   while (g_variant_iter_loop(iter, "(ssssbbusbbi)",
@@ -305,7 +307,18 @@
     // Null entries (entry_id == "") are empty indicators.
     if (entry != "")
     {
-      Entry::Ptr e = indicator->GetEntry(entry_id);
+      Entry::Ptr e;
+      if (!anyIndexDifferent)
+      {
+        // Indicators can only add or remove entries, so if
+        // there is a index change we can't reuse the existing ones
+        // after that index
+        int existingEntryIndex = indicator->EntryIndex(entry_id);
+        if (wantedIndex == existingEntryIndex)
+          e = indicator->GetEntry(entry_id);
+        else
+          anyIndexDifferent = true;
+      }
 
       if (!e)
       {
@@ -321,6 +334,7 @@
       }
 
       entries.push_back(e);
+      wantedIndex++;
     }
   }
   g_variant_iter_free(iter);
@@ -393,12 +407,21 @@
 }
 
 DBusIndicators::DBusIndicators()
-  : pimpl(new Impl(this))
+  : pimpl(new Impl(SERVICE_NAME, this))
+{}
+
+DBusIndicators::DBusIndicators(std::string const& dbus_name)
+  : pimpl(new Impl(dbus_name, this))
 {}
 
 DBusIndicators::~DBusIndicators()
 {}
 
+bool DBusIndicators::IsConnected() const
+{
+  return pimpl->gproxy_.IsConnected();
+}
+
 void DBusIndicators::SyncGeometries(std::string const& name,
                                     EntryLocationMap const& locations)
 {

=== modified file 'UnityCore/DBusIndicators.h'
--- UnityCore/DBusIndicators.h	2012-06-18 02:57:23 +0000
+++ UnityCore/DBusIndicators.h	2012-10-08 14:36:19 +0000
@@ -50,6 +50,10 @@
   virtual void OnShowAppMenu(unsigned int xid, int x, int y,
                              unsigned int timestamp);
 
+protected:
+  DBusIndicators(std::string const& dbus_name);
+  bool IsConnected() const;
+
 private:
   class Impl;
   std::unique_ptr<Impl> pimpl;

=== modified file 'UnityCore/Indicator.cpp'
--- UnityCore/Indicator.cpp	2012-08-08 06:57:43 +0000
+++ UnityCore/Indicator.cpp	2012-10-08 14:36:19 +0000
@@ -115,6 +115,21 @@
   return Entry::Ptr();
 }
 
+int Indicator::EntryIndex(std::string const& entry_id) const
+{
+  int i = 0;
+  for (auto entry : entries_)
+  {
+    if (entry->id() == entry_id)
+    {
+      return i;
+    }
+    ++i;
+  }
+
+  return -1;
+}
+
 void Indicator::OnEntryShowMenu(std::string const& entry_id, unsigned int xid,
                                 int x, int y, unsigned int button, unsigned int timestamp)
 {

=== modified file 'UnityCore/Indicator.h'
--- UnityCore/Indicator.h	2012-06-18 02:57:23 +0000
+++ UnityCore/Indicator.h	2012-10-08 14:36:19 +0000
@@ -48,6 +48,7 @@
 
   void Sync(Entries const& new_entries);
   Entry::Ptr GetEntry(std::string const& entry_id) const;
+  int EntryIndex(std::string const& entry_id) const;
   Entries GetEntries() const;
 
   // Signals

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-10-08 06:36:17 +0000
+++ tests/CMakeLists.txt	2012-10-08 14:36:19 +0000
@@ -110,7 +110,9 @@
                  test_service_lens.h
                  test_service_main.c
                  test_service_model.c
-                 test_service_model.h)
+                 test_service_model.h
+                 test_service_panel.c
+                 test_service_panel.c)
   target_link_libraries(test-gtest-service unity-shared ${LIBS})
   add_dependencies (test-gtest-service unity-core-${UNITY_API_VERSION} gtest)
 
@@ -194,6 +196,7 @@
                  test_utils.h
                  test_ratings_filter.cpp
                  test_results.cpp
+                 test_dbus_indicators.cpp
                 )
   target_link_libraries(test-gtest-dbus gtest unity-shared ${LIBS})
   add_test(UnityGTestDBus test-gtest-dbus)

=== added file 'tests/test_dbus_indicators.cpp'
--- tests/test_dbus_indicators.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_dbus_indicators.cpp	2012-10-08 14:36:19 +0000
@@ -0,0 +1,99 @@
+#include <gtest/gtest.h>
+
+#include <UnityCore/GLibDBusProxy.h>
+#include <UnityCore/GLibSource.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/DBusIndicators.h>
+
+#include "test_utils.h"
+
+using namespace unity;
+using namespace unity::indicator;
+
+namespace
+{
+
+class DBusIndicatorsTest : public DBusIndicators
+{
+public:
+  DBusIndicatorsTest() : DBusIndicators("com.canonical.Unity.Test")
+  {
+  }
+
+  bool HasIndicators() const
+  {
+    return !GetIndicators().empty();
+  }
+
+  using DBusIndicators::IsConnected;
+};
+
+class TestDBusIndicators : public ::testing::Test
+{
+public:
+  void SetUp()
+  {
+    session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+    g_dbus_connection_set_exit_on_close(session, FALSE);
+
+    dbus_indicators.reset(new DBusIndicatorsTest ());
+
+    // wait until the dbus indicator has connected to the panel service
+    Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::IsConnected));
+  }
+
+  bool TriggerResync1Sent() const
+  {
+    GVariant *ret = CallPanelMethod("TriggerResync1Sent");
+    return g_variant_get_boolean(g_variant_get_child_value(ret, 0));
+  }
+
+  GVariant* CallPanelMethod(std::string const& name) const
+  {
+    return g_dbus_connection_call_sync(session,
+                                       "com.canonical.Unity.Test",
+                                       "/com/canonical/Unity/Panel/Service",
+                                       "com.canonical.Unity.Panel.Service",
+                                       name.c_str(),
+                                       NULL,
+                                       NULL,
+                                       G_DBUS_CALL_FLAGS_NONE,
+                                       -1,
+                                       NULL,
+                                       NULL);
+  }
+
+  glib::Object<GDBusConnection> session;
+  std::shared_ptr<DBusIndicatorsTest> dbus_indicators;
+};
+
+TEST_F(TestDBusIndicators, TestConstruction)
+{
+  EXPECT_EQ(dbus_indicators->IsConnected(), true);
+}
+
+TEST_F(TestDBusIndicators, TestSync)
+{
+  // wait until the dbus indicator gets any indicator from the panel service
+  Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::HasIndicators));
+
+  EXPECT_EQ(dbus_indicators->GetIndicators().size(), 1);
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().size(), 2);
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().front()->id(), "test_entry_id");
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().back()->id(), "test_entry_id2");
+
+  // Tell the service to trigger a resync and to send the entries in the reverse order
+  CallPanelMethod("TriggerResync1");
+
+  Utils::WaitUntil(sigc::mem_fun(this, &TestDBusIndicators::TriggerResync1Sent));
+  // We know the resync has been sent, but it may have not been processed
+  // so do one interation of the main loop more
+  g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+  EXPECT_EQ(dbus_indicators->GetIndicators().size(), 1);
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().size(), 2);
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().front()->id(), "test_entry_id2");
+  EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().back()->id(), "test_entry_id");
+}
+
+}

=== modified file 'tests/test_indicator.cpp'
--- tests/test_indicator.cpp	2012-02-01 01:55:05 +0000
+++ tests/test_indicator.cpp	2012-10-08 14:36:19 +0000
@@ -35,6 +35,7 @@
   EXPECT_EQ(indicator.name(), "indicator-test");
   EXPECT_FALSE(indicator.IsAppmenu());
   EXPECT_EQ(indicator.GetEntry("test-entry"), nullptr);
+  EXPECT_EQ(indicator.EntryIndex("test-entry"), -1);
   EXPECT_TRUE(indicator.GetEntries().empty());
 }
 
@@ -76,6 +77,7 @@
   indicator.Sync(sync_data);
   EXPECT_EQ(indicator.GetEntries().size(), 3);
   EXPECT_EQ(indicator.GetEntry("test-entry-2"), entry2);
+  EXPECT_EQ(indicator.EntryIndex("test-entry-2"), 1);
   EXPECT_EQ(added.size(), 3);
   EXPECT_EQ(added.front()->id(), "test-entry-1");
   EXPECT_EQ(added.back()->id(), "test-entry-3");
@@ -91,6 +93,7 @@
   indicator.Sync(sync_data);
   EXPECT_EQ(indicator.GetEntries().size(), 2);
   EXPECT_EQ(indicator.GetEntry("test-entry-2"), nullptr);
+  EXPECT_EQ(indicator.EntryIndex("test-entry-2"), -1);
   EXPECT_EQ(added.size(), 0);
   EXPECT_EQ(removed.size(), 1);
   EXPECT_EQ(removed.front(), entry2->id());

=== modified file 'tests/test_service_main.c'
--- tests/test_service_main.c	2012-03-14 06:24:18 +0000
+++ tests/test_service_main.c	2012-10-08 14:36:19 +0000
@@ -3,6 +3,7 @@
 #include "test_service_lens.h"
 #include "test_service_model.h"
 #include "test_service_hud.h"
+#include "test_service_panel.h"
 #include "test_service_gdbus_wrapper.h"
 
 static void on_bus_aquired(GDBusConnection* conn, const gchar* name, gpointer null);
@@ -37,6 +38,7 @@
 static ServiceLens* lens_ = NULL;
 static ServiceModel* model_ = NULL;
 static ServiceHud* hud_ = NULL;
+static ServicePanel* panel_ = NULL;
 static ServiceGDBusWrapper* gdbus_wrapper_ = NULL;
 gint
 main(gint argc, gchar** argv)
@@ -48,6 +50,7 @@
   lens_ = service_lens_new();
   model_ = service_model_new();
   hud_ = service_hud_new();
+  panel_ = service_panel_new();
   gdbus_wrapper_ = service_gdbus_wrapper_new();
 
   g_bus_own_name(G_BUS_TYPE_SESSION,
@@ -65,6 +68,7 @@
   //g_object_unref(lens_);
   //g_object_unref(model_);
   g_object_unref(hud_);
+  g_object_unref(panel_);
   g_dbus_node_info_unref(introspection_data);
 
   return 0;

=== added file 'tests/test_service_panel.c'
--- tests/test_service_panel.c	1970-01-01 00:00:00 +0000
+++ tests/test_service_panel.c	2012-10-08 14:36:19 +0000
@@ -0,0 +1,253 @@
+#include "test_service_panel.h"
+#include <unity.h>
+#include <gio/gio.h>
+
+static const char * panel_interface = 
+"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+"<node name=\"/\">\n"
+"        <interface name=\"com.canonical.Unity.Panel.Service\">\n"
+"\n"
+"<!-- Begin of real methods/signals -->\n"
+"    <method name='Sync'>"
+"      <arg type='a(ssssbbusbbi)' name='state' direction='out'/>"
+"    </method>"
+"\n"
+"    <signal name='ReSync'>"
+"     <arg type='s' name='indicator_id' />"
+"    </signal>"
+"\n"
+"<!-- Begin of test only methods/signals -->\n"
+"\n"
+"    <method name='TriggerResync1' />"
+"\n"
+"    <method name='TriggerResync1Sent'>"
+"      <arg type='b' name='sent' direction='out'/>"
+"    </method>"
+"\n"
+"        </interface>\n"
+"</node>\n"
+;
+static void bus_got_cb          (GObject *object, GAsyncResult * res, gpointer user_data);
+static void bus_method          (GDBusConnection *connection,
+                                const gchar *sender,
+                                const gchar *object_path,
+                                const gchar *interface_name,
+                                const gchar *method_name,
+                                GVariant *parameters,
+                                GDBusMethodInvocation *invocation,
+                                gpointer user_data);
+
+G_DEFINE_TYPE(ServicePanel, service_panel, G_TYPE_OBJECT);
+static GDBusNodeInfo * node_info = NULL;
+static GDBusInterfaceInfo * iface_info = NULL;
+static GDBusInterfaceVTable bus_vtable = {
+  method_call: bus_method,
+  get_property: NULL,
+  set_property: NULL,
+};
+
+struct _ServicePanelPrivate
+{
+  GDBusConnection * bus;
+  GCancellable * bus_lookup;
+  guint bus_registration;
+  guint sig_emission_handle;
+};
+
+static void
+service_panel_dispose(GObject* object)
+{
+  ServicePanel* self = SERVICE_PANEL(object);
+  if (self->priv->bus_lookup != NULL) {
+    g_cancellable_cancel(self->priv->bus_lookup);
+    g_object_unref(self->priv->bus_lookup);
+    self->priv->bus_lookup = NULL;
+  }
+
+  if (self->priv->bus_registration != 0) {
+    g_dbus_connection_unregister_object(self->priv->bus, self->priv->bus_registration);
+    self->priv->bus_registration = 0;
+  }
+
+  if (self->priv->bus != NULL) {
+    g_object_unref(self->priv->bus);
+    self->priv->bus = NULL;
+  }
+
+  if (self->priv->sig_emission_handle) {
+    g_source_remove(self->priv->sig_emission_handle);
+    self->priv->sig_emission_handle = 0;
+  }
+
+}
+
+static void
+service_panel_class_init(ServicePanelClass* klass)
+{
+  G_OBJECT_CLASS(klass)->dispose = service_panel_dispose;
+  g_type_class_add_private (klass, sizeof (ServicePanelPrivate));
+
+  if (node_info == NULL) 
+  {
+    GError * error = NULL;
+
+    node_info = g_dbus_node_info_new_for_xml(panel_interface, &error);
+    if (error != NULL) 
+    {
+        g_error("Unable to parse Panel interface: %s", error->message);
+        g_error_free(error);
+    }
+  }
+
+  if (node_info != NULL && iface_info == NULL) 
+  {
+    iface_info = g_dbus_node_info_lookup_interface(node_info,"com.canonical.Unity.Panel.Service");
+    if (iface_info == NULL) 
+    {
+      g_error("Unable to find interface 'com.canonical.Unity.Panel.Service'");
+    }
+  }
+
+}
+
+static void
+service_panel_init(ServicePanel* self)
+{
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, SERVICE_TYPE_PANEL, ServicePanelPrivate);
+  self->priv->bus = NULL;
+  self->priv->bus_lookup = NULL;
+  self->priv->bus_registration = 0;
+  
+  self->priv->bus_lookup = g_cancellable_new();
+  g_bus_get(G_BUS_TYPE_SESSION, self->priv->bus_lookup, bus_got_cb, self);
+}
+
+ServicePanel*
+service_panel_new()
+{
+  return g_object_new(SERVICE_TYPE_PANEL, NULL);
+}
+
+static void
+bus_got_cb (GObject *object, GAsyncResult * res, gpointer user_data)
+{
+  GError * error = NULL;
+  ServicePanel * self = SERVICE_PANEL(user_data);
+  GDBusConnection * bus;
+
+  bus = g_bus_get_finish(res, &error);
+  if (error != NULL) {
+    g_critical("Unable to get bus: %s", error->message);
+    g_error_free(error);
+    return;
+  }
+
+  self->priv->bus = bus;
+
+  /* Register object */
+  self->priv->bus_registration = g_dbus_connection_register_object(bus,
+                                                  /* path */       "/com/canonical/Unity/Panel/Service",
+                                                  /* interface */  iface_info,
+                                                  /* vtable */     &bus_vtable,
+                                                  /* userdata */   self,
+                                                  /* destroy */    NULL,
+                                                  /* error */      &error);
+
+  if (error != NULL) {
+    g_critical ("Unable to create bus connection object, %s", error->message);
+    g_error_free(error);
+    return;
+  }
+
+  return;
+}
+
+static void
+add_entry_id(GVariantBuilder *b)
+{
+  g_variant_builder_add (b, "(ssssbbusbbi)",
+                      "test_indicator_id",
+                      "test_entry_id",
+                      "test_entry_name_hint",
+                      "test_entry_label",
+                      TRUE, /* label sensitive */
+                      TRUE, /* label visible */
+                      0, /* image type */
+                      "", /* image_data */
+                      TRUE, /* image sensitive */
+                      TRUE, /* image visible */
+                      1 /* priority  */);
+}
+
+static void
+add_entry_id_2(GVariantBuilder *b)
+{
+  g_variant_builder_add (b, "(ssssbbusbbi)",
+                      "test_indicator_id",
+                      "test_entry_id2",
+                      "test_entry_name_hint2",
+                      "test_entry_label2",
+                      TRUE, /* label sensitive */
+                      TRUE, /* label visible */
+                      0, /* image type */
+                      "", /* image_data */
+                      TRUE, /* image sensitive */
+                      TRUE, /* image visible */
+                      1 /* priority  */);
+}
+
+static int sync_return_mode = 0;
+static int trigger_resync1_sent = FALSE;
+
+static void
+bus_method (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data)
+{
+  if (g_strcmp0(method_name, "Sync") == 0) 
+  {
+    GVariantBuilder b;
+
+    g_variant_builder_init (&b, G_VARIANT_TYPE ("(a(ssssbbusbbi))"));
+    g_variant_builder_open (&b, G_VARIANT_TYPE ("a(ssssbbusbbi)"));
+
+    if (sync_return_mode == 0)
+    {
+      add_entry_id(&b);
+      add_entry_id_2(&b);
+    }
+    else if (sync_return_mode == 1)
+    {
+      add_entry_id_2(&b);
+      add_entry_id(&b);
+    }
+
+    g_variant_builder_close (&b);
+
+    g_dbus_method_invocation_return_value(invocation, g_variant_builder_end (&b));
+
+    if (sync_return_mode == 1)
+    {
+      trigger_resync1_sent = TRUE;
+    }
+  }
+  else if (g_strcmp0(method_name, "TriggerResync1") == 0) 
+  {
+    sync_return_mode = 1;
+    trigger_resync1_sent = FALSE;
+
+    g_dbus_method_invocation_return_value(invocation, NULL);
+    GVariantBuilder ret_builder;
+    g_variant_builder_init(&ret_builder, G_VARIANT_TYPE_TUPLE);
+    g_variant_builder_add_value(&ret_builder, g_variant_new_string(""));
+    g_dbus_connection_emit_signal (connection, NULL, "/com/canonical/Unity/Panel/Service", "com.canonical.Unity.Panel.Service", "ReSync", g_variant_builder_end(&ret_builder), NULL);
+  }
+  else if (g_strcmp0(method_name, "TriggerResync1Sent") == 0) 
+  {
+    GVariantBuilder ret_builder;
+    g_variant_builder_init(&ret_builder, G_VARIANT_TYPE ("(b)"));
+    g_variant_builder_add_value (&ret_builder, g_variant_new_boolean(trigger_resync1_sent));
+    g_dbus_method_invocation_return_value(invocation, g_variant_builder_end (&ret_builder));
+  }
+
+  return;
+}
+

=== added file 'tests/test_service_panel.h'
--- tests/test_service_panel.h	1970-01-01 00:00:00 +0000
+++ tests/test_service_panel.h	2012-10-08 14:36:19 +0000
@@ -0,0 +1,46 @@
+#ifndef _SERVICE_PANEL_H_
+#define _SERVICE_PANEL_H_
+
+#include <glib-object.h>
+G_BEGIN_DECLS
+
+#define SERVICE_TYPE_PANEL (service_panel_get_type ())
+
+#define SERVICE_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
+  SERVICE_TYPE_PANEL, ServicePanel))
+
+#define SERVICE_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
+  SERVICE_TYPE_PANEL, ServicePanelClass))
+
+#define SERVICE_IS_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
+  SERVICE_TYPE_PANEL))
+
+#define SERVICE_IS_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
+  SERVICE_TYPE_PANEL))
+
+#define ServicePanel_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+  SERVICE_TYPE_PANEL, ServicePanelClass))
+
+typedef struct _ServicePanel        ServicePanel;
+typedef struct _ServicePanelClass   ServicePanelClass;
+typedef struct _ServicePanelPrivate ServicePanelPrivate;
+
+struct _ServicePanel
+{
+  GObject parent;
+
+  ServicePanelPrivate *priv;
+};
+
+struct _ServicePanelClass
+{
+  GObjectClass parent_class;
+};
+
+GType service_panel_get_type(void) G_GNUC_CONST;
+
+ServicePanel* service_panel_new(void);
+
+G_END_DECLS
+
+#endif /* _SERVICE_PANEL_H_ */

=== modified file 'tests/test_utils.h'
--- tests/test_utils.h	2012-05-19 05:21:05 +0000
+++ tests/test_utils.h	2012-10-08 14:36:19 +0000
@@ -46,6 +46,20 @@
     EXPECT_TRUE(success);
   }
 
+  static void WaitUntil(std::function<bool()> check_function, bool result = true, unsigned int max_wait = 10)
+  {
+    bool timeout_reached = false;
+    guint32 timeout_id = ScheduleTimeout(&timeout_reached, max_wait * 1000);
+
+    while (!check_function() && !timeout_reached)
+      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+    if (check_function())
+      g_source_remove(timeout_id);
+
+    EXPECT_EQ(check_function(), result);
+  }
+
   static guint32 ScheduleTimeout(bool* timeout_reached, unsigned int timeout_duration = 10)
   {
     return g_timeout_add(timeout_duration, TimeoutCallback, timeout_reached);