Merge lp:~gordallott/unity/unity-ubus into lp:unity

[Gord Allott]

adds UBus Support into unity, a simple message broadcasting service to allow for simple inter component communication without introducing dependencies.

Comes with tests because tests are awesome

[Neil J. Patel (njpatel)]

- g_hash_table_destroy does what you want it to and won't break if they use g_slice to allocate hashtable struct in the future

- Tab indenting in a bunch of places

- The first server you create has a ref count of 2 because it's not initially unowned (hence returns from g_object_new with ref_count = 1) and then your ref it again before retuning; Maybe make it derive from GInitiallyUnowned and return g_object_ref_sink (service)

- Like the singleton approach, haven't seen that in a while ;)

review: Needs Fixing

[Gord Allott (gordallott)]

fixed the hash tab indenting
regarding the reference counting, I think its best to just hold on to our own reference and own it completely, no real reason to start increasing/decreasing the reference count because we can only initialize the object once in the programs lifetime. we want it to stick around :) so i'm just holding on to one reference now and not passing any back to whatever calls get_default ()

[Neil J. Patel (njpatel)]

review: Approve

[Mikkel Kamstrup Erlandsen (kamstrup)]

+UBusMessageInfo *
+ubus_message_info_new (const gchar *message, GVariant *data)
+{
+ UBusMessageInfo *info = g_new (UBusMessageInfo, 1);
+ info->message = g_strdup (message);
+ info->data = data;
+
+ if (data != NULL)
+ g_variant_ref (data);
+ return info;
+}

You probably want to g_variant_ref_sink() instead so one can pass a
floating ref to send() without leaking.

+ if (info->data != NULL)
+ g_variant_unref (info->data);
+ g_free (info);

You're leaking the message string. Why not use the
ubus_message_info_free() function you implemented above?

Static modifiers are missing on all private functions in the .c files.
Right now you exporting all the unnamespaced utility functions.

If we expect the message names to not contain variations like
"unity_msg_N" for random 0 < N < 9999999999 then, ie. constant string
like "Unity.ShowDash", then it's a big waste go g_strdup() the message
in the UBusMessageInfo constructor. Just use a GStringChunk and save
all the reallocations.

Other than that nice work :-)

=== modified file 'libunity/CMakeLists.txt'
--- libunity/CMakeLists.txt	2010-11-19 12:06:29 +0000
+++ libunity/CMakeLists.txt	2010-11-25 14:26:39 +0000
@@ -56,7 +56,7 @@
                  GENERATE_VAPI unity
 )
 
-add_library (${PKGNAME} SHARED ${VALA_C})
+add_library (${PKGNAME} SHARED ${VALA_C} ubus-server.c)
 set_target_properties (${PKGNAME} PROPERTIES
                        VERSION ${libunity_VERSION}
                        SOVERSION ${libunity_SOVERSION}
 
=== added file 'libunity/ubus-server.c'
--- libunity/ubus-server.c	1970-01-01 00:00:00 +0000
+++ libunity/ubus-server.c	2010-11-25 14:26:39 +0000
@@ -0,0 +1,361 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
+/*
+ * u-bus-server.c
+ * Copyright (C) 2010 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Gordon Allott <[e-mail]>
+ */
+
+#include "ubus-server.h"
+#include <string.h>
+#include <stdlib.h>
+#include <glib.h>
+
+#define UBUS_SERVER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+  UBUS_TYPE_SERVER, \
+  UBusServerPrivate))
+
+struct _UBusServerPrivate
+{
+  GHashTable *message_interest_table;
+  GHashTable *dispatch_table;
+
+  GQueue     *message_queue;
+
+  gulong      id_sequencial_number;
+  gboolean    message_pump_queued;
+};
+
+
+G_DEFINE_TYPE (UBusServer, ubus_server, G_TYPE_INITIALLY_UNOWNED);
+
+struct _UBusDispatchInfo
+{
+  gulong    id;
+  UBusCallback callback;
+  gchar       *message;
+  gpointer    *user_data;
+};
+typedef struct _UBusDispatchInfo UBusDispatchInfo;
+
+UBusDispatchInfo *
+ubus_dispatch_info_new (UBusServer* server, const gchar *message,
+                        UBusCallback callback, gpointer user_data)
+{
+  g_return_val_if_fail (UBUS_IS_SERVER (server), NULL);
+  UBusServerPrivate *priv = server->priv;
+  UBusDispatchInfo *info;
+
+  if (priv->id_sequencial_number < 1)
+    {
+      g_critical (G_STRLOC ": ID's are overflowing");
+    }
+
+  info = g_new (UBusDispatchInfo, 1);
+  info->id = priv->id_sequencial_number++;
+  info->callback = callback;
+  info->message = g_strdup (message);
+  info->user_data = user_data;
+
+  return info;
+}
+
+void
+ubus_dispatch_info_free (UBusDispatchInfo *info)
+{
+  g_free (info->message);
+  g_free (info);
+}
+
+struct _UBusMessageInfo
+{
+  gchar     *message;
+  GVariant  *data;
+};
+
+typedef struct _UBusMessageInfo UBusMessageInfo;
+
+UBusMessageInfo *
+ubus_message_info_new (const gchar *message, GVariant *data)
+{
+  UBusMessageInfo *info = g_new (UBusMessageInfo, 1);
+  info->message = g_strdup (message);
+  info->data = data;
+
+  if (data != NULL)
+    g_variant_ref (data);
+  return info;
+}
+
+void
+ubus_message_info_free (UBusMessageInfo *info)
+{
+  g_variant_unref (info->data);
+  g_free (info->message);
+  g_free (info);
+}
+
+gboolean
+ulong_equal (gconstpointer v1,
+             gconstpointer v2)
+{
+  return *((const gulong*) v1) == *((const gulong*) v2);
+}
+
+guint
+ulong_hash (gconstpointer v)
+{
+  return (guint) *(const gulong*) v;
+}
+
+static void
+ubus_server_init (UBusServer *server)
+{
+  UBusServerPrivate *priv;
+  priv = server->priv = UBUS_SERVER_GET_PRIVATE (server);
+
+  // message_interest_table holds the message/DispatchInfo relationship
+  priv->message_interest_table = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                        g_free,
+                                                        (GDestroyNotify)g_sequence_free);
+  // dispatch table holds the individial id/DispatchInfo pairs
+  priv->dispatch_table = g_hash_table_new_full (ulong_hash, ulong_equal,
+                                                g_free,
+                                                (GDestroyNotify)ubus_dispatch_info_free);
+
+  // for anyone thats wondering (hi kamstrup!), there are two hash tables so
+  // that lookups are fast when sending messages and removing handlers
+
+  priv->message_queue = g_queue_new ();
+  priv->id_sequencial_number = 1;
+}
+
+static void
+ubus_server_finalize (GObject *object)
+{
+  UBusServer *server = UBUS_SERVER (object);
+  UBusServerPrivate *priv = server->priv;
+  g_hash_table_destroy (priv->message_interest_table);
+  g_hash_table_destroy (priv->dispatch_table);
+
+  UBusMessageInfo *info = g_queue_pop_tail (priv->message_queue);
+  for (; info != NULL; info = g_queue_pop_tail (priv->message_queue))
+  {
+    if (info->data != NULL)
+      g_variant_unref (info->data);
+    g_free (info);
+  }
+
+  g_queue_free (priv->message_queue);
+
+  G_OBJECT_CLASS (ubus_server_parent_class)->finalize (object);
+}
+
+static void
+ubus_server_class_init (UBusServerClass *klass)
+{
+  GObjectClass* object_class = G_OBJECT_CLASS (klass);
+  g_type_class_add_private (klass, sizeof (UBusServerPrivate));
+  object_class->finalize = ubus_server_finalize;
+}
+
+UBusServer *
+ubus_server_get_default ()
+{
+  static gsize singleton;
+  if (g_once_init_enter (&singleton))
+    {
+      UBusServer *server;
+      server = g_object_new (UBUS_TYPE_SERVER, NULL);
+      g_object_ref_sink (server);
+      g_once_init_leave (&singleton, (gsize) server);
+    }
+
+  // we actually just want to hold our own reference and not let anything
+  // else reference us, because we never want to lose that reference, we are
+  // only allowed to initalise once
+  return (UBusServer *)singleton;
+}
+
+gulong
+ubus_server_register_interest (UBusServer* server, const gchar *message,
+                               UBusCallback callback, gpointer user_data)
+{
+  g_return_val_if_fail (UBUS_IS_SERVER (server), 0);
+  g_return_val_if_fail (message != NULL, 0);
+
+  UBusServerPrivate *priv = server->priv;
+  GSequence *dispatch_list = g_hash_table_lookup (priv->message_interest_table,
+                                                 message);
+  UBusDispatchInfo *info;
+
+  if (dispatch_list == NULL)
+    {
+      // not had this message before so add a new entry to the message_interest table
+      gchar *key = g_strdup (message);
+      dispatch_list = g_sequence_new (NULL); // we use a sequence because its a stable pointer
+      g_hash_table_insert (priv->message_interest_table, key, dispatch_list);
+    }
+
+  // add the callback to the dispatch table
+  info = ubus_dispatch_info_new (server, message, callback, user_data);
+  gulong *id = g_malloc (sizeof (gulong));
+  *id = info->id;
+  g_hash_table_insert (priv->dispatch_table, id, info);
+
+  // add the dispatch info to the dispatch list in the message interest table
+  g_sequence_append (dispatch_list, info);
+
+  return info->id;
+}
+
+gboolean
+ubus_server_pump_message_queue (UBusServer *server)
+{
+  g_return_val_if_fail (UBUS_IS_SERVER (server), FALSE);
+  UBusServerPrivate *priv = server->priv;
+  UBusMessageInfo *info;
+
+  priv->message_pump_queued = TRUE;
+
+  // loop through each message queued and call the dispatch functions associated
+  // with it. something in the back of my mind says it would be quicker in some
+  // situations to sort the queue first so that duplicate messages can re-use
+  // the same dispatch_list lookups.. but thats a specific case.
+
+
+  info = g_queue_pop_tail (priv->message_queue);
+  for (; info != NULL; info = g_queue_pop_tail (priv->message_queue))
+    {
+      GSequence *dispatch_list;
+      dispatch_list = g_hash_table_lookup (priv->message_interest_table,
+                                           info->message);
+
+      if (dispatch_list == NULL)
+        continue; // no handlers for this message
+
+      GSequenceIter *iter = g_sequence_get_begin_iter (dispatch_list);
+      GSequenceIter *end = g_sequence_get_end_iter (dispatch_list);
+
+      while (iter != end)
+        {
+          GSequenceIter *next = g_sequence_iter_next (iter);
+          UBusDispatchInfo *dispatch_info = g_sequence_get (iter);
+          UBusCallback callback = dispatch_info->callback;
+
+          (*callback) (info->data, dispatch_info->user_data);
+
+          iter = next;
+        }
+
+      if (info->data != NULL)
+        g_variant_unref (info->data);
+      g_free (info);
+    }
+
+  return FALSE;
+}
+
+void
+ubus_server_queue_message_pump (UBusServer *server)
+{
+  g_return_if_fail (UBUS_IS_SERVER (server));
+  UBusServerPrivate *priv = server->priv;
+
+  if (priv->message_pump_queued)
+    return;
+
+  g_idle_add ((GSourceFunc)ubus_server_pump_message_queue, server);
+  priv->message_pump_queued = TRUE;
+}
+
+void
+ubus_server_send_message (UBusServer *server, const gchar *message,
+                          GVariant *data)
+{
+  g_return_if_fail (UBUS_IS_SERVER (server));
+  g_return_if_fail (message != NULL);
+  UBusServerPrivate *priv = server->priv;
+
+  UBusMessageInfo *message_info = ubus_message_info_new (message, data);
+  g_queue_push_head (priv->message_queue, message_info);
+
+  ubus_server_queue_message_pump (server);
+}
+
+void
+ubus_server_unregister_interest (UBusServer* server, gulong handle)
+{
+  g_return_if_fail (UBUS_IS_SERVER (server));
+  g_return_if_fail (handle > 0);
+  UBusServerPrivate *priv = server->priv;
+  UBusDispatchInfo *info;
+  GSequence *dispatch_list;
+
+  // get our info
+  info = g_hash_table_lookup (priv->dispatch_table, &handle);
+
+  if (info == NULL)
+    {
+      g_warning (G_STRLOC ": Handle %lu does not exist", handle);
+      return;
+    }
+
+  // now the slightly sucky bit, we have to remove from our message-interest
+  // table, but we can only find it by itterating through a sequence
+  // but this is not so bad because we know *which* sequence its in
+
+  dispatch_list = g_hash_table_lookup (priv->message_interest_table,
+                                       info->message);
+
+  if (dispatch_list == NULL)
+  {
+    g_critical (G_STRLOC ": Handle exists but not dispatch list, ubus has "\
+                         "become unstable");
+    return;
+  }
+
+  GSequenceIter *iter = g_sequence_get_begin_iter (dispatch_list);
+  GSequenceIter *end = g_sequence_get_end_iter (dispatch_list);
+  while (iter != end)
+    {
+      GSequenceIter *next = g_sequence_iter_next (iter);
+      UBusDispatchInfo *info_test = g_sequence_get (iter);
+
+      if (info_test->id == handle)
+      {
+        g_sequence_remove (iter);
+      }
+
+      iter = next;
+    }
+
+  if (g_sequence_get_length (dispatch_list) == 0)
+  {
+    // free the key/value pair
+    g_hash_table_remove (priv->message_interest_table, info->message);
+  }
+
+  // finally remove the dispatch_table hash table.
+  g_hash_table_remove (priv->dispatch_table, &handle);
+
+}
+
+void
+ubus_server_force_message_pump (UBusServer* server)
+{
+  ubus_server_pump_message_queue (server);
+}
 
=== added file 'libunity/ubus-server.h'
--- libunity/ubus-server.h	1970-01-01 00:00:00 +0000
+++ libunity/ubus-server.h	2010-11-25 14:26:39 +0000
@@ -0,0 +1,74 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
+/*
+ * u-bus-server.h
+ * Copyright (C) 2010 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Gordon Allott <[e-mail]>
+ */
+
+#ifndef _U_BUS_SERVER_H_
+#define _U_BUS_SERVER_H_
+
+#include <glib-object.h>
+#include <glib.h>
+G_BEGIN_DECLS
+
+#define UBUS_TYPE_SERVER             (ubus_server_get_type ())
+#define UBUS_SERVER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBUS_TYPE_SERVER, UBusServer))
+#define UBUS_SERVER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), UBUS_TYPE_SERVER, UBusServerClass))
+#define UBUS_IS_SERVER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBUS_TYPE_SERVER))
+#define UBUS_IS_SERVER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), UBUS_TYPE_SERVER))
+#define UBUS_SERVER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), UBUS_TYPE_SERVER, UBusServerClass))
+
+typedef struct _UBusServerClass UBusServerClass;
+typedef struct _UBusServer UBusServer;
+typedef struct _UBusServerPrivate  UBusServerPrivate;
+
+struct _UBusServerClass
+{
+  GObjectClass parent_class;
+
+  /* padding */
+  void (*_unity_padding1) (void);
+  void (*_unity_padding2) (void);
+  void (*_unity_padding3) (void);
+  void (*_unity_padding4) (void);
+  void (*_unity_padding5) (void);
+  void (*_unity_padding6) (void);
+};
+
+struct _UBusServer
+{
+  GObject parent_instance;
+
+  UBusServerPrivate *priv;
+};
+
+typedef void (*UBusCallback) (GVariant *data, gpointer *user_data);
+
+GType ubus_server_get_type (void) G_GNUC_CONST;
+UBusServer *ubus_server_get_default ();
+void   ubus_server_prime_context (UBusServer* server, GMainContext *context);
+gulong ubus_server_register_interest (UBusServer* server, const gchar *message,
+                                      UBusCallback callback, gpointer user_data);
+void   ubus_server_send_message (UBusServer* server, const gchar *message,
+                                 GVariant *data);
+void   ubus_server_unregister_interest (UBusServer* server, gulong handle);
+void   ubus_server_force_message_pump (UBusServer* server);
+
+G_END_DECLS
+
+#endif /* _U_BUS_SERVER_H_ */
 
=== modified file 'services/panel-service.c'
--- services/panel-service.c	2010-11-17 23:53:21 +0000
+++ services/panel-service.c	2010-11-25 14:26:39 +0000
@@ -158,7 +158,7 @@
       GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (self->priv->last_menu));
       if (window == NULL)
         return GDK_FILTER_CONTINUE;
-      
+
       Window     xwindow = gdk_x11_drawable_get_xid (GDK_DRAWABLE (window));
 
       if (xwindow == 0)
@@ -236,7 +236,10 @@
 static gboolean
 initial_resync (PanelService *self)
 {
-  g_signal_emit (self, _service_signals[RE_SYNC], 0, "");
+  if (PANEL_IS_SERVICE (self))
+    g_signal_emit (self, _service_signals[RE_SYNC], 0, "");
+
+
   return FALSE;
 }
 
@@ -264,7 +267,7 @@
 panel_service_get_default ()
 {
   static PanelService *service = NULL;
-  
+
   if (service == NULL || !PANEL_IS_SERVICE (service))
     service = g_object_new (PANEL_TYPE_SERVICE, NULL);
 
@@ -293,13 +296,14 @@
 
   return g_slist_length (self->priv->indicators);
 }
-     
+
 /*
  * Private Methods
  */
 static gboolean
 actually_notify_object (IndicatorObject *object)
 {
+  if (!INDICATOR_IS_OBJECT (object)) return;
   PanelService *self;
   PanelServicePrivate *priv;
   gint position;
@@ -310,7 +314,7 @@
   position = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (object), "position"));
   priv->timeouts[position] = SYNC_WAITING;
 
-  if (!suppress_signals);
+  if (!suppress_signals)
     g_signal_emit (self, _service_signals[RE_SYNC],
                    0, g_object_get_data (G_OBJECT (object), "id"));
 
@@ -392,7 +396,7 @@
                         G_CALLBACK (on_entry_changed), object);
       g_signal_connect (entry->label, "hide",
                         G_CALLBACK (on_entry_changed), object);
-                        
+
     }
   if (GTK_IS_IMAGE (entry->image))
     {
@@ -452,7 +456,7 @@
   priv->indicators = g_slist_append (priv->indicators, object);
 
   g_object_set_data_full (G_OBJECT (object), "id", g_strdup (name), g_free);
-  
+
   g_signal_connect (object, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
                     G_CALLBACK (on_entry_added), self);
   g_signal_connect (object, INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,
@@ -535,7 +539,7 @@
 
   s1 = g_object_get_data (G_OBJECT (o1), "id");
   s2 = g_object_get_data (G_OBJECT (o2), "id");
-  
+
   i1 = name2order (s1);
   i2 = name2order (s2);
 
@@ -573,7 +577,7 @@
       GError     *error = NULL;
 
       pixbuf = gtk_image_get_pixbuf (image);
-     
+
       if (gdk_pixbuf_save_to_buffer (pixbuf, &buffer, &buffer_size, "png", &error, NULL))
         {
           ret = g_base64_encode ((const guchar *)buffer, buffer_size);
@@ -623,7 +627,7 @@
   gboolean is_label = GTK_IS_LABEL (entry->label);
   gboolean is_image = GTK_IS_IMAGE (entry->image);
   gchar *image_data = NULL;
-  
+
   g_variant_builder_add (b, "(sssbbusbb)",
                          indicator_id,
                          id,
@@ -729,7 +733,7 @@
       /* Set the sync back to neutral */
       position = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (i->data), "position"));
       self->priv->timeouts[position] = SYNC_NEUTRAL;
-      
+
       indicator_object_to_variant (i->data, indicator_id, &b);
     }
 
@@ -776,7 +780,7 @@
 {
   PanelServicePrivate  *priv = self->priv;
   IndicatorObjectEntry *entry = g_hash_table_lookup (priv->id2entry_hash, entry_id);
- 
+
   if (GTK_IS_MENU (priv->last_menu))
     {
       priv->last_x = 0;
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2010-11-24 16:36:23 +0000
+++ tests/CMakeLists.txt	2010-11-25 14:26:39 +0000
@@ -16,7 +16,7 @@
      ${TEST_UNIT_DEPS_CFLAGS_OTHER}
      "-DGETTEXT_PACKAGE=\"unity\""
      "-DINDICATORDIR=\"${CMAKE_BINARY_DIR}/tests\""
-     "-DINDICATORICONDIR=\"${CMAKE_BINARY_DIR}/tests\"" 
+     "-DINDICATORICONDIR=\"${CMAKE_BINARY_DIR}/tests\""
      )
 add_definitions (${CFLAGS})
 
@@ -35,6 +35,9 @@
                 unit/TestFavoriteStoreGSettings.cpp
                 unit/TestPanelService.cpp
                 unit/TestMain.cpp
+                unit/TestUBus.cpp
+                ../libunity/ubus-server.c
+                ../libunity/ubus-server.h
                 ../services/panel-service.c
                 ../services/panel-service.h
                 ../src/FavoriteStore.cpp
 
=== modified file 'tests/unit/TestMain.cpp'
--- tests/unit/TestMain.cpp	2010-11-17 21:38:57 +0000
+++ tests/unit/TestMain.cpp	2010-11-25 14:26:39 +0000
@@ -24,6 +24,7 @@
 
 void TestFavoriteStoreGSettingsCreateSuite (void);
 void TestPanelServiceCreateSuite (void);
+void TestUBusCreateSuite (void);
 
 int
 main (int argc, char **argv)
@@ -32,12 +33,13 @@
 
   g_type_init ();
   g_thread_init (NULL);
-  
+
   g_test_init (&argc, &argv, NULL);
 
   //Keep alphabetical please
   TestFavoriteStoreGSettingsCreateSuite ();
   TestPanelServiceCreateSuite ();
+  TestUBusCreateSuite ();
 
   return g_test_run ();
 }
 
=== added file 'tests/unit/TestUBus.cpp'
--- tests/unit/TestUBus.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit/TestUBus.cpp	2010-11-25 14:26:39 +0000
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2010 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
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Gordon Allott <[e-mail]>
+ *
+ */
+
+
+#include "config.h"
+#include "libunity/ubus-server.h"
+
+#define MESSAGE1 "TEST MESSAGE ONE"
+#define MESSAGE2 "ՄᕅᏆⲤꙨႧΈ Ϊટ ಗשׁຣ໐ɱË‼‼❢"
+
+static void TestAllocation    (void);
+static void TestMainLoop      (void);
+static void TestPropagation   (void);
+
+void
+TestUBusCreateSuite ()
+{
+#define _DOMAIN "/Unit/UBus"
+  g_test_add_func (_DOMAIN"/Allocation", TestAllocation);
+  g_test_add_func (_DOMAIN"/Propagation", TestPropagation);
+  g_test_add_func (_DOMAIN"/MainLoop", TestMainLoop);
+}
+
+static void
+TestAllocation ()
+{
+  UBusServer *serv_1 = ubus_server_get_default ();
+  UBusServer *serv_2 = ubus_server_get_default ();
+
+  g_assert (serv_1 != NULL);
+  g_assert (serv_2 != NULL);
+
+  // i used a different way of making a singleton than i am used to
+  // so i'm not 100% confident in it yet
+  g_assert (serv_1 == serv_2);
+}
+
+void
+test_handler_inc_counter (GVariant *data, gpointer *val)
+{
+  // inc a counter when we get called
+  gint *counter = (gint*)val;
+  *counter = *counter + 1;
+}
+
+void
+test_handler_inc_counter_2 (GVariant *data, gpointer *val)
+{
+  // inc a counter by two when called
+  gint *counter = (gint*)val;
+  *counter = *counter + 2;
+}
+
+static void
+TestPropagation ()
+{
+  UBusServer *ubus = ubus_server_get_default ();
+  gint counter = 0;
+  gulong handler1 = ubus_server_register_interest (ubus, MESSAGE1,
+                                                   test_handler_inc_counter,
+                                                   &counter);
+
+  gulong handler2 = ubus_server_register_interest (ubus, MESSAGE2, // tests UNICODE
+                                                   test_handler_inc_counter_2,
+                                                   &counter);
+
+  gint i;
+  for (i=0; i<1000; i++)
+  {
+    ubus_server_send_message (ubus, MESSAGE1, NULL);
+  }
+
+  ubus_server_force_message_pump (ubus);
+
+  counter = 0;
+  for (i=0; i<1000; i++)
+  {
+    ubus_server_send_message (ubus, MESSAGE1, NULL);
+    ubus_server_send_message (ubus, MESSAGE2, NULL);
+  }
+  ubus_server_force_message_pump (ubus);
+
+  g_assert (counter == 3000);
+
+  ubus_server_unregister_interest (ubus, handler1);
+  ubus_server_unregister_interest (ubus, handler2);
+
+  counter = 0;
+  ubus_server_send_message (ubus, MESSAGE1, NULL);
+  ubus_server_send_message (ubus, MESSAGE2, NULL);
+
+  ubus_server_force_message_pump (ubus);
+
+  g_assert (counter == 0);
+}
+
+gboolean
+main_loop_bailout (gpointer data)
+{
+  GMainLoop *mainloop = (GMainLoop*)data;
+  g_main_quit (mainloop);
+  return FALSE;
+}
+
+void
+test_handler_mainloop (GVariant *data, gpointer *val)
+{
+  // inc a counter when we get called
+  gint *counter = (gint*)val;
+  *counter = *counter + 1;
+
+}
+
+static void
+TestMainLoop ()
+{
+  GMainLoop *mainloop;
+  UBusServer *ubus = ubus_server_get_default ();
+  gint counter = 0;
+
+  mainloop = g_main_loop_new (NULL, TRUE);
+  g_timeout_add_seconds (1, main_loop_bailout, mainloop);
+
+  ubus_server_register_interest (ubus, MESSAGE1,
+                                 test_handler_mainloop,
+                                 &counter);
+
+  ubus_server_send_message (ubus, MESSAGE1, NULL);
+  g_main_loop_run (mainloop);
+
+  g_assert (counter == 1);
+
+}
+
+