Merge lp:~ted/hud/automatic-shutdown into lp:hud/phablet

[Ted Gould]

Shutdown the HUD service if it's not used for 10 minutes.

Adds a watchdog to shutdown if it's not being used. This is to help with memory and CPU usage on mobile platforms, all services that might not be used are being asked to shutdown with this style of watchdog.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:373
http://s-jenkins:8080/job/hud-small-ci/272/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/hud-small-ci/./build=pbuilder,distribution=quantal,flavor=i386/272/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/hud-small-ci/272/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:374
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~ted/hud/automatic-shutdown/+merge/156145/+edit-commit-message

http://s-jenkins:8080/job/hud-small-ci/280/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/hud-small-ci/./build=pbuilder,distribution=quantal,flavor=i386/280/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/hud-small-ci/280/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:374
http://s-jenkins:8080/job/hud-small-ci/281/
Executed test runs:
    SUCCESS: http://s-jenkins:8080/job/hud-small-ci/./build=pbuilder,distribution=quantal,flavor=i386/281

Click here to trigger a rebuild:
http://s-jenkins:8080/job/hud-small-ci/281/rebuild

review: Approve (continuous-integration)

[Pete Woods (pete-woods)]

An obvious initial problem is that this is be generating artifacts into the source tree during tests. All generated artifacts must go into the binary tree.

(incomplete review)

review: Needs Fixing

[lp:~ted/hud/automatic-shutdown]

375. By Ted Gould on 2013-04-02

Removing autotools built files from the ignore file

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:375
http://s-jenkins:8080/job/hud-small-ci/297/
Executed test runs:
    SUCCESS: http://s-jenkins:8080/job/hud-small-ci/./build=pbuilder,distribution=quantal,flavor=i386/297

Click here to trigger a rebuild:
http://s-jenkins:8080/job/hud-small-ci/297/rebuild

review: Approve (continuous-integration)

[Pete Woods (pete-woods)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-03-27 23:46:44 +0000
+++ src/CMakeLists.txt	2013-04-02 14:39:23 +0000
@@ -96,6 +96,7 @@
 pronounce-dict.h
 query-columns.h
 usage-tracker.h
+watchdog.h
 )
 
 set(HUD_SERVICE_LIB_SOURCES
@@ -125,6 +126,7 @@
 load-app-info.c
 pronounce-dict.c
 usage-tracker.c
+watchdog.c
 )
 
 add_glib_enumtypes_t(HUD_SERVICE_LIB_SOURCES
 
=== modified file 'src/hud-service.c'
--- src/hud-service.c	2013-03-26 17:33:39 +0000
+++ src/hud-service.c	2013-04-02 14:39:23 +0000
@@ -36,6 +36,7 @@
 #include "hud-iface.h"
 #include "shared-values.h"
 #include "hudquery.h"
+#include "watchdog.h"
 
 /* Prototypes */
 static void            bus_method         (GDBusConnection       *connection,
@@ -65,6 +66,7 @@
 	.set_property = NULL
 };
 static HudApplicationList * application_list = NULL;
+static HudWatchdog * watchdog = NULL;
 
 /* Get our error domain */
 GQuark
@@ -228,7 +230,7 @@
 static HudQuery *
 build_query (HudSourceList * all_sources, HudApplicationList * app_list, GDBusConnection * connection, const gchar * search_string)
 {
-	HudQuery * query = hud_query_new (HUD_SOURCE(all_sources), application_list, search_string, 10, connection, ++query_count);
+	HudQuery * query = hud_query_new (HUD_SOURCE(all_sources), watchdog, application_list, search_string, 10, connection, ++query_count);
 
 	g_ptr_array_add(query_list, query);
 	g_object_weak_ref(G_OBJECT(query), query_destroyed, query_list);
@@ -263,6 +265,8 @@
             GDBusMethodInvocation *invocation,
             gpointer               user_data)
 {
+	hud_watchdog_ping(watchdog);
+
 	if (g_str_equal (method_name, "CreateQuery")) {
 		HudSourceList *all_sources = user_data;
 		GVariant * vsearch;
@@ -385,6 +389,7 @@
 static GVariant *
 bus_get_prop (GDBusConnection * connection, const gchar * sender, const gchar * object_path, const gchar * interface_name, const gchar * property_name, GError ** error, gpointer user_data)
 {
+	hud_watchdog_ping(watchdog);
 	// HudSource *source = user_data;
 
 	if (g_str_equal(property_name, "OpenQueries")) {
@@ -532,9 +537,13 @@
 
   signal(SIGTERM, sigterm_graceful_exit);
   
+  watchdog = hud_watchdog_new(mainloop);
+
   g_main_loop_run (mainloop);
   g_main_loop_unref (mainloop);
 
+  g_clear_object(&watchdog);
+
   g_object_unref (application_list);
   g_object_unref (source_list);
   g_ptr_array_free(query_list, TRUE);
 
=== modified file 'src/hudquery.c'
--- src/hudquery.c	2013-03-26 18:32:27 +0000
+++ src/hudquery.c	2013-04-02 14:39:23 +0000
@@ -30,6 +30,7 @@
 #include "application-source.h"
 #include "application-list.h"
 #include "query-columns.h"
+#include "watchdog.h"
 
 /**
  * SECTION:hudquery
@@ -58,6 +59,7 @@
 {
   GObject parent_instance;
 
+  HudWatchdog * watchdog;
   HudSource *all_sources;
   HudApplicationList *app_list;
   HudSource *current_source;
@@ -285,6 +287,7 @@
 {
   guint64 start_time;
 
+  hud_watchdog_ping(query->watchdog);
   start_time = g_get_monotonic_time ();
 
   dee_model_clear(query->results_model);
@@ -416,6 +419,7 @@
   g_clear_pointer(&query->appstack_name, g_free);
 
   g_clear_object(&query->voice);
+  g_clear_object(&query->watchdog);
 
   G_OBJECT_CLASS (hud_query_parent_class)
     ->finalize (object);
@@ -427,6 +431,7 @@
 {
   g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
   HudQuery * query = HUD_QUERY(user_data);
+  hud_watchdog_ping(query->watchdog);
 
   g_debug("Voice query is loading");
   hud_query_iface_com_canonical_hud_query_emit_voice_query_loading (
@@ -484,6 +489,7 @@
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
 	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	g_debug("Updating Query to: '%s'", search_string);
 
@@ -517,6 +523,7 @@
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
 	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	g_debug("Updating App to: '%s'", app_id);
 
@@ -540,7 +547,8 @@
 handle_execute (HudQueryIfaceComCanonicalHudQuery * skel, GDBusMethodInvocation * invocation, GVariant * command_id, guint timestamp, gpointer user_data)
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
-	//HudQuery * query = HUD_QUERY(user_data);
+	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	/* Do good */
 	GVariant * inner = g_variant_get_variant(command_id);
@@ -578,7 +586,8 @@
 handle_parameterized (HudQueryIfaceComCanonicalHudQuery * skel, GDBusMethodInvocation * invocation, GVariant * command_id, guint timestamp, gpointer user_data)
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
-	//HudQuery * query = HUD_QUERY(user_data);
+	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	GVariant * inner = g_variant_get_variant(command_id);
 	guint64 id = g_variant_get_uint64(inner);
@@ -630,6 +639,7 @@
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
 	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	HudClientQueryToolbarItems item = hud_client_query_toolbar_items_get_value_from_nick(arg_item);
 
@@ -681,6 +691,7 @@
 {
 	g_return_val_if_fail(HUD_IS_QUERY(user_data), FALSE);
 	HudQuery * query = HUD_QUERY(user_data);
+	hud_watchdog_ping(query->watchdog);
 
 	/* Close the query */
 	hud_query_close(query);
@@ -791,6 +802,7 @@
  **/
 HudQuery *
 hud_query_new (HudSource   *all_sources,
+               HudWatchdog *watchdog,
                HudApplicationList *application_list,
                const gchar *search_string,
                gint         num_results,
@@ -807,6 +819,10 @@
   query->app_list = g_object_ref (application_list);
   query->search_string = g_strdup (search_string);
   query->token_list = NULL;
+
+  if (watchdog != NULL) {
+    query->watchdog = g_object_ref(watchdog);
+  }
   
   if (query->search_string[0] != '\0') {
     query->token_list = hud_token_list_new_from_string (query->search_string);
 
=== modified file 'src/hudquery.h'
--- src/hudquery.h	2013-02-27 17:35:32 +0000
+++ src/hudquery.h	2013-04-02 14:39:23 +0000
@@ -22,6 +22,7 @@
 #include "hudsource.h"
 #include "hudresult.h"
 #include "application-list.h"
+#include "watchdog.h"
 
 #define HUD_TYPE_QUERY                                      (hud_query_get_type ())
 #define HUD_QUERY(inst)                                     (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
@@ -36,6 +37,7 @@
 GType                   hud_query_get_type                              (void);
 
 HudQuery *              hud_query_new                                   (HudSource   *all_sources,
+                                                                         HudWatchdog  * watchdog,
                                                                          HudApplicationList  * application_list,
                                                                          const gchar *search_string,
                                                                          gint         num_results,
 
=== added file 'src/watchdog.c'
--- src/watchdog.c	1970-01-01 00:00:00 +0000
+++ src/watchdog.c	2013-04-02 14:39:23 +0000
@@ -0,0 +1,178 @@
+/*
+ * Copyright © 2013 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/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include "watchdog.h"
+
+#define DEFAULT_TIMEOUT  600 /* seconds, or 10 minutes */
+
+typedef struct _HudWatchdogPrivate HudWatchdogPrivate;
+struct _HudWatchdogPrivate {
+	guint timeout;
+	gulong timer;
+	GMainLoop * loop;
+};
+
+#define HUD_WATCHDOG_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), HUD_WATCHDOG_TYPE, HudWatchdogPrivate))
+
+static void hud_watchdog_class_init (HudWatchdogClass *klass);
+static void hud_watchdog_init       (HudWatchdog *self);
+static void hud_watchdog_dispose    (GObject *object);
+static void hud_watchdog_finalize   (GObject *object);
+static gboolean fire_watchdog       (gpointer user_data);
+
+G_DEFINE_TYPE (HudWatchdog, hud_watchdog, G_TYPE_OBJECT);
+
+static void
+hud_watchdog_class_init (HudWatchdogClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (klass, sizeof (HudWatchdogPrivate));
+
+	object_class->dispose = hud_watchdog_dispose;
+	object_class->finalize = hud_watchdog_finalize;
+
+	return;
+}
+
+static void
+hud_watchdog_init (HudWatchdog *self)
+{
+	self->priv = HUD_WATCHDOG_GET_PRIVATE(self);
+
+	const gchar * envvar = g_getenv("HUD_SERVICE_TIMEOUT");
+	if (envvar == NULL) {
+		self->priv->timeout = DEFAULT_TIMEOUT;
+	} else {
+		self->priv->timeout = atoi(envvar);
+	}
+
+	if (self->priv->timeout != 0) {
+		self->priv->timer = g_timeout_add_seconds(self->priv->timeout, fire_watchdog, self);
+	}
+
+	return;
+}
+
+static void
+hud_watchdog_dispose (GObject *object)
+{
+	HudWatchdog * self = HUD_WATCHDOG(object);
+
+	if (self->priv->timer != 0) {
+		g_source_remove(self->priv->timer);
+		self->priv->timer = 0;
+	}
+
+	G_OBJECT_CLASS (hud_watchdog_parent_class)->dispose (object);
+	return;
+}
+
+static void
+hud_watchdog_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (hud_watchdog_parent_class)->finalize (object);
+	return;
+}
+
+/* Oh noes!  It's our time to go!  Do this!  */
+static gboolean
+fire_watchdog (gpointer user_data)
+{
+	g_return_val_if_fail(IS_HUD_WATCHDOG(user_data), TRUE);
+	HudWatchdog * self = HUD_WATCHDOG(user_data);
+
+	g_debug("Firing Watchdog");
+
+	if (self->priv->loop != NULL) {
+		g_main_loop_quit(self->priv->loop);
+	}
+
+	return FALSE;
+}
+
+/**
+ * hud_watchdog_new:
+ * @loop: Mainloop to quit if we timeout
+ *
+ * Sets up a watchdog that will quit on the main loop if it
+ * doesn't get enough attention.  Reminds of an girlfriend
+ * I had once...
+ *
+ * Return value: (transfer full): A new #HudWatchdog object
+ */
+HudWatchdog *
+hud_watchdog_new (GMainLoop * loop)
+{
+	HudWatchdog * watchdog = g_object_new(HUD_WATCHDOG_TYPE, NULL);
+
+	watchdog->priv->loop = loop;
+
+	return watchdog;
+}
+
+/**
+ * hud_watchdog_ping:
+ * @watchdog: Watchdog to give attention to
+ *
+ * Makes sure to startover and not timeout.
+ */
+void
+hud_watchdog_ping (HudWatchdog * watchdog)
+{
+	/* Doing a silent fail on NULL so that our tests can not worry about
+	   setting up dummy watchdogs when just testing the query.  They have
+	   their own timeouts */
+	if (watchdog == NULL) {
+		return;
+	}
+
+	g_return_if_fail(IS_HUD_WATCHDOG(watchdog));
+
+	if (watchdog->priv->timer != 0) {
+		g_source_remove(watchdog->priv->timer);
+		watchdog->priv->timer = 0;
+	}
+
+	if (watchdog->priv->timeout != 0) {
+		watchdog->priv->timer = g_timeout_add_seconds(watchdog->priv->timeout, fire_watchdog, watchdog);
+	}
+	return;
+}
+
+/**
+ * hud_watchdog_get_timeout:
+ * @watchdog: Watchdog to interegate
+ *
+ * Get the timeout of this watchdog.
+ *
+ * Return value: The number of seconds before it goes off
+ */
+guint
+hud_watchdog_get_timeout (HudWatchdog * watchdog)
+{
+	g_return_val_if_fail(IS_HUD_WATCHDOG(watchdog), 0);
+
+	return watchdog->priv->timeout;
+}
 
=== added file 'src/watchdog.h'
--- src/watchdog.h	1970-01-01 00:00:00 +0000
+++ src/watchdog.h	2013-04-02 14:39:23 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2013 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/>.
+ *
+ */
+
+#ifndef __HUD_WATCHDOG_H__
+#define __HUD_WATCHDOG_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define HUD_WATCHDOG_TYPE            (hud_watchdog_get_type ())
+#define HUD_WATCHDOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HUD_WATCHDOG_TYPE, HudWatchdog))
+#define HUD_WATCHDOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HUD_WATCHDOG_TYPE, HudWatchdogClass))
+#define IS_HUD_WATCHDOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HUD_WATCHDOG_TYPE))
+#define IS_HUD_WATCHDOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HUD_WATCHDOG_TYPE))
+#define HUD_WATCHDOG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HUD_WATCHDOG_TYPE, HudWatchdogClass))
+
+typedef struct _HudWatchdog        HudWatchdog;
+typedef struct _HudWatchdogClass   HudWatchdogClass;
+typedef struct _HudWatchdogPrivate HudWatchdogPrivate;
+
+struct _HudWatchdogClass {
+	GObjectClass parent_class;
+};
+
+struct _HudWatchdog {
+	GObject parent;
+	HudWatchdogPrivate * priv;
+};
+
+GType hud_watchdog_get_type (void);
+
+HudWatchdog * hud_watchdog_new  (GMainLoop * loop);
+void          hud_watchdog_ping (HudWatchdog * watchdog);
+guint         hud_watchdog_get_timeout (HudWatchdog * watchdog);
+
+G_END_DECLS
+
+#endif
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-04-02 08:34:53 +0000
+++ tests/CMakeLists.txt	2013-04-02 14:39:23 +0000
@@ -129,6 +129,7 @@
 # HUD Test Suite
 #######################
 
+hudtest(test-watchdog test-watchdog.c test-watchdog.xml)
 hudtest(test-distance test-distance.c test-distance.xml)
 hudtest(test-hud-item test-huditem.c test-hud-item.xml)
 hudtest(test-result-highlighting test-result-highlighting.c test-result-highlighting.xml)
 
=== modified file 'tests/hud-performance.c'
--- tests/hud-performance.c	2013-03-19 01:19:32 +0000
+++ tests/hud-performance.c	2013-04-02 14:39:23 +0000
@@ -63,7 +63,7 @@
           gchar *part_search = g_strndup (search, j);
 
           start_time = g_get_monotonic_time ();
-          query = hud_query_new (source, NULL, part_search, 1u<<30, g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL), 0);
+          query = hud_query_new (source, NULL, NULL, part_search, 1u<<30, g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL), 0);
           g_print ("%-60s: %dus\n", part_search,
                    (int) (g_get_monotonic_time () - start_time));
           g_object_unref (query);
 
=== modified file 'tests/test-source.c'
--- tests/test-source.c	2013-03-26 17:33:39 +0000
+++ tests/test-source.c	2013-04-02 14:39:23 +0000
@@ -193,7 +193,7 @@
 {
   g_debug ("query: [%s], on [%s]", search, g_dbus_connection_get_unique_name(session));
 
-  HudQuery * query = hud_query_new (source, list, search, 1u << 30, session, query_count);
+  HudQuery * query = hud_query_new (source, NULL, list, search, 1u << 30, session, query_count);
 
   return query;
 }
@@ -355,7 +355,7 @@
       g_assert(G_N_ELEMENTS(expected) == G_N_ELEMENTS(expected_distances));
 
       AppListDummy * dummy = app_list_dummy_new(HUD_SOURCE(collector));
-      HudQuery *query = hud_query_new (HUD_SOURCE(source_list), HUD_APPLICATION_LIST(dummy), search, 1u << 30, session, 6);
+      HudQuery *query = hud_query_new (HUD_SOURCE(source_list), NULL, HUD_APPLICATION_LIST(dummy), search, 1u << 30, session, 6);
       test_source_make_assertions_ext (query, appstack, appstack_expected_ids, appstack_expected_icons, G_N_ELEMENTS(appstack_expected_ids), path, name, expected, expected_distances, G_N_ELEMENTS(expected));
 
       // Change the app to the manual_source
 
=== added file 'tests/test-watchdog.c'
--- tests/test-watchdog.c	1970-01-01 00:00:00 +0000
+++ tests/test-watchdog.c	2013-04-02 14:39:23 +0000
@@ -0,0 +1,147 @@
+/*
+Test code for watchdog
+
+Copyright 2013 Canonical Ltd.
+
+Authors:
+    Ted Gould <[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 <glib.h>
+#include <glib-object.h>
+
+#include "watchdog.h"
+
+static void
+test_watchdog_create (void)
+{
+	g_unsetenv("HUD_SERVICE_TIMEOUT");
+
+	/* Try with NULL */
+	HudWatchdog * doggie = hud_watchdog_new(NULL);
+
+	g_assert(IS_HUD_WATCHDOG(doggie));
+	g_assert(hud_watchdog_get_timeout(doggie) == 600);
+
+	g_clear_object(&doggie);
+
+	/* Give it a loop */
+	GMainLoop * loop = g_main_loop_new(NULL, FALSE);
+	doggie = hud_watchdog_new(loop);
+
+	g_assert(IS_HUD_WATCHDOG(doggie));
+	g_assert(hud_watchdog_get_timeout(doggie) == 600);
+
+	g_clear_object(&doggie);
+	g_main_loop_unref(loop);
+
+	/* Set the environment variable */
+	g_setenv("HUD_SERVICE_TIMEOUT", "1000", TRUE);
+
+	doggie = hud_watchdog_new(NULL);
+
+	g_assert(IS_HUD_WATCHDOG(doggie));
+	g_assert(hud_watchdog_get_timeout(doggie) == 1000);
+
+	g_clear_object(&doggie);
+
+	return;
+}
+
+static gboolean
+final_fail (gpointer ploop)
+{
+	g_error("Timeout not via the watchdog.  It didn't work.");
+	g_main_loop_quit((GMainLoop *)ploop);
+	return FALSE;
+}
+
+static gboolean
+ping_watchdog (gpointer pwatchdog)
+{
+	hud_watchdog_ping(pwatchdog);
+	return FALSE;
+}
+
+static gboolean
+hit_one_sec (gpointer pboolean)
+{
+	gboolean * onesec = (gboolean *)pboolean;
+	*onesec = TRUE;
+	return FALSE;
+}
+
+static void
+test_watchdog_timing (void)
+{
+	HudWatchdog * doggie = NULL;
+	GMainLoop * loop = NULL;
+
+	g_setenv("HUD_SERVICE_TIMEOUT", "1", TRUE);
+
+	/* Test base timeout */
+	loop = g_main_loop_new(NULL, FALSE);
+	doggie = hud_watchdog_new(loop);
+
+	glong final = g_timeout_add_seconds(5, final_fail, loop);
+	g_main_loop_run(loop);
+	g_source_remove(final);
+
+	g_clear_object(&doggie);
+
+	/* Test a single ping */
+	gboolean one_sec_hit = FALSE;
+	doggie = hud_watchdog_new(loop);
+
+	final = g_timeout_add_seconds(3, final_fail, loop);
+	g_timeout_add(500, ping_watchdog, doggie);
+	g_timeout_add(1000, hit_one_sec, &one_sec_hit);
+
+	g_main_loop_run(loop);
+	g_source_remove(final);
+
+	g_assert(one_sec_hit);
+	g_clear_object(&doggie);
+
+
+	/* Clean up the loop */
+	g_main_loop_unref(loop);
+
+	return;
+}
+
+/* Build the test suite */
+static void
+test_watchdog_suite (void)
+{
+	g_test_add_func ("/hud/watchdog/create",   test_watchdog_create);
+	g_test_add_func ("/hud/watchdog/timing",   test_watchdog_timing);
+	return;
+}
+
+gint
+main (gint argc, gchar * argv[])
+{
+#ifndef GLIB_VERSION_2_36
+	g_type_init ();
+#endif
+
+	g_test_init(&argc, &argv, NULL);
+
+	/* Test suites */
+	test_watchdog_suite();
+
+	return g_test_run ();
+}