Merge lp:~charlesk/indicator-power/coverage into lp:indicator-power/12.10

[Charles Kerr]

charles brings the code-coverage of this project above 90%.

revised to use most of lars' great suggestions

[Lars Karlitski (larsu)]

Very nice work! And impressive test coverage.

Note: I couldn't test it yet, as I'm still on precise. /me ducks.

src/Makefile.am:207:
  * any reason you're using noinst_HEADERS instead of listing the headers
    in the libraries sources? (the latter is recommended for programs and
    convenience libs in the automake docs)

dbus-listener.c
  * afaict, it could have been written by gdbus-codegen
  * 305: g_signal_new is passed one too many arguments. Please add the
    docstring with the number and names of parameters to it [1]
  * dispose() is missing g_bus_unwatch_name (priv->watcher_id)
  * get_devices_cb:144: trailing whitespace ;)
  * the cancellable is passed into all functions and unreffed in dispose()
    is the cancellable cancelled on unref or do we need to do that explicitely?
    (I can't find anything in the docs)

dbus-listener.h:
  * 50: the signal name is overly complicated (it doesn't need to be namespaced
    to the class)
  * indicator_power_dbus_listener_new is declared but not defined in the .c

device.c:
  * class_init: I prefer saving all pspecs in a static array and installing
    them all at once with g_object_class_install_properties. This also allows
    using g_object_notify_by_pspec
  * finalize doesn't chain up to the parent class
  * get/set_property:
     - use G_OBJECT_WARN_INVALID_PROPERTY_ID in the 'default' switch case
     - PROP_ICON is not handled
     - kind and state should check for sane input values
  * 260 ff: I don't think we can use Richard's code (indicators are CA, right?)
  * indicator_power_device_new_from_variant: check whether the input variant
    has the correct type before calling g_variant_get
  * 298: reference functions with 'function_name()' instead of #function_name
    in doc strings

device.h:
  * 43 ff: no need to namespace gobject properties (tbh, I wouldn't even
    #define them, but simply use the strings)

indicator-power.c:
  * 119: ah, that's why you didn't notice the implementation of
    indicator_power_dbus_listener_new was missing :)
  * ref the floating widgets in the private struct
    (just something I noticed, it has nothing to do with this work)

indicator-power.h:
  * device.h include is superfluous

test/test-dbus-{listener,device}.cc:
  * ensure_glib_initalized: g_type_init can be called multiple times

[1] http://developer.gnome.org/gtk-doc-manual/stable/documenting_symbols.html.en
    Section 3.3.4

review: Needs Fixing

[Charles Kerr (charlesk)]

Lars, thanks for the great review!

> any reason you're using noinst_HEADERS instead of listing the headers
> in the libraries sources? (the latter is recommended for programs and
> convenience libs in the automake docs)

Fixed r204

> dbus-listener.c
>
> 305: g_signal_new is passed one too many arguments. Please add the
> docstring with the number and names of parameters to it [1]

Fixed r205

> dispose() is missing g_bus_unwatch_name (priv->watcher_id)

Fixed r206

> get_devices_cb:144: trailing whitespace ;)

Fixed r207

> the cancellable is passed into all functions and unreffed in dispose()
> is the cancellable cancelled on unref or do we need to do that explicitely?
> (I can't find anything in the docs)

This is a great catch. Looking at the gio code, my assumption was wrong,
it needs to be done explicitly.

Fixed r208

> dbus-listener.h:
> * 50: the signal name is overly complicated (it doesn't need to be namespaced
> to the class)

Fixed r209

> * indicator_power_dbus_listener_new is declared but not defined in the .c

Fixed r210

> device.c:
> class_init: I prefer saving all pspecs in a static array and installing
> them all at once with g_object_class_install_properties. This also allows
> using g_object_notify_by_pspec

Interesting, I don't see that in any of the other indicator code. TIL.

Changed r211

> * finalize doesn't chain up to the parent class

Fixed r212

> * get/set_property:
> - use G_OBJECT_WARN_INVALID_PROPERTY_ID in the 'default' switch case

Fixed r213

> PROP_ICON is not handled

PROP_ICON was cruft, removed r211

> kind and state should check for sane input values

This is already done by glib's plumbing because the pspec defined the sane range. (No change)

> 260 ff: I don't think we can use Richard's code (indicators are CA, right?)

Before my refactoring, i-power was already doing this. One difference is now I'm giving proper attribution. (No change, but maybe a ted question?)

> indicator_power_device_new_from_variant: check whether the input variant has the correct type before calling g_variant_get

Fixed r214.

> 298: reference functions with 'function_name()' instead of #function_name in doc strings

Fixed r215.

> device.h: 43 ff: no need to namespace gobject properties (tbh, I wouldn't even #define them, but simply use the strings)

Fixed r216.

However I've kept the #defines since that idiom catches misspelled keys at compile time...

> indicator-power.c:
> * ref the floating widgets in the private struct
> (just something I noticed, it has nothing to do with this work)

Agreed, but unchanged for this pass...

> indicator-power.h:
> * device.h include is superfluous

Fixed r217

> test/test-dbus-{listener,device}.cc:
> * ensure_glib_initalized: g_type_init can be called multiple times

I don't think this is correct. Are you sure?

[Charles Kerr (charlesk)]

>> 260 ff: I don't think we can use Richard's code (indicators are CA, right?)
>
> Before my refactoring, i-power was already doing this. One difference is now I'm giving proper attribution. (No change, but maybe a ted question?)

Sure enough. Fixed r218.

[Lars Karlitski (larsu)]

Thanks for the quick fixes!

On 06/06/2012 10:28 PM, Charles Kerr wrote:
>> the cancellable is passed into all functions and unreffed in dispose()
>> is the cancellable cancelled on unref or do we need to do that explicitely?
>> (I can't find anything in the docs)
>
> This is a great catch. Looking at the gio code, my assumption was wrong,
> it needs to be done explicitly.
>
> Fixed r208

Thanks for checking.

> [...]
>> kind and state should check for sane input values
>
> This is already done by glib's plumbing because the pspec defined the sane range. (No change)

You're right of course. Sorry.

>> 260 ff: I don't think we can use Richard's code (indicators are CA, right?)
>
> Before my refactoring, i-power was already doing this. One difference is now I'm giving proper attribution. (No change, but maybe a ted question?)

Definitely a Ted question.

>> indicator_power_device_new_from_variant: check whether the input variant has the correct type before calling g_variant_get
>
> Fixed r214.

Hm, I was thinking more along the lines of

  g_variant_is_of_type (v, G_VARIANT_TYPE ("(susdut)"));

The fix in r214 only checks for a tuple with the correct number of elements.

>> test/test-dbus-{listener,device}.cc:
>> * ensure_glib_initalized: g_type_init can be called multiple times
>
> I don't think this is correct. Are you sure?

I'm not sure. Actually, I think you might be right.

[Charles Kerr (charlesk)]

> Hm, I was thinking more along the lines of
>
> g_variant_is_of_type (v, G_VARIANT_TYPE ("(susdut)"));

Oh yes, that is better. Fixed r219

Keep it up, I love these improvements :)

[Lars Karlitski (larsu)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 06/07/2012 04:01 PM, Charles Kerr wrote:
>> Hm, I was thinking more along the lines of
>>
>> g_variant_is_of_type (v, G_VARIANT_TYPE ("(susdut)"));
>
> Oh yes, that is better. Fixed r219

Very cool, thanks.

> Keep it up, I love these improvements :)

:)

 review approve

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iQEcBAEBAgAGBQJP0LcbAAoJEAbD1bcyW6kF0r4H/iQccWs8wGW1Wr/cWBUQFzOb
+xwhmXR5UnR0MX+Lk+V/VwxTR1sMIWb/ye4t641dv58RgG9HORq0K6A8AMASXz6v
jThP3+3Y/gUmJ3wiJX3SKxUH7gRkskPO39Q5WEUyR6NnARMpXg6ySMMZP/TWZVMr
eeQo5FfoN2WIJf2oK9mod0nKvdBsmuLOVX4c2jwqJKAcj5UaZ1v+1YISG+qHXjYy
NI9LXjaJgJXSKwl+LuGbAL+86sSCo07G0EM3bDpYSK8W82CCuj4yqUfLix5Y8xEF
JS/dfmM93pEkkshTYHhWGjbp7Vx90Dlf4MNLDE73xzd662NAUiidVKPmc1iDmnQ=
=Xwze
-----END PGP SIGNATURE-----

review: Approve

[jenkins (martin-mrazik+qa)]

FAILED: Autolanding.
No commit message was specified.
http://s-jenkins:8080/job/indicator-power-autolanding/1/

review: Disapprove (continuous-integration)

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:220
http://s-jenkins:8080/job/indicator-power-ci/2/

review: Approve (continuous-integration)

[Allan LeSage (allanlesage)]

Attempting to kick off autolanding again. . . .

[jenkins (martin-mrazik+qa)]

FAILED: Autolanding.
More details in the following jenkins job:
http://s-jenkins:8080/job/indicator-power-autolanding/2/

review: Disapprove (continuous-integration)

[lp:~charlesk/indicator-power/coverage]

221. By Charles Kerr on 2012-07-03

disable test-dbus-listener for now

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:221
http://s-jenkins:8080/job/indicator-power-ci/3/
Executed test runs:
    SUCCESS: http://s-jenkins:8080/job/indicator-power-ci/./distribution=quantal,flavor=amd64/3/console
    SUCCESS: http://s-jenkins:8080/job/indicator-power-ci/./distribution=quantal,flavor=i386/3/console

review: Approve (continuous-integration)

=== modified file 'Makefile.am'
--- Makefile.am	2012-03-27 20:34:42 +0000
+++ Makefile.am	2012-07-11 17:08:19 +0000
@@ -1,30 +1,11 @@
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
-
-SUBDIRS = \
-	po \
-	data
-
-###################
-# 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
+SUBDIRS = po data src
+
+if BUILD_TESTS
+SUBDIRS += tests
+# build src first
+tests: src
+endif
+
 
 ############################################################
 

=== modified file 'configure.ac'
--- configure.ac	2012-04-11 15:02:18 +0000
+++ configure.ac	2012-07-11 17:08:19 +0000
@@ -11,7 +11,7 @@
 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 @@
 # 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 @@
 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 @@
 Makefile
 po/Makefile.in
 data/Makefile
+src/Makefile
+tests/Makefile
 ])
 AC_OUTPUT
 
@@ -132,5 +155,7 @@
 
 	Prefix:        $prefix
 	Local Install: $with_localinstall
+	Unit Tests:    $enable_tests
 	gcov:          $use_gcov
+
 ])

=== added file 'm4/gtest.m4'
--- m4/gtest.m4	1970-01-01 00:00:00 +0000
+++ m4/gtest.m4	2012-07-11 17:08:19 +0000
@@ -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

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2011-09-23 17:13:42 +0000
+++ po/POTFILES.in	2012-07-11 17:08:19 +0000
@@ -1,2 +1,4 @@
 data/com.canonical.indicator.power.gschema.xml.in
+src/device.c
+src/dbus-listener.c
 src/indicator-power.c

=== added file 'src/Makefile.am'
--- src/Makefile.am	1970-01-01 00:00:00 +0000
+++ src/Makefile.am	2012-07-11 17:08:19 +0000
@@ -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
+

=== added file 'src/dbus-listener.c'
--- src/dbus-listener.c	1970-01-01 00:00:00 +0000
+++ src/dbus-listener.c	2012-07-11 17:08:19 +0000
@@ -0,0 +1,247 @@
+/*
+
+Listens on DBus for Power changes and passes them to an IndicatorPower
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+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);
+}

=== added file 'src/dbus-listener.h'
--- src/dbus-listener.h	1970-01-01 00:00:00 +0000
+++ src/dbus-listener.h	2012-07-11 17:08:19 +0000
@@ -0,0 +1,82 @@
+/*
+
+Listens for Power changes from org.gnome.SettingsDaemon.Power on Dbus
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Javier Jardon <[e-mail]>
+    Charles Kerr <[e-mail]>
+
+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

=== added file 'src/device.c'
--- src/device.c	1970-01-01 00:00:00 +0000
+++ src/device.c	2012-07-11 17:08:19 +0000
@@ -0,0 +1,666 @@
+/*
+
+A simple Device structure used internally by indicator-power
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+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);
+}

=== added file 'src/device.h'
--- src/device.h	1970-01-01 00:00:00 +0000
+++ src/device.h	2012-07-11 17:08:19 +0000
@@ -0,0 +1,107 @@
+/*
+
+A simple Device structure used internally by indicator-power
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+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

=== modified file 'src/indicator-power.c'
--- src/indicator-power.c	2012-04-15 14:23:24 +0000
+++ src/indicator-power.c	2012-07-11 17:08:19 +0000
@@ -20,7 +20,7 @@
 */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+ #include "config.h"
 #endif
 
 /* GStuff */
@@ -28,67 +28,41 @@
 #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
-{
-  IndicatorObject parent_instance;
-
+struct _IndicatorPowerPrivate
+{
   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 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 @@
   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 @@
 static void
 indicator_power_init (IndicatorPower *self)
 {
-  self->menu = GTK_MENU(gtk_menu_new());
-
-  self->accessible_desc = NULL;
-
-  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);
-
-  self->settings = g_settings_new ("com.canonical.indicator.power");
-  g_signal_connect_swapped (self->settings, "changed::" ICON_POLICY_KEY,
+  IndicatorPowerPrivate * priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_POWER_TYPE, IndicatorPowerPrivate);
+
+  priv->menu = GTK_MENU(gtk_menu_new());
+
+  priv->accessible_desc = NULL;
+
+  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 @@
 
   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);
-
-  if (self->devices != NULL) {
-    g_variant_unref (self->devices);
-    self->devices = NULL;
-  }
-
-  if (self->device != NULL) {
-    g_variant_unref (self->device);
-    self->device = NULL;
-  }
-
-  g_clear_object (&self->proxy);
-  g_clear_object (&self->proxy_cancel);
-
-  g_clear_object (&self->settings);
+  IndicatorPowerPrivate * priv = self->priv;
+
+  dispose_devices (self);
+
+  g_clear_object (&priv->dbus_listener);
+  g_clear_object (&priv->settings);
 
   G_OBJECT_CLASS (indicator_power_parent_class)->dispose (object);
 }
@@ -178,8 +160,9 @@
 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 @@
 }
 
 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 @@
   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 @@
   }
 }
 
-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)
-{
-  GIcon *gicon = NULL;
-
-  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);
-
-  g_free (short_details);
-  g_free (details);
-  g_free (accessible_name);
+static gboolean
+menu_add_device (GtkMenu * menu, const IndicatorPowerDevice * device)
+{
+  gboolean added = FALSE;
+  const UpDeviceKind kind = indicator_power_device_get_kind (device);
+
+  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);
+  }
+
+  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;
-
-  n_devices = g_variant_n_children (devices);
-  g_debug ("Num devices: '%" G_GSIZE_FORMAT "'\n", n_devices);
-
-  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;
+  GSList * l;
+  gsize n_added = 0;
+
+  for (l=devices; l!=NULL; l=l->next)
+    if (menu_add_device (menu, l->data))
+      ++n_added;
+
+  return n_added;
 }
 
 static gboolean
@@ -653,75 +313,62 @@
   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);
-
-  for (i = 0; i < n_devices; i++)
+  GSList * l;
+
+  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 @@
           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 @@
           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 (accessible_name);
+  g_free (details);
   g_free (short_details);
-  g_free (details);
-  g_free (accessible_name);
 }
 
-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);
-
-      g_variant_unref (devices_container);
-
-      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);
-        }
-    }
-
+  /* LCOV_EXCL_START */
+  g_return_if_fail (IS_INDICATOR_POWER(self));
+  /* LCOV_EXCL_STOP */
+
+  IndicatorPowerPrivate * priv = self->priv;
+
+  /* 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 @@
                                 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 @@
 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)
 {
+  GIcon *gicon;
   IndicatorPower *self = INDICATOR_POWER (io);
-  GIcon *gicon;
+  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 @@
 
   build_menu (self);
 
-  return GTK_MENU (self->menu);
+  return GTK_MENU (self->priv->menu);
 }
 
 static const gchar *
@@ -1005,7 +528,7 @@
 {
   IndicatorPower *self = INDICATOR_POWER (io);
 
-  return self->accessible_desc;
+  return self->priv->accessible_desc;
 }
 
 static const gchar *
@@ -1019,28 +542,22 @@
 ***/
 
 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 @@
 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 @@
     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)
         {

=== added file 'src/indicator-power.h'
--- src/indicator-power.h	1970-01-01 00:00:00 +0000
+++ src/indicator-power.h	2012-07-11 17:08:19 +0000
@@ -0,0 +1,58 @@
+/*
+An indicator to power related information in the menubar.
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Javier Jardon <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranties of
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* 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

=== added directory 'tests'
=== added file 'tests/Makefile.am'
--- tests/Makefile.am	1970-01-01 00:00:00 +0000
+++ tests/Makefile.am	2012-07-11 17:08:19 +0000
@@ -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/\""
+
+###
+###
+###

=== added file 'tests/Makefile.am.strings'
--- tests/Makefile.am.strings	1970-01-01 00:00:00 +0000
+++ tests/Makefile.am.strings	2012-07-11 17:08:19 +0000
@@ -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)

=== added file 'tests/test-dbus-listener.cc'
--- tests/test-dbus-listener.cc	1970-01-01 00:00:00 +0000
+++ tests/test-dbus-listener.cc	2012-07-11 17:08:19 +0000
@@ -0,0 +1,370 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <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); 
+}

=== added file 'tests/test-device.cc'
--- tests/test-device.cc	1970-01-01 00:00:00 +0000
+++ tests/test-device.cc	2012-07-11 17:08:19 +0000
@@ -0,0 +1,470 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <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);
+}

=== added file 'tests/test-indicator.cc'
--- tests/test-indicator.cc	1970-01-01 00:00:00 +0000
+++ tests/test-indicator.cc	2012-07-11 17:08:19 +0000
@@ -0,0 +1,312 @@
+/*
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <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);
+}