merge lp:~charlesk/indicator-power/coverage

16 files changed, 2730 insertions, 693 deletions

diff --git a/Makefile.am b/Makefile.am
index 25cbee5..00e108d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,30 +1,11 @@
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+SUBDIRS = po data src
 
-SUBDIRS = \
-	po \
-	data
+if BUILD_TESTS
+SUBDIRS += tests
+# build src first
+tests: src
+endif
 
-###################
-# Indicator Stuff
-###################
-
-powerlibdir = $(INDICATORDIR)
-powerlib_LTLIBRARIES = libpower.la
-libpower_la_SOURCES = \
-        src/indicator-power.c
-libpower_la_CFLAGS = \
-        $(UPOWER_CFLAGS) \
-        $(INDICATOR_CFLAGS) \
-		$(COVERAGE_CFLAGS) \
-        -Wall -Werror \
-        -DG_LOG_DOMAIN=\"Indicator-Power\"
-libpower_la_LIBADD = \
-        $(UPOWER_LIBS) \
-        $(INDICATOR_LIBS)
-libpower_la_LDFLAGS = \
-		$(COVERAGE_LDFLAGS) \
-        -module \
-        -avoid-version
 
 ############################################################
 
diff --git a/configure.ac b/configure.ac
index fc287a2..876edf7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -11,7 +11,7 @@ AC_CONFIG_SRCDIR([configure.ac])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_AUX_DIR([build-aux])
 
-AM_INIT_AUTOMAKE([1.11 -Wall foreign subdir-objects dist-xz])
+AM_INIT_AUTOMAKE([1.11 -Wall foreign dist-xz])
 AM_MAINTAINER_MODE([enable])
 
 AM_SILENT_RULES([yes])
@@ -19,6 +19,7 @@ AM_SILENT_RULES([yes])
 # Check for programs
 AC_PROG_CC
 AM_PROG_CC_C_O
+AC_PROG_CXX
 
 # Initialize libtool
 LT_PREREQ([2.2.6])
@@ -48,6 +49,26 @@ PKG_CHECK_MODULES([GSD],[gnome-settings-daemon >= $GSD_REQUIRED_VERSION])
 GLIB_GSETTINGS
 
 ###########################
+# Google Test framework
+###########################
+
+AC_ARG_ENABLE([tests],
+    [AS_HELP_STRING([--disable-tests], [Disable test scripts and tools (default=auto)])],
+    [enable_tests=${enableval}],
+    [enable_tests=auto])
+if test "x$enable_tests" != "xno"; then
+    m4_include([m4/gtest.m4])
+    CHECK_GTEST
+    CHECK_XORG_GTEST
+    if test "x$enable_tests" = "xauto"; then
+        enable_tests=${have_gtest}
+    elif test "x$enable_tests" = "xyes" && test "x$have_gtest" != "xyes"; then
+        AC_MSG_ERROR([tests were requested but gtest is not installed.])
+    fi
+fi
+AM_CONDITIONAL([BUILD_TESTS],[test "x$enable_tests" = "xyes"])
+
+###########################
 # gcov coverage reporting
 ###########################
 
@@ -119,6 +140,8 @@ AC_CONFIG_FILES([
 Makefile
 po/Makefile.in
 data/Makefile
+src/Makefile
+tests/Makefile
 ])
 AC_OUTPUT
 
@@ -132,5 +155,7 @@ Power Indicator Configuration:
 
 	Prefix:        $prefix
 	Local Install: $with_localinstall
+	Unit Tests:    $enable_tests
 	gcov:          $use_gcov
+
 ])
diff --git a/m4/gtest.m4 b/m4/gtest.m4
new file mode 100644
index 0000000..2de334c
--- /dev/null
+++ b/m4/gtest.m4
@@ -0,0 +1,63 @@
+# Copyright (C) 2012 Canonical, Ltd.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Checks whether the gtest source is available on the system. Allows for
+# adjusting the include and source path. Sets have_gtest=yes if the source is
+# present. Sets GTEST_CPPFLAGS and GTEST_SOURCE to the preprocessor flags and
+# source location respectively.
+AC_DEFUN([CHECK_GTEST],
+[
+  AC_ARG_WITH([gtest-include-path],
+              [AS_HELP_STRING([--with-gtest-include-path],
+                              [location of the Google test headers])],
+              [GTEST_CPPFLAGS="-I$withval"])
+
+  AC_ARG_WITH([gtest-source-path],
+              [AS_HELP_STRING([--with-gtest-source-path],
+                              [location of the Google test sources, defaults to /usr/src/gtest])],
+              [GTEST_SOURCE="$withval"],
+              [GTEST_SOURCE="/usr/src/gtest"])
+
+  GTEST_CPPFLAGS="$GTEST_CPPFLAGS -I$GTEST_SOURCE"
+
+  AC_LANG_PUSH([C++])
+
+  tmp_CPPFLAGS="$CPPFLAGS"
+  CPPFLAGS="$CPPFLAGS $GTEST_CPPFLAGS"
+
+  AC_CHECK_HEADER([gtest/gtest.h])
+
+  CPPFLAGS="$tmp_CPPFLAGS"
+
+  AC_LANG_POP
+
+  AC_CHECK_FILES([$GTEST_SOURCE/src/gtest-all.cc]
+                 [$GTEST_SOURCE/src/gtest_main.cc],
+                 [have_gtest_source=yes],
+                 [have_gtest_source=no])
+
+  AS_IF([test "x$ac_cv_header_gtest_gtest_h" = xyes -a \
+              "x$have_gtest_source" = xyes],
+        [have_gtest=yes]
+        [AC_SUBST(GTEST_CPPFLAGS)]
+        [AC_SUBST(GTEST_SOURCE)],
+        [have_gtest=no])
+]) # CHECK_GTEST
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 7c8c8a1..3061414 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -1,2 +1,4 @@
 data/com.canonical.indicator.power.gschema.xml.in
+src/device.c
+src/dbus-listener.c
 src/indicator-power.c
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..b2cf3df
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,36 @@
+CLEANFILES =
+ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+
+###################
+# Indicator Stuff
+###################
+
+powerlibdir = $(INDICATORDIR)
+powerlib_LTLIBRARIES = libpower.la
+
+libpower_la_SOURCES = \
+        dbus-listener.c \
+        dbus-listener.h \
+        device.c \
+        device.h \
+        indicator-power.h \
+        indicator-power.c
+
+CLEANFILES += .libs/*.gcda .libs/*.gcno *.gcda *.gcno
+
+libpower_la_CFLAGS = \
+        $(UPOWER_CFLAGS) \
+        $(INDICATOR_CFLAGS) \
+        $(COVERAGE_CFLAGS) \
+        -Wall -Werror \
+        -DG_LOG_DOMAIN=\"Indicator-Power\"
+
+libpower_la_LIBADD = \
+        $(UPOWER_LIBS) \
+        $(INDICATOR_LIBS)
+
+libpower_la_LDFLAGS = \
+        $(COVERAGE_LDFLAGS) \
+        -module \
+        -avoid-version
+
diff --git a/src/dbus-listener.c b/src/dbus-listener.c
new file mode 100644
index 0000000..b1f64a7
--- /dev/null
+++ b/src/dbus-listener.c
@@ -0,0 +1,247 @@
+/*
+
+Listens on DBus for Power changes and passes them to an IndicatorPower
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU 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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#include "dbus-listener.h"
+#include "device.h"
+
+struct _IndicatorPowerDbusListenerPrivate
+{
+  GCancellable * cancellable;
+  GDBusProxy * proxy;
+  guint watcher_id;
+};
+
+#define INDICATOR_POWER_DBUS_LISTENER_GET_PRIVATE(o) (INDICATOR_POWER_DBUS_LISTENER(o)->priv)
+
+/* Signals */
+enum {
+  SIGNAL_DEVICES,
+  SIGNAL_LAST
+};
+static guint signals[SIGNAL_LAST] = { 0 };
+
+
+/* GObject stuff */
+static void indicator_power_dbus_listener_class_init (IndicatorPowerDbusListenerClass *klass);
+static void indicator_power_dbus_listener_init       (IndicatorPowerDbusListener *self);
+static void indicator_power_dbus_listener_dispose    (GObject *object);
+static void indicator_power_dbus_listener_finalize   (GObject *object);
+
+static void gsd_appeared_callback (GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data);
+
+/* LCOV_EXCL_START */
+G_DEFINE_TYPE (IndicatorPowerDbusListener, indicator_power_dbus_listener, G_TYPE_OBJECT);
+/* LCOV_EXCL_STOP */
+
+static void
+indicator_power_dbus_listener_class_init (IndicatorPowerDbusListenerClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (IndicatorPowerDbusListenerPrivate));
+
+  /* methods */
+  object_class->dispose = indicator_power_dbus_listener_dispose;
+  object_class->finalize = indicator_power_dbus_listener_finalize;
+
+  /**
+   * IndicatorPowerDbusListener::devices-enumerated:
+   *
+   * @listener: the IndicatorPowerDbusListener
+   * @devices: a GSList of #IndicatorPowerDevice objects. (transfer none)
+   *
+   * This is emitted each time a new set of devices is enumerated over the bus.
+   */
+  signals[SIGNAL_DEVICES] = g_signal_new (INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                                          G_TYPE_FROM_CLASS(klass), 0,
+                                          G_STRUCT_OFFSET (IndicatorPowerDbusListenerClass, devices_enumerated),
+                                          NULL, NULL,
+                                          g_cclosure_marshal_VOID__POINTER,
+                                          G_TYPE_NONE, 1, G_TYPE_POINTER);
+}
+
+/* Initialize an instance */
+static void
+indicator_power_dbus_listener_init (IndicatorPowerDbusListener *self)
+{
+  IndicatorPowerDbusListenerPrivate * priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+                                      INDICATOR_POWER_DBUS_LISTENER_TYPE,
+                                      IndicatorPowerDbusListenerPrivate);
+
+  priv->cancellable = g_cancellable_new ();
+
+  priv->watcher_id = g_bus_watch_name (G_BUS_TYPE_SESSION,
+                                       GSD_SERVICE,
+                                       G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                       gsd_appeared_callback,
+                                       NULL,
+                                       self,
+                                       NULL);
+
+  self->priv = priv;
+}
+
+static void
+indicator_power_dbus_listener_dispose (GObject *object)
+{
+  IndicatorPowerDbusListener * self = INDICATOR_POWER_DBUS_LISTENER(object);
+  IndicatorPowerDbusListenerPrivate * priv = self->priv;
+
+  g_clear_object (&priv->proxy);
+
+  if (priv->cancellable != NULL)
+    {
+      g_cancellable_cancel (priv->cancellable);
+      g_clear_object (&priv->cancellable);
+    }
+
+  if (priv->watcher_id)
+    {
+      g_bus_unwatch_name (priv->watcher_id);
+      priv->watcher_id = 0;
+    }
+
+  G_OBJECT_CLASS (indicator_power_dbus_listener_parent_class)->dispose (object);
+}
+
+static void
+indicator_power_dbus_listener_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (indicator_power_dbus_listener_parent_class)->finalize (object);
+}
+
+/***
+****
+***/
+
+static void
+get_devices_cb (GObject      * source_object,
+                GAsyncResult * res,
+                gpointer       user_data)
+{
+  GError *error;
+  GSList * devices = NULL;
+  GVariant * devices_container;
+  IndicatorPowerDbusListener * self = INDICATOR_POWER_DBUS_LISTENER (user_data);
+
+  /* build an array of IndicatorPowerDevices from the DBus response */
+  error = NULL;
+  devices_container = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
+  if (devices_container == NULL)
+    {
+      g_message ("Couldn't get devices: %s\n", error->message);
+      g_error_free (error);
+    }
+  else
+    {
+      gsize i;
+      GVariant * devices_variant = g_variant_get_child_value (devices_container, 0);
+      const int device_count = devices_variant ? g_variant_n_children (devices_variant) : 0;
+
+      for (i=0; i<device_count; i++)
+        {
+          GVariant * v = g_variant_get_child_value (devices_variant, i);
+          devices = g_slist_prepend (devices, indicator_power_device_new_from_variant (v));
+          g_variant_unref (v);
+        }
+
+      devices = g_slist_reverse (devices);
+
+      g_variant_unref (devices_variant);
+      g_variant_unref (devices_container);
+    }
+
+  g_signal_emit (self, signals[SIGNAL_DEVICES], (GQuark)0, devices);
+  g_slist_free_full (devices, g_object_unref);
+}
+
+static void
+request_device_list (IndicatorPowerDbusListener * self)
+{
+  g_dbus_proxy_call (self->priv->proxy,
+                     "GetDevices",
+                     NULL,
+                     G_DBUS_CALL_FLAGS_NONE,
+                     -1,
+                     self->priv->cancellable,
+                     get_devices_cb,
+                     self);
+}
+
+static void
+receive_properties_changed (GDBusProxy *proxy                  G_GNUC_UNUSED,
+                            GVariant   *changed_properties     G_GNUC_UNUSED,
+                            GStrv       invalidated_properties G_GNUC_UNUSED,
+                            gpointer    user_data)
+{
+  request_device_list (INDICATOR_POWER_DBUS_LISTENER(user_data));
+}
+
+
+static void
+service_proxy_cb (GObject      *object,
+                  GAsyncResult *res,
+                  gpointer      user_data)
+{
+  GError * error = NULL;
+  IndicatorPowerDbusListener * self = INDICATOR_POWER_DBUS_LISTENER(user_data);
+  IndicatorPowerDbusListenerPrivate * priv = self->priv;
+
+  priv->proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
+
+  if (error != NULL)
+    {
+      g_error ("Error creating proxy: %s", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  /* we want to change the primary device changes */
+  g_signal_connect (priv->proxy, "g-properties-changed",
+                    G_CALLBACK (receive_properties_changed), user_data);
+
+  /* get the initial state */
+  request_device_list (self);
+}
+
+static void
+gsd_appeared_callback (GDBusConnection *connection,
+                       const gchar     *name,
+                       const gchar     *name_owner,
+                       gpointer         user_data)
+{
+  IndicatorPowerDbusListener * self = INDICATOR_POWER_DBUS_LISTENER(user_data);
+  IndicatorPowerDbusListenerPrivate * priv = self->priv;
+
+  g_dbus_proxy_new (connection,
+                    G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                    NULL,
+                    name,
+                    GSD_POWER_DBUS_PATH,
+                    GSD_POWER_DBUS_INTERFACE,
+                    priv->cancellable,
+                    service_proxy_cb,
+                    self);
+}
diff --git a/src/dbus-listener.h b/src/dbus-listener.h
new file mode 100644
index 0000000..e4d006b
--- /dev/null
+++ b/src/dbus-listener.h
@@ -0,0 +1,82 @@
+/*
+
+Listens for Power changes from org.gnome.SettingsDaemon.Power on Dbus
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Javier Jardon <javier.jardon@codethink.co.uk>
+    Charles Kerr <charles.kerr@canonical.com>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU 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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INDICATOR_POWER_DBUS_LISTENER_H__
+#define __INDICATOR_POWER_DBUS_LISTENER_H__
+
+#include <glib-object.h>
+#include <libupower-glib/upower.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_POWER_DBUS_LISTENER_TYPE            (indicator_power_dbus_listener_get_type ())
+#define INDICATOR_POWER_DBUS_LISTENER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_POWER_DBUS_LISTENER_TYPE, IndicatorPowerDbusListener))
+#define INDICATOR_POWER_DBUS_LISTENER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  INDICATOR_POWER_DBUS_LISTENER_TYPE, IndicatorPowerDbusListenerClass))
+#define INDICATOR_IS_POWER_DBUS_LISTENER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_POWER_DBUS_LISTENER_TYPE))
+#define INDICATOR_IS_POWER_DBUS_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  INDICATOR_POWER_DBUS_LISTENER_TYPE))
+#define INDICATOR_POWER_DBUS_LISTENER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  INDICATOR_POWER_DBUS_LISTENER_TYPE, IndicatorPowerDbusListenerClass))
+
+typedef struct _IndicatorPowerDbusListener IndicatorPowerDbusListener;
+typedef struct _IndicatorPowerDbusListenerClass IndicatorPowerDbusListenerClass;
+typedef struct _IndicatorPowerDbusListenerPrivate IndicatorPowerDbusListenerPrivate;
+
+#define GSD_SERVICE               "org.gnome.SettingsDaemon"
+#define GSD_PATH                  "/org/gnome/SettingsDaemon"
+#define GSD_POWER_DBUS_INTERFACE  GSD_SERVICE ".Power"
+#define GSD_POWER_DBUS_PATH       GSD_PATH "/Power"
+
+/* signals */
+#define INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED  "devices-enumerated"
+
+/**
+ * IndicatorPowerDbusListenerClass:
+ * @parent_class: #GObjectClass
+ */
+struct _IndicatorPowerDbusListenerClass
+{
+  GObjectClass parent_class;
+
+  void (* devices_enumerated) (IndicatorPowerDbusListener*, GSList * devices);
+};
+
+/**
+ * IndicatorPowerDbusListener:
+ * @parent: #GObject
+ * @priv: A cached reference to the private data for the instance.
+*/
+struct _IndicatorPowerDbusListener
+{
+  GObject parent;
+  IndicatorPowerDbusListenerPrivate * priv;
+};
+
+/***
+****
+***/
+
+GType indicator_power_dbus_listener_get_type (void);
+
+G_END_DECLS
+
+#endif
diff --git a/src/device.c b/src/device.c
new file mode 100644
index 0000000..c22aae8
--- /dev/null
+++ b/src/device.c
@@ -0,0 +1,666 @@
+/*
+
+A simple Device structure used internally by indicator-power
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU 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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+
+#include <glib/gi18n.h>
+
+#include "device.h"
+
+struct _IndicatorPowerDevicePrivate
+{
+  UpDeviceKind kind;
+  UpDeviceState state;
+  gchar * object_path;
+  gdouble percentage;
+  time_t time;
+};
+
+#define INDICATOR_POWER_DEVICE_GET_PRIVATE(o) (INDICATOR_POWER_DEVICE(o)->priv)
+
+/* Properties */
+/* Enum for the properties so that they can be quickly found and looked up. */
+enum {
+  PROP_0,
+  PROP_KIND,
+  PROP_STATE,
+  PROP_OBJECT_PATH,
+  PROP_PERCENTAGE,
+  PROP_TIME,
+  N_PROPERTIES
+};
+
+static GParamSpec * properties[N_PROPERTIES];
+
+/* GObject stuff */
+static void indicator_power_device_class_init (IndicatorPowerDeviceClass *klass);
+static void indicator_power_device_init       (IndicatorPowerDevice *self);
+static void indicator_power_device_dispose    (GObject *object);
+static void indicator_power_device_finalize   (GObject *object);
+static void set_property (GObject*, guint prop_id, const GValue*, GParamSpec* );
+static void get_property (GObject*, guint prop_id,       GValue*, GParamSpec* );
+
+/* LCOV_EXCL_START */
+G_DEFINE_TYPE (IndicatorPowerDevice, indicator_power_device, G_TYPE_OBJECT);
+/* LCOV_EXCL_STOP */
+
+static void
+indicator_power_device_class_init (IndicatorPowerDeviceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (IndicatorPowerDevicePrivate));
+
+  object_class->dispose = indicator_power_device_dispose;
+  object_class->finalize = indicator_power_device_finalize;
+  object_class->set_property = set_property;
+  object_class->get_property = get_property;
+
+  properties[PROP_KIND] = g_param_spec_int (INDICATOR_POWER_DEVICE_KIND,
+                                            "kind",
+                                            "The device's UpDeviceKind",
+                                            UP_DEVICE_KIND_UNKNOWN, UP_DEVICE_KIND_LAST,
+                                            UP_DEVICE_KIND_UNKNOWN,
+                                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_STATE] = g_param_spec_int (INDICATOR_POWER_DEVICE_STATE,
+                                             "state",
+                                             "The device's UpDeviceState",
+                                             UP_DEVICE_STATE_UNKNOWN, UP_DEVICE_STATE_LAST,
+                                             UP_DEVICE_STATE_UNKNOWN,
+                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_OBJECT_PATH] = g_param_spec_string (INDICATOR_POWER_DEVICE_OBJECT_PATH,
+                                                      "object path",
+                                                      "The device's DBus object path",
+                                                      NULL,
+                                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_PERCENTAGE] = g_param_spec_double (INDICATOR_POWER_DEVICE_PERCENTAGE,
+                                                     "percentage",
+                                                     "percent charged",
+                                                     0.0, 100.0,
+                                                     0.0,
+                                                     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_TIME] = g_param_spec_uint64 (INDICATOR_POWER_DEVICE_TIME,
+                                               "time",
+                                               "time left",
+                                               0, G_MAXUINT64,
+                                               0,
+                                               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+}
+
+/* Initialize an instance */
+static void
+indicator_power_device_init (IndicatorPowerDevice *self)
+{
+  IndicatorPowerDevicePrivate * priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_POWER_DEVICE_TYPE,
+                                            IndicatorPowerDevicePrivate);
+  priv->kind = UP_DEVICE_KIND_UNKNOWN;
+  priv->state = UP_DEVICE_STATE_UNKNOWN;
+  priv->object_path = NULL;
+  priv->percentage = 0.0;
+  priv->time = 0;
+
+  self->priv = priv;
+}
+
+static void
+indicator_power_device_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (indicator_power_device_parent_class)->dispose (object);
+}
+
+static void
+indicator_power_device_finalize (GObject *object)
+{
+  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(object);
+  IndicatorPowerDevicePrivate * priv = self->priv;
+
+  g_clear_pointer (&priv->object_path, g_free);
+
+  G_OBJECT_CLASS (indicator_power_device_parent_class)->finalize (object);
+}
+
+/***
+****
+***/
+
+static void
+get_property (GObject * o, guint  prop_id, GValue * value, GParamSpec * pspec)
+{
+  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(o);
+  IndicatorPowerDevicePrivate * priv = self->priv;
+
+  switch (prop_id)
+    {
+      case PROP_KIND:
+        g_value_set_int (value, priv->kind);
+        break;
+
+      case PROP_STATE:
+        g_value_set_int (value, priv->state);
+        break;
+
+      case PROP_OBJECT_PATH:
+        g_value_set_string (value, priv->object_path);
+        break;
+
+      case PROP_PERCENTAGE:
+        g_value_set_double (value, priv->percentage);
+        break;
+
+      case PROP_TIME:
+        g_value_set_uint64 (value, priv->time);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(o, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+set_property (GObject * o, guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(o);
+  IndicatorPowerDevicePrivate * priv = self->priv;
+
+  switch (prop_id)
+    {
+      case PROP_KIND:
+        priv->kind = g_value_get_int (value);
+        break;
+
+      case PROP_STATE:
+        priv->state = g_value_get_int (value);
+        break;
+
+      case PROP_OBJECT_PATH:
+        g_free (priv->object_path);
+        priv->object_path = g_value_dup_string (value);
+        break;
+
+      case PROP_PERCENTAGE:
+        priv->percentage = g_value_get_double (value);
+        break;
+
+      case PROP_TIME:
+        priv->time = g_value_get_uint64(value);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(o, prop_id, pspec);
+        break;
+    }
+}
+
+/***
+****  Accessors
+***/
+
+UpDeviceKind
+indicator_power_device_get_kind  (const IndicatorPowerDevice * device)
+{
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), UP_DEVICE_KIND_UNKNOWN);
+  /* LCOV_EXCL_STOP */
+
+  return device->priv->kind;
+}
+
+UpDeviceState
+indicator_power_device_get_state (const IndicatorPowerDevice * device)
+{
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), UP_DEVICE_STATE_UNKNOWN);
+  /* LCOV_EXCL_STOP */
+
+  return device->priv->state;
+}
+
+const gchar *
+indicator_power_device_get_object_path (const IndicatorPowerDevice * device)
+{
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), NULL);
+  /* LCOV_EXCL_STOP */
+
+  return device->priv->object_path;
+}
+
+gdouble
+indicator_power_device_get_percentage (const IndicatorPowerDevice * device)
+{
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), 0.0);
+  /* LCOV_EXCL_STOP */
+
+  return device->priv->percentage;
+}
+
+time_t
+indicator_power_device_get_time (const IndicatorPowerDevice * device)
+{
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), (time_t)0);
+  /* LCOV_EXCL_STOP */
+
+  return device->priv->time;
+}
+
+/***
+****
+****
+***/
+
+static const gchar *
+get_device_icon_suffix (gdouble percentage)
+{
+  if (percentage >= 60) return "full";
+  if (percentage >= 30) return "good";
+  if (percentage >= 10) return "low";
+  return "caution";
+}
+
+static const gchar *
+get_device_icon_index (gdouble percentage)
+{
+  if (percentage >= 90) return "100";
+  if (percentage >= 70) return "080";
+  if (percentage >= 50) return "060";
+  if (percentage >= 30) return "040";
+  if (percentage >= 10) return "020";
+  return "000";
+}
+
+/**
+  indicator_power_device_get_icon_names:
+  @device: #IndicatorPowerDevice from which to generate the icon names
+
+  This function's logic differs from GSD's power plugin in some ways:
+
+  1. All charging batteries use the same icon regardless of progress.
+  <https://bugs.launchpad.net/indicator-power/+bug/824629/comments/7>
+
+  2. For discharging batteries, we decide whether or not to use the 'caution'
+  icon based on whether or not we have <= 30 minutes remaining, rather than
+  looking at the battery's percentage left.
+  <https://bugs.launchpad.net/indicator-power/+bug/743823>
+
+  See also indicator_power_device_get_gicon().
+
+  Return value: (array zero-terminated=1) (transfer full):
+  A GStrv of icon names suitable for passing to g_themed_icon_new_from_names().
+  Free with g_strfreev() when done.
+*/
+GStrv
+indicator_power_device_get_icon_names (const IndicatorPowerDevice * device)
+{
+  const gchar *suffix_str;
+  const gchar *index_str;
+
+  /* LCOV_EXCL_START */
+  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), NULL);
+  /* LCOV_EXCL_STOP */
+
+  gdouble percentage = indicator_power_device_get_percentage (device);
+  const UpDeviceKind kind = indicator_power_device_get_kind (device);
+  const UpDeviceState state = indicator_power_device_get_state (device);
+  const gchar * kind_str = kind_str = up_device_kind_to_string (kind);
+
+  GPtrArray * names = g_ptr_array_new ();
+
+  if (kind == UP_DEVICE_KIND_LINE_POWER)
+    {
+      g_ptr_array_add (names, g_strdup("ac-adapter-symbolic"));
+      g_ptr_array_add (names, g_strdup("ac-adapter"));
+    }
+  else if (kind == UP_DEVICE_KIND_MONITOR)
+    {
+      g_ptr_array_add (names, g_strdup("gpm-monitor-symbolic"));
+      g_ptr_array_add (names, g_strdup("gpm-monitor"));
+    }
+  else switch (state)
+    {
+      case UP_DEVICE_STATE_EMPTY:
+        g_ptr_array_add (names, g_strdup("battery-empty-symbolic"));
+        g_ptr_array_add (names, g_strdup_printf("gpm-%s-empty", kind_str));
+        g_ptr_array_add (names, g_strdup_printf("gpm-%s-000", kind_str));
+        g_ptr_array_add (names, g_strdup("battery-empty"));
+        break;
+
+      case UP_DEVICE_STATE_FULLY_CHARGED:
+        g_ptr_array_add (names, g_strdup("battery-full-charged-symbolic"));
+        g_ptr_array_add (names, g_strdup("battery-full-charging-symbolic"));
+        g_ptr_array_add (names, g_strdup_printf("gpm-%s-full", kind_str));
+        g_ptr_array_add (names, g_strdup_printf("gpm-%s-100", kind_str));
+        g_ptr_array_add (names, g_strdup("battery-full-charged"));
+        g_ptr_array_add (names, g_strdup("battery-full-charging"));
+        break;
+
+      case UP_DEVICE_STATE_CHARGING:
+      case UP_DEVICE_STATE_PENDING_CHARGE:
+        /* When charging, always use the same icon regardless of percentage.
+           <http://bugs.launchpad.net/indicator-power/+bug/824629> */
+        percentage = 0;
+
+        suffix_str = get_device_icon_suffix (percentage);
+        index_str = get_device_icon_index (percentage);
+        g_ptr_array_add (names, g_strdup_printf ("battery-%s-charging-symbolic", suffix_str));
+        g_ptr_array_add (names, g_strdup_printf ("gpm-%s-%s-charging", kind_str, index_str));
+        g_ptr_array_add (names, g_strdup_printf ("battery-%s-charging", suffix_str));
+        break;
+
+      case UP_DEVICE_STATE_DISCHARGING:
+      case UP_DEVICE_STATE_PENDING_DISCHARGE:
+        /* Don't show the caution/red icons unless we have <=30 min left.
+           <https://bugs.launchpad.net/indicator-power/+bug/743823>
+           Themes use the caution color when the percentage is 0% or 20%,
+           so if we have >30 min left, use 30% as the icon's percentage floor */
+        if (indicator_power_device_get_time (device) > (30*60))
+          percentage = MAX(percentage, 30);
+
+        suffix_str = get_device_icon_suffix (percentage);
+        index_str = get_device_icon_index (percentage);
+        g_ptr_array_add (names, g_strdup_printf ("battery-%s-symbolic", suffix_str));
+        g_ptr_array_add (names, g_strdup_printf ("gpm-%s-%s", kind_str, index_str));
+        g_ptr_array_add (names, g_strdup_printf ("battery-%s", suffix_str));
+        break;
+
+      default:
+        g_ptr_array_add (names, g_strdup("battery-missing-symbolic"));
+        g_ptr_array_add (names, g_strdup("gpm-battery-missing"));
+        g_ptr_array_add (names, g_strdup("battery-missing"));
+    }
+
+    g_ptr_array_add (names, NULL); /* terminates the strv */
+    return (GStrv) g_ptr_array_free (names, FALSE);
+}
+
+/**
+  indicator_power_device_get_gicon:
+  @device: #IndicatorPowerDevice to generate the icon names from
+
+  A convenience function to call g_themed_icon_new_from_names()
+  with the names returned by indicator_power_device_get_icon_names()
+
+  Return value: (transfer full): A themed GIcon
+*/
+GIcon *
+indicator_power_device_get_gicon (const IndicatorPowerDevice * device)
+{
+  GStrv names = indicator_power_device_get_icon_names (device);
+  GIcon * icon = g_themed_icon_new_from_names (names, -1);
+  g_strfreev (names);
+  return icon;
+}
+
+/***
+****
+***/
+
+static void
+get_timestring (guint64   time_secs,
+                gchar   **short_timestring,
+                gchar   **detailed_timestring)
+{
+  gint  hours;
+  gint  minutes;
+
+  /* Add 0.5 to do rounding */
+  minutes = (int) ( ( time_secs / 60.0 ) + 0.5 );
+
+  if (minutes == 0)
+    {
+      *short_timestring = g_strdup (_("Unknown time"));
+      *detailed_timestring = g_strdup (_("Unknown time"));
+
+      return;
+    }
+
+  if (minutes < 60)
+    {
+      *short_timestring = g_strdup_printf ("0:%.2i", minutes);
+      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%i minute",
+                                              "%i minutes",
+                                              minutes), minutes);
+      return;
+    }
+
+  hours = minutes / 60;
+  minutes = minutes % 60;
+
+  *short_timestring = g_strdup_printf ("%i:%.2i", hours, minutes);
+
+  if (minutes == 0)
+    {
+      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, 
+                                              "%i hour",
+                                              "%i hours",
+                                              hours), hours);
+    }
+  else
+    {
+      /* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
+       * Swap order with "%2$s %2$i %1$s %1$i if needed */
+      *detailed_timestring = g_strdup_printf (_("%i %s %i %s"),
+                                              hours, g_dngettext (GETTEXT_PACKAGE, "hour", "hours", hours),
+                                              minutes, g_dngettext (GETTEXT_PACKAGE, "minute", "minutes", minutes));
+    }
+}
+
+static const gchar *
+device_kind_to_localised_string (UpDeviceKind kind)
+{
+  const gchar *text = NULL;
+
+  switch (kind) {
+    case UP_DEVICE_KIND_LINE_POWER:
+      /* TRANSLATORS: system power cord */
+      text = _("AC Adapter");
+      break;
+    case UP_DEVICE_KIND_BATTERY:
+      /* TRANSLATORS: laptop primary battery */
+      text = _("Battery");
+      break;
+    case UP_DEVICE_KIND_UPS:
+      /* TRANSLATORS: battery-backed AC power source */
+      text = _("UPS");
+      break;
+    case UP_DEVICE_KIND_MONITOR:
+      /* TRANSLATORS: a monitor is a device to measure voltage and current */
+      text = _("Monitor");
+      break;
+    case UP_DEVICE_KIND_MOUSE:
+      /* TRANSLATORS: wireless mice with internal batteries */
+      text = _("Mouse");
+      break;
+    case UP_DEVICE_KIND_KEYBOARD:
+      /* TRANSLATORS: wireless keyboard with internal battery */
+      text = _("Keyboard");
+      break;
+    case UP_DEVICE_KIND_PDA:
+      /* TRANSLATORS: portable device */
+      text = _("PDA");
+      break;
+    case UP_DEVICE_KIND_PHONE:
+      /* TRANSLATORS: cell phone (mobile...) */
+      text = _("Cell phone");
+      break;
+    case UP_DEVICE_KIND_MEDIA_PLAYER:
+      /* TRANSLATORS: media player, mp3 etc */
+      text = _("Media player");
+      break;
+    case UP_DEVICE_KIND_TABLET:
+      /* TRANSLATORS: tablet device */
+      text = _("Tablet");
+      break;
+    case UP_DEVICE_KIND_COMPUTER:
+      /* TRANSLATORS: tablet device */
+      text = _("Computer");
+      break;
+    default:
+      g_warning ("enum unrecognised: %i", kind);
+      text = up_device_kind_to_string (kind);
+    }
+
+  return text;
+}
+
+void
+indicator_power_device_get_time_details (const IndicatorPowerDevice * device,
+                                         gchar ** short_details,
+                                         gchar ** details,
+                                         gchar ** accessible_name)
+{
+  if (!INDICATOR_IS_POWER_DEVICE(device))
+    {
+      *short_details = NULL;
+      *details = NULL;
+      *accessible_name = NULL;
+      g_warning ("%s: %p is not an IndicatorPowerDevice", G_STRFUNC, device);
+      return;
+    }
+
+  const time_t time = indicator_power_device_get_time (device);
+  const UpDeviceState state = indicator_power_device_get_state (device);
+  const gdouble percentage = indicator_power_device_get_percentage (device);
+  const UpDeviceKind kind = indicator_power_device_get_kind (device);
+  const gchar * device_name = device_kind_to_localised_string (kind);
+
+  if (time > 0)
+    {
+      gchar *short_timestring = NULL;
+      gchar *detailed_timestring = NULL;
+
+      get_timestring (time,
+                      &short_timestring,
+                      &detailed_timestring);
+
+      if (state == UP_DEVICE_STATE_CHARGING)
+        {
+          /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
+          *accessible_name = g_strdup_printf (_("%s (%s to charge (%.0lf%%))"), device_name, detailed_timestring, percentage);
+          *details = g_strdup_printf (_("%s (%s to charge)"), device_name, short_timestring);
+          *short_details = g_strdup_printf ("(%s)", short_timestring);
+        }
+      else if ((state == UP_DEVICE_STATE_DISCHARGING) && (time > (60*60*12)))
+        {
+          *accessible_name = g_strdup_printf (_("%s"), device_name);
+          *details = g_strdup_printf (_("%s"), device_name);
+          *short_details = g_strdup (short_timestring);
+        }
+      else
+        {
+          /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
+          *accessible_name = g_strdup_printf (_("%s (%s left (%.0lf%%))"), device_name, detailed_timestring, percentage);
+          *details = g_strdup_printf (_("%s (%s left)"), device_name, short_timestring);
+          *short_details = g_strdup (short_timestring);
+        }
+
+      g_free (short_timestring);
+      g_free (detailed_timestring);
+    }
+  else if (state == UP_DEVICE_STATE_FULLY_CHARGED)
+    {
+      *details = g_strdup_printf (_("%s (charged)"), device_name);
+      *accessible_name = g_strdup (*details);
+      *short_details = g_strdup ("");
+    }
+  else if (percentage > 0)
+    {
+      /* TRANSLATORS: %2 is a percentage value. Note: this string is only
+       * used when we don't have a time value */
+      *details = g_strdup_printf (_("%s (%.0lf%%)"), device_name, percentage);
+      *accessible_name = g_strdup (*details);
+      *short_details = g_strdup_printf (_("(%.0lf%%)"), percentage);
+    }
+  else if (kind == UP_DEVICE_KIND_LINE_POWER)
+    {
+      *details         = g_strdup (device_name);
+      *accessible_name = g_strdup (device_name);
+      *short_details   = g_strdup (device_name);
+    }
+  else
+    {
+      *details = g_strdup_printf (_("%s (not present)"), device_name);
+      *accessible_name = g_strdup (*details);
+      *short_details = g_strdup (_("(not present)"));
+    }
+}
+
+/***
+****  Instantiation
+***/
+
+IndicatorPowerDevice *
+indicator_power_device_new (const gchar * object_path,
+                            UpDeviceKind  kind,
+                            gdouble percentage,
+                            UpDeviceState state,
+                            time_t timestamp)
+{
+  GObject * o = g_object_new (INDICATOR_POWER_DEVICE_TYPE,
+    INDICATOR_POWER_DEVICE_KIND, kind,
+    INDICATOR_POWER_DEVICE_STATE, state,
+    INDICATOR_POWER_DEVICE_OBJECT_PATH, object_path,
+    INDICATOR_POWER_DEVICE_PERCENTAGE, percentage,
+    INDICATOR_POWER_DEVICE_TIME, (guint64)timestamp,
+    NULL);
+  return INDICATOR_POWER_DEVICE(o);
+}
+
+IndicatorPowerDevice *
+indicator_power_device_new_from_variant (GVariant * v)
+{
+  g_return_val_if_fail (g_variant_is_of_type (v, G_VARIANT_TYPE("(susdut)")), NULL);
+
+  UpDeviceKind kind = UP_DEVICE_KIND_UNKNOWN;
+  UpDeviceState state = UP_DEVICE_STATE_UNKNOWN;
+  const gchar * icon = NULL;
+  const gchar * object_path = NULL;
+  gdouble percentage = 0;
+  guint64 time = 0;
+
+  g_variant_get (v, "(&su&sdut)",
+                 &object_path,
+                 &kind,
+                 &icon,
+                 &percentage,
+                 &state,
+                 &time);
+
+  return indicator_power_device_new (object_path,
+                                     kind,
+                                     percentage,
+                                     state,
+                                     time);
+}
diff --git a/src/device.h b/src/device.h
new file mode 100644
index 0000000..3f7bbee
--- /dev/null
+++ b/src/device.h
@@ -0,0 +1,107 @@
+/*
+
+A simple Device structure used internally by indicator-power
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU 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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INDICATOR_POWER_DEVICE_H__
+#define __INDICATOR_POWER_DEVICE_H__
+
+#include <glib-object.h>
+#include <libupower-glib/upower.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_POWER_DEVICE_TYPE            (indicator_power_device_get_type ())
+#define INDICATOR_POWER_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_POWER_DEVICE_TYPE, IndicatorPowerDevice))
+#define INDICATOR_POWER_DEVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  INDICATOR_POWER_DEVICE_TYPE, IndicatorPowerDeviceClass))
+#define INDICATOR_IS_POWER_DEVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_POWER_DEVICE_TYPE))
+#define INDICATOR_IS_POWER_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  INDICATOR_POWER_DEVICE_TYPE))
+#define INDICATOR_POWER_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  INDICATOR_POWER_DEVICE_TYPE, IndicatorPowerDeviceClass))
+
+typedef struct _IndicatorPowerDevice IndicatorPowerDevice;
+typedef struct _IndicatorPowerDeviceClass IndicatorPowerDeviceClass;
+typedef struct _IndicatorPowerDevicePrivate IndicatorPowerDevicePrivate;
+
+#define INDICATOR_POWER_DEVICE_KIND         "kind"
+#define INDICATOR_POWER_DEVICE_STATE        "state"
+#define INDICATOR_POWER_DEVICE_OBJECT_PATH  "object-path"
+#define INDICATOR_POWER_DEVICE_PERCENTAGE   "percentage"
+#define INDICATOR_POWER_DEVICE_TIME         "time"
+
+/**
+ * IndicatorPowerDeviceClass:
+ * @parent_class: #GObjectClass
+ */
+struct _IndicatorPowerDeviceClass
+{
+  GObjectClass parent_class;
+};
+
+/**
+ * IndicatorPowerDevice:
+ * @parent: #GObject
+ * @priv: A cached reference to the private data for the instance.
+*/
+struct _IndicatorPowerDevice
+{
+  GObject parent;
+  IndicatorPowerDevicePrivate * priv;
+};
+
+/***
+****
+***/
+
+GType indicator_power_device_get_type (void);
+
+IndicatorPowerDevice* indicator_power_device_new (const gchar    * object_path,
+                                                  UpDeviceKind     kind,
+                                                  gdouble          percentage,
+                                                  UpDeviceState    state,
+                                                  time_t           time);
+
+/**
+ * Convenience wrapper around indicator_power_device_new()
+ * @variant holds the same args as indicator_power_device_new() in "(susdut)"
+ */
+IndicatorPowerDevice* indicator_power_device_new_from_variant (GVariant * variant);
+
+
+UpDeviceKind  indicator_power_device_get_kind        (const IndicatorPowerDevice * device);
+UpDeviceState indicator_power_device_get_state       (const IndicatorPowerDevice * device);
+const gchar * indicator_power_device_get_object_path (const IndicatorPowerDevice * device);
+gdouble       indicator_power_device_get_percentage  (const IndicatorPowerDevice * device);
+time_t        indicator_power_device_get_time        (const IndicatorPowerDevice * device);
+
+GStrv         indicator_power_device_get_icon_names  (const IndicatorPowerDevice * device);
+GIcon       * indicator_power_device_get_gicon       (const IndicatorPowerDevice * device);
+
+void          indicator_power_device_get_time_details (const IndicatorPowerDevice * device,
+                                                       gchar ** short_details,
+                                                       gchar ** details,
+                                                       gchar ** accessible_name);
+
+
+
+
+G_END_DECLS
+
+#endif
diff --git a/src/indicator-power.c b/src/indicator-power.c
index 1b3794e..f3a7235 100644
--- a/src/indicator-power.c
+++ b/src/indicator-power.c
@@ -20,7 +20,7 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+ #include "config.h"
 #endif
 
 /* GStuff */
@@ -28,67 +28,41 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <glib/gi18n-lib.h>
 #include <gio/gio.h>
 
-/* upower */
-#include <libupower-glib/upower.h>
-
-/* Indicator Stuff */
-#include <libindicator/indicator.h>
-#include <libindicator/indicator-object.h>
+#include "dbus-listener.h"
+#include "device.h"
+#include "indicator-power.h"
 
 #define ICON_POLICY_KEY "icon-policy"
 
 #define DEFAULT_ICON   "gpm-battery-missing"
 
-#define DBUS_SERVICE                "org.gnome.SettingsDaemon"
-#define DBUS_PATH                   "/org/gnome/SettingsDaemon"
-#define POWER_DBUS_PATH             DBUS_PATH "/Power"
-#define POWER_DBUS_INTERFACE        "org.gnome.SettingsDaemon.Power"
-
 enum {
   POWER_INDICATOR_ICON_POLICY_PRESENT,
   POWER_INDICATOR_ICON_POLICY_CHARGE,
   POWER_INDICATOR_ICON_POLICY_NEVER
 };
 
-#define INDICATOR_POWER_TYPE            (indicator_power_get_type ())
-#define INDICATOR_POWER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_POWER_TYPE, IndicatorPower))
-#define INDICATOR_POWER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_POWER_TYPE, IndicatorPowerClass))
-#define IS_INDICATOR_POWER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_POWER_TYPE))
-#define IS_INDICATOR_POWER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_POWER_TYPE))
-#define INDICATOR_POWER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_POWER_TYPE, IndicatorPowerClass))
-
-typedef struct _IndicatorPowerClass    IndicatorPowerClass;
-typedef struct _IndicatorPower         IndicatorPower;
-
-struct _IndicatorPowerClass
-{
-  IndicatorObjectClass parent_class;
-};
-
-struct _IndicatorPower
+struct _IndicatorPowerPrivate
 {
-  IndicatorObject parent_instance;
-
   GtkMenu   *menu;
 
   GtkLabel *label;
   GtkImage *status_image;
   gchar    *accessible_desc;
 
-  GCancellable *proxy_cancel;
-  GDBusProxy   *proxy;
-  guint         watcher_id;
+  IndicatorPowerDbusListener * dbus_listener;
 
-  GVariant *devices;
-  GVariant *device;
+  GSList * devices;
+  IndicatorPowerDevice * device;
 
   GSettings *settings;
 };
 
-GType indicator_power_get_type (void) G_GNUC_CONST;
 
+/* LCOV_EXCL_START */
 INDICATOR_SET_VERSION
 INDICATOR_SET_TYPE (INDICATOR_POWER_TYPE)
+/* LCOV_EXCL_STOP */
 
 /* Prototypes */
 static void             indicator_power_dispose         (GObject *object);
@@ -105,9 +79,13 @@ static gboolean         should_be_visible               (IndicatorPower * self);
 
 static void             on_entry_added                  (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data);
 
+/*
 static void gsd_appeared_callback (GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data);
+*/
 
+/* LCOV_EXCL_START */
 G_DEFINE_TYPE (IndicatorPower, indicator_power, INDICATOR_OBJECT_TYPE);
+/* LCOV_EXCL_STOP */
 
 static void
 indicator_power_class_init (IndicatorPowerClass *klass)
@@ -115,6 +93,8 @@ indicator_power_class_init (IndicatorPowerClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   IndicatorObjectClass *io_class = INDICATOR_OBJECT_CLASS (klass);
 
+  g_type_class_add_private (klass, sizeof (IndicatorPowerPrivate));
+
   object_class->dispose = indicator_power_dispose;
   object_class->finalize = indicator_power_finalize;
 
@@ -128,20 +108,20 @@ indicator_power_class_init (IndicatorPowerClass *klass)
 static void
 indicator_power_init (IndicatorPower *self)
 {
-  self->menu = GTK_MENU(gtk_menu_new());
+  IndicatorPowerPrivate * priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_POWER_TYPE, IndicatorPowerPrivate);
 
-  self->accessible_desc = NULL;
+  priv->menu = GTK_MENU(gtk_menu_new());
 
-  self->watcher_id = g_bus_watch_name (G_BUS_TYPE_SESSION,
-                                       DBUS_SERVICE,
-                                       G_BUS_NAME_WATCHER_FLAGS_NONE,
-                                       gsd_appeared_callback,
-                                       NULL,
-                                       self,
-                                       NULL);
+  priv->accessible_desc = NULL;
 
-  self->settings = g_settings_new ("com.canonical.indicator.power");
-  g_signal_connect_swapped (self->settings, "changed::" ICON_POLICY_KEY,
+  priv->dbus_listener = g_object_new (INDICATOR_POWER_DBUS_LISTENER_TYPE, NULL);
+  g_signal_connect_swapped (priv->dbus_listener, INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                            G_CALLBACK(indicator_power_set_devices), self);
+
+  priv->settings = g_settings_new ("com.canonical.indicator.power");
+  g_signal_connect_swapped (priv->settings, "changed::" ICON_POLICY_KEY,
                             G_CALLBACK(update_visibility), self);
   g_object_set (G_OBJECT(self),
                 INDICATOR_OBJECT_DEFAULT_VISIBILITY, FALSE,
@@ -149,27 +129,29 @@ indicator_power_init (IndicatorPower *self)
 
   g_signal_connect (INDICATOR_OBJECT(self), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
                     G_CALLBACK(on_entry_added), NULL);
+
+  self->priv = priv;
 }
 
 static void
+dispose_devices (IndicatorPower * self)
+{
+  IndicatorPowerPrivate * priv = self->priv;
+
+  g_clear_object (&priv->device);
+  g_slist_free_full (priv->devices, g_object_unref);
+  priv->devices = NULL;
+}
+static void
 indicator_power_dispose (GObject *object)
 {
   IndicatorPower *self = INDICATOR_POWER(object);
+  IndicatorPowerPrivate * priv = self->priv;
 
-  if (self->devices != NULL) {
-    g_variant_unref (self->devices);
-    self->devices = NULL;
-  }
-
-  if (self->device != NULL) {
-    g_variant_unref (self->device);
-    self->device = NULL;
-  }
+  dispose_devices (self);
 
-  g_clear_object (&self->proxy);
-  g_clear_object (&self->proxy_cancel);
-
-  g_clear_object (&self->settings);
+  g_clear_object (&priv->dbus_listener);
+  g_clear_object (&priv->settings);
 
   G_OBJECT_CLASS (indicator_power_parent_class)->dispose (object);
 }
@@ -178,8 +160,9 @@ static void
 indicator_power_finalize (GObject *object)
 {
   IndicatorPower *self = INDICATOR_POWER(object);
+  IndicatorPowerPrivate * priv = self->priv;
 
-  g_free (self->accessible_desc);
+  g_free (priv->accessible_desc);
 
   G_OBJECT_CLASS (indicator_power_parent_class)->finalize (object);
 }
@@ -198,216 +181,17 @@ spawn_command_line_async (const char * command)
 }
 
 static void
-show_info_cb (GtkMenuItem *item,
-              gpointer     data)
-{
-  /*TODO: show the statistics of the specific device*/
-  spawn_command_line_async ("gnome-power-statistics");
-}
-
-static void
 option_toggled_cb (GtkCheckMenuItem *item, IndicatorPower * self)
 {
-  gtk_widget_set_visible (GTK_WIDGET (self->label),
+  gtk_widget_set_visible (GTK_WIDGET (self->priv->label),
                           gtk_check_menu_item_get_active(item));
 }
 
-static void
-show_preferences_cb (GtkMenuItem *item,
-                     gpointer     data)
-{
-  spawn_command_line_async ("gnome-control-center power");
-}
-
-static void
-get_timestring (guint64   time_secs,
-                gchar   **short_timestring,
-                gchar   **detailed_timestring)
-{
-  gint  hours;
-  gint  minutes;
-
-  /* Add 0.5 to do rounding */
-  minutes = (int) ( ( time_secs / 60.0 ) + 0.5 );
-
-  if (minutes == 0)
-    {
-      *short_timestring = g_strdup (_("Unknown time"));
-      *detailed_timestring = g_strdup (_("Unknown time"));
-
-      return;
-    }
-
-  if (minutes < 60)
-    {
-      *short_timestring = g_strdup_printf ("0:%.2i", minutes);
-      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%i minute",
-                                              "%i minutes",
-                                              minutes), minutes);
-      return;
-    }
-
-  hours = minutes / 60;
-  minutes = minutes % 60;
-
-  *short_timestring = g_strdup_printf ("%i:%.2i", hours, minutes);
-
-  if (minutes == 0)
-    {
-      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, 
-                                              "%i hour",
-                                              "%i hours",
-                                              hours), hours);
-    }
-  else
-    {
-      /* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
-       * Swap order with "%2$s %2$i %1$s %1$i if needed */
-      *detailed_timestring = g_strdup_printf (_("%i %s %i %s"),
-                                              hours, g_dngettext (GETTEXT_PACKAGE, "hour", "hours", hours),
-                                              minutes, g_dngettext (GETTEXT_PACKAGE, "minute", "minutes", minutes));
-    }
-}
-
-static const gchar *
-device_kind_to_localised_string (UpDeviceKind kind)
-{
-  const gchar *text = NULL;
-
-  switch (kind) {
-    case UP_DEVICE_KIND_LINE_POWER:
-      /* TRANSLATORS: system power cord */
-      text = _("AC adapter");
-      break;
-    case UP_DEVICE_KIND_BATTERY:
-      /* TRANSLATORS: laptop primary battery */
-      text = _("Battery");
-      break;
-    case UP_DEVICE_KIND_UPS:
-      /* TRANSLATORS: battery-backed AC power source */
-      text = _("UPS");
-      break;
-    case UP_DEVICE_KIND_MONITOR:
-      /* TRANSLATORS: a monitor is a device to measure voltage and current */
-      text = _("Monitor");
-      break;
-    case UP_DEVICE_KIND_MOUSE:
-      /* TRANSLATORS: wireless mice with internal batteries */
-      text = _("Mouse");
-      break;
-    case UP_DEVICE_KIND_KEYBOARD:
-      /* TRANSLATORS: wireless keyboard with internal battery */
-      text = _("Keyboard");
-      break;
-    case UP_DEVICE_KIND_PDA:
-      /* TRANSLATORS: portable device */
-      text = _("PDA");
-      break;
-    case UP_DEVICE_KIND_PHONE:
-      /* TRANSLATORS: cell phone (mobile...) */
-      text = _("Cell phone");
-      break;
-    case UP_DEVICE_KIND_MEDIA_PLAYER:
-      /* TRANSLATORS: media player, mp3 etc */
-      text = _("Media player");
-      break;
-    case UP_DEVICE_KIND_TABLET:
-      /* TRANSLATORS: tablet device */
-      text = _("Tablet");
-      break;
-    case UP_DEVICE_KIND_COMPUTER:
-      /* TRANSLATORS: tablet device */
-      text = _("Computer");
-      break;
-    default:
-      g_warning ("enum unrecognised: %i", kind);
-      text = up_device_kind_to_string (kind);
-    }
-
-  return text;
-}
-
-static void
-build_device_time_details (const gchar    *device_name,
-                           guint64         time,
-                           UpDeviceState   state,
-                           gdouble         percentage,
-                           gchar         **short_details,
-                           gchar         **details,
-                           gchar         **accessible_name)
-{
-  gchar *short_timestring = NULL;
-  gchar *detailed_timestring = NULL;
-
-  if (time > 0)
-    {
-      get_timestring (time,
-                      &short_timestring,
-                      &detailed_timestring);
-
-      if (state == UP_DEVICE_STATE_CHARGING)
-        {
-          /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
-          *accessible_name = g_strdup_printf (_("%s (%s to charge (%.0lf%%))"),
-                                              device_name, detailed_timestring, percentage);
-          *details = g_strdup_printf (_("%s (%s to charge)"),
-                                      device_name, short_timestring);
-          *short_details = g_strdup_printf ("(%s)", short_timestring);
-        }
-      else if (state == UP_DEVICE_STATE_DISCHARGING)
-        {
-          *short_details = g_strdup_printf ("%s", short_timestring);
-
-          if (time > 43200) /* 12 hours */
-            {
-              *accessible_name = g_strdup_printf (_("%s"), device_name);
-              *details = g_strdup_printf (_("%s"), device_name);
-            }
-          else
-            {
-              /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
-              *accessible_name = g_strdup_printf (_("%s (%s left (%.0lf%%))"),
-                                                  device_name, detailed_timestring, percentage);
-              *details = g_strdup_printf (_("%s (%s left)"),
-                                          device_name, short_timestring);
-            }
-        }
-
-      g_free (short_timestring);
-      g_free (detailed_timestring);
-    }
-  else
-    {
-      if (state == UP_DEVICE_STATE_FULLY_CHARGED)
-        {
-          *details = g_strdup_printf (_("%s (charged)"), device_name);
-          *accessible_name = g_strdup (*details);
-          *short_details = g_strdup ("");
-        }
-      else if (percentage > 0)
-        {
-          /* TRANSLATORS: %2 is a percentage value. Note: this string is only
-           * used when we don't have a time value */
-          *details = g_strdup_printf (_("%s (%.0lf%%)"),
-                                      device_name, percentage);
-          *accessible_name = g_strdup (*details);
-          *short_details = g_strdup_printf (_("(%.0lf%%)"),
-                                            percentage);
-        }
-      else
-        {
-          *details = g_strdup_printf (_("%s (not present)"), device_name);
-          *accessible_name = g_strdup (*details);
-          *short_details = g_strdup (_("(not present)"));
-        }
-    }
-}
-
 /* ensure that the entry is using self's accessible description */
 static void
 refresh_entry_accessible_desc (IndicatorPower * self, IndicatorObjectEntry * entry)
 {
-  const char * newval = self->accessible_desc;
+  const char * newval = self->priv->accessible_desc;
 
   if (entry->accessible_desc != newval)
   {
@@ -433,8 +217,8 @@ set_accessible_desc (IndicatorPower *self, const gchar *desc)
   if (desc && *desc)
   {
     /* update our copy of the string */
-    char * oldval = self->accessible_desc;
-    self->accessible_desc = g_strdup (desc);
+    char * oldval = self->priv->accessible_desc;
+    self->priv->accessible_desc = g_strdup (desc);
 
     /* ensure that the entries are using self's accessible description */
     GList * l;
@@ -448,194 +232,70 @@ set_accessible_desc (IndicatorPower *self, const gchar *desc)
   }
 }
 
-static const gchar *
-get_icon_percentage_for_status (const gchar *status)
-{
-
-  if (g_strcmp0 (status, "caution") == 0)
-    return "000";
-  else if (g_strcmp0 (status, "low") == 0)
-    return "040";
-  else if (g_strcmp0 (status, "good") == 0)
-    return "080";
-  else
-    return "100";
-}
-
-static GIcon*
-build_battery_icon (UpDeviceState  state,
-                    gchar         *suffix_str)
-{
-  GIcon *gicon;
-
-  GString *filename;
-  gchar **iconnames;
-
-  filename = g_string_new (NULL);
-
-  if (state == UP_DEVICE_STATE_FULLY_CHARGED)
-    {
-      g_string_append (filename, "battery-charged;");
-      g_string_append (filename, "battery-full-charged-symbolic;");
-      g_string_append (filename, "battery-full-charged;");
-      g_string_append (filename, "gpm-battery-charged;");
-      g_string_append (filename, "gpm-battery-100-charging;");
-    }
-  else if (state == UP_DEVICE_STATE_CHARGING)
-    {
-      g_string_append (filename, "battery-000-charging;");
-      g_string_append (filename, "battery-caution-charging-symbolic;");
-      g_string_append (filename, "battery-caution-charging;");
-      g_string_append (filename, "gpm-battery-000-charging;");
-    }
-  else if (state == UP_DEVICE_STATE_DISCHARGING)
-    {
-      const gchar *percentage = get_icon_percentage_for_status (suffix_str);
-      g_string_append_printf (filename, "battery-%s;", suffix_str);
-      g_string_append_printf (filename, "battery-%s-symbolic;", suffix_str);
-      g_string_append_printf (filename, "battery-%s;", percentage);
-      g_string_append_printf (filename, "gpm-battery-%s;", percentage);
-    }
-
-  iconnames = g_strsplit (filename->str, ";", -1);
-  gicon = g_themed_icon_new_from_names (iconnames, -1);
-
-  g_strfreev (iconnames);
-  g_string_free (filename, TRUE);
-
-  return gicon;
-}
-
-static GIcon*
-get_device_icon (UpDeviceKind   kind,
-                 UpDeviceState  state,
-                 guint64        time_sec,
-                 const gchar   *device_icon)
+static gboolean
+menu_add_device (GtkMenu * menu, const IndicatorPowerDevice * device)
 {
-  GIcon *gicon = NULL;
+  gboolean added = FALSE;
+  const UpDeviceKind kind = indicator_power_device_get_kind (device);
 
-  if (kind == UP_DEVICE_KIND_BATTERY &&
-      (state == UP_DEVICE_STATE_FULLY_CHARGED ||
-       state == UP_DEVICE_STATE_CHARGING ||
-       state == UP_DEVICE_STATE_DISCHARGING))
-    {
-      if (state == UP_DEVICE_STATE_FULLY_CHARGED ||
-          state == UP_DEVICE_STATE_CHARGING)
-        {
-          gicon = build_battery_icon (state, NULL);
-        }
-      else if (state == UP_DEVICE_STATE_DISCHARGING)
-        {
-          if ((time_sec > 60 * 30) && /* more than 30 minutes left */
-              (g_strrstr (device_icon, "000") ||
-               g_strrstr (device_icon, "020") ||
-               g_strrstr (device_icon, "caution"))) /* the icon is red */
-            {
-              gicon = build_battery_icon (state, "low");
-            }
-        }
-    }
-
-  if (gicon == NULL)
-    gicon = g_icon_new_for_string (device_icon, NULL);
-
-  return gicon;
-}
-
-
-static void
-menu_add_device (GtkMenu  *menu,
-                 GVariant *device)
-{
-  UpDeviceKind kind;
-  UpDeviceState state;
-  GtkWidget *icon;
-  GtkWidget *item;
-  GtkWidget *details_label;
-  GtkWidget *grid;
-  GIcon *device_gicons;
-  const gchar *device_icon = NULL;
-  const gchar *object_path = NULL;
-  gdouble percentage;
-  guint64 time;
-  const gchar *device_name;
-  gchar *short_details = NULL;
-  gchar *details = NULL;
-  gchar *accessible_name = NULL;
-  AtkObject *atk_object;
-
-  if (device == NULL)
-    return;
-
-  g_variant_get (device,
-                 "(&su&sdut)",
-                 &object_path,
-                 &kind,
-                 &device_icon,
-                 &percentage,
-                 &state,
-                 &time);
-
-  g_debug ("%s: got data from object %s", G_STRFUNC, object_path);
-
-  if (kind == UP_DEVICE_KIND_LINE_POWER)
-    return;
-
-  /* Process the data */
-  device_gicons = get_device_icon (kind, state, time, device_icon);
-  icon = gtk_image_new_from_gicon (device_gicons,
-                                   GTK_ICON_SIZE_SMALL_TOOLBAR);
-  g_clear_object (&device_gicons);
-
-  device_name = device_kind_to_localised_string (kind);
-
-  build_device_time_details (device_name, time, state, percentage, &short_details, &details, &accessible_name);
-
-  /* Create menu item */
-  item = gtk_image_menu_item_new ();
-  atk_object = gtk_widget_get_accessible(item);
-  if (atk_object != NULL)
-    atk_object_set_name (atk_object, accessible_name);
-
-  grid = gtk_grid_new ();
-  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
-  gtk_grid_attach (GTK_GRID (grid), icon, 0, 0, 1, 1);
-  details_label = gtk_label_new (details);
-  gtk_grid_attach_next_to (GTK_GRID (grid), details_label, icon, GTK_POS_RIGHT, 1, 1);
-  gtk_container_add (GTK_CONTAINER (item), grid);
-  gtk_widget_show (grid);
-
-  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
-
-  g_signal_connect (G_OBJECT (item), "activate",
-                    G_CALLBACK (show_info_cb), NULL);
+  if (kind != UP_DEVICE_KIND_LINE_POWER)
+  {
+    GtkWidget *icon;
+    GtkWidget *item;
+    GtkWidget *details_label;
+    GtkWidget *grid;
+    GIcon *device_gicon;
+    gchar *short_details = NULL;
+    gchar *details = NULL;
+    gchar *accessible_name = NULL;
+    AtkObject *atk_object;
+
+    /* Process the data */
+    device_gicon = indicator_power_device_get_gicon (device);
+    icon = gtk_image_new_from_gicon (device_gicon, GTK_ICON_SIZE_SMALL_TOOLBAR);
+    g_clear_object (&device_gicon);
+
+    indicator_power_device_get_time_details (device, &short_details, &details, &accessible_name);
+
+    /* Create menu item */
+    item = gtk_image_menu_item_new ();
+    atk_object = gtk_widget_get_accessible(item);
+    if (atk_object != NULL)
+      atk_object_set_name (atk_object, accessible_name);
+
+    grid = gtk_grid_new ();
+    gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
+    gtk_grid_attach (GTK_GRID (grid), icon, 0, 0, 1, 1);
+    details_label = gtk_label_new (details);
+    gtk_grid_attach_next_to (GTK_GRID (grid), details_label, icon, GTK_POS_RIGHT, 1, 1);
+    gtk_container_add (GTK_CONTAINER (item), grid);
+    gtk_widget_show (grid);
+
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+    added = TRUE;
+
+    g_signal_connect_swapped (G_OBJECT (item), "activate",
+                              G_CALLBACK (spawn_command_line_async), "gnome-power-statistics");
+
+    g_free (short_details);
+    g_free (details);
+    g_free (accessible_name);
+  }
 
-  g_free (short_details);
-  g_free (details);
-  g_free (accessible_name);
+  return added;
 }
 
 static gsize
-menu_add_devices (GtkMenu  *menu,
-                  GVariant *devices)
+menu_add_devices (GtkMenu * menu, GSList * devices)
 {
-  gsize n_devices;
-  guint i;
-
-  if (devices == NULL)
-    return 0;
+  GSList * l;
+  gsize n_added = 0;
 
-  n_devices = g_variant_n_children (devices);
-  g_debug ("Num devices: '%" G_GSIZE_FORMAT "'\n", n_devices);
+  for (l=devices; l!=NULL; l=l->next)
+    if (menu_add_device (menu, l->data))
+      ++n_added;
 
-  for (i = 0; i < n_devices; i++)
-    {
-      GVariant * device = g_variant_get_child_value (devices, i);
-      menu_add_device (menu, device);
-      g_variant_unref (device);
-    }
-
-  return n_devices;
+  return n_added;
 }
 
 static gboolean
@@ -653,75 +313,62 @@ build_menu (IndicatorPower *self)
   GtkWidget *image;
   GList *children;
   gsize n_devices = 0;
+  IndicatorPowerPrivate * priv = self->priv;
 
   /* remove the existing menuitems */
-  children = gtk_container_get_children (GTK_CONTAINER (self->menu));
+  children = gtk_container_get_children (GTK_CONTAINER (priv->menu));
   g_list_foreach (children, (GFunc) gtk_widget_destroy, NULL);
   g_list_free (children);
 
   /* devices */
-  n_devices = menu_add_devices (self->menu, self->devices);
+  n_devices = menu_add_devices (priv->menu, priv->devices);
 
   if (!get_greeter_mode ()) {
     /* only do the separator if we have at least one device */
     if (n_devices != 0)
       {
         item = gtk_separator_menu_item_new ();
-        gtk_menu_shell_append (GTK_MENU_SHELL (self->menu), item);
+        gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
       }
 
     /* options */
     item = gtk_check_menu_item_new_with_label (_("Show Time in Menu Bar"));
     g_signal_connect (item, "toggled", G_CALLBACK(option_toggled_cb), self);
-    g_settings_bind (self->settings, "show-time", item, "active", G_SETTINGS_BIND_DEFAULT);
-    gtk_menu_shell_append (GTK_MENU_SHELL (self->menu), item);
+    g_settings_bind (priv->settings, "show-time", item, "active", G_SETTINGS_BIND_DEFAULT);
+    gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
 
     /* preferences */
-    item = gtk_image_menu_item_new_with_label (_("Power Settings..."));
+    item = gtk_image_menu_item_new_with_label (_("Power Settings…"));
     image = gtk_image_new_from_icon_name (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
     gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
-    g_signal_connect (G_OBJECT (item), "activate",
-                      G_CALLBACK (show_preferences_cb), NULL);
-    gtk_menu_shell_append (GTK_MENU_SHELL (self->menu), item);
+    g_signal_connect_swapped (G_OBJECT (item), "activate",
+                              G_CALLBACK (spawn_command_line_async), "gnome-control-center power");
+    gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
   }
 
   /* show the menu */
-  gtk_widget_show_all (GTK_WIDGET (self->menu));
+  gtk_widget_show_all (GTK_WIDGET (priv->menu));
 }
 
-static GVariant *
-get_primary_device (GVariant *devices)
+static IndicatorPowerDevice*
+get_primary_device (GSList * devices)
 {
-  gint primary_device_charging_index = -1;
-  gint primary_device_discharging_index = -1;
-  gint primary_device_index = -1;
+  IndicatorPowerDevice * primary_device = NULL;
+  IndicatorPowerDevice * primary_device_charging = NULL;
+  IndicatorPowerDevice * primary_device_discharging = NULL;
   gboolean charging = FALSE;
   gboolean discharging = FALSE;
   guint64 min_discharging_time = G_MAXUINT64;
   guint64 max_charging_time = 0;
-  guint i;
-
-  const gsize n_devices = devices ? g_variant_n_children (devices) : 0;
-  g_debug ("Num devices: '%" G_GSIZE_FORMAT "'\n", n_devices);
+  GSList * l;
 
-  for (i = 0; i < n_devices; i++)
+  for (l=devices; l!=NULL; l=l->next)
     {
-      const gchar *object_path;
-      UpDeviceKind kind;
-      const gchar *device_icon;
-      gdouble percentage;
-      UpDeviceState state;
-      guint64 time = 0;
-
-      g_variant_get_child (devices, i, "(&su&sdut)",
-                           &object_path,
-                           &kind,
-                           &device_icon,
-                           &percentage,
-                           &state,
-                           &time);
-
-      g_debug ("%s: got data from object %s", G_STRFUNC, object_path);
+      IndicatorPowerDevice * device = INDICATOR_POWER_DEVICE(l->data);
+      const UpDeviceKind kind = indicator_power_device_get_kind (device);
+      const UpDeviceState state = indicator_power_device_get_state (device);
+      const gdouble percentage  = indicator_power_device_get_percentage (device);
+      const time_t time = indicator_power_device_get_time (device);
 
       /* Try to fix the case when we get a empty battery bay as a real battery */
       if (state == UP_DEVICE_STATE_UNKNOWN &&
@@ -738,7 +385,7 @@ get_primary_device (GVariant *devices)
           if (time < min_discharging_time)
             {
               min_discharging_time = time;
-              primary_device_discharging_index = i;
+              primary_device_discharging = device;
             }
         }
       else if (state == UP_DEVICE_STATE_CHARGING)
@@ -746,126 +393,79 @@ get_primary_device (GVariant *devices)
           charging = TRUE;
           if (time == 0) /* Battery broken */
             {
-              primary_device_charging_index = i;
+              primary_device_charging = device;
             }
           if (time > max_charging_time)
             {
               max_charging_time = time;
-              primary_device_charging_index = i;
+              primary_device_charging = device;
             }
         }
       else
         {
-          primary_device_index = i;
+          primary_device = device;
         }
     }
 
   if (discharging)
     {
-      primary_device_index = primary_device_discharging_index;
+      primary_device = primary_device_discharging;
     }
   else if (charging)
     {
-      primary_device_index = primary_device_charging_index;
+      primary_device = primary_device_charging;
     }
 
-  if (primary_device_index >= 0)
-    return g_variant_get_child_value (devices, primary_device_index);
+  if (primary_device != NULL)
+    g_object_ref (primary_device);
 
-  return NULL;
+  return primary_device;
 }
 
 static void
-put_primary_device (IndicatorPower *self,
-                    GVariant *device)
+put_primary_device (IndicatorPower *self, IndicatorPowerDevice *device)
 {
-  UpDeviceKind kind;
-  UpDeviceState state;
-  GIcon *device_gicons;
-  gchar *short_details = NULL;
-  gchar *details = NULL;
-  gchar *accessible_name = NULL;
-  const gchar *device_icon = NULL;
-  const gchar *object_path = NULL;
-  gdouble percentage;
-  guint64 time;
-  const gchar *device_name;
-
-  /* set the icon and text */
-  g_variant_get (device,
-                 "(&su&sdut)",
-                 &object_path,
-                 &kind,
-                 &device_icon,
-                 &percentage,
-                 &state,
-                 &time);
-
-  g_debug ("%s: got data from object %s", G_STRFUNC, object_path);
+  IndicatorPowerPrivate * priv = self->priv;
 
   /* set icon */
-  device_gicons = get_device_icon (kind, state, time, device_icon);
-  gtk_image_set_from_gicon (self->status_image,
-                            device_gicons,
-                            GTK_ICON_SIZE_LARGE_TOOLBAR);
-  g_clear_object (&device_gicons);
-  gtk_widget_show (GTK_WIDGET (self->status_image));
-
-
-  /* get the device name */
-  device_name = device_kind_to_localised_string (kind);
+  GIcon * device_gicon = indicator_power_device_get_gicon (device);
+  gtk_image_set_from_gicon (priv->status_image, device_gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
+  g_clear_object (&device_gicon);
+  gtk_widget_show (GTK_WIDGET (priv->status_image));
 
   /* get the description */
-  build_device_time_details (device_name, time, state, percentage, &short_details, &details, &accessible_name);
-
-  gtk_label_set_label (GTK_LABEL (self->label),
-                       short_details);
+  gchar * short_details;
+  gchar * details;
+  gchar * accessible_name;
+  indicator_power_device_get_time_details (device, &short_details, &details, &accessible_name);
+  gtk_label_set_label (GTK_LABEL (priv->label), short_details);
   set_accessible_desc (self, accessible_name);
-
-  g_free (short_details);
-  g_free (details);
   g_free (accessible_name);
+  g_free (details);
+  g_free (short_details);
 }
 
-static void
-get_devices_cb (GObject      *source_object,
-                GAsyncResult *res,
-                gpointer      user_data)
+void
+indicator_power_set_devices (IndicatorPower * self, GSList * devices)
 {
-  IndicatorPower *self = INDICATOR_POWER (user_data);
-  GVariant *devices_container;
-  GError *error = NULL;
-
-  devices_container = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
-  if (devices_container == NULL)
-    {
-      g_message ("Couldn't get devices: %s\n", error->message);
-      g_error_free (error);
-    }
-  else /* update 'devices' */
-    {
-      if (self->devices != NULL)
-        g_variant_unref (self->devices);
-      self->devices = g_variant_get_child_value (devices_container, 0);
+  /* LCOV_EXCL_START */
+  g_return_if_fail (IS_INDICATOR_POWER(self));
+  /* LCOV_EXCL_STOP */
 
-      g_variant_unref (devices_container);
+  IndicatorPowerPrivate * priv = self->priv;
 
-      if (self->device != NULL)
-        g_variant_unref (self->device);
-      self->device = get_primary_device (self->devices);
-
-      if (self->device == NULL)
-        {
-          g_message ("Couldn't find primary device");
-        }
-      else
-        {
-          put_primary_device (self, self->device);
-        }
-    }
+  /* update our devices & primary device */
+  g_slist_foreach (devices, (GFunc)g_object_ref, NULL);
+  dispose_devices (self);
+  priv->devices = g_slist_copy (devices);
+  priv->device = get_primary_device (priv->devices);
 
+  /* and our menus/visibility from the new device list */
+  if (priv->device != NULL)
+      put_primary_device (self, priv->device);
+  else
+      g_message ("Couldn't find primary device");
   build_menu (self);
-
   update_visibility (self);
 }
 
@@ -876,85 +476,6 @@ update_visibility (IndicatorPower * self)
                                 should_be_visible (self));
 }
 
-static void
-receive_properties_changed (GDBusProxy *proxy                  G_GNUC_UNUSED,
-                            GVariant   *changed_properties     G_GNUC_UNUSED,
-                            GStrv       invalidated_properties G_GNUC_UNUSED,
-                            gpointer    user_data)
-{
-  IndicatorPower *self = INDICATOR_POWER (user_data);
-
-  /* it's time to refresh our device list */
-  g_dbus_proxy_call (self->proxy,
-                     "GetDevices",
-                     NULL,
-                     G_DBUS_CALL_FLAGS_NONE,
-                     -1,
-                     self->proxy_cancel,
-                     get_devices_cb,
-                     user_data);
-}
-
-static void
-service_proxy_cb (GObject      *object,
-                  GAsyncResult *res,
-                  gpointer      user_data)
-{
-  IndicatorPower *self = INDICATOR_POWER (user_data);
-  GError *error = NULL;
-
-  self->proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
-
-  g_clear_object (&self->proxy_cancel);
-
-  if (error != NULL)
-    {
-      g_error ("Error creating proxy: %s", error->message);
-      g_error_free (error);
-
-      return;
-    }
-
-  /* we want to change the primary device changes */
-  g_signal_connect (self->proxy,
-                    "g-properties-changed",
-                    G_CALLBACK (receive_properties_changed),
-                    user_data);
-
-  /* get the initial state */
-  g_dbus_proxy_call (self->proxy,
-                     "GetDevices",
-                     NULL,
-                     G_DBUS_CALL_FLAGS_NONE,
-                     -1,
-                     self->proxy_cancel,
-                     get_devices_cb,
-                     user_data);
-}
-
-static void
-gsd_appeared_callback (GDBusConnection *connection,
-                       const gchar     *name,
-                       const gchar     *name_owner,
-                       gpointer         user_data)
-{
-  IndicatorPower *self = INDICATOR_POWER (user_data);
-
-  self->proxy_cancel = g_cancellable_new ();
-
-  g_dbus_proxy_new (connection,
-                    G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
-                    NULL,
-                    name,
-                    POWER_DBUS_PATH,
-                    POWER_DBUS_INTERFACE,
-                    self->proxy_cancel,
-                    service_proxy_cb,
-                    self);
-}
-
-
-
 
 /* Grabs the label. Creates it if it doesn't
    exist already */
@@ -962,32 +483,34 @@ static GtkLabel *
 get_label (IndicatorObject *io)
 {
   IndicatorPower *self = INDICATOR_POWER (io);
+  IndicatorPowerPrivate * priv = self->priv;
 
-  if (self->label == NULL)
+  if (priv->label == NULL)
     {
       /* Create the label if it doesn't exist already */
-      self->label = GTK_LABEL (gtk_label_new (""));
-      gtk_widget_set_visible (GTK_WIDGET (self->label), FALSE);
+      priv->label = GTK_LABEL (gtk_label_new (""));
+      gtk_widget_set_visible (GTK_WIDGET (priv->label), FALSE);
     }
 
-  return self->label;
+  return priv->label;
 }
 
 static GtkImage *
 get_image (IndicatorObject *io)
 {
-  IndicatorPower *self = INDICATOR_POWER (io);
   GIcon *gicon;
+  IndicatorPower *self = INDICATOR_POWER (io);
+  IndicatorPowerPrivate * priv = self->priv;
 
-  if (self->status_image == NULL)
+  if (priv->status_image == NULL)
   {
     /* Will create the status icon if it doesn't exist already */
     gicon = g_themed_icon_new (DEFAULT_ICON);
-    self->status_image = GTK_IMAGE (gtk_image_new_from_gicon (gicon,
+    priv->status_image = GTK_IMAGE (gtk_image_new_from_gicon (gicon,
                                                               GTK_ICON_SIZE_LARGE_TOOLBAR));
   }
 
-  return self->status_image;
+  return priv->status_image;
 }
 
 static GtkMenu *
@@ -997,7 +520,7 @@ get_menu (IndicatorObject *io)
 
   build_menu (self);
 
-  return GTK_MENU (self->menu);
+  return GTK_MENU (self->priv->menu);
 }
 
 static const gchar *
@@ -1005,7 +528,7 @@ get_accessible_desc (IndicatorObject *io)
 {
   IndicatorPower *self = INDICATOR_POWER (io);
 
-  return self->accessible_desc;
+  return self->priv->accessible_desc;
 }
 
 static const gchar *
@@ -1019,28 +542,22 @@ get_name_hint (IndicatorObject *io)
 ***/
 
 static void
-count_batteries(GVariant *devices, int *total, int *inuse)
+count_batteries (GSList * devices, int *total, int *inuse)
 {
-  const int n_devices = devices ? g_variant_n_children (devices) : 0;
+  GSList * l;
 
-  int i;
-  for (i=0; i<n_devices; i++)
+  for (l=devices; l!=NULL; l=l->next)
     {
-      GVariant * device = g_variant_get_child_value (devices, i);
+      const IndicatorPowerDevice * device = INDICATOR_POWER_DEVICE(l->data);
 
-      UpDeviceKind kind;
-      g_variant_get_child (device, 1, "u", &kind);
-      if (kind == UP_DEVICE_KIND_BATTERY)
+      if (indicator_power_device_get_kind(device) == UP_DEVICE_KIND_BATTERY)
         {
           ++*total;
 
-          UpDeviceState state;
-          g_variant_get_child (device, 4, "u", &state);
+          const UpDeviceState state = indicator_power_device_get_state (device);
           if ((state == UP_DEVICE_STATE_CHARGING) || (state == UP_DEVICE_STATE_DISCHARGING))
             ++*inuse;
         }
-
-      g_variant_unref (device);
     }
 
     g_debug("count_batteries found %d batteries (%d are charging/discharging)", *total, *inuse);
@@ -1050,8 +567,9 @@ static gboolean
 should_be_visible (IndicatorPower * self)
 {
   gboolean visible = TRUE;
+  IndicatorPowerPrivate * priv = self->priv;
 
-  const int icon_policy = g_settings_get_enum (self->settings, ICON_POLICY_KEY);
+  const int icon_policy = g_settings_get_enum (priv->settings, ICON_POLICY_KEY);
 
   g_debug ("icon_policy is: %d (present==0, charge==1, never==2)", icon_policy);
 
@@ -1062,7 +580,7 @@ should_be_visible (IndicatorPower * self)
     else
     {
       int batteries=0, inuse=0;
-      count_batteries (self->devices, &batteries, &inuse);
+      count_batteries (priv->devices, &batteries, &inuse);
 
       if (icon_policy == POWER_INDICATOR_ICON_POLICY_PRESENT)
         {
diff --git a/src/indicator-power.h b/src/indicator-power.h
new file mode 100644
index 0000000..a696b40
--- /dev/null
+++ b/src/indicator-power.h
@@ -0,0 +1,58 @@
+/*
+An indicator to power related information in the menubar.
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Javier Jardon <javier.jardon@codethink.co.uk>
+
+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/>.
+*/
+
+/* Gtk required */
+#include <gtk/gtk.h>
+
+/* parent class */
+#include <libindicator/indicator.h>
+#include <libindicator/indicator-object.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_POWER_TYPE            (indicator_power_get_type ())
+#define INDICATOR_POWER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_POWER_TYPE, IndicatorPower))
+#define INDICATOR_POWER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_POWER_TYPE, IndicatorPowerClass))
+#define IS_INDICATOR_POWER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_POWER_TYPE))
+#define IS_INDICATOR_POWER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_POWER_TYPE))
+#define INDICATOR_POWER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_POWER_TYPE, IndicatorPowerClass))
+
+typedef struct _IndicatorPower         IndicatorPower;
+typedef struct _IndicatorPowerClass    IndicatorPowerClass;
+typedef struct _IndicatorPowerPrivate  IndicatorPowerPrivate;
+
+struct _IndicatorPowerClass
+{
+  IndicatorObjectClass parent_class;
+};
+
+struct _IndicatorPower
+{
+  IndicatorObject parent_instance;
+  IndicatorPowerPrivate * priv;
+};
+
+GType indicator_power_get_type (void) G_GNUC_CONST;
+
+void indicator_power_set_devices (IndicatorPower         * power,
+                                  GSList                 * devices);
+
+G_END_DECLS
diff --git a/tests/Makefile.am b/tests/Makefile.am
new file mode 100644
index 0000000..0c60247
--- /dev/null
+++ b/tests/Makefile.am
@@ -0,0 +1,62 @@
+TESTS =
+CLEANFILES = 
+BUILT_SOURCES =
+check_PROGRAMS =
+
+###
+###
+###
+
+# stock UMB tests on user-visible strings
+include $(srcdir)/Makefile.am.strings
+
+check_LIBRARIES = libgtest.a
+nodist_libgtest_a_SOURCES = \
+  $(GTEST_SOURCE)/src/gtest-all.cc \
+  $(GTEST_SOURCE)/src/gtest_main.cc
+
+AM_CPPFLAGS = $(GTEST_CPPFLAGS) -I${top_srcdir}/src -Wall -Werror
+AM_CXXFLAGS = $(GTEST_CXXFLAGS)
+
+###
+###
+###
+
+TEST_LIBS = \
+	$(top_builddir)/src/.libs/libpower.a \
+	$(INDICATOR_LIBS) \
+	$(UPOWER_LIBS) \
+        $(COVERAGE_LDFLAGS) \
+	libgtest.a
+
+TEST_CPPFLAGS = \
+	$(AM_CPPFLAGS) \
+	$(UPOWER_CFLAGS) \
+        $(INDICATOR_CFLAGS)
+
+BUILT_SOURCES += gschemas.compiled
+CLEANFILES += gschemas.compiled
+gschemas.compiled: Makefile
+	@glib-compile-schemas --targetdir=$(abs_builddir) $(top_builddir)/data
+
+TESTS += test-device
+check_PROGRAMS += test-device
+test_device_SOURCES = test-device.cc
+test_device_LDADD = $(TEST_LIBS)
+test_device_CPPFLAGS = $(TEST_CPPFLAGS)
+
+#TESTS += test-dbus-listener
+#check_PROGRAMS += test-dbus-listener
+#test_dbus_listener_SOURCES = test-dbus-listener.cc
+#test_dbus_listener_LDADD = $(TEST_LIBS)
+#test_dbus_listener_CPPFLAGS = $(TEST_CPPFLAGS)
+
+TESTS += test-indicator
+check_PROGRAMS += test-indicator
+test_indicator_SOURCES = test-indicator.cc
+test_indicator_LDADD = $(TEST_LIBS)
+test_indicator_CPPFLAGS = $(TEST_CPPFLAGS) -DSCHEMA_DIR="\"$(top_builddir)/tests/\""
+
+###
+###
+###
diff --git a/tests/Makefile.am.strings b/tests/Makefile.am.strings
new file mode 100644
index 0000000..26a23a8
--- /dev/null
+++ b/tests/Makefile.am.strings
@@ -0,0 +1,38 @@
+TESTS += \
+	test-ellipsis \
+	test-space-ellipsis \
+	test-ascii-quotes
+
+#####
+# Tests for there being proper ellipsis instead of three periods in a row
+#####
+test-ellipsis: $(top_srcdir)/po
+	@echo "#!/bin/bash" > $@
+	@echo "(cd $(top_srcdir)/po && make $(GETTEXT_PACKAGE).pot)" >> $@
+	@echo "grep -c -e \"^msgid.*\.\.\.\\\"\" $(top_srcdir)/po/$(GETTEXT_PACKAGE).pot > /dev/null && echo \"Ellipsis found in user visible strings\" >&2 && exit 1" >> $@
+	@echo "exit 0" >> $@
+	@chmod +x $@
+
+#####
+# Tests for there being a space before an ellipsis
+#####
+test-space-ellipsis: $(top_srcdir)/po
+	@echo "#!/bin/bash" > $@
+	@echo "(cd $(top_srcdir)/po && make $(GETTEXT_PACKAGE).pot)" >> $@
+	@echo "grep -c -e \"^msgid.* …\\\"\" $(top_srcdir)/po/$(GETTEXT_PACKAGE).pot > /dev/null && echo \"Space before ellipsis found in user visible strings\" >&2 && exit 1" >> $@
+	@echo "exit 0" >> $@
+	@chmod +x $@
+
+#####
+# Tests for ASCII quote types
+#####
+test-ascii-quotes: $(top_srcdir)/po
+	@echo "#!/bin/bash" > $@
+	@echo "(cd $(top_srcdir)/po && make $(GETTEXT_PACKAGE).pot)" >> $@
+	@echo "grep -c -e \"^msgid \\\".*'.*\\\"\" $(top_srcdir)/po/$(GETTEXT_PACKAGE).pot > /dev/null && echo \"ASCII apostrophy found in user visible strings\" >&2 && exit 1" >> $@
+	@echo "grep -c -e \"^msgid \\\".*\\\".*\\\"\" $(top_srcdir)/po/$(GETTEXT_PACKAGE).pot > /dev/null && echo \"ASCII quote found in user visible strings\" >&2 && exit 1" >> $@
+	@echo "grep -c -e \"^msgid \\\".*\\\`.*\\\"\" $(top_srcdir)/po/$(GETTEXT_PACKAGE).pot > /dev/null && echo \"ASCII backtick found in user visible strings\" >&2 && exit 1" >> $@
+	@echo "exit 0" >> $@
+	@chmod +x $@
+
+CLEANFILES += $(TESTS)
diff --git a/tests/test-dbus-listener.cc b/tests/test-dbus-listener.cc
new file mode 100644
index 0000000..8bf74bf
--- /dev/null
+++ b/tests/test-dbus-listener.cc
@@ -0,0 +1,370 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+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 <gtest/gtest.h>
+
+#include "dbus-listener.h"
+#include "device.h"
+
+/***
+****
+***/
+
+namespace
+{
+  void ensure_glib_initialized ()
+  {
+    static bool initialized = false;
+
+    if (G_UNLIKELY(!initialized))
+    {
+      initialized = true;
+      g_type_init();
+    }
+  }
+}
+
+/***
+****
+***/
+
+class DbusListenerTest : public ::testing::Test
+{
+  protected:
+    GSList * devices;
+    GDBusConnection * connection;
+    GMainLoop * mainloop;
+    GTestDBus * bus;
+    GDBusNodeInfo * gsd_power_introspection_data;
+    GVariant * get_devices_retval;
+    bool bus_acquired;
+    bool name_acquired;
+    int gsd_name_ownership_id;
+    int gsd_power_registration_id;
+    char * gsd_power_error_string;
+  
+  protected:
+
+    static void
+    on_bus_acquired (GDBusConnection *conn, const gchar * name, gpointer gself)
+    {
+      g_debug ("bus acquired: %s, connection is %p", name, conn);
+
+      DbusListenerTest * test = static_cast<DbusListenerTest*> (gself);
+      test->connection = conn;
+      test->bus_acquired = true;
+    }
+
+    static void
+    on_name_acquired (GDBusConnection * conn, const gchar * name, gpointer gself)
+    {
+      g_debug ("name acquired: %s, connection is %p", name, conn);
+
+      DbusListenerTest * test = static_cast<DbusListenerTest*> (gself);
+      test->name_acquired = true;
+      g_main_loop_quit (test->mainloop);
+    }
+
+    static void
+    on_name_lost (GDBusConnection * conn, const gchar * name, gpointer gself)
+    {
+      g_debug ("name lost: %s, connection is %p", name, conn);
+
+      DbusListenerTest * test = static_cast<DbusListenerTest*> (gself);
+      test->name_acquired = false;
+      g_main_loop_quit (test->mainloop);
+    }
+
+  protected:
+
+    static void
+    on_devices_enumerated (IndicatorPowerDbusListener * l, GSList * devices, gpointer gself)
+    {
+      g_debug ("on_devices_enumerated");
+
+      DbusListenerTest * test = static_cast<DbusListenerTest*> (gself);
+      test->name_acquired = false;
+      g_slist_foreach (devices, (GFunc)g_object_ref, NULL);
+      test->devices = g_slist_copy (devices);
+      g_main_loop_quit (test->mainloop);
+    }
+
+    static void
+    gsd_power_handle_method_call (GDBusConnection       * connection,
+                                  const gchar           * sender,
+                                  const gchar           * object_path,
+                                  const gchar           * interface_name,
+                                  const gchar           * method_name,
+                                  GVariant              * parameters,
+                                  GDBusMethodInvocation * invocation,
+                                  gpointer                gself)
+    {
+      DbusListenerTest * test = static_cast<DbusListenerTest*> (gself);
+      g_assert (!g_strcmp0 (method_name, "GetDevices"));
+      if (test->gsd_power_error_string != NULL) {
+        const GQuark domain = g_quark_from_static_string ("mock-gsd-power");
+        g_message ("returning an error");
+        g_dbus_method_invocation_return_error_literal (invocation, domain, 0, test->gsd_power_error_string);
+      } else {
+        g_dbus_method_invocation_return_value (invocation, test->get_devices_retval);
+      }
+    }
+
+  protected:
+
+    virtual void SetUp()
+    {
+      bus_acquired = false;
+      name_acquired = false;
+      connection = NULL;
+      devices = NULL;
+      get_devices_retval = NULL;
+      gsd_power_error_string = NULL;
+
+      // bring up the test bus
+      ensure_glib_initialized ();
+      mainloop =  g_main_loop_new (NULL, FALSE);
+      bus = g_test_dbus_new (G_TEST_DBUS_NONE);
+      g_test_dbus_up (bus);
+
+      // own org.gnome.SettingsDameon on this test bus
+      gsd_name_ownership_id = g_bus_own_name (
+        G_BUS_TYPE_SESSION,
+        GSD_SERVICE,
+        G_BUS_NAME_OWNER_FLAGS_NONE,
+        on_bus_acquired,
+        on_name_acquired,
+        on_name_lost,
+        this, NULL);
+      ASSERT_FALSE (bus_acquired);
+      ASSERT_FALSE (name_acquired);
+      ASSERT_TRUE (connection == NULL);
+      g_main_loop_run (mainloop);
+      ASSERT_TRUE (bus_acquired);
+      ASSERT_TRUE (name_acquired);
+      ASSERT_TRUE (G_IS_DBUS_CONNECTION(connection));
+
+      // parse the org.gnome.SettingsDaemon.Power interface
+      const gchar introspection_xml[] =
+        "<node>"
+        "  <interface name='org.gnome.SettingsDaemon.Power'>"
+        "    <property name='Icon' type='s' access='read'>"
+        "    </property>"
+        "    <property name='Tooltip' type='s' access='read'>"
+        "    </property>"
+        "    <method name='GetDevices'>"
+        "      <arg name='devices' type='a(susdut)' direction='out' />"
+        "    </method>"
+        "  </interface>"
+        "</node>";
+      gsd_power_introspection_data = g_dbus_node_info_new_for_xml(introspection_xml, NULL);
+      ASSERT_TRUE (gsd_power_introspection_data != NULL);
+
+      // Set up a mock GSD.
+      // All it really does is wait for calls to GetDevice and
+      // returns the get_devices_retval variant
+      const GDBusInterfaceVTable gsd_power_interface_vtable = {
+        gsd_power_handle_method_call,
+        NULL, /* GetProperty */
+        NULL, /* SetProperty */
+      };
+      gsd_power_registration_id = g_dbus_connection_register_object (connection,
+                                                                     GSD_POWER_DBUS_PATH,
+                                                                     gsd_power_introspection_data->interfaces[0],
+                                                                     &gsd_power_interface_vtable,
+                                                                     this, NULL, NULL);
+    }
+
+    virtual void TearDown()
+    {
+      g_free (gsd_power_error_string);
+
+      g_dbus_connection_unregister_object (connection, gsd_power_registration_id);
+
+      g_dbus_node_info_unref (gsd_power_introspection_data);
+      g_bus_unown_name (gsd_name_ownership_id);
+
+      g_slist_free_full (devices, g_object_unref);
+      g_test_dbus_down (bus);
+      g_main_loop_unref (mainloop);
+    }
+};
+
+/***
+****
+***/
+
+
+TEST_F(DbusListenerTest, GSDHasPowerAndBattery)
+{
+  // build a GetDevices retval that shows an AC line and a discharging battery
+  GVariantBuilder * builder = g_variant_builder_new (G_VARIANT_TYPE("a(susdut)"));
+  g_variant_builder_add (builder, "(susdut)",
+                         "/org/freedesktop/UPower/devices/line_power_AC",
+                         UP_DEVICE_KIND_LINE_POWER,
+                         ". GThemedIcon ac-adapter-symbolic ac-adapter ",
+                         0.0,
+                         UP_DEVICE_STATE_UNKNOWN,
+                         0);
+  g_variant_builder_add (builder, "(susdut)",
+                         "/org/freedesktop/UPower/devices/battery_BAT0",
+                         UP_DEVICE_KIND_BATTERY,
+                         ". GThemedIcon battery-good-symbolic gpm-battery-060 battery-good ",
+                         52.871712,
+                         UP_DEVICE_STATE_DISCHARGING,
+                         8834);
+  GVariant * value = g_variant_builder_end (builder);
+  get_devices_retval = g_variant_new_tuple (&value, 1);
+  g_variant_builder_unref (builder);
+
+  // create an i-power dbus listener to watch for GSD
+  ASSERT_EQ (g_slist_length(devices), 0);
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_DBUS_LISTENER_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DBUS_LISTENER(o));
+  g_signal_connect(o, INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                   G_CALLBACK(on_devices_enumerated), this);
+  g_main_loop_run (mainloop);
+
+  // test the devices should have gotten
+  ASSERT_EQ (g_slist_length(devices), 2);
+  IndicatorPowerDevice * device = INDICATOR_POWER_DEVICE (g_slist_nth_data (devices, 0));
+  ASSERT_EQ (indicator_power_device_get_kind(device), UP_DEVICE_KIND_LINE_POWER);
+  ASSERT_STREQ ("/org/freedesktop/UPower/devices/line_power_AC", indicator_power_device_get_object_path(device));
+  device = INDICATOR_POWER_DEVICE (g_slist_nth_data (devices, 1));
+  ASSERT_EQ (UP_DEVICE_KIND_BATTERY, indicator_power_device_get_kind(device));
+  ASSERT_STREQ ("/org/freedesktop/UPower/devices/battery_BAT0", indicator_power_device_get_object_path(device));
+
+  // cleanup
+  g_object_run_dispose (o); // used to get coverage of both branches in the object's dispose func's g_clear_*() calls
+  g_object_unref (o); 
+}
+
+TEST_F(DbusListenerTest, GSDHasNoDevices)
+{
+  GVariantBuilder * builder = g_variant_builder_new (G_VARIANT_TYPE("a(susdut)"));
+  GVariant * value = g_variant_builder_end (builder);
+  get_devices_retval = g_variant_new_tuple (&value, 1);
+  g_variant_builder_unref (builder);
+
+  // create an i-power dbus listener to watch for GSD
+  ASSERT_EQ (g_slist_length(devices), 0);
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_DBUS_LISTENER_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DBUS_LISTENER(o));
+  g_signal_connect(o, INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                   G_CALLBACK(on_devices_enumerated), this);
+  g_main_loop_run (mainloop);
+
+  // test the devices should have gotten
+  ASSERT_EQ (g_slist_length(devices), 0);
+
+  // FIXME: this test improves coverage and confirms that the code
+  // doesn't crash, but more meaningful tests would be better too.
+
+  // cleanup
+  g_object_run_dispose (o); // used to get coverage of both branches in the object's dispose func's g_clear_*() calls
+  g_object_unref (o); 
+}
+
+TEST_F(DbusListenerTest, GSDReturnsError)
+{
+  gsd_power_error_string = g_strdup ("no devices for you lol");
+
+  // create an i-power dbus listener to watch for GSD
+  ASSERT_EQ (g_slist_length(devices), 0);
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_DBUS_LISTENER_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DBUS_LISTENER(o));
+  g_signal_connect(o, INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                   G_CALLBACK(on_devices_enumerated), this);
+  g_main_loop_run (mainloop);
+
+  // test the devices should have gotten
+  ASSERT_EQ (g_slist_length(devices), 0);
+
+  // FIXME: this test improves coverage and confirms that the code
+  // doesn't crash, but more meaningful tests would be better too.
+
+  // cleanup
+  g_object_run_dispose (o); // used to get coverage of both branches in the object's dispose func's g_clear_*() calls
+  g_object_unref (o); 
+}
+
+/* This test emits a PropertiesChanged signal and confirms that
+   the dbus listener asks for a fresh set of devices as a result. */
+TEST_F(DbusListenerTest, GSDPropChanged)
+{
+  gsd_power_error_string = g_strdup ("no devices for you lol");
+
+  // create an i-power dbus listener to watch for GSD
+  ASSERT_EQ (g_slist_length(devices), 0);
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_DBUS_LISTENER_TYPE, NULL));
+  ASSERT_TRUE (INDICATOR_IS_POWER_DBUS_LISTENER(o));
+  g_signal_connect(o, INDICATOR_POWER_DBUS_LISTENER_DEVICES_ENUMERATED,
+                   G_CALLBACK(on_devices_enumerated), this);
+  g_main_loop_run (mainloop);
+  // test the devices should have gotten
+  ASSERT_EQ (g_slist_length(devices), 0);
+
+  // build a GetDevices retval that shows an AC line and a discharging battery
+  g_clear_pointer (&gsd_power_error_string, g_free);
+  GVariantBuilder * builder = g_variant_builder_new (G_VARIANT_TYPE("a(susdut)"));
+  g_variant_builder_add (builder, "(susdut)",
+                         "/org/freedesktop/UPower/devices/line_power_AC",
+                         UP_DEVICE_KIND_LINE_POWER,
+                         ". GThemedIcon ac-adapter-symbolic ac-adapter ",
+                         0.0,
+                         UP_DEVICE_STATE_UNKNOWN,
+                         0);
+  g_variant_builder_add (builder, "(susdut)",
+                         "/org/freedesktop/UPower/devices/battery_BAT0",
+                         UP_DEVICE_KIND_BATTERY,
+                         ". GThemedIcon battery-good-symbolic gpm-battery-060 battery-good ",
+                         52.871712,
+                         UP_DEVICE_STATE_DISCHARGING,
+                         8834);
+  GVariant * value = g_variant_builder_end (builder);
+  get_devices_retval = g_variant_new_tuple (&value, 1);
+  g_variant_builder_unref (builder);
+
+  // tell the listener that some property changed
+  GVariantBuilder props_builder;
+  g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}"));
+  GVariant * props_changed = g_variant_new ("(s@a{sv}@as)", GSD_POWER_DBUS_INTERFACE,
+    g_variant_builder_end (&props_builder),
+    g_variant_new_strv (NULL, 0));
+  g_variant_ref_sink (props_changed);
+  GError * error = NULL;
+  g_dbus_connection_emit_signal (connection,
+                                 NULL,
+                                 GSD_POWER_DBUS_PATH,
+                                 "org.freedesktop.DBus.Properties",
+                                 "PropertiesChanged",
+                                 props_changed,
+                                 &error);
+  ASSERT_TRUE(error == NULL);
+
+  // give i-power's dbus listener a chance to ask for a fresh device list
+  g_main_loop_run (mainloop);
+  ASSERT_EQ (g_slist_length(devices), 2);
+
+  // cleanup
+  g_object_unref (o); 
+}
diff --git a/tests/test-device.cc b/tests/test-device.cc
new file mode 100644
index 0000000..2c88ea1
--- /dev/null
+++ b/tests/test-device.cc
@@ -0,0 +1,470 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+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 <gtest/gtest.h>
+#include "device.h"
+
+namespace
+{
+  void ensure_glib_initialized ()
+  {
+    static bool initialized = false;
+
+    if (G_UNLIKELY(!initialized))
+    {
+      initialized = true;
+      g_type_init();
+    }
+  }
+}
+
+class DeviceTest : public ::testing::Test
+{
+  protected:
+
+    virtual void SetUp()
+    {
+      ensure_glib_initialized ();
+    }
+
+    virtual void TearDown()
+    {
+    }
+
+  protected:
+
+    void check_icon_names (const IndicatorPowerDevice * device, const char * expected)
+    {
+      char ** names = indicator_power_device_get_icon_names (device);
+      char * str = g_strjoinv (";", names);
+      ASSERT_STREQ (expected, str);
+      g_free (str);
+      g_strfreev (names);
+    }
+
+    void check_strings (const IndicatorPowerDevice * device,
+                        const char * expected_timestring,
+                        const char * expected_details,
+                        const char * expected_accessible)
+    {
+      char * timestring = NULL;
+      char * details = NULL;
+      char * accessible = NULL;
+
+      indicator_power_device_get_time_details (device, &timestring, &details, &accessible);
+      EXPECT_STREQ (expected_timestring, timestring);
+      EXPECT_STREQ (expected_details, details);
+      EXPECT_STREQ (expected_accessible, accessible);
+
+      g_free (accessible);
+      g_free (details);
+      g_free (timestring);
+    }
+};
+
+
+/***
+****
+***/
+
+TEST_F(DeviceTest, GObjectNew)
+{
+  ensure_glib_initialized ();
+
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_DEVICE_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DEVICE(o));
+  g_object_run_dispose (o); // used to get coverage of both branches in the object's dispose func's g_clear_*() calls
+  g_object_unref (o);
+}
+
+TEST_F(DeviceTest, Properties)
+{
+  int i;
+  gdouble d;
+  GObject * o;
+  gchar * str;
+  guint64 u64;
+  const gchar * key;
+
+  ensure_glib_initialized ();
+
+  o = G_OBJECT (g_object_new (INDICATOR_POWER_DEVICE_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DEVICE(o));
+
+  // Test getting & setting a Device's properties.
+
+  // KIND
+  key = INDICATOR_POWER_DEVICE_KIND;
+  g_object_set (o, key, UP_DEVICE_KIND_BATTERY, NULL);
+  g_object_get (o, key, &i, NULL);
+  ASSERT_EQ (i, UP_DEVICE_KIND_BATTERY);
+
+  // STATE
+  key = INDICATOR_POWER_DEVICE_STATE;
+  g_object_set (o, key, UP_DEVICE_STATE_CHARGING, NULL);
+  g_object_get (o, key, &i, NULL);
+  ASSERT_EQ (i, UP_DEVICE_STATE_CHARGING);
+
+  // OBJECT_PATH
+  key = INDICATOR_POWER_DEVICE_OBJECT_PATH;
+  g_object_set (o, key, "/object/path", NULL);
+  g_object_get (o, key, &str, NULL);
+  ASSERT_STREQ (str, "/object/path");
+  g_free (str);
+
+  // PERCENTAGE
+  key = INDICATOR_POWER_DEVICE_PERCENTAGE;
+  g_object_set (o, key, 50.0, NULL);
+  g_object_get (o, key, &d, NULL);
+  ASSERT_EQ((int)d, 50);
+
+  // TIME
+  key = INDICATOR_POWER_DEVICE_TIME;
+  g_object_set (o, key, (guint64)30, NULL);
+  g_object_get (o, key, &u64, NULL);
+  ASSERT_EQ(u64, 30);
+
+  // cleanup
+  g_object_unref (o);
+}
+
+TEST_F(DeviceTest, New)
+{
+  ensure_glib_initialized ();
+
+  IndicatorPowerDevice * device = indicator_power_device_new ("/object/path",
+                                                              UP_DEVICE_KIND_BATTERY,
+                                                              50.0,
+                                                              UP_DEVICE_STATE_CHARGING,
+                                                              30);
+  ASSERT_TRUE (device != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DEVICE(device));
+  ASSERT_EQ (indicator_power_device_get_kind(device), UP_DEVICE_KIND_BATTERY);
+  ASSERT_EQ (indicator_power_device_get_state(device), UP_DEVICE_STATE_CHARGING);
+  ASSERT_STREQ (indicator_power_device_get_object_path(device), "/object/path");
+  ASSERT_EQ ((int)indicator_power_device_get_percentage(device), 50);
+  ASSERT_EQ (indicator_power_device_get_time(device), 30);
+
+  // cleanup
+  g_object_unref (device);
+}
+
+TEST_F(DeviceTest, NewFromVariant)
+{
+  ensure_glib_initialized ();
+
+  GVariant * variant = g_variant_new ("(susdut)",
+                                      "/object/path",
+                                      UP_DEVICE_KIND_BATTERY,
+                                      "icon",
+                                      50.0,
+                                      UP_DEVICE_STATE_CHARGING,
+                                      30);
+  IndicatorPowerDevice * device = indicator_power_device_new_from_variant (variant);
+  ASSERT_TRUE (variant != NULL);
+  ASSERT_TRUE (device != NULL);
+  ASSERT_TRUE (INDICATOR_IS_POWER_DEVICE(device));
+  ASSERT_EQ (indicator_power_device_get_kind(device), UP_DEVICE_KIND_BATTERY);
+  ASSERT_EQ (indicator_power_device_get_state(device), UP_DEVICE_STATE_CHARGING);
+  ASSERT_STREQ (indicator_power_device_get_object_path(device), "/object/path");
+  ASSERT_EQ ((int)indicator_power_device_get_percentage(device), 50);
+  ASSERT_EQ (indicator_power_device_get_time(device), 30);
+
+  // cleanup
+  g_object_unref (device);
+  g_variant_unref (variant);
+}
+
+TEST_F(DeviceTest, BadAccessors)
+{
+  ensure_glib_initialized ();
+
+  // test that these functions can handle being passed NULL pointers
+  IndicatorPowerDevice * device = NULL;
+  indicator_power_device_get_kind (device);
+  indicator_power_device_get_time (device);
+  indicator_power_device_get_state (device);
+  indicator_power_device_get_percentage (device);
+  indicator_power_device_get_object_path (device);
+
+  // test that these functions can handle being passed non-device GObjects
+  device = reinterpret_cast<IndicatorPowerDevice*>(g_cancellable_new ());
+  indicator_power_device_get_kind (device);
+  indicator_power_device_get_time (device);
+  indicator_power_device_get_state (device);
+  indicator_power_device_get_percentage (device);
+  indicator_power_device_get_object_path (device);
+  g_object_unref (device);
+}
+
+/***
+****
+***/
+
+TEST_F(DeviceTest, IconNames)
+{
+  IndicatorPowerDevice * device = INDICATOR_POWER_DEVICE (g_object_new (INDICATOR_POWER_DEVICE_TYPE, NULL));
+  GObject * o = G_OBJECT(device);
+
+  // bad arguments
+  ASSERT_TRUE (indicator_power_device_get_icon_names (NULL) == NULL);
+
+  // power
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_LINE_POWER,
+                   NULL);
+  check_icon_names (device, "ac-adapter-symbolic;"
+                            "ac-adapter");
+
+  // monitor
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_MONITOR,
+                   NULL);
+  check_icon_names (device, "gpm-monitor-symbolic;"
+                            "gpm-monitor");
+
+  // empty battery
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_EMPTY,
+                   NULL);
+  check_icon_names (device, "battery-empty-symbolic;"
+                            "gpm-battery-empty;"
+                            "gpm-battery-000;"
+                            "battery-empty");
+
+  // charged battery
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_FULLY_CHARGED,
+                   NULL);
+  check_icon_names (device, "battery-full-charged-symbolic;battery-full-charging-symbolic;"
+                            "gpm-battery-full;gpm-battery-100;"
+                            "battery-full-charged;battery-full-charging");
+
+  // charging battery, 95%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 95.0,
+                   NULL);
+  check_icon_names (device, "battery-caution-charging-symbolic;"
+                            "gpm-battery-000-charging;"
+                            "battery-caution-charging");
+
+  // charging battery, 85%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 85.0,
+                   NULL);
+  check_icon_names (device, "battery-caution-charging-symbolic;"
+                            "gpm-battery-000-charging;"
+                            "battery-caution-charging");
+
+  // charging battery, 50%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   NULL);
+  check_icon_names (device, "battery-caution-charging-symbolic;"
+                            "gpm-battery-000-charging;"
+                            "battery-caution-charging");
+
+  // charging battery, 25%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 25.0,
+                   NULL);
+  check_icon_names (device, "battery-caution-charging-symbolic;"
+                            "gpm-battery-000-charging;"
+                            "battery-caution-charging");
+
+  // charging battery, 5%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 5.0,
+                   NULL);
+  check_icon_names (device, "battery-caution-charging-symbolic;"
+                            "gpm-battery-000-charging;"
+                            "battery-caution-charging");
+
+
+  // discharging battery, 95%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 95.0,
+                   NULL);
+  check_icon_names (device, "battery-full-symbolic;"
+                            "gpm-battery-100;"
+                            "battery-full");
+
+  // discharging battery, 85%
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 85.0,
+                   NULL);
+  check_icon_names (device, "battery-full-symbolic;"
+                            "gpm-battery-080;"
+                            "battery-full");
+
+  // discharging battery, 50% -- 1 hour left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   INDICATOR_POWER_DEVICE_TIME, (guint64)(60*60),
+                   NULL);
+  check_icon_names (device, "battery-good-symbolic;"
+                            "gpm-battery-060;"
+                            "battery-good");
+
+  // discharging battery, 25% -- 1 hour left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 25.0,
+                   INDICATOR_POWER_DEVICE_TIME, (guint64)(60*60),
+                   NULL);
+  check_icon_names (device, "battery-good-symbolic;"
+                            "gpm-battery-040;"
+                            "battery-good");
+
+  // discharging battery, 25% -- 15 minutes left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 25.0,
+                   INDICATOR_POWER_DEVICE_TIME, (guint64)(60*15),
+                   NULL);
+  check_icon_names (device, "battery-low-symbolic;"
+                            "gpm-battery-020;"
+                            "battery-low");
+
+  // discharging battery, 5% -- 1 hour left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 5.0,
+                   INDICATOR_POWER_DEVICE_TIME, (guint64)(60*60),
+                   NULL);
+  check_icon_names (device, "battery-good-symbolic;"
+                            "gpm-battery-040;"
+                            "battery-good");
+
+  // discharging battery, 5% -- 15 minutes left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 5.0,
+                   INDICATOR_POWER_DEVICE_TIME, (guint64)(60*15),
+                   NULL);
+  check_icon_names (device, "battery-caution-symbolic;"
+                            "gpm-battery-000;"
+                            "battery-caution"); 
+  // state unknown
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_UNKNOWN, 
+                   NULL);
+  check_icon_names (device, "battery-missing-symbolic;"
+                            "gpm-battery-missing;"
+                            "battery-missing");
+
+  // cleanup
+  g_object_unref(o);
+}
+
+
+TEST_F(DeviceTest, Labels)
+{
+  // set our language so that i18n won't break these tests
+  char * real_lang = g_strdup(g_getenv ("LANG"));
+  g_setenv ("LANG", "en_US.UTF-8", TRUE);
+
+  // bad args: NULL device
+  check_strings (NULL, NULL, NULL, NULL);
+
+  // bad args: a GObject that isn't a device
+  GObject * o = G_OBJECT(g_cancellable_new());
+  check_strings ((IndicatorPowerDevice*)o, NULL, NULL, NULL);
+  g_object_unref (o);
+
+  /**
+  ***
+  **/
+ 
+  IndicatorPowerDevice * device = INDICATOR_POWER_DEVICE (g_object_new (INDICATOR_POWER_DEVICE_TYPE, NULL));
+  o = G_OBJECT(device);
+
+  // charging
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(60*61),
+                   NULL);
+  check_strings (device, "(1:01)",
+                         "Battery (1:01 to charge)",
+                         "Battery (1 hour 1 minute to charge (50%))");
+
+  // discharging, < 12 hours left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(60*61),
+                   NULL);
+  check_strings (device, "1:01",
+                         "Battery (1:01 left)",
+                         "Battery (1 hour 1 minute left (50%))");
+
+  // discharging, > 12 hours left
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(60*60*13),
+                   NULL);
+  check_strings (device, "13:00", "Battery", "Battery");
+
+  // fully charged
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_FULLY_CHARGED,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 100.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                   NULL);
+  check_strings (device, "", "Battery (charged)", "Battery (charged)");
+
+  // percentage but no time estimate
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                   NULL);
+  check_strings (device, "(50%)", "Battery (50%)", "Battery (50%)");
+
+  // no percentage, no time estimate
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_BATTERY,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 0.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                   NULL);
+  check_strings (device, "(not present)", "Battery (not present)", "Battery (not present)");
+
+  // power line
+  g_object_set (o, INDICATOR_POWER_DEVICE_KIND, UP_DEVICE_KIND_LINE_POWER,
+                   INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_UNKNOWN,
+                   INDICATOR_POWER_DEVICE_PERCENTAGE, 0.0,
+                   INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                   NULL);
+  check_strings (device, "AC Adapter", "AC Adapter", "AC Adapter");
+
+  // cleanup
+  g_object_unref(o);
+  g_setenv ("LANG", real_lang, TRUE);
+  g_free (real_lang);
+}
diff --git a/tests/test-indicator.cc b/tests/test-indicator.cc
new file mode 100644
index 0000000..b9f7321
--- /dev/null
+++ b/tests/test-indicator.cc
@@ -0,0 +1,312 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+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 <gtest/gtest.h>
+
+#include "dbus-listener.h"
+#include "device.h"
+#include "indicator-power.h"
+
+/***
+****
+***/
+
+namespace
+{
+  void ensure_glib_initialized ()
+  {
+    static bool initialized = false;
+
+    if (G_UNLIKELY(!initialized))
+    {
+      initialized = true;
+      g_type_init();
+    }
+  }
+}
+
+/***
+****
+***/
+
+class IndicatorTest : public ::testing::Test
+{
+  protected:
+
+    IndicatorPowerDevice * ac_device;
+    IndicatorPowerDevice * battery_device;
+
+    virtual void SetUp()
+    {
+      ensure_glib_initialized ();
+         
+      g_setenv( "GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
+
+      ac_device = indicator_power_device_new (
+        "/org/freedesktop/UPower/devices/line_power_AC",
+        UP_DEVICE_KIND_LINE_POWER,
+        0.0, UP_DEVICE_STATE_UNKNOWN, 0);
+
+      battery_device = indicator_power_device_new (
+        "/org/freedesktop/UPower/devices/battery_BAT0",
+        UP_DEVICE_KIND_BATTERY,
+        52.871712, UP_DEVICE_STATE_DISCHARGING, 8834);
+    }
+
+    virtual void TearDown()
+    {
+      g_object_unref (battery_device);
+      g_object_unref (ac_device);
+    }
+
+    const char* GetAccessibleDesc (IndicatorPower * power) const
+    {
+      GList * entries = indicator_object_get_entries (INDICATOR_OBJECT(power));
+      g_assert (g_list_length(entries) == 1); 
+      IndicatorObjectEntry * entry = static_cast<IndicatorObjectEntry*>(entries->data);
+      const char * ret = entry->accessible_desc;
+      g_list_free (entries);
+      return ret;
+    }
+};
+
+/***
+****
+***/
+
+TEST_F(IndicatorTest, GObjectNew)
+{
+  GObject * o = G_OBJECT (g_object_new (INDICATOR_POWER_TYPE, NULL));
+  ASSERT_TRUE (o != NULL);
+  ASSERT_TRUE (IS_INDICATOR_POWER(o));
+  g_object_run_dispose (o); // used to get coverage of both branches in the object's dispose func's g_clear_*() calls
+  g_object_unref (o);
+}
+
+TEST_F(IndicatorTest, SetDevices)
+{
+  GSList * devices;
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+
+  devices = NULL;
+  devices = g_slist_append (devices, ac_device);
+  devices = g_slist_append (devices, battery_device);
+  indicator_power_set_devices (power, devices);
+  g_slist_free (devices); 
+
+  g_object_unref (power);
+}
+
+TEST_F(IndicatorTest, DischargingStrings)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+  GSList * devices = g_slist_append (NULL, battery_device);
+
+  // give the indicator a discharging battery with 30 minutes of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*30),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (30 minutes left (50%))");
+
+  // give the indicator a discharging battery with 1 hour of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_DISCHARGING,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*60),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (1 hour left (50%))");
+
+  // give the indicator a discharging battery with 2 hours of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 100.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*60*2),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (2 hours left (100%))");
+
+  // give the indicator a discharging battery with over 12 hours of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*60*12 + 1),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery");
+
+  // give the indicator a discharging battery with 29 seconds left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_TIME, guint64(29),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (Unknown time left (100%))");
+
+  // what happens if the time estimate isn't available
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (50%)");
+
+  // what happens if the time estimate AND percentage isn't available
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 0.0,
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (not present)");
+
+  // cleanup
+  g_slist_free (devices);
+  g_object_unref (power);
+}
+
+TEST_F(IndicatorTest, ChargingStrings)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+  GSList * devices = g_slist_prepend (NULL, battery_device);
+
+  // give the indicator a discharging battery with 1 hour of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_CHARGING,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 50.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*60),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (1 hour to charge (50%))");
+
+  // give the indicator a discharging battery with 2 hours of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_TIME, guint64(60*60*2),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (2 hours to charge (50%))");
+
+  // cleanup
+  g_slist_free (devices);
+  g_object_unref (power);
+}
+
+TEST_F(IndicatorTest, ChargedStrings)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+  GSList * devices = g_slist_append (NULL, battery_device);
+
+  // give the indicator a discharging battery with 1 hour of life left
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_FULLY_CHARGED,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 100.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                NULL);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (charged)");
+
+  // cleanup
+  g_slist_free (devices);
+  g_object_unref (power);
+}
+
+TEST_F(IndicatorTest, AvoidChargingBatteriesWithZeroSecondsLeft)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+
+  g_object_set (battery_device,
+                INDICATOR_POWER_DEVICE_STATE, UP_DEVICE_STATE_FULLY_CHARGED,
+                INDICATOR_POWER_DEVICE_PERCENTAGE, 100.0,
+                INDICATOR_POWER_DEVICE_TIME, guint64(0),
+                NULL);
+  IndicatorPowerDevice * bad_battery_device  = indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/battery_BAT0",
+    UP_DEVICE_KIND_BATTERY,
+    53, UP_DEVICE_STATE_CHARGING, 0);
+
+  GSList * devices = NULL;
+  devices = g_slist_append (devices, battery_device);
+  devices = g_slist_append (devices, bad_battery_device);
+  indicator_power_set_devices (power, devices);
+  ASSERT_STREQ (GetAccessibleDesc(power), "Battery (53%)");
+
+  // cleanup
+  g_slist_free (devices);
+  g_object_unref (power);
+  g_object_unref (bad_battery_device);
+}
+
+TEST_F(IndicatorTest, OtherDevices)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+
+  g_object_ref (battery_device);
+  GSList * devices = g_slist_append (NULL, battery_device);
+
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/mouse", UP_DEVICE_KIND_MOUSE,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/ups", UP_DEVICE_KIND_UPS,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/keyboard", UP_DEVICE_KIND_KEYBOARD,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/pda", UP_DEVICE_KIND_PDA,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/phone", UP_DEVICE_KIND_PHONE,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/monitor", UP_DEVICE_KIND_MONITOR,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/media_player", UP_DEVICE_KIND_MEDIA_PLAYER,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/tablet", UP_DEVICE_KIND_TABLET,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/computer", UP_DEVICE_KIND_COMPUTER,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+  devices = g_slist_append (devices, indicator_power_device_new (
+    "/org/freedesktop/UPower/devices/unknown", UP_DEVICE_KIND_UNKNOWN,
+    0, UP_DEVICE_STATE_UNKNOWN, 0));
+
+  indicator_power_set_devices (power, devices);
+
+  // FIXME: this tests to confirm the code doesn't crash,
+  // but further tests would be helpful
+
+  // cleanup
+  g_slist_free_full (devices, g_object_unref);
+  g_object_unref (power);
+}
+
+TEST_F(IndicatorTest, NoDevices)
+{
+  IndicatorPower * power = INDICATOR_POWER(g_object_new (INDICATOR_POWER_TYPE, NULL));
+
+  indicator_power_set_devices (power, NULL);
+
+  // FIXME: this tests to confirm the code doesn't crash,
+  // but further tests would be helpful
+
+  // cleanup
+  g_object_unref (power);
+}