Fix codding style

Change-Id: I9f4c1f7a3a6da62ba4836abf1b8b2c3a8b899e88
Signed-off-by: Konrad Kuchciak <k.kuchciak@samsung.com>

diff --git a/src/action/action_executed_handler.c b/src/action/action_executed_handler.c
index 1989333db8422376619e17a685bfde4eae886458..58e499b1c84a64e5f1fea021b300b6c19194341e 100644 (file)
--- a/src/action/action_executed_handler.c
+++ b/src/action/action_executed_handler.c
@@ -47,5 +47,5 @@ static struct faultd_event_handler action_executed_event_handler = {
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(action_executed_event_handler,
-                              action_executed_eh,
-                              FAULTD_MODULE_TYPE_ACTION_EXECUTOR)
+                                                         action_executed_eh,
+                                                         FAULTD_MODULE_TYPE_ACTION_EXECUTOR)

diff --git a/src/action/action_executor.c b/src/action/action_executor.c
index a66c3058603657a3d771822191bb2a30ea1c56d8..5e4e91ad7d8439c4591198e302cfce4348cee42b 100644 (file)
--- a/src/action/action_executor.c
+++ b/src/action/action_executor.c
@@ -74,8 +74,8 @@ static struct action_executor action_executor = {
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(action_executor.handler,
-                              action_executor_eh,
-                              FAULTD_MODULE_TYPE_ACTION_EXECUTOR)
+                                                         action_executor_eh,
+                                                         FAULTD_MODULE_TYPE_ACTION_EXECUTOR)
 
 static int action_executor_callback(sd_event_source *s, int fd,
                                                                        uint32_t revents, void *userdata)

diff --git a/src/action/action_executor.h b/src/action/action_executor.h
index 383b05848d3a372d423ba795a1a2009ee66d6419..6992866d7bf9f824fb8be267376a6845b30ad826 100644 (file)
--- a/src/action/action_executor.h
+++ b/src/action/action_executor.h
@@ -38,25 +38,25 @@ struct faultd_action {
 int action_executor_action_register(struct faultd_action *act);
 void action_executor_action_unregister(struct faultd_action *act);
 
-#define FAULTD_ACTION_REGISTER(ACT, NAME)                                               \
-static int action_ ##NAME## _init(struct faultd_module *module,  \
+#define FAULTD_ACTION_REGISTER(ACT, NAME)                                                              \
+static int action_ ##NAME## _init(struct faultd_module *module,                        \
                                                                  struct faultd_config *config,                 \
                                                                                 sd_event *event_loop)                  \
 {                                                                                                                                              \
-    return action_executor_action_register(&ACT);                                              \
+       return action_executor_action_register(&ACT);                                           \
 }                                                                                                                                              \
                                                                                                                                                \
 static void action_ ##NAME## _cleanup(struct faultd_module *module)            \
 {                                                                                                                                              \
-    action_executor_action_unregister(&ACT);                                                   \
+       action_executor_action_unregister(&ACT);                                                        \
 }                                                                                                                                              \
                                                                                                                                                \
 static struct faultd_module action_ ##NAME## _module = {                               \
-    .name = #NAME,                                                                     \
+       .name = #NAME,                                                                                                          \
        .type = FAULTD_MODULE_TYPE_ACTION,                                                                      \
-    .init = action_ ##NAME## _init,                                                                            \
-    .cleanup = action_ ##NAME## _cleanup,                                                              \
-    .node = LIST_HEAD_INIT(action_ ##NAME## _module.node),                             \
+       .init = action_ ##NAME## _init,                                                                         \
+       .cleanup = action_ ##NAME## _cleanup,                                                           \
+       .node = LIST_HEAD_INIT(action_ ##NAME## _module.node),                          \
 };                                                                                                                                             \
                                                                                                                                                \
 FAULTD_MODULE_REGISTER(&action_ ##NAME## _module)

diff --git a/src/action/system_reboot_to_recovery.c b/src/action/system_reboot_to_recovery.c
index 76f550c394e32d4e9a2f75f197a5867b041288f8..d2335d6c943ff214f19bb35de52fac082b8a0217 100644 (file)
--- a/src/action/system_reboot_to_recovery.c
+++ b/src/action/system_reboot_to_recovery.c
@@ -26,7 +26,7 @@
 #include "log.h"
 #include "systemd_dbus.h"
 
-#define REBOOT_PARAM_PATH      "/run/systemd/reboot-param"
+#define REBOOT_PARAM_PATH "/run/systemd/reboot-param"
 #define REBOOT_PARAM "recovery\n"
 
 static int reboot_system_to_recovery(struct faultd_action *action)

diff --git a/src/core/event.c b/src/core/event.c
index 23063092eea2d4bece72201cf52eb0033124be67..37a69666bf9a6dc7aba616d7edd60348e87320a9 100644 (file)
--- a/src/core/event.c
+++ b/src/core/event.c
@@ -51,7 +51,7 @@ struct event_factory {
 
 static int init_event_factory(struct faultd_module *module,
                                                          struct faultd_config *config,
-                              sd_event *event_loop)
+                                                         sd_event *event_loop)
 {
        return 0;
 }

diff --git a/src/core/event.h b/src/core/event.h
index 2e3433aeffa6aaeac5d3c4613246d9ddbc4a3892..8b40730d6e2d5a530e965fe998ed31079e0f598c 100644 (file)
--- a/src/core/event.h
+++ b/src/core/event.h
@@ -85,22 +85,22 @@ static int CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _init)(struct faultd_mo
                                                                          struct faultd_config *config, \
                                                                          sd_event *event_loop)                 \
 {                                                                                                                                      \
-    return faultd_event_type_register(&EVENT_TYPE);                 \
+       return faultd_event_type_register(&EVENT_TYPE);                 \
 }                                                                                                                                      \
-                                                                    \
+                                                                                                                                       \
 static void CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _cleanup)(struct faultd_module *module) \
 {                                                                                                                                      \
-    faultd_event_type_unregister(&EVENT_TYPE);                      \
+       faultd_event_type_unregister(&EVENT_TYPE);                      \
 }                                                                                                                                      \
-                                                                    \
+                                                                                                                                       \
 static struct faultd_module CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _module) = {         \
-    .name = FAULTD_MODNAME,                                                                                    \
-    .type = FAULTD_MODULE_TYPE_EVENT,                               \
-    .init = CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _init),      \
-    .cleanup = CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _cleanup), \
-    .node = LIST_HEAD_INIT(CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _module.node)), \
+       .name = FAULTD_MODNAME,                                                                                 \
+       .type = FAULTD_MODULE_TYPE_EVENT,                               \
+       .init = CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _init),   \
+       .cleanup = CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _cleanup), \
+       .node = LIST_HEAD_INIT(CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _module.node)), \
 };                                                                                                                                     \
-                                                                    \
+                                                                                                                                       \
 FAULTD_MODULE_REGISTER(&CONCAT(CONCAT(event_type_, FAULTD_MODNAME_T), _module))
 
 int faultd_event_create(const char *type, void *data, struct faultd_event **ev);

diff --git a/src/core/event_processor.c b/src/core/event_processor.c
index 1f0dd7a2e996a07b9fc1d3c44033126f59922845..7ef9b0b31d5fd8f7d93fcf08111e2a40ae3a19c9 100644 (file)
--- a/src/core/event_processor.c
+++ b/src/core/event_processor.c
@@ -35,7 +35,7 @@ struct event_processor {
 
 /* called each time when new event arrived */
 static int event_processor_callback(sd_event_source *s,
-                                    int fd, uint32_t revents, void *userdata)
+                                                                       int fd, uint32_t revents, void *userdata)
 {
        struct event_processor *eprocessor = userdata;
        struct faultd_event *ev = nqueue_pop(&eprocessor->pending_events,
@@ -159,7 +159,7 @@ unref_obj:
 }
 
 static int event_processor_handler_callback(sd_event_source *s, int fd,
-                                            uint32_t revents, void *userdata)
+                                                                                       uint32_t revents, void *userdata)
 {
        struct faultd_event_handler *handler = userdata;
 

diff --git a/src/core/event_processor.h b/src/core/event_processor.h
index d2a32751676bc8b9238b59246d9318a02c14f4d2..e6b7668413d26812976c4104518265d18110e1e6 100644 (file)
--- a/src/core/event_processor.h
+++ b/src/core/event_processor.h
@@ -50,20 +50,20 @@ static int event_handler_ ##NAME## _init(struct faultd_module *module,  \
                                                                                 struct faultd_config *config,  \
                                                                                 sd_event *event_loop)                  \
 {                                                                                                                                              \
-    return event_processor_handler_register(&EVENT_HANDLER);                   \
+       return event_processor_handler_register(&EVENT_HANDLER);                        \
 }                                                                                                                                              \
                                                                                                                                                \
 static void event_handler_ ##NAME## _cleanup(struct faultd_module *module) \
 {                                                                                                                                              \
-    event_processor_handler_unregister(&EVENT_HANDLER);                                        \
+       event_processor_handler_unregister(&EVENT_HANDLER);                                     \
 }                                                                                                                                              \
                                                                                                                                                \
 static struct faultd_module event_handler_ ##NAME## _module = {                        \
-    .name = #NAME,                                                                                                             \
-    .type = TYPE,                                                                                                              \
-    .init = event_handler_ ##NAME## _init,                                                             \
-    .cleanup = event_handler_ ##NAME## _cleanup,                                               \
-    .node = LIST_HEAD_INIT(event_handler_ ##NAME## _module.node),              \
+       .name = #NAME,                                                                                                          \
+       .type = TYPE,                                                                                                           \
+       .init = event_handler_ ##NAME## _init,                                                          \
+       .cleanup = event_handler_ ##NAME## _cleanup,                                            \
+       .node = LIST_HEAD_INIT(event_handler_ ##NAME## _module.node),           \
 };                                                                                                                                             \
                                                                                                                                                \
 FAULTD_MODULE_REGISTER(&event_handler_ ##NAME## _module)

diff --git a/src/core/module.c b/src/core/module.c
index 7f5323451f60393f35c3e8d2f06213306122dcb2..b861a4da3525436de0a40128b7a81ca269af9424 100644 (file)
--- a/src/core/module.c
+++ b/src/core/module.c
@@ -226,9 +226,8 @@ int faultd_modules_load()
        ret = 0;
 out:
        free(filename);
-       while (num-- > 0) {
+       while (num-- > 0)
                free(namelist[num]);
-       }
 
        free(namelist);
        return ret;

diff --git a/src/database/ejdb.c b/src/database/ejdb.c
index 943a60e7393428793e7f45e7d2317bed4d412c52..4242f7791e179d32639a033d499f6805f2647ef4 100644 (file)
--- a/src/database/ejdb.c
+++ b/src/database/ejdb.c
@@ -198,13 +198,13 @@ static int bson_to_faultd_object(bson *b, struct faultd_object *out)
                        break;
                case BSON_BINDATA:
                        switch (bson_iterator_bin_type(&it)) {
-                               case BSON_BIN_UUID:
-                                       ret = faultd_object_append_uuid(out, key,
-                                                 (sd_id128_t *)bson_iterator_bin_data(&it));
-                                       break;
-                               default:
-                                       ret = -ENOTSUP;
-                                       break;
+                       case BSON_BIN_UUID:
+                               ret = faultd_object_append_uuid(out, key,
+                                         (sd_id128_t *)bson_iterator_bin_data(&it));
+                               break;
+                       default:
+                               ret = -ENOTSUP;
+                               break;
                        }
                        break;
                case BSON_OBJECT:

diff --git a/src/decision_makers/rv_dm.c b/src/decision_makers/rv_dm.c
index 151c832381b6822c5992476f5c4d7b94079e030b..79341895b3b7d74457b8e38d634e50aefde4cfd9 100644 (file)
--- a/src/decision_makers/rv_dm.c
+++ b/src/decision_makers/rv_dm.c
@@ -102,5 +102,5 @@ static struct faultd_event_handler resource_violation_event_handler = {
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(resource_violation_event_handler,
-                              resource_violation_eh,
-                              FAULTD_MODULE_TYPE_DECISION_MAKER)
+                                                         resource_violation_eh,
+                                                         FAULTD_MODULE_TYPE_DECISION_MAKER)

diff --git a/src/decision_makers/standard_fault_dm.c b/src/decision_makers/standard_fault_dm.c
index d3dda2c6622dfd418c18f82ed498cedcff9b8c26..696b381b81e731491cc7a86dd722963e618b78b4 100644 (file)
--- a/src/decision_makers/standard_fault_dm.c
+++ b/src/decision_makers/standard_fault_dm.c
@@ -141,5 +141,5 @@ static struct faultd_event_handler standard_fault_event_handler = {
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(standard_fault_event_handler,
-                              standard_fault_eh,
-                              FAULTD_MODULE_TYPE_DECISION_MAKER)
+                                                         standard_fault_eh,
+                                                         FAULTD_MODULE_TYPE_DECISION_MAKER)

diff --git a/src/decision_makers/vip_fault_dm.c b/src/decision_makers/vip_fault_dm.c
index 3d11f5729cb296ab598786ba494067b54b69720c..31207d05851cef71a8da48e765f8514d53149775 100644 (file)
--- a/src/decision_makers/vip_fault_dm.c
+++ b/src/decision_makers/vip_fault_dm.c
@@ -94,5 +94,5 @@ static struct faultd_event_handler vip_fault_event_handler = {
 };
 
 FAULTD_EVENT_HANDLER_REGISTER(vip_fault_event_handler,
-                              vip_fault_eh,
-                              FAULTD_MODULE_TYPE_DECISION_MAKER)
+                                                         vip_fault_eh,
+                                                         FAULTD_MODULE_TYPE_DECISION_MAKER)

diff --git a/src/event_types/action_executed_event.c b/src/event_types/action_executed_event.c
index dd0b5edd7beaceb1178893a62de6c3fc389339d0..d575a9ba853b789115e1841299b9fd426cc738ba 100644 (file)
--- a/src/event_types/action_executed_event.c
+++ b/src/event_types/action_executed_event.c
@@ -25,7 +25,7 @@
 #include "action_executed_event.h"
 
 static int allocate_ae_event(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct action_executed_event *ae_ev;
        struct ae_event_data *ae_ev_data = data;

diff --git a/src/event_types/decision_made_event.c b/src/event_types/decision_made_event.c
index 4c7905ed020e25528b5f7bdc5d5c6c6628c1ef62..c4157328e6175b3d688f1780a965339ecc19d744 100644 (file)
--- a/src/event_types/decision_made_event.c
+++ b/src/event_types/decision_made_event.c
@@ -25,7 +25,7 @@
 #include "decision_made_event.h"
 
 static int allocate_dm_event(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct decision_made_event *dm_ev;
        struct dm_event_data *dm_ev_data = data;

diff --git a/src/event_types/faultd_started_event.c b/src/event_types/faultd_started_event.c
index d95f6852b021f1ea6b26d6a967d1eda1f5933d49..84dadb3f295c6f0e52fd194064aa499ab356fabb 100644 (file)
--- a/src/event_types/faultd_started_event.c
+++ b/src/event_types/faultd_started_event.c
@@ -4,7 +4,7 @@
 #include "faultd_started_event.h"
 
 static int fs_event_allocate(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct faultd_started_event *fs_ev;
        int ret;
@@ -50,7 +50,7 @@ TEST_ENTRY_POINT(deserialize_fs_event);
 
 static void fs_event_release(struct faultd_event *ev)
 {
-       struct faultd_started_event *fs_ev = 
+       struct faultd_started_event *fs_ev =
                to_faultd_started_event(ev);
 
        faultd_event_cleanup_internal(&fs_ev->event);

diff --git a/src/event_types/resource_violation_event.c b/src/event_types/resource_violation_event.c
index f3960760b00c1e4bee389033734bc2bd0addd29a..35d804bfb3d889ff2ad3c8daa91615987e24699d 100644 (file)
--- a/src/event_types/resource_violation_event.c
+++ b/src/event_types/resource_violation_event.c
@@ -23,7 +23,7 @@
 #include "resource_violation_event.h"
 
 static int allocate_rv_event(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct resource_violation_event *rv_ev;
        struct rv_event_data *rv_ev_data = data;

diff --git a/src/event_types/service_failed_event.c b/src/event_types/service_failed_event.c
index a994ccc536dc1444d38556f7e3225fd01e024b29..fd84e3a61c7049f0cdcf4869e048caf3c67d317e 100644 (file)
--- a/src/event_types/service_failed_event.c
+++ b/src/event_types/service_failed_event.c
@@ -23,7 +23,7 @@
 #include "service_failed_event.h"
 
 static int allocate_sf_event(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct service_failed_event *sf_ev;
        struct sf_event_data *sf_ev_data = data;

diff --git a/src/event_types/system_booted_event.c b/src/event_types/system_booted_event.c
index a217908966092c4fdaea3cd0b9cb5a716638f156..3587936e7f750b66d89f23f7edd556a754a77b80 100644 (file)
--- a/src/event_types/system_booted_event.c
+++ b/src/event_types/system_booted_event.c
@@ -23,7 +23,7 @@
 #include "system_booted_event.h"
 
 static int allocate_sb_event(struct faultd_event_type *type,
-                             void *data, struct faultd_event **ev)
+                                                        void *data, struct faultd_event **ev)
 {
        struct system_booted_event *sb_ev;
        struct sb_event_data *sb_ev_data = data;
@@ -92,7 +92,7 @@ TEST_ENTRY_POINT(deserialize_sb_event);
 
 static void sb_event_release(struct faultd_event *ev)
 {
-       struct system_booted_event *sb_ev=
+       struct system_booted_event *sb_ev =
                to_system_booted_event(ev);
 
        faultd_event_cleanup_internal(&sb_ev->event);
@@ -124,7 +124,7 @@ static char *sb_event_to_string(struct faultd_event *ev)
 
 static void sb_event_serialize(struct faultd_event *ev, struct faultd_object *out)
 {
-       struct system_booted_event *sb_ev=
+       struct system_booted_event *sb_ev =
                to_system_booted_event(ev);
 
        faultd_event_serialize_internal(ev, out);

diff --git a/src/faultd.c b/src/faultd.c
index dcb9900e0968b0006ad482c68bae3330092fcfc3..ef60e5a54639febbe0e05835faa0a4719a8fd9e8 100644 (file)
--- a/src/faultd.c
+++ b/src/faultd.c
@@ -40,8 +40,8 @@ int sigint_handler(sd_event_source *s, const struct signalfd_siginfo *si,
                                   void *userdata);
 
 int sigint_handler(sd_event_source *s,
-                   const struct signalfd_siginfo *si,
-                   void *userdata)
+                                  const struct signalfd_siginfo *si,
+                                  void *userdata)
 {
        sd_event *loop = userdata;
 

diff --git a/src/listeners/systemd.c b/src/listeners/systemd.c
index 7032bed594a80d6844224ffc107610916f172c01..aa18e93d6f7211c26fdd505e4616f08fb5118bda 100644 (file)
--- a/src/listeners/systemd.c
+++ b/src/listeners/systemd.c
@@ -38,7 +38,7 @@ struct systemd_listener {
        container_of(MOD, struct systemd_listener, module)
 
 static int on_unit_properties_changed(sd_bus_message *m, void *userdata,
-                                      sd_bus_error *ret_error)
+                                                                         sd_bus_error *ret_error)
 {
        int rc = 1;
        const char *interface;
@@ -115,9 +115,8 @@ static int on_unit_properties_changed(sd_bus_message *m, void *userdata,
                        rc = sd_bus_message_exit_container(m);
                        log_debug("        %s:%s", key, value);
 
-                       if (strcmp("failed", value) == 0) {
+                       if (strcmp("failed", value) == 0)
                                has_failed = true;
-                       }
 
                } else if (strncmp("ConditionTimestamp", key, 18) == 0) {
                        uint64_t value;

diff --git a/src/util/list.h b/src/util/list.h
index 11a2910f32f4e119f9d3bb9284aae9a081202164..48e8e587e65bdb083777e46c0775a734dfdfcf2c 100644 (file)
--- a/src/util/list.h
+++ b/src/util/list.h
@@ -49,8 +49,8 @@ static inline void INIT_LIST_HEAD(struct list_head *head)
  * Should be used only internally
  */
 static inline void __list_add(struct list_head *new,
-                              struct list_head *prev,
-                              struct list_head *next)
+                                                         struct list_head *prev,
+                                                         struct list_head *next)
 {
        next->prev = new;
        new->next = next;

diff --git a/src/util/log.c b/src/util/log.c
index 8faf8ac6ad403822a962c9077bea1b18c2404149..ffe2dac34706a22da70f0c2d70d5aba7f4dfe4b9 100644 (file)
--- a/src/util/log.c
+++ b/src/util/log.c
@@ -70,11 +70,11 @@ int log_parse_level_name(const char *name)
 }
 
 int log_internal(int level,
-                 int error,
-                 const char *file,
-                 int line,
-                 const char *func,
-                 const char *format, ...)
+                                int error,
+                                const char *file,
+                                int line,
+                                const char *func,
+                                const char *format, ...)
 {
        char buffer[LINE_MAX];
        va_list ap;

diff --git a/src/util/log.h b/src/util/log.h
index a6072e4c4931973a75b1872d6f171b6b995441e4..35375142da3d438219b2ddd15e3aa79618f53962 100644 (file)
--- a/src/util/log.h
+++ b/src/util/log.h
@@ -5,8 +5,8 @@
 #include <syslog.h>
 
 #define log_full_errno(level, error, ...) ({                                                   \
-    int _l = (level), _e = error;                                       \
-    (LOG_PRI(_l) <= log_get_max_level()) ?                                                             \
+       int _l = (level), _e = error;                                       \
+       (LOG_PRI(_l) <= log_get_max_level()) ?                                                          \
        log_internal(_l, _e, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)     \
        : -abs(_e);                                                                                                                     \
 })

diff --git a/src/util/notify_queue.h b/src/util/notify_queue.h
index 66db64f03cefe6351dd7085254196c520d81229f..f43b46e2019d6b983cd9495dd0c2e34d6cd5b035 100644 (file)
--- a/src/util/notify_queue.h
+++ b/src/util/notify_queue.h
@@ -49,7 +49,7 @@ static inline int nqueue_get_notify_fd(struct nqueue_head *head)
 #define INIT_NQUEUE_NODE(node) INIT_QUEUE_HEAD(node)
 
 static inline int nqueue_append(struct nqueue_head *head,
-                                struct nqueue_node *new)
+                                                               struct nqueue_node *new)
 {
        ssize_t ret;
        uint64_t buf = 1;

diff --git a/tests/unit/fdtf.h b/tests/unit/fdtf.h
index 29368eaafb9d1f7898a87397080354d399d5770b..bc21377d2338ea4b09e02cad2d7736f5cd8aac4d 100644 (file)
--- a/tests/unit/fdtf.h
+++ b/tests/unit/fdtf.h
@@ -14,7 +14,7 @@
        TEST_ENTRY_POINT_NAME(MOD, FUNC)
 
 #define DECLARE_TEST_ENTRY_POINT(MOD, FUNC, RET, ...)          \
-       extern RET (*TEST_ENTRY_POINT_NAME(MOD, FUNC))(__VA_ARGS__)
+       extern RET(*TEST_ENTRY_POINT_NAME(MOD, FUNC))(__VA_ARGS__)
 
 struct fdtf_test_group {
        char *name;

diff --git a/tests/unit/helpers.c b/tests/unit/helpers.c
index 160a49457343f06e41c6b4a04d11c4f545898816..17bd5ffdba8648bb3f334b2a639c1ee800b69d59 100644 (file)
--- a/tests/unit/helpers.c
+++ b/tests/unit/helpers.c
@@ -4,57 +4,57 @@ void test_serialization(struct serialized_element *data, int size, struct faultd
 {
        for (int i = 0; i < size; ++i) {
                switch (data[i].type) {
-                       case TYPE_OID:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(faultd_oid_t, val, parent, data[i].key, data[i].type);
-                                       assert_oid_equal(&val, data[i].desired);
-                                       break;
-                               }
-                       case TYPE_STRING:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(char*, val, parent, data[i].key, data[i].type);
-                                       assert_string_equal(val, *(char**)data[i].desired);
-                                       break;
-                               }
-                       case TYPE_INT:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(int, val, parent, data[i].key, data[i].type);
-                                       assert_int_equal(val, *(int*)(data[i].desired));
-                                       break;
-                               }
-                       case TYPE_TIMESPEC:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(struct timespec, val, parent, data[i].key, data[i].type);
-                                       assert_timespec_equal(&val, data[i].desired);
-                                       break;
-                               }
-                       case TYPE_TIME_T:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(time_t, val, parent, data[i].key, data[i].type);
-                                       assert_time_t_equal(val, *(time_t*)data[i].desired);
-                                       break;
-                               }
-                       case TYPE_UUID:
-                               {
-                                       GET_FAULTD_OBJECT_VAL(sd_id128_t, val, parent, data[i].key, data[i].type);
-                                       assert_uuid_equal(&val, data[i].desired);
-                                       break;
-                               }
-                       case TYPE_OBJECT:
-                               {
-                                       struct faultd_object *child;
-                                       int ret;
-
-                                       ret = faultd_object_get_object(parent, data[i].key, &child);
-                                       assert_int_equal(ret, 0);
-                                       test_serialization(data[i].child, data[i].children_num, child);
-                                       break;
-                               }
-                       default:
-                               fprintf(stderr, "Type '%d' is not supported (key: '%s')\n",
-                                               data[i].type, data[i].key);
-                               fail();
+               case TYPE_OID:
+                       {
+                               GET_FAULTD_OBJECT_VAL(faultd_oid_t, val, parent, data[i].key, data[i].type);
+                               assert_oid_equal(&val, data[i].desired);
                                break;
+                       }
+               case TYPE_STRING:
+                       {
+                               GET_FAULTD_OBJECT_VAL(char*, val, parent, data[i].key, data[i].type);
+                               assert_string_equal(val, *(char**)data[i].desired);
+                               break;
+                       }
+               case TYPE_INT:
+                       {
+                               GET_FAULTD_OBJECT_VAL(int, val, parent, data[i].key, data[i].type);
+                               assert_int_equal(val, *(int*)(data[i].desired));
+                               break;
+                       }
+               case TYPE_TIMESPEC:
+                       {
+                               GET_FAULTD_OBJECT_VAL(struct timespec, val, parent, data[i].key, data[i].type);
+                               assert_timespec_equal(&val, data[i].desired);
+                               break;
+                       }
+               case TYPE_TIME_T:
+                       {
+                               GET_FAULTD_OBJECT_VAL(time_t, val, parent, data[i].key, data[i].type);
+                               assert_time_t_equal(val, *(time_t*)data[i].desired);
+                               break;
+                       }
+               case TYPE_UUID:
+                       {
+                               GET_FAULTD_OBJECT_VAL(sd_id128_t, val, parent, data[i].key, data[i].type);
+                               assert_uuid_equal(&val, data[i].desired);
+                               break;
+                       }
+               case TYPE_OBJECT:
+                       {
+                               struct faultd_object *child;
+                               int ret;
+
+                               ret = faultd_object_get_object(parent, data[i].key, &child);
+                               assert_int_equal(ret, 0);
+                               test_serialization(data[i].child, data[i].children_num, child);
+                               break;
+                       }
+               default:
+                       fprintf(stderr, "Type '%d' is not supported (key: '%s')\n",
+                                       data[i].type, data[i].key);
+                       fail();
+                       break;
                }
        }
 
@@ -92,8 +92,7 @@ void assert_faultd_object_equal(struct faultd_object *actual,
                                                                         struct faultd_object,
                                                                         node);
 
-       while (&child_actual->node != &actual->val.children)
-       {
+       while (&child_actual->node != &actual->val.children) {
                if (child_actual->type == TYPE_OBJECT) {
                        assert_faultd_object_equal(child_actual, child_desired);
                } else {
@@ -237,10 +236,9 @@ char *generate_string(int len)
        str = calloc(len + 1, sizeof(char));
        assert_non_null(str);
 
-       for (int i = 0; i < len; ++i) {
+       for (int i = 0; i < len; ++i)
                str[i] = generate_char();
 
-       }
        str[len] = '\0';
 
        return str;

diff --git a/tests/unit/helpers.h b/tests/unit/helpers.h
index a6672ce7c2b8982d1d064ef00872b1e2ada8d993..96373c7800441ba6fecf4dc4bce4de98c5a48c79 100644 (file)
--- a/tests/unit/helpers.h
+++ b/tests/unit/helpers.h
@@ -59,7 +59,7 @@ void test_serialization(struct serialized_element *data, int size,
 int faultd_object_count_children(struct faultd_object *obj);
 
 void assert_test_attrs_equal(struct serialized_element *actual,
-                                                        struct serialized_element *desired, int size);
+                                                        struct serialized_element *desired, int size);
 void assert_faultd_object_equal(struct faultd_object *actual,
                                                                struct faultd_object *desired);
 void assert_data_equal(int type, void *actual, void *desired);

diff --git a/tests/unit/runner.c b/tests/unit/runner.c
index f82e7f8d7de9b5d3aace5d07216914fd04546cc6..f05c3a9a978c22aff5475763b5a0e8d3df01eb0d 100644 (file)
--- a/tests/unit/runner.c
+++ b/tests/unit/runner.c
@@ -30,7 +30,7 @@ int fdtf_run_all_test_groups()
        int fail = 0;
 
        list_for_each_entry(tg, &test_groups, node)
-               if((ret = fdtf_run_test_group(tg)) != 0)
+               if ((ret = fdtf_run_test_group(tg)) != 0)
                        fail = ret;
 
        if (fail != 0)