Update formatting to match style (as close as possible)

(bzr r1307)

8 files changed, 524 insertions, 520 deletions

diff --git a/tests/unit/TestFavoriteStoreGSettings.cpp b/tests/unit/TestFavoriteStoreGSettings.cpp
index 5336131f3..8bad0959c 100644
--- a/tests/unit/TestFavoriteStoreGSettings.cpp
+++ b/tests/unit/TestFavoriteStoreGSettings.cpp
@@ -36,12 +36,14 @@
 #define BASE_STORE_CONTENTS "[desktop/unity/launcher]\n" \
 "favorites=['evolution.desktop', 'firefox.desktop', '%s']"
 
-namespace {
+namespace
+{
 
-const char *base_store_favs[] = { "evolution.desktop",
+const char* base_store_favs[] = { "evolution.desktop",
 "firefox.desktop",
 CUSTOM_DESKTOP,
- NULL };
+ NULL
+ };
 const int n_base_store_favs = G_N_ELEMENTS(base_store_favs) - 1; /* NULL */
 
 void TestAllocation();
@@ -64,38 +66,39 @@ using namespace unity;
 void TestFavoriteStoreGSettingsCreateSuite()
 {
 #define TEST_DOMAIN "/Unit/FavoriteStoreGSettings"
- g_test_add_func (TEST_DOMAIN"/Allocation", TestAllocation);
- g_test_add_func (TEST_DOMAIN"/GetFavorites", TestGetFavorites);
- g_test_add_func (TEST_DOMAIN"/AddFavorite", TestAddFavorite);
- g_test_add_func (TEST_DOMAIN"/AddFavoritePosition", TestAddFavoritePosition);
- g_test_add_func (TEST_DOMAIN"/AddFavoriteLast", TestAddFavoriteLast);
- g_test_add_func (TEST_DOMAIN"/AddFavoriteOutOfRange", TestAddFavoriteOutOfRange);
- g_test_add_func (TEST_DOMAIN"/RemoveFavorite", TestRemoveFavorite);
- g_test_add_func (TEST_DOMAIN"/RemoveFavoriteBad", TestRemoveFavoriteBad);
- g_test_add_func (TEST_DOMAIN"/MoveFavorite", TestMoveFavorite);
- g_test_add_func (TEST_DOMAIN"/MoveFavoriteBad", TestMoveFavoriteBad);
+ g_test_add_func(TEST_DOMAIN"/Allocation", TestAllocation);
+ g_test_add_func(TEST_DOMAIN"/GetFavorites", TestGetFavorites);
+ g_test_add_func(TEST_DOMAIN"/AddFavorite", TestAddFavorite);
+ g_test_add_func(TEST_DOMAIN"/AddFavoritePosition", TestAddFavoritePosition);
+ g_test_add_func(TEST_DOMAIN"/AddFavoriteLast", TestAddFavoriteLast);
+ g_test_add_func(TEST_DOMAIN"/AddFavoriteOutOfRange", TestAddFavoriteOutOfRange);
+ g_test_add_func(TEST_DOMAIN"/RemoveFavorite", TestRemoveFavorite);
+ g_test_add_func(TEST_DOMAIN"/RemoveFavoriteBad", TestRemoveFavoriteBad);
+ g_test_add_func(TEST_DOMAIN"/MoveFavorite", TestMoveFavorite);
+ g_test_add_func(TEST_DOMAIN"/MoveFavoriteBad", TestMoveFavoriteBad);
 #undef TEST_DOMAIN
 }
 
-namespace {
+namespace
+{
 
 GSettingsBackend* CreateDefaultKeyFileBackend()
 {
- GSettingsBackend *b;
- GError *error = NULL;
- gchar *contents = NULL;
+ GSettingsBackend* b;
+ GError* error = NULL;
+ gchar* contents = NULL;
 
- contents = g_strdup_printf (BASE_STORE_CONTENTS, CUSTOM_DESKTOP);
+ contents = g_strdup_printf(BASE_STORE_CONTENTS, CUSTOM_DESKTOP);
 
- g_file_set_contents (BASE_STORE_FILE,
- contents,
- -1,
- &error);
- g_assert (error == NULL);
+ g_file_set_contents(BASE_STORE_FILE,
+ contents,
+ -1,
+ &error);
+ g_assert(error == NULL);
 
- b = g_keyfile_settings_backend_new (BASE_STORE_FILE, "/", "root");
+ b = g_keyfile_settings_backend_new(BASE_STORE_FILE, "/", "root");
 
- g_free (contents);
+ g_free(contents);
 return b;
 }
 
@@ -127,7 +130,7 @@ void TestGetFavorites()
 internal::FavoriteStoreGSettings settings(backend.Release());
 
 FavoriteList const& favs = settings.GetFavorites();
- g_assert_cmpint(favs.size(), ==, 3);
+ g_assert_cmpint(favs.size(), == , 3);
 g_assert(ends_with(at(favs, 0), base_store_favs[0]));
 g_assert(ends_with(at(favs, 1), base_store_favs[1]));
 g_assert(at(favs, 2) == base_store_favs[2]);
@@ -142,7 +145,7 @@ void TestAddFavorite()
 settings.AddFavorite(other_desktop, 0);
 FavoriteList const& favs = settings.GetFavorites();
 g_assert(other_desktop == at(favs, 0));
- g_assert_cmpint(favs.size(), ==, n_base_store_favs + 1);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs + 1);
 }
 
 void TestAddFavoritePosition()
@@ -154,7 +157,7 @@ void TestAddFavoritePosition()
 settings.AddFavorite(other_desktop, 2);
 FavoriteList const& favs = settings.GetFavorites();
 g_assert(other_desktop == at(favs, 2));
- g_assert_cmpint(favs.size(), ==, n_base_store_favs + 1);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs + 1);
 }
 
 void TestAddFavoriteLast()
@@ -166,7 +169,7 @@ void TestAddFavoriteLast()
 settings.AddFavorite(other_desktop, -1);
 FavoriteList const& favs = settings.GetFavorites();
 g_assert(other_desktop == favs.back());
- g_assert_cmpint(favs.size(), ==, n_base_store_favs + 1);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs + 1);
 }
 
 void TestAddFavoriteOutOfRange()
@@ -178,7 +181,7 @@ void TestAddFavoriteOutOfRange()
 FavoriteList const& favs = settings.GetFavorites();
 settings.AddFavorite(other_desktop, n_base_store_favs + 1);
 // size didn't change
- g_assert_cmpint(favs.size(), ==, n_base_store_favs);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs);
 // didn't get inserted
 FavoriteList::const_iterator iter = std::find(favs.begin(), favs.end(), other_desktop);
 g_assert(iter == favs.end());
@@ -192,11 +195,11 @@ void TestRemoveFavorite()
 FavoriteList const& favs = settings.GetFavorites();
 settings.RemoveFavorite(at(favs, 0));
 
- g_assert_cmpint(favs.size(), ==, n_base_store_favs - 1);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs - 1);
 g_assert(ends_with(at(favs, 0), base_store_favs[1]));
 
 settings.RemoveFavorite(at(favs, 1));
- g_assert_cmpint(favs.size(), ==, n_base_store_favs - 2);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs - 2);
 g_assert(ends_with(at(favs, 0), base_store_favs[1]));
 }
 
@@ -207,13 +210,13 @@ void TestRemoveFavoriteBad()
 
 FavoriteList const& favs = settings.GetFavorites();
 settings.RemoveFavorite("");
- g_assert_cmpint(favs.size(), ==, n_base_store_favs);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs);
 
 settings.RemoveFavorite("foo.desktop");
- g_assert_cmpint(favs.size(), ==, n_base_store_favs);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs);
 
 settings.RemoveFavorite("/this/desktop/doesnt/exist/hopefully.desktop");
- g_assert_cmpint(favs.size(), ==, n_base_store_favs);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs);
 }
 
 void TestMoveFavorite()
@@ -225,7 +228,7 @@ void TestMoveFavorite()
 
 settings.MoveFavorite(base_store_favs[2], 0);
 
- g_assert_cmpint(favs.size(), ==, n_base_store_favs);
+ g_assert_cmpint(favs.size(), == , n_base_store_favs);
 g_assert(at(favs, 0) == base_store_favs[2]);
 g_assert(ends_with(at(favs, 1), base_store_favs[0]));
 g_assert(ends_with(at(favs, 2), base_store_favs[1]));
@@ -241,7 +244,7 @@ void TestMoveFavoriteBad()
 settings.MoveFavorite("", 0);
 settings.MoveFavorite(at(favs, 0), 100);
 
- g_assert_cmpint(favs.size(), ==, 3);
+ g_assert_cmpint(favs.size(), == , 3);
 g_assert(ends_with(at(favs, 0), base_store_favs[0]));
 g_assert(ends_with(at(favs, 1), base_store_favs[1]));
 g_assert(at(favs, 2) == base_store_favs[2]);
diff --git a/tests/unit/TestMain.cpp b/tests/unit/TestMain.cpp
index 8569ef591..df73d1bec 100644
--- a/tests/unit/TestMain.cpp
+++ b/tests/unit/TestMain.cpp
@@ -25,63 +25,63 @@
 #include "Nux/Nux.h"
 #include "Nux/WindowThread.h"
 
-void TestFavoriteStoreGSettingsCreateSuite (void);
+void TestFavoriteStoreGSettingsCreateSuite(void);
 //void TestPanelServiceCreateSuite (void);
-void TestPlaceFactoryFileCreateSuite (void);
-void TestUBusCreateSuite (void);
-void TestQuicklistMenuitemsCreateSuite (void);
+void TestPlaceFactoryFileCreateSuite(void);
+void TestUBusCreateSuite(void);
+void TestQuicklistMenuitemsCreateSuite(void);
 
 nux::WindowThread*
-createThread ()
+createThread()
 {
 nux::WindowThread* thread = NULL;
 
- nux::NuxInitialize (0);
- thread = nux::CreateGUIThread (TEXT ("Unit-Test Dummy Window"),
- 320,
- 240,
- 0,
- NULL,
- 0);
+ nux::NuxInitialize(0);
+ thread = nux::CreateGUIThread(TEXT("Unit-Test Dummy Window"),
+ 320,
+ 240,
+ 0,
+ NULL,
+ 0);
 return thread;
 }
 
 void
-runThread (nux::WindowThread* thread)
+runThread(nux::WindowThread* thread)
 {
- thread->Run (NULL);
+ thread->Run(NULL);
 }
 
 void
-stopThread (nux::WindowThread* thread)
+stopThread(nux::WindowThread* thread)
 {
- thread->TerminateThread ();
+ thread->TerminateThread();
 delete thread;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char** argv)
 {
- g_setenv ("GSETTINGS_SCHEMA_DIR", BUILDDIR"/settings/", TRUE);
+ g_setenv("GSETTINGS_SCHEMA_DIR", BUILDDIR"/settings/", TRUE);
 
- g_type_init ();
- g_thread_init (NULL);
- gtk_init (&argc, &argv);
+ g_type_init();
+ g_thread_init(NULL);
+ gtk_init(&argc, &argv);
 
- g_test_init (&argc, &argv, NULL);
+ g_test_init(&argc, &argv, NULL);
 
 //Keep alphabetical please
- TestFavoriteStoreGSettingsCreateSuite ();
+ TestFavoriteStoreGSettingsCreateSuite();
 //TestPanelServiceCreateSuite ();
- TestPlaceFactoryFileCreateSuite ();
- TestQuicklistMenuitemsCreateSuite ();
- TestUBusCreateSuite ();
+ TestPlaceFactoryFileCreateSuite();
+ TestQuicklistMenuitemsCreateSuite();
+ TestUBusCreateSuite();
 
- nux::WindowThread* thread = createThread ();
+ nux::WindowThread* thread = createThread();
 
- int ret = g_test_run ();
+ int ret = g_test_run();
 
- stopThread (thread);
+ stopThread(thread);
 
 return ret;
 }
diff --git a/tests/unit/TestPanelService.cpp b/tests/unit/TestPanelService.cpp
index 55206bae6..fdc842239 100644
--- a/tests/unit/TestPanelService.cpp
+++ b/tests/unit/TestPanelService.cpp
@@ -29,19 +29,19 @@
 #define TEST_TYPE_OBJECT (test_object_get_type ())
 
 #define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
-	TEST_TYPE_OBJECT, TestObject))
+ TEST_TYPE_OBJECT, TestObject))
 
 #define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
-	TEST_TYPE_OBJECT, TestObjectClass))
+ TEST_TYPE_OBJECT, TestObjectClass))
 
 #define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
-	TEST_TYPE_OBJECT))
+ TEST_TYPE_OBJECT))
 
 #define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
-	TEST_TYPE_OBJECT))
+ TEST_TYPE_OBJECT))
 
 #define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
-	TEST_TYPE_OBJECT, TestObjectClass))
+ TEST_TYPE_OBJECT, TestObjectClass))
 
 typedef struct _TestObject TestObject;
 typedef struct _TestObjectClass TestObjectClass;
@@ -50,7 +50,7 @@ struct _TestObject
 {
 IndicatorObject parent;
 
- GList *entries;
+ GList* entries;
 };
 
 struct _TestObjectClass
@@ -58,64 +58,64 @@ struct _TestObjectClass
 IndicatorObjectClass parent_class;
 };
 
-GType test_object_get_type (void) G_GNUC_CONST;
+GType test_object_get_type(void) G_GNUC_CONST;
 
-IndicatorObject * test_object_new ();
+IndicatorObject* test_object_new();
 
-IndicatorObjectEntry * test_object_add_entry (TestObject *self,
- const gchar *label,
- const gchar *icon_name);
+IndicatorObjectEntry* test_object_add_entry(TestObject* self,
+ const gchar* label,
+ const gchar* icon_name);
 
 //--- .c
 
-G_DEFINE_TYPE (TestObject, test_object, INDICATOR_OBJECT_TYPE);
+G_DEFINE_TYPE(TestObject, test_object, INDICATOR_OBJECT_TYPE);
 
 void
-test_object_dispose (GObject *object)
+test_object_dispose(GObject* object)
 {
- TestObject *self = TEST_OBJECT (object);
+ TestObject* self = TEST_OBJECT(object);
 
- GList *e;
+ GList* e;
 for (e = self->entries; e; e = e->next)
- {
- g_slice_free (IndicatorObjectEntry, e->data);
- }
- g_list_free (self->entries);
+ {
+ g_slice_free(IndicatorObjectEntry, e->data);
+ }
+ g_list_free(self->entries);
 self->entries = NULL;
 
- G_OBJECT_CLASS (test_object_parent_class)->dispose (object);
+ G_OBJECT_CLASS(test_object_parent_class)->dispose(object);
 }
 
-GList *
-test_object_get_entries (IndicatorObject *io)
+GList*
+test_object_get_entries(IndicatorObject* io)
 {
- g_return_val_if_fail (TEST_IS_OBJECT (io), NULL);
+ g_return_val_if_fail(TEST_IS_OBJECT(io), NULL);
 
- return g_list_copy (TEST_OBJECT (io)->entries);
+ return g_list_copy(TEST_OBJECT(io)->entries);
 }
 
 guint
-test_object_get_location (IndicatorObject *io,
- IndicatorObjectEntry *entry)
+test_object_get_location(IndicatorObject* io,
+ IndicatorObjectEntry* entry)
 {
- g_return_val_if_fail (TEST_IS_OBJECT (io), 0);
+ g_return_val_if_fail(TEST_IS_OBJECT(io), 0);
 
- return g_list_index (TEST_OBJECT (io)->entries, entry);
+ return g_list_index(TEST_OBJECT(io)->entries, entry);
 }
 
 void
-test_object_entry_activate (IndicatorObject *io,
- IndicatorObjectEntry *entry,
- guint timestamp)
+test_object_entry_activate(IndicatorObject* io,
+ IndicatorObjectEntry* entry,
+ guint timestamp)
 {
 
 }
 
 void
-test_object_class_init (TestObjectClass *klass)
+test_object_class_init(TestObjectClass* klass)
 {
- GObjectClass *obj_class = G_OBJECT_CLASS (klass);
- IndicatorObjectClass *ind_class = INDICATOR_OBJECT_CLASS (klass);
+ GObjectClass* obj_class = G_OBJECT_CLASS(klass);
+ IndicatorObjectClass* ind_class = INDICATOR_OBJECT_CLASS(klass);
 
 obj_class->dispose = test_object_dispose;
 
@@ -125,44 +125,44 @@ test_object_class_init (TestObjectClass *klass)
 }
 
 void
-test_object_init (TestObject *self)
+test_object_init(TestObject* self)
 {
 
 }
 
-IndicatorObject *
-test_object_new ()
+IndicatorObject*
+test_object_new()
 {
- return (IndicatorObject *)g_object_new (TEST_TYPE_OBJECT, NULL);
+ return (IndicatorObject*)g_object_new(TEST_TYPE_OBJECT, NULL);
 }
 
-IndicatorObjectEntry *
-test_object_add_entry (TestObject *self,
- const gchar *label,
- const gchar *icon_name)
+IndicatorObjectEntry*
+test_object_add_entry(TestObject* self,
+ const gchar* label,
+ const gchar* icon_name)
 {
- IndicatorObjectEntry *entry;
- g_return_val_if_fail (TEST_IS_OBJECT (self), NULL);
+ IndicatorObjectEntry* entry;
+ g_return_val_if_fail(TEST_IS_OBJECT(self), NULL);
 
- entry = g_slice_new0 (IndicatorObjectEntry);
- entry->label = (GtkLabel *)gtk_label_new (label);
- entry->image = icon_name ? (GtkImage *)gtk_image_new_from_icon_name (icon_name,
- GTK_ICON_SIZE_MENU) : NULL;
+ entry = g_slice_new0(IndicatorObjectEntry);
+ entry->label = (GtkLabel*)gtk_label_new(label);
+ entry->image = icon_name ? (GtkImage*)gtk_image_new_from_icon_name(icon_name,
+ GTK_ICON_SIZE_MENU) : NULL;
 entry->menu = NULL;
 
- self->entries = g_list_append (self->entries, entry);
+ self->entries = g_list_append(self->entries, entry);
 
- g_signal_emit (self, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED_ID, 0, entry, TRUE);
+ g_signal_emit(self, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED_ID, 0, entry, TRUE);
 
 return entry;
 }
 
 void
-test_object_show_entry (TestObject *self,
- IndicatorObjectEntry *entry,
- guint timestamp)
+test_object_show_entry(TestObject* self,
+ IndicatorObjectEntry* entry,
+ guint timestamp)
 {
- g_signal_emit (self, INDICATOR_OBJECT_SIGNAL_MENU_SHOW_ID, 0, entry, timestamp);
+ g_signal_emit(self, INDICATOR_OBJECT_SIGNAL_MENU_SHOW_ID, 0, entry, timestamp);
 }
 
 //----------------------- /TESTING INDICATOR STUFF ----------------------------
@@ -170,75 +170,75 @@ test_object_show_entry (TestObject *self,
 //------------------------ USEFUL FUNCTIONS -----------------------------------
 
 guint
-get_n_indicators_in_result (GVariant *result)
+get_n_indicators_in_result(GVariant* result)
 {
 guint ret = 0;
- gchar *current_object_id = NULL;
- GVariantIter *iter;
- gchar *indicator_id;
- gchar *entry_id;
- gchar *label;
+ gchar* current_object_id = NULL;
+ GVariantIter* iter;
+ gchar* indicator_id;
+ gchar* entry_id;
+ gchar* label;
 gboolean label_sensitive;
 gboolean label_visible;
 guint32 image_type;
- gchar *image_data;
+ gchar* image_data;
 gboolean image_sensitive;
 gboolean image_visible;
 
- g_variant_get (result, "(a(sssbbusbb))", &iter);
- while (g_variant_iter_loop (iter, "(sssbbusbb)",
- &indicator_id,
- &entry_id,
- &label,
- &label_sensitive,
- &label_visible,
- &image_type,
- &image_data,
- &image_sensitive,
- &image_visible))
+ g_variant_get(result, "(a(sssbbusbb))", &iter);
+ while (g_variant_iter_loop(iter, "(sssbbusbb)",
+ &indicator_id,
+ &entry_id,
+ &label,
+ &label_sensitive,
+ &label_visible,
+ &image_type,
+ &image_data,
+ &image_sensitive,
+ &image_visible))
+ {
+ if (g_strcmp0(current_object_id, indicator_id) != 0)
 {
- if (g_strcmp0 (current_object_id, indicator_id) != 0)
- {
- ret++;
- g_free (current_object_id);
- current_object_id = g_strdup (indicator_id);
- }
+ ret++;
+ g_free(current_object_id);
+ current_object_id = g_strdup(indicator_id);
 }
- g_free (current_object_id);
+ }
+ g_free(current_object_id);
 
 return ret;
 }
 
 guint
-get_n_entries_in_result (GVariant *result)
+get_n_entries_in_result(GVariant* result)
 {
 guint ret = 0;
- GVariantIter *iter;
- gchar *indicator_id;
- gchar *entry_id;
- gchar *label;
+ GVariantIter* iter;
+ gchar* indicator_id;
+ gchar* entry_id;
+ gchar* label;
 gboolean label_sensitive;
 gboolean label_visible;
 guint32 image_type;
- gchar *image_data;
+ gchar* image_data;
 gboolean image_sensitive;
 gboolean image_visible;
 
- g_variant_get (result, "(a(sssbbusbb))", &iter);
- while (g_variant_iter_loop (iter, "(sssbbusbb)",
- &indicator_id,
- &entry_id,
- &label,
- &label_sensitive,
- &label_visible,
- &image_type,
- &image_data,
- &image_sensitive,
- &image_visible))
- {
- if (g_strcmp0 (entry_id, "") != 0)
- ret++;
- }
+ g_variant_get(result, "(a(sssbbusbb))", &iter);
+ while (g_variant_iter_loop(iter, "(sssbbusbb)",
+ &indicator_id,
+ &entry_id,
+ &label,
+ &label_sensitive,
+ &label_visible,
+ &image_type,
+ &image_data,
+ &image_sensitive,
+ &image_visible))
+ {
+ if (g_strcmp0(entry_id, "") != 0)
+ ret++;
+ }
 
 return ret;
 }
@@ -247,155 +247,155 @@ get_n_entries_in_result (GVariant *result)
 
 //------------------------ /USEFUL FUNCTIONS ----------------------------------
 
-static void TestAllocation (void);
-static void TestIndicatorLoading (void);
-static void TestEmptyIndicatorObject (void);
-static void TestEntryAddition (void);
-static void TestEntryActivateRequest (void);
+static void TestAllocation(void);
+static void TestIndicatorLoading(void);
+static void TestEmptyIndicatorObject(void);
+static void TestEntryAddition(void);
+static void TestEntryActivateRequest(void);
 
 void
-TestPanelServiceCreateSuite ()
+TestPanelServiceCreateSuite()
 {
 #define _DOMAIN "/Unit/PanelService"
 
- g_test_add_func (_DOMAIN"/Allocation", TestAllocation);
- g_test_add_func (_DOMAIN"/IndicatorLoading", TestIndicatorLoading);
- g_test_add_func (_DOMAIN"/EmptyIndicatorObject", TestEmptyIndicatorObject);
- g_test_add_func (_DOMAIN"/EntryAddition", TestEntryAddition);
- g_test_add_func (_DOMAIN"/EntryActivateRequest", TestEntryActivateRequest);
+ g_test_add_func(_DOMAIN"/Allocation", TestAllocation);
+ g_test_add_func(_DOMAIN"/IndicatorLoading", TestIndicatorLoading);
+ g_test_add_func(_DOMAIN"/EmptyIndicatorObject", TestEmptyIndicatorObject);
+ g_test_add_func(_DOMAIN"/EntryAddition", TestEntryAddition);
+ g_test_add_func(_DOMAIN"/EntryActivateRequest", TestEntryActivateRequest);
 }
 
 static void
-TestAllocation ()
+TestAllocation()
 {
- PanelService *service;
+ PanelService* service;
 
- service = panel_service_get_default ();
- g_assert (PANEL_IS_SERVICE (service));
+ service = panel_service_get_default();
+ g_assert(PANEL_IS_SERVICE(service));
 
- g_object_unref (service);
- g_assert (PANEL_IS_SERVICE (service) == FALSE);
+ g_object_unref(service);
+ g_assert(PANEL_IS_SERVICE(service) == FALSE);
 }
 
 static void
-TestIndicatorLoading ()
+TestIndicatorLoading()
 {
- PanelService *service;
- IndicatorObject *object;
- GList *objects = NULL;
+ PanelService* service;
+ IndicatorObject* object;
+ GList* objects = NULL;
 
- object = test_object_new ();
- g_assert (INDICATOR_IS_OBJECT (object));
- objects = g_list_append (objects, object);
+ object = test_object_new();
+ g_assert(INDICATOR_IS_OBJECT(object));
+ objects = g_list_append(objects, object);
 
- service = panel_service_get_default_with_indicators (objects);
- g_assert (PANEL_IS_SERVICE (service));
+ service = panel_service_get_default_with_indicators(objects);
+ g_assert(PANEL_IS_SERVICE(service));
 
- g_assert_cmpint (panel_service_get_n_indicators (service), ==, 1);
+ g_assert_cmpint(panel_service_get_n_indicators(service), == , 1);
 
- g_list_free (objects);
- g_object_unref (object);
- g_object_unref (service);
+ g_list_free(objects);
+ g_object_unref(object);
+ g_object_unref(service);
 }
 
 static void
-TestEmptyIndicatorObject ()
+TestEmptyIndicatorObject()
 {
- PanelService *service;
- IndicatorObject *object;
- GList *objects = NULL;
- GVariant *result;
+ PanelService* service;
+ IndicatorObject* object;
+ GList* objects = NULL;
+ GVariant* result;
 
- object = test_object_new ();
- g_assert (INDICATOR_IS_OBJECT (object));
- objects = g_list_append (objects, object);
+ object = test_object_new();
+ g_assert(INDICATOR_IS_OBJECT(object));
+ objects = g_list_append(objects, object);
 
- service = panel_service_get_default_with_indicators (objects);
- g_assert (PANEL_IS_SERVICE (service));
+ service = panel_service_get_default_with_indicators(objects);
+ g_assert(PANEL_IS_SERVICE(service));
 
- g_assert_cmpint (panel_service_get_n_indicators (service), ==, 1);
+ g_assert_cmpint(panel_service_get_n_indicators(service), == , 1);
 
- result = panel_service_sync (service);
- g_assert (result != NULL);
+ result = panel_service_sync(service);
+ g_assert(result != NULL);
 
- g_assert_cmpint (get_n_indicators_in_result (result), ==, 1);
+ g_assert_cmpint(get_n_indicators_in_result(result), == , 1);
 
- g_variant_unref (result);
- g_list_free (objects);
- g_object_unref (object);
- g_object_unref (service);
+ g_variant_unref(result);
+ g_list_free(objects);
+ g_object_unref(object);
+ g_object_unref(service);
 }
 
 static void
-TestEntryAddition ()
+TestEntryAddition()
 {
- PanelService *service;
- TestObject *object;
- GList *objects = NULL;
- GVariant *result;
+ PanelService* service;
+ TestObject* object;
+ GList* objects = NULL;
+ GVariant* result;
 int i;
 
- object = (TestObject *)test_object_new ();
- test_object_add_entry (object, "Hello", "gtk-apply");
- g_assert (INDICATOR_IS_OBJECT (object));
- objects = g_list_append (objects, object);
+ object = (TestObject*)test_object_new();
+ test_object_add_entry(object, "Hello", "gtk-apply");
+ g_assert(INDICATOR_IS_OBJECT(object));
+ objects = g_list_append(objects, object);
 
- service = panel_service_get_default_with_indicators (objects);
- g_assert (PANEL_IS_SERVICE (service));
+ service = panel_service_get_default_with_indicators(objects);
+ g_assert(PANEL_IS_SERVICE(service));
 
- result = panel_service_sync (service);
- g_assert (result != NULL);
- g_assert_cmpint (get_n_entries_in_result (result), ==, 1);
+ result = panel_service_sync(service);
+ g_assert(result != NULL);
+ g_assert_cmpint(get_n_entries_in_result(result), == , 1);
 
 for (i = 2; i < 10; i++)
- {
- g_variant_unref (result);
-
- test_object_add_entry (object, "Bye", "gtk-forward");
- result = panel_service_sync (service);
- g_assert_cmpint (get_n_entries_in_result (result), ==, i);
- }
-
- g_variant_unref (result);
- g_list_free (objects);
- g_object_unref (object);
- g_object_unref (service);
+ {
+ g_variant_unref(result);
+
+ test_object_add_entry(object, "Bye", "gtk-forward");
+ result = panel_service_sync(service);
+ g_assert_cmpint(get_n_entries_in_result(result), == , i);
+ }
+
+ g_variant_unref(result);
+ g_list_free(objects);
+ g_object_unref(object);
+ g_object_unref(service);
 }
 
 static void
-OnEntryActivateRequest (IndicatorObject *object,
- const gchar *entry_id,
- const gchar *entry_id_should_be)
+OnEntryActivateRequest(IndicatorObject* object,
+ const gchar* entry_id,
+ const gchar* entry_id_should_be)
 {
- g_assert_cmpstr (entry_id, ==, entry_id_should_be);
+ g_assert_cmpstr(entry_id, == , entry_id_should_be);
 }
 
 static void
-TestEntryActivateRequest ()
+TestEntryActivateRequest()
 {
- PanelService *service;
- TestObject *object;
- GList *objects = NULL;
- IndicatorObjectEntry *entry;
- gchar *id;
- 
- object = (TestObject *)test_object_new ();
- entry = test_object_add_entry (object, "Hello", "gtk-apply");
- id = g_strdup_printf ("%p", entry);
- g_assert (INDICATOR_IS_OBJECT (object));
- objects = g_list_append (objects, object);
-
- service = panel_service_get_default_with_indicators (objects);
- g_assert (PANEL_IS_SERVICE (service));
-
- g_signal_connect (service, "entry-activate-request",
- G_CALLBACK (OnEntryActivateRequest),
- id);
-
- test_object_show_entry (object, entry, 1234);
-
- g_free (id);
- g_list_free (objects);
- g_object_unref (object);
- g_object_unref (service);
+ PanelService* service;
+ TestObject* object;
+ GList* objects = NULL;
+ IndicatorObjectEntry* entry;
+ gchar* id;
+
+ object = (TestObject*)test_object_new();
+ entry = test_object_add_entry(object, "Hello", "gtk-apply");
+ id = g_strdup_printf("%p", entry);
+ g_assert(INDICATOR_IS_OBJECT(object));
+ objects = g_list_append(objects, object);
+
+ service = panel_service_get_default_with_indicators(objects);
+ g_assert(PANEL_IS_SERVICE(service));
+
+ g_signal_connect(service, "entry-activate-request",
+ G_CALLBACK(OnEntryActivateRequest),
+ id);
+
+ test_object_show_entry(object, entry, 1234);
+
+ g_free(id);
+ g_list_free(objects);
+ g_object_unref(object);
+ g_object_unref(service);
 }
diff --git a/tests/unit/TestPlaceFactoryFile.cpp b/tests/unit/TestPlaceFactoryFile.cpp
index 2f66bc824..b2d03baf6 100644
--- a/tests/unit/TestPlaceFactoryFile.cpp
+++ b/tests/unit/TestPlaceFactoryFile.cpp
@@ -23,28 +23,28 @@
 
 #include "PlaceFactoryFile.h"
 
-static void TestAllocation (void);
+static void TestAllocation(void);
 
 void
-TestPlaceFactoryFileCreateSuite ()
+TestPlaceFactoryFileCreateSuite()
 {
 #define _DOMAIN "/Unit/PlaceFactoryFile"
 
 if (0)
- g_test_add_func (_DOMAIN"/Allocation", TestAllocation);
+ g_test_add_func(_DOMAIN"/Allocation", TestAllocation);
 }
 
 static void
-TestAllocation ()
+TestAllocation()
 {
- PlaceFactoryFile *factory;
+ PlaceFactoryFile* factory;
 
- factory = new PlaceFactoryFile ();
- g_assert (factory);
+ factory = new PlaceFactoryFile();
+ g_assert(factory);
 
 // while (!factory->read_directory)
 while (1)
- g_main_context_iteration (NULL, TRUE);
+ g_main_context_iteration(NULL, TRUE);
 
 delete factory;
 }
diff --git a/tests/unit/TestQuicklistMenuitems.cpp b/tests/unit/TestQuicklistMenuitems.cpp
index 9018cac9c..d9b082cc8 100644
--- a/tests/unit/TestQuicklistMenuitems.cpp
+++ b/tests/unit/TestQuicklistMenuitems.cpp
@@ -36,203 +36,203 @@
 #include "QuicklistView.h"
 #include "TestThreadHelper.h"
 
-static void TestMenuItemCheckmark (void);
-static void TestMenuItemLabel (void);
-static void TestMenuItemRadio (void);
-static void TestMenuItemSeparator (void);
-static void TestQuicklistMenuItem (void);
+static void TestMenuItemCheckmark(void);
+static void TestMenuItemLabel(void);
+static void TestMenuItemRadio(void);
+static void TestMenuItemSeparator(void);
+static void TestQuicklistMenuItem(void);
 
 nux::WindowThread* thread = NULL;
 
 void
-TestQuicklistMenuitemsCreateSuite ()
+TestQuicklistMenuitemsCreateSuite()
 {
 #define _DOMAIN "/Unit/QuicklistMenuitems"
 
- g_test_add_func (_DOMAIN"/MenuItemCheckmark", TestMenuItemCheckmark);
- g_test_add_func (_DOMAIN"/MenuItemLabel", TestMenuItemLabel);
- g_test_add_func (_DOMAIN"/MenuItemRadio", TestMenuItemRadio);
- g_test_add_func (_DOMAIN"/MenuItemSeparator", TestMenuItemSeparator);
- g_test_add_func (_DOMAIN"/QuicklistMenuItem", TestQuicklistMenuItem);
+ g_test_add_func(_DOMAIN"/MenuItemCheckmark", TestMenuItemCheckmark);
+ g_test_add_func(_DOMAIN"/MenuItemLabel", TestMenuItemLabel);
+ g_test_add_func(_DOMAIN"/MenuItemRadio", TestMenuItemRadio);
+ g_test_add_func(_DOMAIN"/MenuItemSeparator", TestMenuItemSeparator);
+ g_test_add_func(_DOMAIN"/QuicklistMenuItem", TestQuicklistMenuItem);
 }
 
 static void
-TestMenuItemCheckmark ()
+TestMenuItemCheckmark()
 {
 DbusmenuMenuitem* item = NULL;
 
 
- item = dbusmenu_menuitem_new ();
+ item = dbusmenu_menuitem_new();
 
- dbusmenu_menuitem_property_set (item,
- DBUSMENU_MENUITEM_PROP_LABEL,
- "Unchecked");
+ dbusmenu_menuitem_property_set(item,
+ DBUSMENU_MENUITEM_PROP_LABEL,
+ "Unchecked");
 
- dbusmenu_menuitem_property_set (item,
- DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
- DBUSMENU_MENUITEM_TOGGLE_CHECK);
+ dbusmenu_menuitem_property_set(item,
+ DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
+ DBUSMENU_MENUITEM_TOGGLE_CHECK);
 
- dbusmenu_menuitem_property_set_bool (item,
- DBUSMENU_MENUITEM_PROP_ENABLED,
- false);
+ dbusmenu_menuitem_property_set_bool(item,
+ DBUSMENU_MENUITEM_PROP_ENABLED,
+ false);
 
- dbusmenu_menuitem_property_set_int (item,
- DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
- DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+ dbusmenu_menuitem_property_set_int(item,
+ DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
+ DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
 
 QuicklistMenuItemCheckmark* qlCheckmarkItem = NULL;
 
- qlCheckmarkItem = new QuicklistMenuItemCheckmark (item, true);
+ qlCheckmarkItem = new QuicklistMenuItemCheckmark(item, true);
 
- g_assert_cmpstr (qlCheckmarkItem->GetLabel (), ==, "Unchecked");
- g_assert_cmpint (qlCheckmarkItem->GetEnabled (), ==, false);
- g_assert_cmpint (qlCheckmarkItem->GetActive (), ==, false);
+ g_assert_cmpstr(qlCheckmarkItem->GetLabel(), == , "Unchecked");
+ g_assert_cmpint(qlCheckmarkItem->GetEnabled(), == , false);
+ g_assert_cmpint(qlCheckmarkItem->GetActive(), == , false);
 
 //qlCheckmarkItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
 // &CallerClass::RecvChanged));
 
 
- qlCheckmarkItem->Dispose ();
- g_object_unref (item);
+ qlCheckmarkItem->Dispose();
+ g_object_unref(item);
 }
 
 static void
-TestMenuItemLabel ()
+TestMenuItemLabel()
 {
 DbusmenuMenuitem* item = NULL;
 
- item = dbusmenu_menuitem_new ();
+ item = dbusmenu_menuitem_new();
 
- dbusmenu_menuitem_property_set (item,
- DBUSMENU_MENUITEM_PROP_LABEL,
- "A Label");
+ dbusmenu_menuitem_property_set(item,
+ DBUSMENU_MENUITEM_PROP_LABEL,
+ "A Label");
 
- dbusmenu_menuitem_property_set_bool (item,
- DBUSMENU_MENUITEM_PROP_ENABLED,
- true);
+ dbusmenu_menuitem_property_set_bool(item,
+ DBUSMENU_MENUITEM_PROP_ENABLED,
+ true);
 
 QuicklistMenuItemLabel* qlLabelItem = NULL;
 
- qlLabelItem = new QuicklistMenuItemLabel (item, true);
+ qlLabelItem = new QuicklistMenuItemLabel(item, true);
 
- g_assert_cmpstr (qlLabelItem->GetLabel (), ==, "A Label");
- g_assert_cmpint (qlLabelItem->GetEnabled (), ==, true);
+ g_assert_cmpstr(qlLabelItem->GetLabel(), == , "A Label");
+ g_assert_cmpint(qlLabelItem->GetEnabled(), == , true);
 
 //qlLabelItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
 // &CallerClass::RecvChanged));
- 
- qlLabelItem->Dispose ();
- g_object_unref (item);
+
+ qlLabelItem->Dispose();
+ g_object_unref(item);
 }
 
 static void
-TestMenuItemRadio ()
+TestMenuItemRadio()
 {
 DbusmenuMenuitem* item = NULL;
 
- item = dbusmenu_menuitem_new ();
+ item = dbusmenu_menuitem_new();
 
- dbusmenu_menuitem_property_set (item,
- DBUSMENU_MENUITEM_PROP_LABEL,
- "Radio Active");
+ dbusmenu_menuitem_property_set(item,
+ DBUSMENU_MENUITEM_PROP_LABEL,
+ "Radio Active");
 
- dbusmenu_menuitem_property_set (item,
- DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
- DBUSMENU_MENUITEM_TOGGLE_RADIO);
+ dbusmenu_menuitem_property_set(item,
+ DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,
+ DBUSMENU_MENUITEM_TOGGLE_RADIO);
 
- dbusmenu_menuitem_property_set_bool (item,
- DBUSMENU_MENUITEM_PROP_ENABLED,
- true);
+ dbusmenu_menuitem_property_set_bool(item,
+ DBUSMENU_MENUITEM_PROP_ENABLED,
+ true);
 
- dbusmenu_menuitem_property_set_int (item,
- DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
- DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED);
+ dbusmenu_menuitem_property_set_int(item,
+ DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,
+ DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED);
 
 QuicklistMenuItemRadio* qlRadioItem = NULL;
 
- qlRadioItem = new QuicklistMenuItemRadio (item, true);
+ qlRadioItem = new QuicklistMenuItemRadio(item, true);
 
- g_assert_cmpstr (qlRadioItem->GetLabel (), ==, "Radio Active");
- g_assert_cmpint (qlRadioItem->GetEnabled (), ==, true);
- g_assert_cmpint (qlRadioItem->GetActive (), ==, true);
+ g_assert_cmpstr(qlRadioItem->GetLabel(), == , "Radio Active");
+ g_assert_cmpint(qlRadioItem->GetEnabled(), == , true);
+ g_assert_cmpint(qlRadioItem->GetActive(), == , true);
 
 //qlRadioItem->sigChanged.connect (sigc::mem_fun (pointerToCallerClass,
 // &CallerClass::RecvChanged));
- 
- qlRadioItem->Dispose ();
- g_object_unref (item);
+
+ qlRadioItem->Dispose();
+ g_object_unref(item);
 }
 
 static void
-TestMenuItemSeparator ()
+TestMenuItemSeparator()
 {
 DbusmenuMenuitem* item = NULL;
 
- item = dbusmenu_menuitem_new ();
+ item = dbusmenu_menuitem_new();
 
- dbusmenu_menuitem_property_set (item,
- "type",
- DBUSMENU_CLIENT_TYPES_SEPARATOR);
+ dbusmenu_menuitem_property_set(item,
+ "type",
+ DBUSMENU_CLIENT_TYPES_SEPARATOR);
 
- dbusmenu_menuitem_property_set_bool (item,
- DBUSMENU_MENUITEM_PROP_ENABLED,
- true);
+ dbusmenu_menuitem_property_set_bool(item,
+ DBUSMENU_MENUITEM_PROP_ENABLED,
+ true);
 
 QuicklistMenuItemSeparator* qlSeparatorItem = NULL;
 
- qlSeparatorItem = new QuicklistMenuItemSeparator (item, true);
+ qlSeparatorItem = new QuicklistMenuItemSeparator(item, true);
 
- g_assert_cmpint (qlSeparatorItem->GetEnabled (), ==, true);
+ g_assert_cmpint(qlSeparatorItem->GetEnabled(), == , true);
 
- qlSeparatorItem->Dispose ();
- g_object_unref (item);
+ qlSeparatorItem->Dispose();
+ g_object_unref(item);
 }
 
 static void
-TestQuicklistMenuItem ()
+TestQuicklistMenuItem()
 {
- DbusmenuMenuitem* root = dbusmenu_menuitem_new ();
- 
- dbusmenu_menuitem_set_root (root, true);
-
- DbusmenuMenuitem* child = dbusmenu_menuitem_new ();
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "label 0");
- dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
- dbusmenu_menuitem_child_append (root, child);
- 
- child = dbusmenu_menuitem_new ();
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
- dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
- dbusmenu_menuitem_child_append (root, child);
- 
- child = dbusmenu_menuitem_new ();
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "label 1");
- dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
- dbusmenu_menuitem_child_append (root, child);
- 
- child = dbusmenu_menuitem_new ();
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
- dbusmenu_menuitem_property_set (child, DBUSMENU_MENUITEM_PROP_LABEL, "check mark 0");
- dbusmenu_menuitem_property_set_bool (child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
- dbusmenu_menuitem_property_set_int (child, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
- dbusmenu_menuitem_child_append (root, child);
-
- QuicklistView* quicklist = new QuicklistView ();
- 
- quicklist->TestMenuItems (root);
- 
- g_assert_cmpint (quicklist->GetNumItems (), ==, 4);
- g_assert_cmpint (quicklist->GetNthType (0), ==, MENUITEM_TYPE_LABEL);
- g_assert_cmpint (quicklist->GetNthType (1), ==, MENUITEM_TYPE_SEPARATOR);
- g_assert_cmpint (quicklist->GetNthType (2), ==, MENUITEM_TYPE_LABEL);
- g_assert_cmpint (quicklist->GetNthType (3), ==, MENUITEM_TYPE_CHECK);
- 
- g_assert_cmpstr (quicklist->GetNthItems (0)->GetLabel (), ==, "label 0");
- g_assert_cmpstr (quicklist->GetNthItems (2)->GetLabel (), ==, "label 1");
- g_assert_cmpstr (quicklist->GetNthItems (3)->GetLabel (), ==, "check mark 0");
- 
- 
- quicklist->Dispose (); 
+ DbusmenuMenuitem* root = dbusmenu_menuitem_new();
+
+ dbusmenu_menuitem_set_root(root, true);
+
+ DbusmenuMenuitem* child = dbusmenu_menuitem_new();
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_LABEL, "label 0");
+ dbusmenu_menuitem_property_set_bool(child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+ dbusmenu_menuitem_child_append(root, child);
+
+ child = dbusmenu_menuitem_new();
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
+ dbusmenu_menuitem_property_set_bool(child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+ dbusmenu_menuitem_child_append(root, child);
+
+ child = dbusmenu_menuitem_new();
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_MENUITEM_PROP_LABEL);
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_LABEL, "label 1");
+ dbusmenu_menuitem_property_set_bool(child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+ dbusmenu_menuitem_child_append(root, child);
+
+ child = dbusmenu_menuitem_new();
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK);
+ dbusmenu_menuitem_property_set(child, DBUSMENU_MENUITEM_PROP_LABEL, "check mark 0");
+ dbusmenu_menuitem_property_set_bool(child, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+ dbusmenu_menuitem_property_set_int(child, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED);
+ dbusmenu_menuitem_child_append(root, child);
+
+ QuicklistView* quicklist = new QuicklistView();
+
+ quicklist->TestMenuItems(root);
+
+ g_assert_cmpint(quicklist->GetNumItems(), == , 4);
+ g_assert_cmpint(quicklist->GetNthType(0), == , MENUITEM_TYPE_LABEL);
+ g_assert_cmpint(quicklist->GetNthType(1), == , MENUITEM_TYPE_SEPARATOR);
+ g_assert_cmpint(quicklist->GetNthType(2), == , MENUITEM_TYPE_LABEL);
+ g_assert_cmpint(quicklist->GetNthType(3), == , MENUITEM_TYPE_CHECK);
+
+ g_assert_cmpstr(quicklist->GetNthItems(0)->GetLabel(), == , "label 0");
+ g_assert_cmpstr(quicklist->GetNthItems(2)->GetLabel(), == , "label 1");
+ g_assert_cmpstr(quicklist->GetNthItems(3)->GetLabel(), == , "check mark 0");
+
+
+ quicklist->Dispose();
 }
diff --git a/tests/unit/TestSwitcherModel.cpp b/tests/unit/TestSwitcherModel.cpp
index 671b2d0b6..43ac8ad96 100644
--- a/tests/unit/TestSwitcherModel.cpp
+++ b/tests/unit/TestSwitcherModel.cpp
@@ -28,75 +28,76 @@
 
 using namespace unity::switcher;
 
-namespace {
+namespace
+{
 
-TEST(TestSwitcher, TestConstructor) 
+TEST(TestSwitcher, TestConstructor)
 {
- AbstractLauncherIcon *first = new MockLauncherIcon ();
- AbstractLauncherIcon *second = new MockLauncherIcon ();
+ AbstractLauncherIcon* first = new MockLauncherIcon();
+ AbstractLauncherIcon* second = new MockLauncherIcon();
 std::vector<AbstractLauncherIcon*> icons;
- icons.push_back (first);
- icons.push_back (second);
+ icons.push_back(first);
+ icons.push_back(second);
 
- SwitcherModel::Ptr model (new SwitcherModel (icons));
+ SwitcherModel::Ptr model(new SwitcherModel(icons));
 
- EXPECT_EQ(model->Size (), 2);
- EXPECT_EQ(model->Selection (), first);
- EXPECT_EQ(model->LastSelection (), first);
- EXPECT_EQ(model->SelectionIndex (), 0);
- EXPECT_EQ(model->LastSelectionIndex (), 0);
+ EXPECT_EQ(model->Size(), 2);
+ EXPECT_EQ(model->Selection(), first);
+ EXPECT_EQ(model->LastSelection(), first);
+ EXPECT_EQ(model->SelectionIndex(), 0);
+ EXPECT_EQ(model->LastSelectionIndex(), 0);
 
 delete first;
 delete second;
 }
 
-TEST(TestSwitcher, TestSelection) 
+TEST(TestSwitcher, TestSelection)
 {
 std::vector<AbstractLauncherIcon*> icons;
- AbstractLauncherIcon *first = new MockLauncherIcon ();
- AbstractLauncherIcon *second = new MockLauncherIcon ();
- AbstractLauncherIcon *third = new MockLauncherIcon ();
- AbstractLauncherIcon *fourth = new MockLauncherIcon ();
- 
- icons.push_back (first);
- icons.push_back (second);
- icons.push_back (third);
- icons.push_back (fourth);
-
- SwitcherModel::Ptr model (new SwitcherModel (icons));
-
- EXPECT_EQ(model->Size (), 4);
- EXPECT_EQ(model->Selection (), first);
-
- model->Next ();
- EXPECT_EQ (model->Selection (), second);
- EXPECT_EQ (model->LastSelection (), first);
- model->Next ();
- EXPECT_EQ (model->Selection (), third);
- EXPECT_EQ (model->LastSelection (), second);
- model->Next ();
- EXPECT_EQ (model->Selection (), fourth);
- EXPECT_EQ (model->LastSelection (), third);
- model->Next ();
- EXPECT_EQ (model->Selection (), first);
- EXPECT_EQ (model->LastSelection (), fourth);
- model->Next ();
- EXPECT_EQ (model->Selection (), second);
- EXPECT_EQ (model->LastSelection (), first);
- model->Prev ();
- EXPECT_EQ (model->Selection (), first);
- EXPECT_EQ (model->LastSelection (), second);
- model->Prev ();
- EXPECT_EQ (model->Selection (), fourth);
- EXPECT_EQ (model->LastSelection (), first);
-
- model->Select (2);
- EXPECT_EQ (model->Selection (), third);
- EXPECT_EQ (model->LastSelection (), fourth);
-
- model->Select (first);
- EXPECT_EQ (model->Selection (), first);
- EXPECT_EQ (model->LastSelection (), third);
+ AbstractLauncherIcon* first = new MockLauncherIcon();
+ AbstractLauncherIcon* second = new MockLauncherIcon();
+ AbstractLauncherIcon* third = new MockLauncherIcon();
+ AbstractLauncherIcon* fourth = new MockLauncherIcon();
+
+ icons.push_back(first);
+ icons.push_back(second);
+ icons.push_back(third);
+ icons.push_back(fourth);
+
+ SwitcherModel::Ptr model(new SwitcherModel(icons));
+
+ EXPECT_EQ(model->Size(), 4);
+ EXPECT_EQ(model->Selection(), first);
+
+ model->Next();
+ EXPECT_EQ(model->Selection(), second);
+ EXPECT_EQ(model->LastSelection(), first);
+ model->Next();
+ EXPECT_EQ(model->Selection(), third);
+ EXPECT_EQ(model->LastSelection(), second);
+ model->Next();
+ EXPECT_EQ(model->Selection(), fourth);
+ EXPECT_EQ(model->LastSelection(), third);
+ model->Next();
+ EXPECT_EQ(model->Selection(), first);
+ EXPECT_EQ(model->LastSelection(), fourth);
+ model->Next();
+ EXPECT_EQ(model->Selection(), second);
+ EXPECT_EQ(model->LastSelection(), first);
+ model->Prev();
+ EXPECT_EQ(model->Selection(), first);
+ EXPECT_EQ(model->LastSelection(), second);
+ model->Prev();
+ EXPECT_EQ(model->Selection(), fourth);
+ EXPECT_EQ(model->LastSelection(), first);
+
+ model->Select(2);
+ EXPECT_EQ(model->Selection(), third);
+ EXPECT_EQ(model->LastSelection(), fourth);
+
+ model->Select(first);
+ EXPECT_EQ(model->Selection(), first);
+ EXPECT_EQ(model->LastSelection(), third);
 
 delete first;
 delete second;
diff --git a/tests/unit/TestThreadHelper.h b/tests/unit/TestThreadHelper.h
index 1bcd3af0c..2911a0ae9 100644
--- a/tests/unit/TestThreadHelper.h
+++ b/tests/unit/TestThreadHelper.h
@@ -18,6 +18,6 @@
 *
 */
 
-extern nux::WindowThread* createThread (void);
-extern void runThread (nux::WindowThread* thread);
-extern void stopThread (nux::WindowThread* thread);
+extern nux::WindowThread* createThread(void);
+extern void runThread(nux::WindowThread* thread);
+extern void stopThread(nux::WindowThread* thread);
diff --git a/tests/unit/TestUBus.cpp b/tests/unit/TestUBus.cpp
index f10fc9b9f..f0257997c 100644
--- a/tests/unit/TestUBus.cpp
+++ b/tests/unit/TestUBus.cpp
@@ -25,132 +25,132 @@
 #define MESSAGE1 "TEST MESSAGE ONE"
 #define MESSAGE2 "ՄᕅᏆⲤꙨႧΈ Ϊટ ಗשׁຣ໐ɱË‼‼❢"
 
-static void TestAllocation (void);
-static void TestMainLoop (void);
-static void TestPropagation (void);
+static void TestAllocation(void);
+static void TestMainLoop(void);
+static void TestPropagation(void);
 
 void
-TestUBusCreateSuite ()
+TestUBusCreateSuite()
 {
 #define _DOMAIN "/Unit/UBus"
- g_test_add_func (_DOMAIN"/Allocation", TestAllocation);
- g_test_add_func (_DOMAIN"/Propagation", TestPropagation);
- g_test_add_func (_DOMAIN"/MainLoop", TestMainLoop);
+ g_test_add_func(_DOMAIN"/Allocation", TestAllocation);
+ g_test_add_func(_DOMAIN"/Propagation", TestPropagation);
+ g_test_add_func(_DOMAIN"/MainLoop", TestMainLoop);
 }
 
 static void
-TestAllocation ()
+TestAllocation()
 {
- UBusServer *serv_1 = ubus_server_get_default ();
- UBusServer *serv_2 = ubus_server_get_default ();
+ UBusServer* serv_1 = ubus_server_get_default();
+ UBusServer* serv_2 = ubus_server_get_default();
 
- g_assert (serv_1 != NULL);
- g_assert (serv_2 != NULL);
+ g_assert(serv_1 != NULL);
+ g_assert(serv_2 != NULL);
 
 // i used a different way of making a singleton than i am used to
 // so i'm not 100% confident in it yet
- g_assert (serv_1 == serv_2);
+ g_assert(serv_1 == serv_2);
 }
 
 void
-test_handler_inc_counter (GVariant *data, gpointer val)
+test_handler_inc_counter(GVariant* data, gpointer val)
 {
 // inc a counter when we get called
- gint *counter = (gint*)val;
+ gint* counter = (gint*)val;
 *counter = *counter + 1;
 }
 
 void
-test_handler_inc_counter_2 (GVariant *data, gpointer val)
+test_handler_inc_counter_2(GVariant* data, gpointer val)
 {
 // inc a counter by two when called
- gint *counter = (gint*)val;
+ gint* counter = (gint*)val;
 *counter = *counter + 2;
 }
 
 static void
-TestPropagation ()
+TestPropagation()
 {
- UBusServer *ubus;
+ UBusServer* ubus;
 gint counter, i;
 guint handler1, handler2;
- 
- ubus = ubus_server_get_default ();
- handler1 = ubus_server_register_interest (ubus, MESSAGE1,
- test_handler_inc_counter,
- &counter);
 
- handler2 = ubus_server_register_interest (ubus, MESSAGE2, // tests UNICODE
- test_handler_inc_counter_2,
- &counter);
+ ubus = ubus_server_get_default();
+ handler1 = ubus_server_register_interest(ubus, MESSAGE1,
+ test_handler_inc_counter,
+ &counter);
+
+ handler2 = ubus_server_register_interest(ubus, MESSAGE2, // tests UNICODE
+ test_handler_inc_counter_2,
+ &counter);
 
 counter = 0;
- for (i=0; i<1000; i++)
+ for (i = 0; i < 1000; i++)
 {
- ubus_server_send_message (ubus, MESSAGE1, NULL);
+ ubus_server_send_message(ubus, MESSAGE1, NULL);
 }
 
- ubus_server_force_message_pump (ubus);
+ ubus_server_force_message_pump(ubus);
 
 counter = 0;
- for (i=0; i<1000; i++)
+ for (i = 0; i < 1000; i++)
 {
- ubus_server_send_message (ubus, MESSAGE1, NULL);
- ubus_server_send_message (ubus, MESSAGE2, NULL);
+ ubus_server_send_message(ubus, MESSAGE1, NULL);
+ ubus_server_send_message(ubus, MESSAGE2, NULL);
 }
- ubus_server_force_message_pump (ubus);
+ ubus_server_force_message_pump(ubus);
 
- g_assert (counter == 3000);
+ g_assert(counter == 3000);
 
- ubus_server_unregister_interest (ubus, handler1);
- ubus_server_unregister_interest (ubus, handler2);
+ ubus_server_unregister_interest(ubus, handler1);
+ ubus_server_unregister_interest(ubus, handler2);
 
 counter = 0;
- ubus_server_send_message (ubus, MESSAGE1, NULL);
- ubus_server_send_message (ubus, MESSAGE2, NULL);
+ ubus_server_send_message(ubus, MESSAGE1, NULL);
+ ubus_server_send_message(ubus, MESSAGE2, NULL);
 
- ubus_server_force_message_pump (ubus);
+ ubus_server_force_message_pump(ubus);
 
- g_assert (counter == 0);
+ g_assert(counter == 0);
 }
 
 gboolean
-main_loop_bailout (gpointer data)
+main_loop_bailout(gpointer data)
 {
- GMainLoop *mainloop = (GMainLoop*)data;
- g_main_quit (mainloop);
+ GMainLoop* mainloop = (GMainLoop*)data;
+ g_main_quit(mainloop);
 return FALSE;
 }
 
 void
-test_handler_mainloop (GVariant *data, gpointer val)
+test_handler_mainloop(GVariant* data, gpointer val)
 {
 // inc a counter when we get called
- gint *counter = (gint*)val;
+ gint* counter = (gint*)val;
 *counter = *counter + 1;
 
 }
 
 static void
-TestMainLoop ()
+TestMainLoop()
 {
- GMainLoop *mainloop;
- UBusServer *ubus;
+ GMainLoop* mainloop;
+ UBusServer* ubus;
 gint counter = 0;
- 
- ubus = ubus_server_get_default (); 
- mainloop = g_main_loop_new (NULL, TRUE);
 
- g_timeout_add_seconds (1, main_loop_bailout, mainloop);
+ ubus = ubus_server_get_default();
+ mainloop = g_main_loop_new(NULL, TRUE);
+
+ g_timeout_add_seconds(1, main_loop_bailout, mainloop);
 
- ubus_server_register_interest (ubus, MESSAGE1,
- test_handler_mainloop,
- &counter);
+ ubus_server_register_interest(ubus, MESSAGE1,
+ test_handler_mainloop,
+ &counter);
 
- ubus_server_send_message (ubus, MESSAGE1, NULL);
- g_main_loop_run (mainloop);
+ ubus_server_send_message(ubus, MESSAGE1, NULL);
+ g_main_loop_run(mainloop);
 
- g_assert (counter == 1);
+ g_assert(counter == 1);
 
 }